已排序？ 检查数组是否在 Java 中按升序或降序排序

Question

can someone help me check my codes if are right or help me know if there is any other is way to solve this question I was trying to check if an array is in ascending or descending order then return 1 if not then return 0; at first I created some method for sorting array in increasing order and order and another method for decreasing and then I used those method to compare with the original array if it is sorted. I used the code below:

public class IsSorted {

public static void main(String[] args){
    int[] list ={4,3,2,1};
    System.out.println(isSorted(list));

}

public static int isSorted(int[] a){

    if(a.length==0){
        return 1;
    }
    if(a.length==1){
        return 1;
    }

    int[] holdingArray=new int[a.length];

    for (int i =0; i<a.length; i++){
        holdingArray[i]=a[i];
    }


    int[] virtualIncreasedArray= new int[holdingArray.length];
    int[] virtualDecreasedArray= new int[holdingArray.length];
    sortIncrease(holdingArray);

    for(int i=0; i<holdingArray.length;i++){
        virtualIncreasedArray[i]=holdingArray[i];
    }
    sortDecrease(holdingArray);

    for(int i=0; i<holdingArray.length;i++){
        virtualDecreasedArray[i]=holdingArray[i];
    }

    //check if array is decreasing
    for(int i=0; i<virtualDecreasedArray.length;i++){
        if(virtualDecreasedArray[i]!=a[i]&&virtualIncreasedArray[i]!=a[i]){
            return 0;
        }

    }
    //check if array is increasing


    return 1;
}


static void sortIncrease(int[] a){
    for(int unsorted=a.length-1; unsorted>0; unsorted--){
        for(int i=0; i<unsorted;i++){
            if(a[i]>a[i+1]){
                swap(a,i,i+1);
            }
        }
    }
}


static void sortDecrease(int[] a){
    for(int unsorted=a.length-1; unsorted>0; unsorted--){
        for(int i=0; i<unsorted; i++){
            if(a[i]<a[i+1]){
                swap(a,i,i+1);
            }
        }
    }
}

static void swap(int[] a, int i, int j){
    if(i==j){
        return;
    }
    int temp = a[i];
    a[i]=a[j];
    a[j]=temp;
}

}

Answer 1

For an accurate verification, the following should be done as there are important side cases to consider.

• Checking if any list starts out with some number of equal values.
• Determine the starting index where the values first differ.
• If all the values are equal, return true immediately.
• Note that in the worst case when all the values are equal, the entire array needs to be checked (sans the last value since then it could be either ascending or descending).

int[] sortedAscending = { 1, 1, 3, 4, 7, 10, 11, 15, 15 };
int[] sortedDescending = { 22, 22, 12, 8, 8, 8, 5, 2, 1 };
int[] sortedBoth = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
int[] unsorted = { 2, 1, 2, 19, 19, 2, 4 };

System.out.println(isSorted(sortedAscending));
System.out.println(isSorted(sortedDescending));
System.out.println(isSorted(sortedBoth));
System.out.println(isSorted(unsorted));

Prints

true
true
true
false

The check method.

    
public static boolean isSorted(int[] arr) {
    
    int start = 0;
    // if the lists start with equal values, need to 
    // determine a starting point.
    while (arr[start] == arr[start+1]
            && start++ < arr.length - 2);
    if (start >= arr.length - 2) {
        // all but the last the same value, its sorted 
        return true;
    }
    boolean asc = arr[start] < arr[start + 1];
    for (int i = start; i < arr.length - 1; i++) {
        if (asc) {
            //check ascending
            if (arr[i] > arr[i + 1]) {
                return false;
            }
            // check descending
        } else if (arr[i] < arr[i + 1]) {
            return false;
        }
    }
    return true;
}

Answer 2

Since you asked for another way to do this, here is a different approach.

What you could do is:

• Determine whether the array is (supposedly) sorted in ascending or descending order based on the first 2 elements (if these exist)
• Consider equal values when determining the supposed sorting (thanks for pointing that out @WJS)
• Then, check the rest of the array for the correct order, based on what was determined

Updated Example:

public static void main(String[] args) {
    int[] sortedAsc = { 1, 2, 3, 4, 5 };
    int[] sortedDesc = { 5, 4, 2, 1 };
    int[] unsortedArray = { 1, 8, 2, 4 };
    int[] allEqual = { 3, 3, 3, 3, 3 };
    int[] firstEqual = { 2, 2, 3, 2 };

    System.out.println(isSorted(sortedAsc));
    System.out.println(isSorted(sortedDesc));
    System.out.println(isSorted(unsortedArray));
    System.out.println(isSorted(allEqual));
    System.out.println(isSorted(firstEqual));
}

public static boolean isSorted(int[] arr) {
    boolean isAscending = false;

    if (arr.length < 2) { // if the array has less than 2 elements, must be sorted
        return true;
    }

    if (arr[0] < arr[1]) { // do we think this array is sorted ascending?
        isAscending = true;
    } else {
        int index = 0;
        while (arr[index] == arr[index + 1] && index++ < arr.length - 2) {
            // keep checking for sorting if array consists of equal values
            if (index >= arr.length - 2) {
                return true; // whole array consists of equal values
            }
        }
        // now that equal values were skipped, check for sorting again
        isAscending = arr[index] < arr[index + 1]; 
    }

    // check all elements of the array
    for (int i = 0; i < arr.length - 1; i++) {
        if (isAscending) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        } else {
            if (arr[i] < arr[i + 1]) {
                return false;
            }
        }
    }
    return true;
}

Output:

true
true
false
true
false

Sidenotes for your code:

• Instead of returning an int (0, 1), your isSorted() method should definitely return boolean .
• There is no point in the holdingArray .