如果数组不是降序或升序，为什么我的代码不会返回 false？答案

【问题标题】：why will my code not return false if the array is not descending or ascending order?如果数组不是降序或升序，为什么我的代码不会返回 false？
【发布时间】：2015-03-12 15:30:00
【问题描述】：

public class SmallestLargest {

    public static void main(String[] args) {
        int [] arr = {3,6,2,1,23,6,7,54,3,2};
        System.out.println(isIncreasing(arr));

    }
    public static boolean isIncreasing(int[]arr)
    {
        for(int i=1; i<arr.length;i++)
        {
            if(arr[i] > arr[i+1] || arr[i] < arr[i+1] )
                return true;
        }
        return false;
     }

    }

所以如果数组是 int[] arr = {1,2,3} 它应该返回 true，如果它的降序它也应该是 true 其他任何东西它应该返回 false，但我的输出总是 true。

【问题讨论】：

因为在您第一次检查时您返回 true，它没有到达循环的末尾以返回 false。
arr[0] 呢？！？你的 for 循环从 1 开始......你也会在某个时候遇到 arr[i+1] 的越界

标签： java

【解决方案1】：

如果您要检查您的数组是否正在发送，您必须更改您的检查：

public class SmallestLargest {

    public static void main(String[] args) {
        int [] arr = {3,6,2,1,23,6,7,54,3,2};
        System.out.println(isIncreasing(arr));

    }
    public static boolean isIncreasing(int[]arr)
    {
        for(int i=0; i<arr.length-1;i++)
        {
            if( arr[i] > arr[i+1] )
                return false;
        }
        return true;
     }

    }

你的循环必须结束at arr.length-1 如果没有，你会得到一个ArrayIndexOutOfBoundsException。

而且你必须从 0 开始，因为 Java 中的数组是从零开始的。

【讨论】：

【解决方案2】：

问题在于，只要您有一个值小于另一个值，您的代码就会返回 true。您的代码应如下所示。

public class SmallestLargest {

public static void main(String[] args) {
    int [] arr = {3,6,2,1,23,6,7,54,3,2};
    System.out.println(isIncreasing(arr));

}
public static boolean isIncreasing(int[]arr)
{
    for(int i=0; i<arr.length - 1;i++)
    {
        if(arr[i] > arr[i+1]){
            return false;
        }
    }
    return true;
 }

}

【讨论】：

我的回答不像 jens 的回答。条件检查与他的相反。
{3,6,2,1,23,6,7,54,3,2} 比较 3 2 返回 false。如果它们都是
为什么要从array.length中减去一个？
假设我们有 9 个元素，当我到达第 9 个元素时，我不希望将它与不存在的第 10 个元素进行比较。它会给我一个 ArrayIndexOutOfBoundsException。

【解决方案3】：

如果数组已排序 - 升序或降序，这将返回 true。它还可以处理数组的平坦部分，其中所有条目都是平坦的，有一个条目，没有条目。

空数组是否排序值得商榷。

public enum Direction {

    Descending {

                @Override
                boolean is(int a, int b) {
                    return b <= a;
                }
            },
    Ascending {
                @Override
                boolean is(int a, int b) {
                    return a <= b;
                }
            };

    abstract boolean is(int a, int b);
}

public static boolean isSorted(int[] n) {
    // All possible directions.
    Set<Direction> possibles = EnumSet.<Direction>allOf(Direction.class);
    for (int i = 0; i < n.length - 1 && possibles.size() > 0; i++) {
        // Check all currently possible directions.
        for (Iterator<Direction> it = possibles.iterator(); it.hasNext();) {
            Direction d = it.next();
            if (!d.is(n[i], n[i + 1])) {
                // Not in that direction.
                it.remove();
            }
        }
    }
    return possibles.size() > 0;
}

public void test(int[] arr) {
    System.out.println(Arrays.toString(arr) + " is " + (!isSorted(arr) ? "not " : "") + "sorted");
}

public void test() {
    test(new int[]{3, 6, 2, 1, 23, 6, 7, 54, 3, 2});
    test(new int[]{3, 4, 5, 6, 7, 8, 9});
    test(new int[]{3, 4, 4, 4, 5, 6, 7, 9});
    test(new int[]{4, 4, 4, 4});
    test(new int[]{1});
    test(new int[]{});
    test(new int[]{100, 50, 25, 12, 6, 3, 1});
}

【讨论】：

创建枚举来决定排序顺序是不是有点矫枉过正？我会简单地创建两个单独的方法。
@RohitJain - 恕我直言，两种单独的方法效率会降低。把事情做好并不过分。这种机制将涵盖许多其他模式。
我什至没有在谈论效率，但是既然你已经开始了，我看不出两种方法的效率会降低多少。您仍然会检查您的数组两次 - 每次递增和递减顺序。你已经在做。谈到许多其他模式 - 我想说，早期泛化，就像早期优化是万恶之源。
@RohitJain - 我可能会执行两次比较，但我只遍历数组一次。

【解决方案4】：

试试这个：

boolean status=false;
public static boolean isIncreasing(int[]arr)
{
    for(int i=0; i<arr.length-1;i++)
    {
        if(arr[i] > arr[i+1] || arr[i] < arr[i+1] )
            status=true;
        else
            return false;
    }
    return true;
 }

【讨论】：