1. 排序的概念及引用

• 1、排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
• 2、稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持 不变，即在原序列中， r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中， r[i]仍在r[j]之前，则称这种排序算法是稳 定的；否则称为不稳定的。

• 3、内部排序：数据元素全部放在内存中的排序。（RAM）
• 4、外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

2. 常见排序算法的实现

2.1 插入排序

2.1.1 直接插入排序

直接插入排序是一种简单的插入排序法，其基本思想是：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到 一个新的有序序列 。实际中我们玩扑克牌时，就用了插入排序的思想。

当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i- 1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：最好 O(N)
3. 时间复杂度：最坏 O(N^2)
4. 空间复杂度： O(1)，它是一种稳定的排序算法
5. 稳定性：稳定
6. 结论：对于直接插入排序来说，数据越有序越快。
7. 一个本身就稳定的排序，可以实现为不稳定。但是一个本身不稳定的排序，无法变成稳定的排序。

    //直接插入排序
    public void insertSort(int[] array){
        for(int i=1;i<array.length;i++){
            int tmp=array[i];
            int j=i-1;
            for(;j>=0;j--){
                if(array[j]>tmp){
                    array[j+1]=array[j];
                }else{
                    break;
                }
            }
            array[j+1]=tmp;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Test02 {
    public static void main(String[] args) {
        int[] array={1,5,2,9,4,6};
        Sort sort=new Sort();
        sort.insertSort(array);
        System.out.println(Arrays.toString(array));
    }
}
1
2
3
4
5
6
7
8

2.1.2 希尔排序( 缩小增量排序 )

希尔排序：是对直接插入排序法的一个改进。

• 采用分组的思想。
• 组内之间插入排序。
• 每次缩小分组的增量。

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

public class Test02 {
    public static void main(String[] args) {
        int[] array={9,1,2,5,7,4,8,6,3,5};
        Sort sort=new Sort();
//        sort.insertSort(array);
        Sort.shellSort(array);
        System.out.println(Arrays.toString(array));
    }
}
1
2
3
4
5
6
7
8
9

    private static void shell(int[] array,int gap){
        //i++:只有这样才能保证每一组都进行了插入排序
        for(int i=gap;i< array.length;i++){
            int tmp=array[i];
            int j=i-gap;
            for(;j>=0;j-=gap){
                if(array[j]>tmp){
                    array[j+gap]=array[j];
                }else{
                    break;
                }
            }
            array[j+gap]=tmp;
        }
    }

    //希尔排序
    public static void shellSort(int[] array){
        int gap=array.length;
        while (gap>1){
            shell(array,gap);
            gap/=2;
        }
        shell(array,1);//最后将整体看成插入排序
        
/*        int[] drr={5,2,1};//增量
        for(int i=0;i
    }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很 快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排 序的时间复杂度都不固定：

《数据结构(C语言版)》— 严蔚敏

《数据结构-用面向对象方法与C++描述》 — 殷人昆

因为gap是按照Knuth提出的方式取值的，而且Knuth进行了大量的试验统计，按照：O（n^1.25）到 O（1.6*n^1.25）来算。
4. 稳定性：不稳定

2.2 选择排序

基本思想：每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元 素排完 。

2.2.1 直接选择排序

• 在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
• 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个(第一个)元素交换
• 在剩余的array[i]–array[n-2] (array[i+1]–array[n-1])集合中，重复上述步骤，直到集合剩余1个元素

    //直接选择排序
    public static void selectSort(int[] array){
        for(int i=0;i< array.length;i++){
            int minIndex=i;
            for(int j=i+1;j<array.length;j++){
                if(array[minIndex]>array[j]){
                    minIndex=j;
                }
            }
            swap(array,minIndex,i);
            }
        }
        //交换函数：交换array数组的i和j下标
        private static void swap(int[] array,int i,int j){
            int tmp=array[i];
            array[i]=array[j];
            array[j]=tmp;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Test02 {
    public static void main(String[] args) {
        int[] array={9,1,2,5,7,4,8,6,3,5};
        Sort sort=new Sort();
//        sort.insertSort(array);
//        Sort.shellSort(array);
        Sort.selectSort(array);
        System.out.println(Arrays.toString(array));
    }
}
1
2
3
4
5
6
7
8
9
10

【直接选择排序的特性总结】

1. 直接选择排序好理解，但是效率不是很好，实际中很少使用。
2. 时间复杂度： O(N^2) (也是等差数列)
3. 空间复杂度： O(1)
4. 稳定性：不稳定

2.2.2 堆排序

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆（默认是升序）。

    //堆排序
    public static void heapSort(int[] array){
        //1.创建大根堆
        createBigHeap(array);
        int end= array.length-1;
        while(end>=0){
            swap(array,0,end);
            shiftDown(array,0,end);
            end--;
        }
    }

    //创建一个大根堆
    private static void  createBigHeap(int[] array){
        for(int parent=(array.length-1-1)/2;parent>=0;parent--){
            shiftDown(array,parent, array.length);
        }
    }

    //向下调整
    private static void shiftDown(int[] array,int parent,int len){
        int child=2*parent-1;
        //最起码保证有左孩子
        while(child<len){
            if(child+1<len && array[child]<array[child+1]){
                child++;
            }
            if(array[child]>array[parent]){
                swap(array,child,parent);
                parent=child;
                child=2*parent+1;
            }else{
                break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度： O(N*log2N)
3. 空间复杂度： O(1) 没有额外的内存
4. 稳定性：不稳定

2.3 交换排序

2.3.1 冒泡排序

冒泡排序：

• 时间复杂度：O（N^2）
• 针对优化后的代码，在有序情况下，时间复杂度就变成了O（N）
• 空间复杂度：O（1）
• 稳定性：稳定

    /**
     * 冒泡排序
     * 时间复杂度：O（N^2）
     *       针对优化后的代码，在有序情况下，时间复杂度就变成了O（N）
     * 空间复杂度：O（1）
     * 稳定性：稳定
     * @param array
     */
    public static void bubbleSort(int[] array){
        for(int i=0;i< array.length-1;i++){
            boolean fla=false;
            for(int j=0;j< array.length-1-i;j++){
                if(array[j]>array[j+1]){
                    swap(array,j,j+1);
                    fla=true;
                }
            }
            if(!fla)break;
        }
    }

    private static void swap(int[] array, int j, int i) {
        int tmp=array[j];
        array[j]=array[i];
        array[i]=tmp;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.3.2 快速排序

2.3.2.1 Hoare法

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为： 任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

简易版：

    /**
     * Hoare法  找基准
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int partitionHoare(int[] array,int start,int end) {
        int i = start;//事先存储好start下标
        int key = array[start];
        while (start < end) {
            //为啥取等号？ 不然就死循环了
            while (start < end && array[end] >= key) {
                end--;
            }
            while (start < end && array[start] <= key) {
                start++;
            }
            swap(array,start,end);
        }
        swap(array,start,i);
        return start;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

完全版：

import java.util.Arrays;

/**
 * @author Susie-Wen
 * @version 1.0
 * @description:
 * @date 2022/7/18 9:42
 */
public class Test01 {

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

    public static int partition(int[] array,int start,int end){
        int i=start;
        int key=array[start];
        while(start<end){
            while(start<end && array[end]>=key){
                end--;
            }

            while(start<end && array[start]<=key){
                start++;
            }
            swap(array,start,end);
        }
        swap(array,start,i);
        return start;
    }

    public static void quickSort(int[] array){
        quick(array,0, array.length-1);
    }

    private static void quick(int[] array,int left,int right){
        //递归结束的条件：左边>=右边
        //当左边=右边时，相当于只有一个节点
        // 而左边有可能大于右边，即没有子树（因为新的right=基准-1），可能超过left，因此要大于
        if(left>=right)return;
        int pivot=partition(array,left,right);//找到基准
        //递归基准的左边和右边
        quick(array,left,pivot-1);
        quick(array,pivot+1,right);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

2.3.2.2 挖坑法

简易版：

   /**
     * 挖坑法
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int partitionHole(int[] array,int start,int end) {
        int key = array[start];
        while (start < end) {
            while (start < end && array[end] >= key) {
                end--;
            }
            array[start] = array[end];
            while (start < end && array[start] <= key) {
                start++;
            }
            array[end] = array[start];
        }
        array[start] = key;
        return start;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

完全版：

public class Test{
    private static int partition(int[] array,int start,int end){
        int key=array[start];
        while(start<end){
            while(start<end && array[end]>=key){
                end--;
            }
            array[start]=array[end];
            while(start<end && array[start]<=key){
                start++;
            }
            array[end]=array[start];
        }
        array[start]=key;
        return start;
    }

    public static void quickSort(int[] array){
        quick(array,0, array.length-1);
    }

    private static void quick(int[] array,int left,int right){
        //递归结束的条件：左边>=右边
        //当左边=右边时，相当于只有一个节点
        // 而左边有可能大于右边，即没有子树（因为新的right=基准-1），可能超过left，因此要大于
        if(left>=right)return;//左右相遇的时候，结束
        int pivot=partition(array,left,right);//找到基准
        //递归基准的左边和右边
        quick(array,left,pivot-1);
        quick(array,pivot+1,right);
    }
    
    public static void main(String[] args) {
        int[] array={6,3,5,7,9,0,1,4,6,5};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2.3.2.3 前后指针法

简易版：

    /**
     * 前后指针法
     * @param array
     * @param start
     * @param end
     * @return
     */
    private static int partition(int[] array,int start,int end) {
        int prev = start ;
        int cur = start+1;
        while (cur <= end) {
            if(array[cur] < array[start] && array[++prev] != array[cur]) {
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,start);
        return prev;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.3.2.4快排时空复杂度

• 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
• 时间复杂度：O（N*log2N）在理想的情况下，每次都是均分待排序序列
• 时间复杂度：最慢：O（N^2）数据有序或者逆序
• 空间复杂度：最好：O（log2N）树的高度（只递归左树或者右树）
• 空间复杂度：最坏：O（N）有序情况下递归N次（出现单分支树的情况）
• 分析：当N足够大的时候，栈溢出的风险就足够大
• 稳定性：不稳定
  

由于对于有序的数据，使用快排可能出现栈溢出的风险，因此这里提出几种解决方案：

2.3.2.5 解决方案：随机选取基准法

---

2.3.2.6 解决方案：三数取中法

找三数的中间大小的值的下标：

    //三数取中法,解决快排栈溢出问题
    private static int midNumIndex(int[] array,int left,int right){
        int mid=(left+right)/2;
        //3<9
        if(array[left]<array[right]){
            if(array[mid]<array[left]){
                return left;
            }else if(array[mid]>array[right]){
                return right;
            }else{
                return mid;
            }
        }else{//9>3
                if(array[mid]<array[right]){
                    return right;
                }else if(array[mid]>array[left]){
                    return left;
                }else{
                    return mid;
                }
            }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.3.2.7 解决方案：小区间插排法

可以在递归的过程当中使用插入排序：

主要优化递归的深度：

    private static void quick(int[] array,int left,int right) {
        //这里代表 只要一个节点了 大于号：有可能没有子树  有序  逆序
        if(left >= right) {
            return;
        }

        //小区间使用直接插入排序： 主要优化了递归的深度
        if(right - left + 1 <= 7) {
            //使用直接插入排序
            insertSort2(array,left,right);
            return;
        }

        //三数取中：解决递归深度问题 基本上 有了三数取中  你的待排序序列 基本上每次都是二分N*logn
        int index = midNumIndex(array,left,right);
        swap(array,left,index);

        int pivot = partitionHoare(array,left,right);

        quick(array,left,pivot-1);
        quick(array,pivot+1,right);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2.3.2.8 非递归实现快速排序

    /**
     * 非递归实现 快速排序
     * @param array
     */
    public static void quickSort(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;
        //三数取中：解决递归深度问题 基本上 有了三数取中  你的待排序序列 基本上每次都是二分N*logn
        int index = midNumIndex(array,left,right);
        swap(array,left,index);
        int pivot = partitionHole(array,left,right);//找基准
        if(pivot > left+1) {
            stack.push(left);
            stack.push(pivot - 1);
        }
        
		//如果pivot=right-1，说明此时右边只有一个元素
        if(pivot < right-1) {
            stack.push(pivot + 1);
            stack.push(right);
        }
		
		//栈不为空时弹出两个元素
        while (!stack.empty()) {
            right = stack.pop();
            left = stack.pop();
            index = midNumIndex(array,left,right);
            swap(array,left,index);
            pivot = partition(array,left,right);
            if(pivot > left+1) {
                stack.push(left);
                stack.push(pivot - 1);
            }
            if(pivot < right-1) {
                stack.push(pivot + 1);
                stack.push(right);
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

2.4 归并排序

归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divideand Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

若将两个有序表合并成一个有序表，称为二路归并。

思想：二叉树递归思想。

先分解再合并：

2.4.1 归并排序的递归实现

---

    private static void mergeSortFunc(int[] array,int left,int right){
        int mid=(left+right)/2;
        //1.分解左边
        mergeSortFunc(array,left,mid);
        //2.分解右边
        mergeSortFunc(array, mid+1, right);
        //3.进行合并
        merge(array,left,right,mid);
    }
    private static void merge(int[] array,int start,int end,int minIndex){
        int[] tmpArr=new int[end-start+1];
        int k=0;//tmpArr数组的下标
        int s1=start;//第一段开始
        int e1=minIndex;//第一段结束
        int s2=minIndex+1;//第二段开始
        int e2=end;//第二段结束
        while(s1<=e1 && s2<=e2){
            //两个归并段都存在数据
            if(array[s1]<array[s2]){
                tmpArr[k++]=array[s1++];
            }else{
                tmpArr[k++]=array[s2++];
            }
        }
        //当走到这里的时候，说明有一个归并段当中没有数据了，拷贝另一半的全部到tmpArr数组当中
        while(s1<=e1){
            tmpArr[k++]=array[s1++];
        }
        while(s2<=e2){
            tmpArr[k++]=array[s2++];
        }
        //把排好序的数字拷贝会原数组
        for(int i=0;i<k;i++){
            array[i+start]=tmpArr[i];
        }
    }

    public static void mergeSort(int[] array){
     mergeSortFunc(array,0,array.length-1);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

• 时间复杂度：O（N*log2N）(不管有序还是无序，都是每层递归N次，一共log2N层)
• 空间复杂度：O（N）（因为要归并的时候，要开辟新的数组空间来存放）
• 稳定性：稳定

2.4.2 归并排序的非递归实现

    public static void mergerSort(int[] array) {

        int gap = 1;//每组的数据

        while (gap < array.length) {

            for (int i = 0; i < array.length; i += gap*2 ) {
                //进入这个循环 i一定合法
                int s1 = i;
                int e1 = s1+gap-1;
                if(e1 >= array.length) {
                    e1 = array.length-1;
                }
                int s2 = e1+1;
                if(s2 >= array.length) {
                    s2 = array.length-1;
                }/**/
                int e2 = s2+gap-1;
                //int e2 = e1+gap;
                if(e2 >= array.length) {
                    e2 = array.length-1;
                }
                merge(array,s1,e2,e1);
            }
            gap *= 2;
        }
    }

    private static void merge(int[] array,int start,int end,
                              int midIndex) {

        int[] tmpArr = new int[end-start+1];
        int k = 0;//tmpArr数组的下标

        int s1 = start;
        int s2 = midIndex+1;

        //两个归并段 都有数据
        while (s1 <= midIndex && s2 <= end) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }

        //当走到这里的时候 说明 有个归并段 当中 没有了数据 ，拷贝另一半的全部 到tmpArr数组当中
        while (s1 <= midIndex) {
            tmpArr[k++] = array[s1++];
        }

        while (s2 <= end) {
            tmpArr[k++] = array[s2++];
        }
        //把排好序的数字  拷贝回 原数组
        for (int i = 0; i < k; i++) {
            array[i+start] = tmpArr[i];
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2.4.3 海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

1. 先把文件切分成 200 份，每个 512 M。
2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以。
3. 进行2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了。

2.5 计数排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

创建一个新数组，遍历原数组，对应的值是几就在新数组对应下标的值++，最后打印新数组（新数组的值就是要打印的下标的次数）。

新数组的大小是原数组的最大值+1，因此空间复杂度和范围有关。

【计数排序的特性总结】

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度： O(MAX(N,范围))
3. 空间复杂度： O(范围)
4. 稳定性：稳定

    /**
     * 时间复杂度：O（N+范围）
     * 空间复杂度：O（范围）
     * 稳定性：稳定
     * 计数排序：适合给定一个范围进行排序
     * @param array
     */
    //计数排序
    public static void countSort(int[] array){
        int maxVal=array[0];
        int minVal=array[0];
        for(int i=0;i<array.length;i++){
            if(array[i]<minVal){
                minVal=array[i];
            }
            if(array[i]>maxVal){
                maxVal=array[i];
            }
        }
        //此时可以确定要排序数组的最大和最小值了
        int len=maxVal-minVal+1;//计数数组的长度
        int[] count=new int[len];//计数数组
        //开始遍历array数组进行计数
        for(int i=0;i< array.length;i++){
            int val=array[i];
            count[val-minVal]++;
        }
        int index=0;//array数组的下标
        for(int i=0;i<count.length;i++){
            //确保count数组可以检查完
            while(count[i]!=0){
                array[index]=i+minVal;
                index++;
                count[i]--;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

3. 排序算法复杂度及稳定性分析

4. 选择题

1. 快速排序算法是基于()的一个排序算法。
   A：分治法 B ：贪心法 C ：递归法 D ：动态规划法

解答：A。没有C这种说法

2. 对记录 ( 54,38,96,23,15,72,60,45,83) 进行从小到大的直接插入排序时 ，当把第8个记录45插入到有序表时 ，为找到插入 位置需比较()次？ (采用从后往前比较)
   A: 3 B: 4 C: 5 D: 6

解答：C。先把45前面的都调整为有序，然后45是i，45之前的元素是j，然后进行比较。

3. 以下排序方式中占用O(n)辅助存储空间的是()
   A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序

解答：D。归并排序无论是否有序，空间复杂度都是O（N）

4. 下列排序算法中稳定且时间复杂度为O(n2)的是()
   A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序

解答：B。只有B和D选项是稳定的，D的时间复杂度是O(n * log(n))

5. 关于排序 ，下面说法不正确的是()
   A: 快排时间复杂度为O(N*logN) ，空间复杂度为O(logN)
   B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
   C: 序列基本有序时 ，快排退化成冒泡排序 ，直接插入排序最快
   D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)

解答：D。

6. 下列排序法中 ，最坏情况下时间复杂度最小的是 ( )
   A: 堆排序 B: 快速排序 C: 希尔排序 D: 冒泡排序

解答：A。

7. 设一组初始记录关键字序列为(65,56,72,99,86,25,34,66) ，则以第一个关键字65为基准而得到的一趟快速排序结果是 ()
   A: 34 ，56 ，25 ，65 ，86 ，99 ，72 ，66
   B: 25 ，34 ，56 ，65 ，99 ，86 ，72 ，66
   C: 34 ，56 ，25 ，65 ，66 ，99 ，86 ，72
   D: 34 ，56 ，25 ，65 ，99 ，86 ，72 ，66

解答：使用挖坑法得选项A。