面试常见排序算法

本文先给一个表格总结各个排序算法的时间复杂度、空间复杂度、稳定性等。然后重点介绍快速排序和堆排序两个面试过程中必问的排序，最后再介绍其他排序算法。

---

一、常见排序算法总结

稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

注意：堆排序和快速排序都是不稳定的，堆排序的平均情况和最好最坏情况时间复杂度都是O（nlogn）。
快速排序平均情况和最好情况时O(nlogn)，最坏情况时O(n2)，面试过程中常问。

---

二、快速排序算法总结

2.1、快排的基本思想

1. 先从数列中取出一个数作为基准数
2. 分区过程，将小于或等于基准数的放到左边，将大于基准数的放到右边。
3. 再对第二步得到的左右两个区间重复1、2过程，直到各区间只有一个数。

实例介绍
有以下一组数：

72	6	57	88	60	42	83	73	48	85

1. 选取基准数：原则上基准数要随机选取，但是我们这边的数据可以认为是随机的，所以我们每次的基准数都选取第一个数。这里为72.
2. 分区。分为如下左右两区：

6	57	60	42	48	72	88	83	73	85

3. 对左右两区重复1、2步，截止到每个区只有一个数。
左区重复，选基准数、分区过程

6	57	60	42	48

右区

88	83	73	85

---

2.2、快排的时间复杂度和空间复杂度分析

时间复杂度

快速排序的时间复杂度依赖于划分是否平衡。

• 最坏情况分析：O(n^2)
  每次划分的时候左右两区间分别包含了n-1个元素和0个元素

• 最好情况分析：O(nlogn)
  每次划分的时候左右两区间的元素个数几乎相等。

---

2.3、快排的程序编写

int* quickSort(int* A, int n) {
        // write code here
        //入参校验
        if(A==NULL || n<=0){
            cout<<"入参不合法"<<endl;
            return NULL;
        }

        //快排
        coreQuickSort(A, 0, n-1);

        return A;
    }

    /*
    * 快排，里面递归调用，递归截止条件为left>=right
    */
    void coreQuickSort(int* A, int left, int right){
        if(left<right){
            int mid=parition(A, left, right);
            coreQuickSort(A, left, mid-1);
            coreQuickSort(A, mid+1, right);
        }
    }


    /**
    * 一次划分
    *@return 一次划分完后的中间索引
    */
    int parition(int* A, int left, int right){
        int key=A[right];
        int lessNumIndex=left-1;

        for(int search=left; search<=right; search++){
            if(A[search]<=key){
                lessNumIndex++;
                swap(A, lessNumIndex, search);
            }
        }

        return lessNumIndex;
    }

    /**
    * 交换函数
    */
    void swap(int* A, int index1, int index2){
        int tmp=A[index1];
        A[index1]=A[index2];
        A[index2]=tmp;
    }

---

三、堆排序算法总结

3.1、堆排序的思想

堆：以最小堆为例，根节点不大于左右子节点。
堆排序：先将数组初始化为最小堆，然后每次取出堆顶的元素，取完之后对堆进行维护，维护其为最小堆。这样取出来的元素就会是从小到大排列的。

3.2、堆排序的时间复杂度和空间复杂度分析

时间复杂度：

时间复杂度是O(n*logn)，对数组初始化为堆的时候，时间复杂度为O(n)，取完堆顶元素后，需要维护堆，每次维护堆的时间复杂度为O(logn)，共需要N-1次维护堆的操作。
所以O(N)+(N-1)*O(logN)=O(N*logN)

3.3、堆排序程序编写

int* heapSort(int* A, int n) {
        int lastPosi=n-1;
        maxHeapBuild(A, lastPosi);     //建最大堆
        while(lastPosi>=1){            //维护最大堆
            swap(A, 0, lastPosi);
            lastPosi=lastPosi-1;
            heapifyMax(A, 0, lastPosi);
        }
        return A;
    }

    //建立最大堆
    void maxHeapBuild(int* A, int lastPosi){
        for(int i=(lastPosi-1)/2; i>=0; i--){
            heapifyMax(A, i, lastPosi);
        }
    }

    //堆下沉，建立最大堆和维护堆的时候都需要的过程
    void heapifyMax(int* A, int posi, int lastPosi){
        int maxLR=2*posi+1;
        while(maxLR<=lastPosi){
            if( maxLR < lastPosi && A[maxLR+1]>A[maxLR]){
                maxLR++;
            }
            if(A[maxLR] <= A[posi]){
                break;
            }
            else{
                swap(A, posi,maxLR);
                posi=maxLR;
                maxLR=2*posi+1;
            }
        }
    }

    //交换
    void swap(int* A, int index1, int index2){
        int tmp=A[index1];
        A[index1]=A[index2];
        A[index2]=tmp;
    }