检查数组的有序性--数组的排序--数组的逆序

检查数组的有序性

给定一个整形数组，判断是否该数组是有序的（升序）

public static void main(String[] args) {
    int[] array = {1,2,4,3,5};
    int[] array2 = {};
    int[] array3 = {1,1,1,1,1,1};
    System.out.println(isSorted(array));
    System.out.println(isSorted(array2));
    System.out.println(isSorted(array3));
    int[] array4 = null;
    System.out.println(isSorted(array4));
}
public static boolean isSorted(int[] array){
    if(array == null || array.length == 0){
        return false;
    }
    for (int i = 0; i < array.length-1; i++) {
        if(array[i] > array[i+1]){
            return false;
        }
    }
    return true;
}

冒泡排序（从大到小排序）

思想：设置一个下标j，让array[j]>和array[j+1]进行比较，array[j]>array[j+1]，两个就换换，一直到array.length-1，j++,依次进行下去，第一趟冒泡排序，最大的那个数字就有序了
然后j=0,一直到array.length-2，第二趟冒泡排序

第三趟冒泡排序
第四趟冒泡排序

总共五个数据，进行了四趟冒泡排序，每趟都比上一趟少一次比较

public static void main(String[] args) {
    int[] array = {2,5,7,9,1,4,8,3,2};
    System.out.println(Arrays.toString(array));
    bubbleSort2(array);
    System.out.println(Arrays.toString(array));
}


public static void bubbleSort2(int[] array){
    for (int i = 1; i < array.length-1; i++) {
        for (int j = 0; j < array.length-i; j++) {
            if(array[j]>array[j+1]){
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
            }
        }
    }
}

如果array={1,2,3,4,5}，如果一遍一遍的比较，是很浪费时间的，因为他本身就是已经是有序的了，所以我们可以提前判断一下数组是否已经是有序的了，如果有序了，就停止。下面进行优化

public static void bubbleSort2(int[] array){
    long start = System.currentTimeMillis();
    for (int i = 1; i < array.length-1; i++) {
        int count = 0;
        for (int j = 0; j < array.length-i; j++) {
            if(array[j]>array[j+1]){
                int tmp = array[j];
                array[j] = array[j+1];
                array[j+1] = tmp;
                count++;
            }
            if (count == 0){
                break;
            }
        }
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start);
}

这里面的long start = System.currentTimeMillis();和long end = System.currentTimeMillis();表示的是开始和结束的时间，这里可以计算运行的时间

数组的逆序

给定一个数组，将里面的元素逆序排列。

public static void reverse(int[] array){
    for (int j = 0; j <array.length-1 ; j++) {
        if(array.length-j-1 != j) {
            int tmp = array[array.length-1-j];
            array[array.length-1-j] = array[j];
            array[j] = tmp;
        }else{
            break;
        }
    }
}

public static void reverse2(int[] array){
    int i= 0;
    int j = array.length-1;
    while(i<=j){
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
        i++;
        j--;
    }
}

数组的排列

给定一个整形数组，将所有的偶数放在前半部分，将所有的奇数放在数组的后半部分
例如{1,2,3,4} 调整后得到{4,2,3,1}

public static void sort(int[] array){
    int i = 0;
    int j = array.length-1;
    while (i<j) {
        if (array[i] % 2 == 1 || array[j] % 2 == 0) {
            int tmp = array[i];
            array[i] = array[j];
            array[j] = tmp;
            i++;
            j--;
        }
        if (array[i] % 2 == 0) {
            i++;
        }
        if (array[j] % 2 == 1) {
            j--;
        }
    }
}