数据结构内排序之惨死攻略（一）

刺骨的言语ヽ痛彻心扉 2022-05-12 16:30 177阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70][]

**目录**

1 基本定义

2 插入排序

2.1 直接插入排序（Straight Insertion Sort）

2.1.1 栗子

2.1.2 代码实现

2.1.3 算法分析

2.2 Shell排序

2.2.1 栗子——增量每次除以2递减

2.2.2 代码实现

2.2.3 算法分析

2.2.4 增量选择

3 选择排序

3.1 直接选择排序

3.1.1 栗子

3.1.2 代码实现

3.1.3 算法分析

3.2 堆排序

3.2.1 栗子

3.2.2代码实现

3.2.3 算法分析

4 交换排序

4.1 冒泡排序

4.1.1 栗子

4.1.2 代码实现

4.1.3 算法实现

4.2 快速排序

4.2.1 轴值的选择（核心）

4.2.2 栗子

4.2.3 代码实现

4.2.4 算法分析

--------------------

# 1 基本定义 #

**内排序：**整个排序过程在内存中完成

**排序的稳定性**

*  存在多个具有相同排序码的记录
 *  排序后这些记录的相对次序保持不变

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1][]

**排序算法的时间代价：**记录的比较和移动次数

# 2 插入排序 #

[《插入排序之舞》][Link 1]

## 2.1 直接插入排序（Straight Insertion Sort） ##

发扑克牌的时候我喜欢一边摸牌，一边理牌。这个过程就类似于直接插入排序。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2][]

**基本操作：**将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录数+1的有序表。

### **2.1.1 栗子** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3][]

本来有牌45

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4][]

抽到了一张34，放45的前面

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5][]

抽到了一张78，放45的后面

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6][]

抽到了一张12，依次跟78,45,34比较，最后放在45的前面

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7][]

其他同理

### **2.1.2 代码实现** ###

template<class Record>
    void ImprovedInsertSort(Record Array[], int n){//Array为待排数组，n为数组长度
        Record TempRecord;    //临时变量
        //将待排元素一个个取出，存到临时变量里
        for(int i=1; i<n; i++){
            TempRecord = Array[i];
            //记录i往前与序列中的元素比较
            int j = i - 1;
            //将大于等于记录i的记录后移(j=-1时，即原序列无元素，记录i为第一个元素)
            while（j >= 0 && (TempTecord < Array[j])）{
                Array[j+1] = Array[j];
                j = j - 1;
            }
            //此时j后面就是记录i的位置
            Array[j+1] = TempRecord
        }
    }

### 2.1.3 算法分析 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8][]

## 2.2 Shell排序 ##

[《希尔排序之舞》][Link 2]

**基于直接插入排序的两个性质**

1.  序列本身有序的情况下，时间代价为O(n)
2.  对于短排序，直接插入排序比较有效

**Shell排序算法思想**

1.  将序列转化为若干小序列，在这些小序列内进行插入排序
2.  逐渐壮大小序列的规模，减少序列个数，使待排序序列逐渐处于更有序的状态
3.  最后对全体记录进行一次直接插入排序

### **2.2.1 栗子——增量每次除以2递减** ###

选择增量为4的两个元素为一组（4 = 待排序列总数 / 2）

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 9][]

采用直接插入排序

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 12][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 14][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 15][]

选择增量为2的4个元素为一组，采用直接插入排序

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 16][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 17][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 18][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 19][]

最后一轮，增量为1，对全部记录进行一次直接插入排序

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 20][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 21][]

### **2.2.2 代码实现** ###

template<class Record>
    void ShellSort(Record Array[], int n){//Array[]为待排序数组，n为数组长度
        int i, delta;
        //增量delta每次除以2递减，直到delta=1
        for(delta = n/2; delta>0; delta /=2)
            for(i = 0; i<delta; i++)
                //分别对delta个子序列进行插入排序
                //&传Array[i]的地址，数组总长度为n-i
                //i=0,数组长为n,delta=n/2
                ModInsSort(&Array[i],n-i,delta);
                //如果增量序列不能保证最后一个delta间隔为1
                //可以安排下面这个扫尾性质的插入排序
                //ModInsSort(Array, n, 1)
    }

**针对增量而修改的插入排序算法**

template<class Record>
    void ModInsSort(Record Array[], int n, int delta){
        int i, j;
        //对子序列中第i个记录，寻找合适的插入位置
        //以下标为delta的记录开始处理，其前面的元素下标为0
        for(i = delta; i < n; i += delta)
            //j以delta为步长向前寻找逆序对进行调整
            for(j = i; j >= delta; j -= delta){
                if(Array[j] < Array[j-delta])//逆序对
                    swap(Array,j,j-delta);//交换
                else break;
            }
    }

### **2.2.3 算法分析** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 22][]

### **2.2.4 增量选择** ###

**（1）增量不互质**

![2018103017163038.png][]

选取的增量之间不互质，导致重复排序。如

45与34'第一轮在同一子序列里

![20181030172234416.png][]

第二轮还在同一子序列里

![20181030172346453.png][]

**（2）增量互质**

![20181030171945291.png][]

![20181030172749640.png][]

# 3 选择排序 #

[《选择排序之舞》][Link 3]

## 3.1 直接选择排序 ##

依次选出剩下的未排序的记录中的最小记录。

过程类似于打擂台。

### **3.1.1 栗子** ###

![20181031165206773.png][]

**第一回合**

第一个站在擂台上的是45,34去跟45打，34赢了。

78去跟34打，78输了，目前站在擂台的还是34。

12去跟34打，精彩，34输了，12领先。

34'去跟12打，输了。32去跟12打，输了。29去跟12打，输了。64去跟12打，还是输。

第一回合，获胜的是12！其他同理。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 23][]

### 3.1.2 代码实现 ###

template<class Record>
    void SelectSort(Record Array[], int n){
        //依次选出第i小的记录，即剩余记录中最小的那个
        for(int i=0; i<n-1; i++){
            //首先假设记录i就是最小的
            int smallest = i;
            //开始向后扫描所有剩余记录
            for(int j=i+1; j<n; j++)
                //如果发现更小的记录，记录它的位置
                if(Array[j] < Array[smallest])
                    smallest = i;
            swap(Array,i,smallest);//将smallest赋值给Array[i] 
        }
    }

### 3.1.3 算法分析 ###

![20181031172145873.png][]

## 3.2 堆排序 ##

基于最大堆来实现。而堆的本质是一棵用数组表示的完全二叉树。

### 3.2.1 栗子 ###

**（1）建立最大堆**

将已经存在的N个元素按最大堆的要求存放在一个一维数组中。

![20181031172601153.png][]

**（2）**找到最大值就将其删除。即将堆里的最后元素与堆顶元素交换

![20181031173534223.png][]

**（3）**最大值78出堆，堆的规模-1。剩余的元素从根开始调整。

![20181031173735877.png][]

### 3.2.2代码实现 ###

template<class Record>
    void sort(Record Array[], int n){
        int i;
        //建堆
        MaxHeap<Record> max_heap = MaxHeap<Record>(Array,n,n);
        //算法操作n-1次，最小元素不需要出堆
        for(i=0; i<n-1; i++)
            //依次找出剩余记录中的最大记录，即堆顶
            max_heap.RemoveMax();
    }

### 3.2.3 算法分析 ###

![20181031175156386.png][]

此外可以改写堆排序算法，发现逆序对直接交换。

# 4 交换排序 #

## 4.1 冒泡排序 ##

不断比较相邻的记录，不满足排序要求的就交换相邻记录，直到所有记录都已经排好序。

[《冒泡排序之舞》][Link 4]

### 4.1.1 栗子 ###

![20181101095613525.png][]

从最后开始。发现逆序对就交换。

![20181101095832708.png][]

发现逆序对32 29

![20181101095905155.png][]

交换位置

![20181101095948268.png][]

发现逆序对34’ 29

![20181101100105461.png][]

交换位置

![20181101100037818.png][]

......第一轮比较结束后，选出了最小元素12

![20181101100415584.png][]

直接选择排序中没有这么多次的交换，站在擂台上的数不一定是最小数。

### 4.1.2 代码实现 ###

template<class Record>
    void BubbleSort(Record Array[], int n){
        bool NoSwap;            //用来标识是否发生了交换
        int i, j;
        for(i = 0; i<n-1; i++){//比较n-1轮
            NoSwap = true;      //标识初始为true  
            for(j = n-1; j>i;j--){
                if(Array[j] < Array[j-1]){//判断是否为逆序对
                    swap(Array,j,j-1);//交换逆序对
                    NoSwap = false;        //发生了交换，标志为false
                }
            }
            if(NoSwap)        //这一轮的元素都是排好序的，没发生交换，直接退出冒泡排序
                return;       
        }
    }

### 4.1.3 算法实现 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 24][]

## 4.2 快速排序 ##

[《快速排序（Quicksort）学习笔记》][Quicksort]

快速排序是对冒泡排序的改进，它的元素间比较次数比较少，所以速度较快。

冒泡排序：比较和交换在两个相邻的元素间进行，每次交换只能使元素上移或下移一个位置，导致总的移动和比较次数比较多。

快速排序：元素之间的比较从两端向中间进行，值较大的元素一次就能交换到后面的某一位置上，值较小的元素一次也能交换到前面的某一位置上，元素移动的间隔距离较大，因此总的比较和移动次数较少。

### 4.2.1 快速排序的核心思想 ###

（1）选择轴点 pivot（核心）：在代排序列中任意选择一个元素作为分界元素

（2）将序列划分成两个子序列 L 和 R，使得 L 中所有记录都小于或等于 轴点，R 中记录都大于轴点，而所选的轴点在每一趟排序后都正好处在最终位置上

（3）对子序列 L 和 R 递归进行快速排序（L 的元素不用再和 R 的元素比较，各自比较内部的元素就行）

### 4.2.2 轴值的选择（核心） ###

**尽可能使得L，R长度相等**

（1）选择首元素或尾元素作为轴值（完全正序或完全逆序的输入就会比较糟糕）

> 第 1 趟排序经过 n-1 次比较后，第 1 个元素仍处在原来的位置上，并得到一个长度为 n-1 的子序列；
> 
> 第 2 趟排序经过 n-2 次比较后，第 2 个元素仍处在原来的位置上，并得到一个长度为 n-2 的子序列；
> 
> ......
> 
> 最终比较次数 = (n-1) + (n-2) + (n-3) + ... + 1 = n(n-1)/2，时间复杂度为 O(n^2)

（2）随机选择

（3）选择平均值

### 4.2.3 栗子 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 25][]

**一次的分割过程**

选择32作为轴值

![20181101151837996.png][]

然后把最右端的元素64填充进去，然后最右边的位置就空出来了

![20181101152132326.png][]

接着从左边开始看，将左边的元素25与轴值32做比较。

![2018110115252551.png][]

25<32,不是逆序元素，i继续往右走指向34,34>32,34填充到最右边的位置。此时左边空出了一个位置。

![20181101152754895.png][]

此时左边空出了一个位置。移动右边的j，从右边找一个逆序元素29填入左边的空位。

![20181101153005717.png][]

此时右边空出了一个位置。从左边找一个逆序元素45填入右边的空位。

![2018110115321049.png][]

风水轮流转，左边有空位了。继续移动右边的j，从右边找一个逆序元素12填入左边的空位

![20181101153318161.png][]

最终

![20181101153347995.png][]

**具体过程描述：**

*  选择轴值并存储轴值（上述例子取中间记录作为轴值）
 *  最后一个元素放到轴值位置
 *  初始化下标 i, j，分别指向头尾
 *  递增直到遇到比轴值大的元素，将此元素覆盖到 j 的位置；j 递减直到遇到比轴值小的元素，将此元素覆盖到 i 的位置
 *  重复上一步直到 i==j，将轴值放到 i 的位置，完毕

### 4.2.4 代码实现 ###

template<class Record>
    void QuickSort(Record Array[], int left, int right){
        //Array[]为待排序数组，left，right分别为数组两端
        if(right <= left)    //如果只有0个或1个记录，就不需要排序
            return;
        int pivot = SelectPivot(left,right);    //选择轴值
        swap(Array,pivot,right);                //轴值放到数组末端
        pivot = Partition(Array,left,right);    //分割后轴值正确
        QuickSort(Array,left,pivot-1);          //左子序列递归快排
        QuickSort(Array,pivot+1,right);         //右子序列递归快排
    }
    int SelectPivot(int left,int right){
        //选择轴值，参数left,right分别表示序列的左右端下标
        return(left+right)/2; //选中间记录作为轴值
    }

**分割函数**

template<class Record>
    int Partition(Record Array[],int left,int right){
        //分割函数，分割后轴值已到达正确位置
        int l = left;      //l为左指针
        int r = right;     //r为右指针
        Record TempRecord = Array[r];//保存轴值
        while(l != r){//l,r不断向中间移动，直到相遇
            //l指针向右移动，直到找到一个大于轴值的记录
            while(Array[l] <= TempRecord && r>l)
                l++;
            if(l<r)//未相遇，将逆置元素换到右边空位
                Array[r] = Array[l];
                r--;  //r指针向左移动一步
            //r指针向左移动，直到找到一个小于轴值的记录
            while(Array[r] >= TempRecord && r>l){
                r--;
            if(l < r){       //未相遇，将逆置元素换到左空位
                Array[l] = Array[r];
                l++;         //l指针向右移动一步
            }
        }//end while
        Array[l] = TempRecord;//将轴值回填到分界位置上
        return l;  //返回分界位置l
    }

### 4.2.5 算法分析 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 26][]

![20181101170738975.png][]

你们以为这就结束了？天真！

![20181101171356930.png][]

下面转至[《数据结构内排序之惨死攻略（二）》][Link 5]

--------------------

学习自：

张铭《数据结构》

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70]: /images/20220504/f2fd2981ab2e41eaa03f378fea4c7ef7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 1]: /images/20220504/51713dacf2d549ebb08febfd73cb393d.png
[Link 1]: http://t.cn/hros0W
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 2]: /images/20220504/c1629653429e43f4921f5c186c182447.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 3]: /images/20220504/a6bae6c6afa34313b8ece06c2ad65591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 4]: /images/20220504/0b9a9ac2f9d54deab3cc0097a70b8036.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 5]: /images/20220504/5cef9cb7ab0447e0825052f91066b76f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 6]: /images/20220504/1a9004c3ddfc4f0987c99aa6ec5c96bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 7]: /images/20220504/e76a0bd3d0a64bd895a0b97d15fe63f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 8]: /images/20220504/110794fbf38d4cbfb28fa6b75fb364da.png
[Link 2]: http://t.cn/hrosvb
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 9]: /images/20220504/3d54e054eacb4da7ba45558eaa715af9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 10]: /images/20220504/be8451fe609a46eb81bd5c1f1587cc9c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 11]: /images/20220504/d03eb6133a5d43b6b2195363b2528ab3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 12]: /images/20220504/f2525f1731a14861bf5beb7127abc326.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 13]: /images/20220504/e34b02cf321a48949de9eb554a6ad335.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 14]: /images/20220504/3c441cfa929c47a392870666ece35fa5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 15]: /images/20220504/a9b7d2ca019040c1acbc7de32508ac71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 16]: /images/20220504/7dfc0fd571d747079bf3712b16ab3ec9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 17]: /images/20220504/9f04b9911e644e5fb5d63f64d2b3e591.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 18]: /images/20220504/1dbe119ccb2045fc89e501f6a29d634d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 19]: /images/20220504/4143b5fa50864aec8cf61ab3e93e4e1f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 20]: /images/20220504/c53bcf6532684685b9534d7f45597c26.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 21]: /images/20220504/b776ea8b36694c8a80079bd5e1fb4a50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 22]: /images/20220504/a553697a85824a819114e991107a4a08.png
[2018103017163038.png]: /images/20220504/8fd6a0676694497e9ef4946c455afe00.png
[20181030172234416.png]: /images/20220504/d48369962ce54959ae24254838891b28.png
[20181030172346453.png]: /images/20220504/ba161bc73a1144d7ae6d40da48a690dd.png
[20181030171945291.png]: /images/20220504/3376a0aaa9664eb6b01508810173e13f.png
[20181030172749640.png]: /images/20220504/a3455e4ced9d426a8d3499a57e76285c.png
[Link 3]: http://t.cn/hros6e
[20181031165206773.png]: /images/20220504/82fa26c0058c43848603d33f701c02a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 23]: /images/20220504/67c7293795b84c438c1adc371ef9ee35.png
[20181031172145873.png]: /images/20220504/5e4bfe4d072342bb841787a898c293ed.png
[20181031172601153.png]: /images/20220504/73f9db2bcc7c49849d152462949736c8.png
[20181031173534223.png]: /images/20220504/979e9ad8a4684b79b6ed27310741218c.png
[20181031173735877.png]: /images/20220504/0b4269db262246c9b081826b7d77d13d.png
[20181031175156386.png]: /images/20220504/d1fe82937d17462b93be9a6ae936bb07.png
[Link 4]: http://v.youku.com/v_show/id_XMjU4MTg3MTU2.html
[20181101095613525.png]: /images/20220504/d5ca1e1dcb214eb6baa353c921fa0a63.png
[20181101095832708.png]: /images/20220504/1cde846fae8d4752abe3fc35e1ddbdc0.png
[20181101095905155.png]: /images/20220504/dbe7a57c65c74c42b4b6695c14615e85.png
[20181101095948268.png]: /images/20220504/6d7de5e3a50c43af99ea2ec3a51718f4.png
[20181101100105461.png]: /images/20220504/7cdda1e3f13b4ea88384008f044b5fd5.png
[20181101100037818.png]: /images/20220504/161733841570487dbc3bcc7b822ded1e.png
[20181101100415584.png]: /images/20220504/7a360d78679f4e9488c7bcf998615413.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 24]: /images/20220504/229e13f0a5834b479031ca2ba2b284ad.png
[Quicksort]: https://blog.csdn.net/wydyd110/article/details/79126808
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 25]: /images/20220504/31d94c8a6d2546a5a5ecad984be45f02.png
[20181101151837996.png]: /images/20220504/44e1a34e7b714119b32d760f8ebb1e3f.png
[20181101152132326.png]: /images/20220504/e73bc8e7e2264e61998a8905c560814d.png
[2018110115252551.png]: /images/20220504/62c9cfb376694923a74def0c40a75e01.png
[20181101152754895.png]: /images/20220504/9942bdbae7c34de9aeb57ddd0e3f6f8e.png
[20181101153005717.png]: /images/20220504/3977341cad514de0860b1431d5d196f1.png
[2018110115321049.png]: /images/20220504/d512affa90c74cf7b258fe7594c5648d.png
[20181101153318161.png]: /images/20220504/fb9bdb6df9af4cd49a9ad848e41065fc.png
[20181101153347995.png]: /images/20220504/8dc41af6d54f4c29999b69aecccfc04c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d5ZHlkMTEw_size_16_color_FFFFFF_t_70 26]: /images/20220504/eb6ea55d76e3469e8a1a8e0eef44c18e.png
[20181101170738975.png]: /images/20220504/eef2fe6025f749d18fa0575bc42b17eb.png
[20181101171356930.png]: /images/20220504/4d5bbdc715344ba5a4fec93751fc0536.png
[Link 5]: https://blog.csdn.net/wydyd110/article/details/83539544