08-Little prince's trip to Java-数组排序

常用的排序方法有以下几种：

• 1> 冒泡排序
• 2> 选择排序
• 3> 插入排序
• 4> shell排序（希尔排序）

1.冒泡排序

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定性：稳定

执行过程如下：

第一次循环过程如下：

   如图：执行完第一次循环最大值 9 被换到了最后一位，剩余循环同第一次循环依次将较大值换到相应位置。

完整代码：

public class TestArray_BubbleSort {
    public static void bubbleSort(int [] array) {
        int temp = 0;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int [] array = {6,4,8,2,3,9,1,7,5};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

运行结果：

冒泡排序的优化

• 时间复杂度: O(n)

  定义一个计数器count，如果是一个有序数组进行第一次for循环之后进行判断count的真假。count为假，则跳出循环。

public class TestArray_BubbleSort {
    public static void bubbleSort(int [] array) {
        boolean count = false;
        int temp = 0;
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    count = true;
                }
                if (!count ) {//加上该语句后冒泡排序的时间复杂度变为O(n)
                    break;
                }
            }
        }
    }
    public static void main(String[] args) {
        int [] array = {1,2,3,4,5,6,7,8,9};
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

2.选择性排序

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
• 稳定性：不稳定

执行过程如下：

第一次循环过程如下：

完整代码：

public class TestSortDemo {

    public static void selectSort(int [] array) {
        int temp = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[i] > array[j]) {
                    temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int [] array = {12,4,3,6,1,7};
        selectSort(array);
        System.out.println(Arrays.toString(array));
    }
}

运行结果：

3.直接插入排序

• 时间复杂度：
    1> 无序：O(n^2)
    2> 有序：O(n)------越有序越快

执行过程：

执行一次循环过程：

  第一次循环较短不明显故此处列举第二次循环过程：

完整代码：

public class TestSortDemo {
    public static void insertSort(int [] array) {
        int temp = 0;
        for (int i = 1; i < array.length; i++) {
            temp = array[i];
            int j = 0;
            for (j = i - 1; j >= 0; j--) {
                if (array[j] > temp) {
                    array[j + 1] = array[j];
                }else {
                    break;
                }
            }
            array[j + 1] = temp;
        }
    }
    public static void main(String[] args) {
        int [] array = {12,4,3,6,1,7};
        insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}

运行结果：

4.shell排序

• 稳定性：不稳定
• 采用分组思想，组内进行插入排序最后分为一组进行直接插入排序（越有序越快，此时大数字基本都在数组末尾）

注：因为shell排序用到了直接插入排序如果不注意条件，可能代码也可运行而且结果正确。

完整代码：

public class TestDemoShell {
    public static void shellSort(int [] array) {
        int drr[] = {5,3,1};
        for (int i = 0; i < drr.length; i++) {
            shell(array,drr[i]);
        }
    }
    public static void shell(int [] array, int gap) {
        for (int i = gap; i < array.length; i++) {
            int temp = array[i];
            int j = 0;
            for (j = i - gap; j >= 0; j-=gap) {
                if (array[j] > temp) {
                    array[j + gap] = array[j];
                }else {
                    break;
                }
            }
            array[j + gap] = temp;
        }
    }
    public static void main(String[] args) {
        int [] array = {7,4,9,34,0,8,5,22,55,6,12,33,56,89,77};
        shellSort(array);
        System.out.println(Arrays.toString(array));
    }
}

运行结果：