Question

我正在尝试创建一个返回int的方法 - 发送数组中最大整数的值。我想让这个方法工作的方法是检查for循环中数组的最后一个元素和，并以中间方式工作。所以i =第一个整数，k =最后一个整数。当i = 0, k = n-1（索引）时i = 1, k = n-2，如果你抓住了我的漂移。在每个循环中，它需要检查if a[i]>a[k]。然后他们换位置。然后我知道最大的数字是在数组的前半部分，然后我希望它检查那一半，所以最终最大的int是在索引0。

我试过这样：

public static int maxOfArray(int[] a)
{
    int length = a.length;

    if(length<1)
        throw new NoSuchElementException("Not at least one integer in array");

    while (length > 1)
    {
        int k = length;

        for(int i = 0; i < length/2; i++)
        {
            k--;

            if(a[i]<a[k])
            {
                int j = a[i];
                a[i] = a[k];
                a[k] = j;
            }
        }
        length /=2;
    }
    return a[0];
}

..但我真的不明白......我很难“想象”这里发生了什么......但它并不总是有效......（虽然有时候）。

修改另外：阵列{6,15,2,5,8,14,10,16,11,17,13,7,1,18,3,4,9,12};将吐出17作为最大的数字。我意识到我必须修复奇怪的bug，但我想首先解决这个偶数长度的数组..

Answer 1

遇到length时遇到的错误是奇怪的。

在这些情况下，你会“错过”中间元素。

示例：对于输入int[] arr = { 8, 1, 5, 4, 9, 4, 3, 7, 2 }; - 元素9将与自身进行比较和检查，但随后缩小length的大小，排除来自您要接下来迭代的数组的9。

我相信可以通过将问题减少到ceil(length/2)而不是length/2（以及处理length==1的特殊情况）来解决问题

评论中提到的另一个问题是：您需要迭代到length/2 ，而不是最多length，否则你就会压倒自己。

最后 - 标志错误。

if(a[i]>a[k])

应该是

if(a[i]<a[k])

请记住 - 如果第一个元素小于第二个元素，则尝试交换元素，以便将较大的元素推送到数组的头部。

Answer 2

但我真的不明白......我很难“想象”这里发生了什么......但它并不总是有效......（虽然有时候）。

在这种情况下，您应该使用调试器来逐步执行代码，以了解每行代码的作用。

我要做的是：

public static int maxOfArray(int[] a) {
    int max = a[0];
    for (int i : a)
        if (max < i)
            max = i;
    return max;
}

public static int findMaxTheHardWay(int[] array) {
    for (int length = array.length; length > 1; length = (length + 1) / 2) {
        for (int i = 0; i < length / 2; i++) {
            if (array[i] < array[length - i - 1])
                array[i] = array[length - i - 1]; // don't need to swap.
        }
    }
    return array[0];
}

public static void main(String... args) {
    Random rand = new Random(1);
    for (int i = 1; i <= 1000; i++) {
        int[] a = new int[i];
        for (int j = 0; j < i; j++) a[j] = rand.nextInt();
        int max = maxOfArray(a);
        int max2 = findMaxTheHardWay(a);
        if (max != max2)
            throw new AssertionError(i + ": " + max + " != " + max2);
    }
}

Answer 3

这是解决问题的一种疯狂方式，但我会一直玩。

问题在于内循环。

你从i = 0开始，k =长度 - 1。
如果a [i]＆gt; a [k]你交换它们。
...
你最终得到k = 0和i = length - 1
如果a [i]＆gt; a [k]你交换它们。

如果仔细观察，你会注意到如果我们在第一次交换中交换了元素，我们也会在最后一次交换中交换它们;即我们将取消第一次掉期的影响。这同样适用于整个数组切片。

请参阅？

你需要做的是停止内循环...然后考虑length奇数的情况。

顺便说一句，我之所以称之为“相当疯狂”，是因为明显而简单的方法要快得多：O(N)与O(NlogN)

Answer 4

int a[] = {1,7,3};   
List<Integer> list = Arrays.asList(a);  
Integer largest = Collections.max(list);

这将为您提供Array中最大的数字。

Answer 5

这是一个符合您想要的规格的解决方案（与此处的许多其他规格，humm，humm不同）：

    final Integer[] input = {1, 2, 6, 32, 4, 44 ,12, 42, 3, 7, 17, 22, 57, 23, 102, 103 };

    int half = (input.length / 2);
    int mod = input.length % 2;
    while (half >= 0) {
        for (int i = 0, j = (half * 2) + mod - 1; i <= half && j >= half; i++, j--) {
            if (input[i] < input[j]) {
                final int tmp = input[i];
                input[i] = input[j];
                input[j] = tmp;
            }
        }
        if (half == 0) break;
        half = half / 2;
        mod = half % 2;
    }
    //Here, input[0] = the biggest number in the original input.

编辑：添加了mod，如果最后一个元素是最大的那么它可以工作..

Answer 6

我认为你的代码正常工作，你只需要在奇数数组的情况下将长度/ 2调整，但我的测试会返回正确的结果：

package org.devince.largestinteger;

import java.util.NoSuchElementException;

public class LargestInteger {
    final static int[] input = {1, 2, 6, 32, 4, 44 ,12, 42, 3, 7, 17, 22, 57, 23, 102, 103 };
//  final static int[] input = { 8, 1, 5, 4, 9, 4, 3, 7, 2 };
//  final static int[] input = {1,3,7};

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(String.valueOf(maxOfArray(input)));
    }

    public static int maxOfArray(int[] a)
    {
        int length = a.length;

        if(length<1)
            throw new NoSuchElementException("Not at least one integer in array");

        while (length > 1)
        {
            int k = length;

            for(int i = 0; i < length; i++)
            {
                k--;

                if(a[i]>a[k])
                {
                    int j = a[i];
                    a[i] = a[k];
                    a[k] = j;
                }
            }
            length = (int) Math.ceil(length / 2f);
        }
        return a[0];
    }

}

Answer 7

为什么不将数组的第一个值存储到变量max。

之后只需从第二个位置开始循环到最后一个位置，在循环中只检查当前值是否大于max。如果它更大，只需指定max该值。

返回max，您的号码最多。

public int FindLargest()
{
    int[] num = { 1, 2, 5, 12, 13, 56, 16, 4 };
    int max = num[0];

    for (int i = 1; i <num.length; i++)
    {
        if (num[i] > max)
        {
            max = num[i];
        }
    }

    return max;
}

Answer 8

同样你也可以这样做，

int length = a.length;
   while (length > 1)
    {
        int k = length;
        for(int i = 0; i < length; i++)
        { 
            for(int y = k-1; y >= i; y--) 
            {         
                if(a[i]<a[y])
                {
                    int j = a[i];
                    a[i] = a[y];
                    a[y] = j;               
                }
            }       
        }
        length /=2;
    }

Answer 9

         final int validSampleRates[] = new int[]{
                    5644800, 2822400, 352800, 192000, 176400, 96000,
                    88200, 50400, 50000, 4800,47250, 44100, 44056, 37800, 32000, 22050, 16000, 11025, 4800, 8000};
          ArrayList <Integer> YourArray = new ArrayList <Integer> ():
 for (int smaple : validSampleRates){

                    YourArray.add(smaple);
                }
            Integer largest = Collections.max(YourArray);
            System.out.println("Largest   " + String.valueOf(largest));

最好的方法是使用扩展List Collection的Array作为ArrayList

查找数组中最大整数的算法

9 个答案: