Question

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，但我的输出总是为真。 / p>

Answer 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中的数组是基于零的。

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

}

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

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

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

4 个答案: