排序相关代码（数据结构笔试、复测、Leecode、牛客）

基础概念

基础排序

插入类排序

直接插入排序、折半插入排序、希尔排序

直接插入

基本思想：每趟将一个待排序的关键字按照大小插入到已排好的部分有序序列的适当位置中

时间复杂度$O(n^2)$
空间复杂度$O(1)$

vector<int> MySort(vector<int>& arr) {
        // write code here
        int i, j;
        int t;
        for(i = 1; i< arr.size();i++){
            t = arr[i];
            j = i-1;
            while(j>=0 && arr[j] > t)
            {
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = t;
            
        }
        return arr;
    }

折半插入

基本思想：采用折半查找法来查找插入位置
序列已经有序，查找插入位置

时间复杂度$O(nlogn)$
空间复杂度$O(1)$

 // 折半插入
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int i, j, t;
        int low, mid, high;
        for(i = 1; i< arr.size();i++){
            t = arr[i];
            low = 0;
            high = i-1;
            // 折半查找
            while(low <= high)
            {
                mid = (low+high)/2;
                if(arr[mid]>t)
                    high = mid-1;
                else
                    low = mid+1;
            }
            for(j=i-1; j>=high+1; j--)
            {
                arr[j+1] = arr[j];
            }
            arr[high+1] = t;
            
            
        }
        return arr;
    }

希尔排序

基本思想：缩小增量排序+直接插入排序

时间复杂度$O(n^2)$
空间复杂度$O(1)$

        // 希尔排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int gap;//增量
        int i,j;
        int n = arr.size();
        for(gap = n/2; gap>0; gap=gap/2){
            for(i=0; i<gap; i++){
                for(j=i+gap; j < n; j+=gap)
                {
                    if(arr[j] < arr[j-gap])
                    {
                        int t = arr[j];
                        int k = j-gap;
                        while(k>=0 && arr[k] >=t)
                        {
                            arr[k+gap] = arr[k];
                            k -= gap;
                        }
                        arr[k+gap] = t;
                    }
                }
            }
        }
        return arr;
    }

交换类排序

冒泡排序、快速排序

冒泡排序

    //冒泡排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int i, j, t;
        int flag;//标记是否发生了变化
        int n = arr.size();
        for(i=n-1; i>=1; --i)
        {
            flag = 0;
            for(j=0; j<i; j++)
            {
                if(arr[j+1]<arr[j])
                {
                    t = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = t;
                    flag = 1;
                }
                
            }
            if(flag == 0)
                return arr;
        }
        return arr;
    }

快速排序

通过多次划分操作实现排序
每一趟选择当前所有子序列中的一个关键字（第一个）作为轴，将比轴小的放在前面，大的放在后面

     //快速排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        srand(0);
        QuickSort(arr, 0, arr.size()-1);
        return arr;
    }
    void QuickSort(vector<int>& arr, int low, int high) {
        // write code here
        int n = arr.size();
        int i = low, j = high;
        int t;
        if(low<high)
        {
            t = arr[low];
            while(i<j)
            {
                while(j>i && arr[j] >= t)
                    j--;
                if(i<j)
                {
                    arr[i] = arr[j];
                    i++;
                }
                while(i<j && arr[i] <= t)
                    i++;
                if(i<j)
                {
                    arr[j] = arr[i];
                    j--;
                }
            }
            arr[i] = t;
            QuickSort(arr, low, i-1);
            QuickSort(arr, i+1, high);
        }
        
    }

选择类排序

简单选择排序、堆排序

简单选择排序

从头到尾顺序扫描序列，找到最小的一个关键字和第一个关键字交换

    // 简单选择排序
         //快速排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int i,j,k;
        int t;
        for(i = 0; i<arr.size(); i++)
        {
            k = i;
            for(j = i+1; j<arr.size(); j++)
            {
                if(arr[j]<arr[k])
                    k = j;
            }
            t = arr[i];
            arr[i] = arr[k];
            arr[k] = t;
        }
        return arr;
    }

堆排序

• 堆是一种数据结构，可以把堆看成一棵完全二叉树
• 完全二叉树满足:任何一个非叶结点的值都不大于（或不小于）其左右孩子结点的值。
• 若父亲大孩子小，则这样的堆叫作大顶堆;
• 若父亲小孩子大，则这样的堆叫作小顶堆。

将序列调整为堆

    //堆排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        if(arr.empty())
            return arr;
        
        HeapSort(arr, arr.size());
        return arr;
    }
    
    // 在数组arr[low]到arr[high]对位置low上的结点进行调整
    void Sift(vector<int>& arr, int low, int high){
        int i = low, j = 2*i; //arr[j]为arr[i]的左孩子结点
        int t = arr[i];
        while(j<=high)
        {
            if(j<high && arr[j]<arr[j+1]) //右孩子大，指向右孩子
                ++j;
            if(t < arr[j])
            {
                arr[i] = arr[j];
                i = j;
                j = 2*i;
            }
            else
                break;
        }
        arr[i] = t;
    }
    
    void HeapSort(vector<int>& arr, int n){
        int i;
        int t;
        for(i = n/2; i>=0; --i){ //初始堆,找到最大的节点
            Sift(arr, i, n-1);
        }
        for(i = n-1; i>=1; --i)
        {
        	//将最大的节点放在最后面
            t = arr[0];
            arr[0] = arr[i];
            arr[i] = t;
            Sift(arr, 0, i-1);
        }
        return;
    }

归并类排序

二路归并排序

进阶应用