JAVA学习日记(15)——排序

1.概念

1.1 排序

排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作

平时的上下文中，如果提到排序，通常指的是排升序（非降序）

通常意义上的排序，都是指的原地排序(in place sort)

1.2 稳定性(重要)

两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法

例如上面就是一个稳定的排序

2.七种基于比较的排序 - 总览

3. 插入排序

3.1 直接插入排序

整个区间被分为

1. 有序区间
2. 无序区间

每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

例如数组{10，7，3，6，8}，我们让 i 从1号下标开始，j 每次从 i-1 位置开始，每次让 i 下标所对应的值保存到 tmp 中，然后让 j 向前遍历，直到找到比 tmp 中值大的，然后让 j 位置的值给 j+1 位置，依次循环，直到找到小的或者遍历结束，再把tmp的值给 j+1 位置，因此，【0，j】就是已排序区间，【i，length-1】就是待排序区间

3.2 实现

代码示例：

//插入排序
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i-1;
            for (; j >= 0; j--) {
   
                if (arr[j] > tmp) {
                    arr[j+1] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+1] = tmp;
        }
    }

结果演示

[3, 6, 7, 8, 10]

3.3 性能分析

时间复杂度：

1. 最好：O(N) 数组中的数据是有序的
2. 最坏：O(N^2) 数组中的数据是无序的

空间复杂度： O(1)

稳定性： 稳定

特点：插入排序，初始数据越接近有序时，时间效率越高

3.4 折半插入排序(了解)

在有序区间选择数据应该插入的位置时，因为区间的有序性，可以利用折半查找的思想，即在有序区间使用二分查找

代码示例：

public static void bsInsertSort(int[] array) {
    for (int i = 1; i < array.length; i++) {
        int v = array[i];
        int left = 0;
        int right = i;
        // [left, right)
        // 需要考虑稳定性
        while (left < right) {
            int m = (left + right) / 2;
            if (v >= array[m]) {
                left = m + 1;
           } else {
                right = m;
           }
       }
        // 搬移
        for (int j = i; j > left; j--) {
   
            array[j] = array[j - 1];
       }
         	array[left] = v;
   }
}

4. 希尔排序

4.1 原理

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作，当到达=1时，所有记录在统一组内排好序

1. 希尔排序是对直接插入排序的优化
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果，我们实现后可以进行性能测试的对比

例如上边数组，我们第一次5个一组，然后插入排序得到一个结果 (只不过插入排序 j 的移动和组的大小有关，i 的初值也和组的大小有关) ，然后再分3个一组，再插入排序又得到一个结果，最后我们再进行最后一次插入排序，就能将上面数组进行排序

4.2 实现

代码示例：

//希尔排序
    public static void shellSort(int[] arr,int gap) {
        for (int i = gap; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i-gap;
            for (; j >= 0; j-=gap) {
                if (arr[j] > tmp) {
                    arr[j+gap] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+gap] = tmp;
        }
    }
    //增量值
    public static void shellSort(int[] arr) {
        int[] count = {
  5,3,1};
        for (int i = 0; i < count.length; i++) {
            shellSort(arr,count[i]);
        }
    }

结果演示

[0, 4, 5, 6, 7, 8, 9, 12, 22, 33, 34, 55, 56, 77, 89]

4.3 性能分析

时间复杂度：

O(N^1.3) - O(N^1.5) 具体和增量值有关

空间复杂度： O(1)

稳定性： 不稳定 因为每次都是跳跃式交换

5.选择排序

5.1 直接选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完



让 i 从0开始，j 从 i+1 开始，j 向后遍历，每次只要找到比 i 小的值就交换，然后一次遍历结束后 i 的值向后加1，再次循环，直到有序

5.2 实现

代码示例：

//选择排序
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;