Java a[我]； a[i]=a[k]； a[k]=j； } } 长度=（int）Math.ceil（长度/2f）； } 返回[0]； } }

同样的u也可以接近

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;
    }

int length=a.length；
而（长度>1）
{
int k=长度；
for（int i=0；i=i；y--）
{         
如果（a[i]
final int validSampleRates[]=新int[]{
5644800, 2822400, 352800, 192000, 176400, 96000,
88200, 50400, 50000, 4800,47250, 44100, 44056, 37800, 32000, 22050, 16000, 11025, 4800, 8000};
ArrayList YourArray=新的ArrayList（）：
适用于（国际标准示例：有效安培拉）{
添加（smaple）；
}
整数最大=Collections.max（数组）；
System.out.println（“最大”+字符串.valueOf（最大））；

最好的方法是使用扩展列表集合的数组作为ArrayList
你能详细解释一下为什么你要尝试这样一种复杂的方法，其中线性扫描就可以做到这一点吗？这是HW吗？来自一本书的例子？采访？这可能会帮助我们给你更集中的答案。“[…]然后他们交换位置”-看起来OP实际上想要以气泡排序的方式对数组进行排序。请添加测验标签！@amit好的，是的。这是一个小的学校项目。我可以用其他方法看到很多答案，但要求比较第一个和最后一个，如果最后一个更大，则交换位置-然后继续向数组的中间移动最大的不是放在索引0中，而是放在数组的“左侧”，因此在时机成熟时将其放在索引0中。最大的并不总是在前半部分。假设您的数组是[1,5,3]，那么您首先比较（1>3），然后比较（5>5），最后比较（3>1）。您现在有了[3,5,1]将长度除以2，得到数组[3]。丢失了5。此外，如果切换比较，则不必扫描整个数组，只需扫描一半。现在，首先将大数字移到上半部分，然后再移回下半部分。因此
for（int i=0；i
是错误的，您只需要迭代数组的前半部分：
for（int i=0；i
。还要检查数组大小为奇数时会发生什么。这并不能回答OPs问题。
我希望此方法工作的方式是……
@amit添加了一个解决方案，以艰难的方式找到最大值。；（1）它没有回答OPs问题。
我希望这个方法的工作方式是……
（2）它不是java（
长度
字段）.C#Isuspect@amit好吧，它没有回答OPs问题，但提供了一个可行的替代方案。为什么不呢？@amit
num.length
完全正确，请检查一个SO示例。@f_puras添加此注释时它是
num.length
）@freebird
num.length
正确，
num.length
不正确。为什么要将其更改回去？谢谢你，我现在意识到奇数长度会破坏这一点，但是，我正在用不同的数组测试我的方法，其中一些有效，并且（到目前为止）失败的是偶数长度数组={6,15,2,5,8,14,10,16,11,17,13,7,1,18,3,4,9,12}在索引0处设置17，即使18更大。@StianF:我相信f_puras的评论也是正确的。除了我在这里提到的内容之外，你应该迭代到
length/2
。@StianF:给你-if条件符号也错了。我编辑了答案以反映它。@StianF:你解决了奇怪的数组长度问题吗？可能是这样偶数长度数组偶数出现，因为您不断地划分问题（例如，长度=18，第二次迭代的长度=9），所以您可以通过以下方法解决它：
length=（int）Math.ceil（（double）length/2）
修改
长度
。谢谢！但是，仍然有一些错误。可能是我愚蠢的代码中的其他东西，但是我现在已经在
iYea的中途停止了循环，如果你将大量数字拖到左边，你给出的比较符号是错误的代码中的lem是，尝试添加traceprints或使用调试器运行它。我们找到了答案。amit是对的。问题是我没有考虑奇数长度数组。我愚蠢地选择不这样做，因为我在使用偶数长度数组时得到了错误的输出，但由于该数组的长度是
18
，因此它将具有奇数l英语
9
在第二轮。顺便问一下，我如何计算出0（NlogN）的东西？它在英语中叫什么？@Stainf-在英语中，它被称为“复杂性分析”，即“大O”或“Landau”符号。等他们教给你，或者在维基百科上查找：-）
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);
    }
}

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;
}

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

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

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

    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.

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];
    }

}

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;
    }

         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));