如何在java中正确使用函数

Question

给定一个包含 N 个正整数的数组 arr[]，其中元素是连续的（已排序）。此外，还有一个元素重复 X（任何变量）次数。现在，任务是找到重复的元素和重复的次数。 这是我的代码：-

import java.util.*;
import java.lang.*;
import java.io.*;
class GFG
 {
    public static void main (String[] args)
     {
         Scanner sc= new Scanner(System.in);
         int t,n,i,left,rightleftid,rightid;
         t=sc.nextInt();
         while(t!=0){
             n=sc.nextInt();
             int arr[]=new int [n];
             for(i=0;i<n;i++){
                 arr[i]=sc.nextInt();
             }
             left=0;right=n-1;
             mid=(left+right)/2;
             leftid=funcleft(arr[],n,left,right);
             rightid=funcright(arr[],n,left,right);
             System.out.println(arr[leftid]+" "+(rightid-leftid+1));
             t--;
         }
     }
     static int funcleft(int arr[],int n,int left,int right){
         mid=(left+right)/2;
         if(arr[mid]==arr[mid+1]&&arr[mid]!=arr[mid-1])
         return mid;
         if(arr[mid]==arr[mid-1])
         return funcleft(arr[],n,left,mid-1);
         if(arr[mid]-arr[0]<mid)
         return funcleft(arr[],n,left,mid-1);
         else
         return funcleft(arr[],n,mid+1,right);
     }
     static int funcright(int arr[],int n,int left,int right){
         mid=(left+right)/2;
         if(arr[mid]==arr[mid-1]&&arr[mid]!=arr[mid+1])
         return mid;
         if(arr[mid]==arr[mid+1])
         return funcright(arr[],n,mid+1,right);
         if(arr[mid]-arr[0]<mid)
         return funcleft(arr[],n,left,mid-1);
         else
         return funcleft(arr[],n,mid+1,right);
     }
}

编译器显示一些错误

errors:-

请告诉我我做错了什么我是java的初学者

Answer 1

你应该打电话

funcleft(arr,n,left,mid-1);

没有括号表示您的错误。

但是您编写的代码并不能解决您所描述的问题。您说“给定”数组，但正在创建 t 个长度为 n 的数组，并自己填充数组的元素，这些元素可能会或可能不会根据您的输入进行排序。

Answer 2

首先需要编译代码，有几个问题：

• 变量的范围
• 代码行是java应该以';'结尾
• 你也不需要嵌入类

作为示例，您可以采用通过编译的代码版本：

 package com.company;

import java.util.Scanner;


class GFG {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t, n, i, left, right, leftid, rightid, mid;
        //int t,n,i,left,right,left,id,rightid;
        t = sc.nextInt();
        while (t != 0) {
            n = sc.nextInt();
            int[] arr = new int[n];
            for (i = 0; i < n; i++) {
                arr[i] = sc.nextInt();
            }
            left = 0;
            right = n - 1;
            mid = (left + right) / 2;
            leftid = funcleft(arr, n, left, right);
            rightid = funcright(arr, n, left, right);
            System.out.println(arr[leftid] + " " + (rightid - leftid + 1));
            t--;
        }
    }

    static int funcleft(int[] arr, int n, int left, int right) {
        // mid = (left + right) / 2;
        int mid = (left + right) / 2;
        if (arr[mid] == arr[mid + 1] && arr[mid] != arr[mid - 1])
            return mid;
        if (arr[mid] == arr[mid - 1])
            return funcleft(arr, n, left, mid - 1);
        if (arr[mid] - arr[0] < mid)
            return funcleft(arr, n, left, mid - 1);
        else
            return funcleft(arr, n, mid + 1, right);
    }

    static int funcright(int[] arr, int n, int left, int right) {
        int mid = (left + right) / 2;
        if (arr[mid] == arr[mid - 1] && arr[mid] != arr[mid + 1])
            return mid;
        if (arr[mid] == arr[mid + 1])
            return funcright(arr,n, mid + 1, right);
        if (arr[mid] - arr[0] < mid)
            return funcleft(arr,n, left, mid - 1);
         else
        return funcleft(arr,n, mid + 1, right);
    }
}

其次，您可能需要考虑算法本身，作为一个简单的解决方案，您可以使用 Map，例如TreeMap 遍历元素并为每个成员增加计数器。

Answer 3

那些特定的编译错误是由于Java中定义和访问数组的方式：

在定义变量arr 时，它应该指向你的存储数组，在类型之后使用括号，而不是在名称之后，因为它是整数类型数组的变量，因此声明应该是

int[] arr=new int [n];

然后，当使用整个数组而不是特定元素时，仅使用变量的名称，即 arr，因此在访问 funcleft 或 funcright 时应该是

funcleft(arr,n,left,right);

或funcright 相同。

修复这些错误后，您将遇到编译器尚未给出的进一步编译错误，因为他没有走那么远。您的代码的工作示例可能如下所示：

import java.util.*;
import java.lang.*;
import java.io.*;
class GFG
 {
    public static void main (String[] args)
     {
         Scanner sc= new Scanner(System.in);
         int t,n,i,left,right,rightleftid,rightid,leftid,mid;
         t=sc.nextInt();
         while(t!=0){
             n=sc.nextInt();
             int[] arr=new int [n];
             for(i=0;i<n;i++){
                 arr[i]=sc.nextInt();
             }
             left=0;
             right=n-1;
             mid=(left+right)/2;
             leftid=funcleft(arr,n,left,right);  
             rightid=funcright(arr,n,left,right);
             System.out.println(arr[leftid]+" "+(rightid-leftid+1));
             t--;
         }
     }
     static int funcleft(int arr[],int n,int left,int right){
         int mid=(left+right)/2;
         if(arr[mid]==arr[mid+1]&&arr[mid]!=arr[mid-1])
         return mid;
         if(arr[mid]==arr[mid-1])
         return funcleft(arr,n,left,mid-1);
         if(arr[mid]-arr[0]<mid)
         return funcleft(arr,n,left,mid-1);
         else
         return funcleft(arr,n,mid+1,right);
     }
     static int funcright(int arr[],int n,int left,int right){
         int mid=(left+right)/2;
         if(arr[mid]==arr[mid-1]&&arr[mid]!=arr[mid+1])
         return mid;
         if(arr[mid]==arr[mid+1])
         return funcright(arr,n,mid+1,right);
         if(arr[mid]-arr[0]<mid)
         return funcleft(arr,n,left,mid-1);
         else
         return funcleft(arr,n,mid+1,right);
     }
}

尽管正如@Gokberk Gul 指出的那样，这并不能完全解决您给定的任务

Answer 4

感谢所有人.....我不知道的是-在函数调用期间，如果我想将数组（arr []）作为参数传递，那么我只需将其名称（arr）作为参数传递不是方括号（[]）以及它。这是我新优化的无错误代码，已经提交成功了。

import java.util.*;
import java.lang.*;
import java.io.*;
class GFG
 {
    public static void main (String[] args)
     {
         Scanner sc= new Scanner(System.in);
         int t,n,i,left,right,leftid,rightid;
         t=sc.nextInt();
         while(t!=0){
             n=sc.nextInt();
             int arr[]=new int [n];
             for(i=0;i<n;i++){
                 arr[i]=sc.nextInt();
             }
             left=0;right=n-1;
             leftid=funcleft(arr,n,left,right);
             rightid=funcright(arr,n,left,right);
             System.out.println(arr[leftid]+" "+(rightid-leftid+1));
             t--;
         }
     }
     static int funcleft(int arr[],int n,int left,int right){
         int mid=(left+right)/2;
         if(mid==0)
         return mid;
         if(arr[mid]==arr[mid+1]&&arr[mid]!=arr[mid-1])
         return mid;
         if(arr[mid]==arr[mid-1])
         return funcleft(arr,n,left,mid-1);
         if(arr[mid]-arr[0]<mid)
         return funcleft(arr,n,left,mid-1);
         else
         return funcleft(arr,n,mid+1,right);
     }
     static int funcright(int arr[],int n,int left,int right){
         int mid=(left+right)/2;
         if(mid==n-1)
         return mid;
         if(arr[mid]==arr[mid-1]&&arr[mid]!=arr[mid+1])
         return mid;
         if(arr[mid]==arr[mid+1])
         return funcright(arr,n,mid+1,right);
         if(arr[mid]-arr[0]<mid)
         return funcright(arr,n,left,mid-1);
         else
         return funcright(arr,n,mid+1,right);
     }
}```