Question

我必须找到第一，第二和第三大阵列。我知道我可以简单地对它进行排序并返回数组[0]，数组[1]，数组[3]。但问题是，我需要索引，而不是价值。例如，如果我有float[] listx={8.0, 3.0, 4.0, 5.0, 9.0}，它应该返回4,0和3。

这是我的代码，但它不起作用：

//declaration max1-3        
public void maxar (float[] listx){

    float maxel1=0;
    float maxel2=0;
    float maxel3=0;

    for (int i=0; i<listx.length; i++){
        if(maxel1<listx[i])
        {maxel1=listx[i];
        max1=i;
        }
    }
    listx[max1]=0; //to exclude this one in nextsearch

    for (int j=0; j<listx.length; j++){
        if(listx[j]>maxel2)
        {maxel2=listx[j];
        max2=j;
        }
    }
    listx[max2]=0;

    for (int k=0; k<listx.length; k++){
        if(listx[k]>maxel3)
        {maxel3=listx[k];
        max3=k;
        }
    }
}

我得到max1正确但之后所有元素都变为0.因此max2和max3变为0.请告诉我这个解决方案有什么问题。谢谢。

Answer 1

您可以使用单个循环找到这三个元素，而无需修改数组。

当您遇到一个新的最大元素时，您需要将之前的最大元素和之前的第二大元素向下移动一个位置。

同样，当您找到新的第二大元素时，您需要将maxel2转换为maxel3。

您可能希望使用数组，而不是使用这三个变量。这将使您能够简化逻辑，并使其易于推广到k最大元素。

Answer 2

对数组进行3次传递：第一次传递查找值和最大元素M1的第一个索引，第二次传递查找值和最大元素M2的第一个索引，小于{{1}和第三次传递查找值/第一个索引M1。

Answer 3

尝试使用此代码：）

  public class Array
    {
  public void getMax( double ar[] )
   {
    double max1 = ar[0]; // Assume the first
    double max2 = ar[0]; // element in the array
    double max3 = ar[0]; // is the maximum element.
    int ZERO = 0; 
     // Variable to store inside it the index of the max value to set it to zero.

    for( int i = 0; i < ar.length; i++ )
    {
        if( ar[i] >= max1)
        {
            max1 = ar[i];
            ZERO = i;
        }
    }

    ar[ZERO] = 0; // Set the index contains the 1st max to ZERO.

    for( int j = 0; j < ar.length; j++ )
    {
        if( ar[j] >= max2 )
        {
            max2 = ar[j];
            ZERO = j;
        }
    }

    ar[ZERO] = 0; // Set the index contains the 2st max to ZERO.

    for( int k = 0; k < ar.length; k++ )
    {
        if( ar[k] >= max3 )
        {
            max3 = ar[k];
            ZERO = k;
        }
    }

            System.out.println("1st max:" + max1 + ", 2nd: " +max2 + ",3rd: "+ max3);                              
   }

public static void main(String[] args)
{
    // Creating an object from the class Array to be able to use its methods.
    Array array = new Array();
    // Creating an array of type double.
    double a[] = {2.2, 3.4, 5.5, 5.5, 6.6, 5.6};

    array.getMax( a ); // Calling the method that'll find the 1st max, 2nd max, and      and 3rd max.
}

  }

Answer 4

我建议一次通过而不是三次通过优化。下面的代码适合我。请注意，代码不断言listx至少有3个元素。如果它只包含2个或更少的元素，由你决定应该发生什么。

我对这段代码的喜欢之处在于它只对数组进行了一次传递，在最佳情况下，与三次传递相比，运行时间更快，其中一个因子与{{1}中的元素数量成比例}。

假设 i1 ， i2 和 i3 存储listx和 i0中三个最大元素的索引是指向最小元素的 i1，i2 和 i3 之一。在开始时， i1 = i2 = i3 因为我们还没有找到最大的元素。所以让 i0 = i1 。如果我们找到一个新的索引 j ，使listx，我们设置 i0 = j ，用一个导致更大元素的索引替换旧索引。然后我们找到 i1，i2 和 i3 中的索引，现在导致三个中的最小元素，这样我们就可以安全地丢弃那个万一有新的大元素出现。

注意：此代码位于C中，因此如果要使用它，请将其转换为Java。我确保使用类似的语法来使这更容易。（我在C中写道，因为我缺少Java测试环境。）

listx[j] > listx[i0]

Answer 5

public class ArrayExample {
    public static void main(String[] args) {
        int secondlargest = 0;
        int thirdLargest=0;
        int largest = 0;
        int arr[] = {5,4,3,8,12,95,14,376,37,2,73};
        for (int i = 0; i < arr.length; i++) {
            if (largest < arr[i]) {
                secondlargest = largest;
                largest = arr[i];
            }
            if (secondlargest < arr[i] && largest != arr[i])
                secondlargest = arr[i];
            if(thirdLargest<arr[i] && secondlargest!=arr[i] && largest!=arr[i] && thirdLargest<largest && thirdLargest<secondlargest)
                thirdLargest =arr[i];
        }
        System.out.println("Largest number is: " + largest);
        System.out.println("Second Largest number is: " + secondlargest);
        System.out.println("third Largest number is: " + thirdLargest);
    }
}

Answer 6

def third_mar_array(arr):
    max1=0
    max2=0
    max3=0
    for i in range(0,len(arr)-1):
         if max1<arr[i]:
             max1=arr[i]
             max_in1=i
    arr[max_in1]=0
    for j in range(0,len(arr)-1):
         if max2<arr[j]:
             max2=arr[j]
             max_in2=j
    arr[max_in2]=0
    for k in range(0,len(arr)-1):
         if max3<arr[k]:
             max3=arr[k]
             max_in3=k
    #arr[max_in3]=0
    return max3

n=[5,6,7,3,2,1]

f=first_array(n)
print f

Answer 7

class Main {

public static void main (String[] args) {


        Scanner sc = new Scanner(System.in);
        int testcase=sc.nextInt();
        while(testcase-->0){
        int sizeOfArray=sc.nextInt();
        int[] arr= new int[sizeOfArray];
        for(int i=0; i<sizeOfArray; i++){
        arr[i]=sc.nextInt();
        }
        int max1, max2, max3;
        max1=0;
        max2=0;
        max3=0;
        for (int i=0; i<sizeOfArray; i++) {
            if (arr[i] > max1) {
                max3 = max2;
                max2 = max1;
                max1 = arr[i];
            }
            else if (arr[i] > max2) {
                max3 = max2;
                max2 = arr[i];
            }
            else if (arr[i] > max3) {
                max3 = arr[i];
            }
        }
        System.out.println(max1 + " " + max2 + " " + max3);


}}}

找到第二个和第三个最大元素数组java

7 个答案: