数据结构基础-排序算法整理

welcome to my blog

0. 笔记

不具备稳定性的排序： 选择排序、快速排序、堆排序. 例子{2,2,1}经选择排序后变成{1,2,2}
具备稳定性的排序： 冒泡排序、插入排序、归并排序、一切桶排序思想下的排序
目前没有找到时间复杂度O(NlogN)，额外空间复杂度O(1)，又稳定的排序

常见的坑
1，归并排序的额外空间复杂度可以变成O(1)，但是非常难，不需要掌握，有兴 趣可以搜“归并排序 内部缓存法”
2，“原地归并排序”的帖子都是垃圾，会让归并排序的时间复杂度变成O(N^2)
3，快速排序可以做到稳定性问题，但是非常难，不需要掌握， 可以搜“01 stable sort”
4，所有的改进都不重要，因为目前没有找到时间复杂度O(N*logN)，额外空间复 杂度O(1)，又稳定的排序。
5，有一道题目，是奇数放在数组左边，偶数放在数组右边，还要求原始的相对 次序不变，碰到这个问题，可以怼面试官。

1. 排序分类

根据能否将待排序的全部数据放入内存, 将排序分成内部排序和外部排序, 常见的排序指的是内部排序

根据排序过程中依据的原则, 可将内部排序分成:
|-- 插入排序: 直接插入排序; 希尔排序
|-- 交换排序: 冒泡排序; 快速排序
|-- 选择排序: 简单选择排序; 堆排序
|-- 归并排序: 二路归并排序

《算法》讲排序的顺序
|-- 初级排序: 选择排序; 插入排序; 希尔排序
|-- 归并排序
|-- 快速排序
|-- 堆排序

2. 选择排序

选择排序
外循环: 安排第0个位置, 安排第1个位置,安排第2个位置,…,安排第N-2个位置
外循环: [0,0]有序 [0,1]有序 [0,2]有序,…, [0,N-2]有序
外循环表示从什么范围上选出最小值: [0,N-1], [1,N-1], [2,N-1],…, [N-2, N-1]
对于每个范围, 拿出第一个元素作为临时最小值, 对于剩下的元素
通过内循环分别与最小值作比较, 该更新最小值的时候就进行更新

内循环结束后交换元素: 最小值和当前外循环范围的第一个元素交换

public static void selectionSort(int[] arr) {
   
    if (arr == null || arr.length < 2)
        return;
    int N = arr.length;
    for (int i = 0; i < N-1; i++) {
   
        int minIndex = i;
        for (int j = i + 1; j < N; j++) {
   
            if (arr[j] < arr[minIndex])
                minIndex = j;
        }
        swap(arr, i, minIndex); //注意和i交换
    }
}

(这已经简单到了极点):
1)选择最小的元素; 2)交换
两个特点:
1)运行时间和输入无关: 一个有序的数组和乱序的数组的排序时间是一样的! 因为不管有序无序,每次都得扫描待排序的所有元素, 也就是当前扫描一遍数组并不能为下一遍扫描提供什么信息, 这是个缺点, 其他排序算法会更善于利用输入的初始状态
2)数据移动是最少的: 每次扫描完一遍数组交换一次, N个元素一共交换N-1次. 交换次数和数组的大小是线性关系, 下面提到的所有排序算法都不具备这个特点(大部分的增长数量级都是线性对数或是平方级别)

3. 插入排序

插入排序
(就是抓扑克牌的样子; 当数组中逆序对较少时, 插入排序很可能比其他算法都快)
* 外循环: 安排索引为i的元素, 将arr[i]放到合适的位置(不一定是最终的位置), 使得arr[i] >= arr[i-1]
* 外循环: [0,1]有序 [0,2]有序 [0,3]有序,…, [0,N-1]有序
* 当N-1个元素都放在合适的位置之后, 整个数组也就有序了
* 内循环: 将arr[i]放到合适的位置

public static void insertionSort(int[] arr){
   
    if(arr==null || arr.length<2)
        return;//不对数组做操作
    int N = arr.length;
    for(int i=1; i<N; i++){
   
        for(int j=i; j>0 && arr[j] < arr[j-1]; j--){
   
            swap(arr, j, j-1);
        }
    }
}

为了给要插入的元素腾出空间, 我们需要将其余的所有元素在插入之前都向右移动一位
和选择排序相同的地方: 当前索引左边的所有元素都是有序的,但它们的最终位置还不确定, 为了给更小的元素腾出空间, 它们可能还会被移动. 当索引达到数组的右端时,数组排序就完成了
和选择排序不同的地方: 插入排序所需的时间取决于输入中元素的初始顺序. 例如,对于一个很大的且其中的元素已经有序(或接近有序)的数组进行排序将会比对随机顺序的数组或是逆序数组进行排序快得多

改进的插入排序
//改进版的插入排序,数组访问次数减半
//不再交换元素,因为交换一次需要访问两次数组(三次?)
//将交换替换为移动: 把大的元素向右移动

public static void insertionSortWithoutxchanges(int[] arr){
   
    Stopwatch timer = new Stopwatch();
    if(arr==null || arr.length<2)
        return;
    int N = arr.length;
    for(int i=1; i<N; i++){
   
        int temp = arr[i];
        int j;
        for(j = i; j>0 && arr[j-1] > temp; j--){
   
            arr[j] = arr[j-1];//大的元素右移
        }
        arr[j] = temp;
    }
}

4. 希尔排序

希尔排序
改进的插入排序, 将数组分成h组, 目的是增大每个元素的移动距离, 从而减少移动元素的次数

public static void shellSort(int[] arr){
   
    if(arr==null || arr.length <2)
        return;
    int N = arr.length;
    int h = 1;
    while(h < N/3)
        h = 3*h + 1;
    while(h>=1){
   
        //将数组变成h有序
        for(int i=h; i<N; i++){
   //因为要和当前元素"之前h距离"的元素相比, 所以第一个元素从h开始, 其之前的元素是0
            for(int j=i; j>=h && arr[j] < arr[j-h]; j -= h){
    //子数组进行排序,h个子数组依次实现:前2两个元素有序, 前3个元素有序,..., 前h个元素有序
                swap(arr, j, j-h);
            }
        }
        h = h/3; //减小增量
    }
}

5. 冒泡排序

冒泡排序
*外循环:[N-1,N-1]有序, [N-2,N-1]有序, [N-3,N-1]有序,…,[2,N-1]有序, [1,N-1]有序
*外循环:将arr[i]放到正确的位置上
*内循环:将内循环范围中的最大值放到待排序元素的最后

public static void bubbleSort(int[] arr){
   
    if(arr==null || arr.length<2)
        return;
    int N = arr.length;
    //外循环:安排i
    for(int i=N-1; i>0; i--){
   
        for(int j=0; j<i; j++){
   
            if(arr[j] > arr[j+1])
                swap(arr, j, j+1);
        }
    }
}

6. 归并排序

归并排序
细节
|-- 如果不判断数组arr.length==0的情况,会导致栈溢出
|-- 注意辅助数组的长度
|-- 注意while的循环条件
|-- 归并过程可以浓缩成一句话 aux[i++] = arr[p1]<arr[p2] ? arr[p1++]:arr[p2++];
|-- 注意aux==>arr过程中,arr的起始索引

public static void mergeSort(int[] arr){
   
    if(arr==null || arr.length < 2) return; //细节:arr.length==0时如果不加判断, 会导致栈溢出! 一直递归调用left=0, right=-1, mid=-1的情况