【数据结构算法】快排/归并/堆排序 c++

一个用来了解数据结构算法（各种排序，列表，树等）很友好的网站：
https://visualgo.net/en

该题目来自于牛客：算法篇-排序问题

快排（必备）+归并（体会分治）+堆(自己建堆)

//快速排序 关键在于 partition函数，可以自己参考一个模板，我这个参考大话数据结构

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    //1.快速排序
    vector<int> MySort(vector<int>& arr) {
        // write code here
        int left=0;
        int right=arr.size()-1;
        QuickSort(arr,left,right);
        return arr;
    }
    int QuickTemp(vector<int>& arr,int left,int right){        
        int i = left;
        int j = right;
        int temp = arr[left];
        while(i<j){
            while(temp<=arr[j]&&i<j) --j;
            arr[i]=arr[j];
            while(temp>=arr[i]&&i<j) ++i;
            arr[j]=arr[i];
        }
        arr[i] = temp;
        return i;
    }
    void QuickSort(vector<int>& arr,int left,int right){
        if(left<right){
            int mid=QuickTemp(arr,left,right);
            QuickSort(arr, left,mid-1);
            QuickSort(arr, mid+1, right);
        }
    }
};

//归并排序 关键在于构造一个数组 然后merge，所以这个 merge函数是关键
class Solution {
public:
    //归并排序
    vector<int> MySort(vector<int>& arr) {
        MySortCore(arr,0,arr.size()-1);


        return arr;
    }
    void MySortCore(vector<int>&arr,int start,int end){
        if(start>=end) return;

        int middle=start+((end-start)>>1);
        MySortCore(arr,start,middle);
        MySortCore(arr,middle+1,end);

        Merge(arr,start,middle,end);
    }
    void Merge(vector<int>&arr,int start,int middle,int end){
        int* tmp=new int[end-start+1];

        int left=start;
        int right=middle+1;

        int pTmp=0;    //辅助数组指针
        while(left<=middle && right<=end){
            if(arr[left]<arr[right])
                tmp[pTmp++]=arr[left++];
            else
                tmp[pTmp++]=arr[right++];

        }
        while(left<=middle)
            tmp[pTmp++]=arr[left++];
        while(right<=end)
            tmp[pTmp++]=arr[right++];

        //排序完数组拷贝回原数组
        for(int i=0;i<end-start+1;i++)
            arr[start+i]=tmp[i];

    }
};
//堆排序，分为两步，建堆+排序
//一些细节可以参考大话数据结构
//我这个堆是从下标为0开始的，所以左子节点 left=2*root+1, right=2*root+1

class Solution {
public:
    //堆排序
    void Swap(int&a,int &b){
        int tmp=a;
        a=b;
        b=tmp;
    }
    void HeapAdjust(vector<int>&arr,int root,int len){
        int tmp=arr[root];

        for(int j=2*root+1;j<len;j=2*j+1){
            if(j<len-1 && arr[j]<arr[j+1])
                ++j;
            if(tmp>arr[j])
                break;
            arr[root]=arr[j];
            root=j;
        }
        arr[root]=tmp;

    }
    vector<int> MySort(vector<int>& arr) {
        for(int i=arr.size()/2-1;i>=0;i--)
            HeapAdjust(arr,i,arr.size());

        for(int i=arr.size()-1;i>0;i--){
            Swap(arr[0],arr[i]);
            HeapAdjust(arr,0,i);
        }

        return arr;
    }
};

---

小结：
在做快排序的时候，出现了超时问题，解决办法：
1、逻辑调整
2、把i++/j–，替换成++i/–j。
3、使用递归前的函数传参最好不是计算式。

---

以下是其他友友的代码和注释（写的很认真就贴了过来）：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型vector 待排序的数组
     * @return int整型vector
     */
    vector<int> MySort(vector<int>& arr) {
        // write code here
        mySort1(arr);
        return arr;
    }
    // 1、快速排序（通过）
    // 时间复杂度O(logn)。空间复杂度是O(n)。
    // 主要是要找出标杆值（中间值），默认最后一个值为标杆值，然后比它小的放左边，比他大的放右边，然后交换最后一位。就得到标杆值在中间的下标。
// 树，从上往下排序
    // 不稳定算法
    void mySort1(vector<int>& arr) {
        quicksort(arr, 0, arr.size()-1);
    }  
    void quicksort(vector<int> &arr, int left, int right) {
        if (left > right) return;

        int pivotIndex = partition(arr, left, right); // 标杆值所在的位置
        quicksort(arr, left, pivotIndex-1); // 左半边
        quicksort(arr, pivotIndex+1, right); // 右半边
    }

    int partition(vector<int> &arr, int left, int right) {
        // 最后一个值当做标杆
        int counter = left;      // 记录小于标杆值的个数
        while (left < right) {
            if (arr[left] < arr[right]) { // 当前值和标杆值比较，决定是放在左边还是右边
                swap(arr[left], arr[counter]);
                counter++;
            }
            left++;
        }
        swap(arr[counter], arr[right]);   // 最后把标杆值移到中间位置，然后返回下标。
        return counter;
    }

    // 2、归并排序（通过）
    // 时间复杂度O(logn)。空间复杂度是O(n)。
    // 归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
    // 树，从下往上排序
    // 是稳定的算法
    void mySort2(vector<int>& arr) {
        mergeSort(arr, 0, arr.size()-1);
    }  

    void mergeSort(vector<int> &arr, int left, int right) {
        if (left >= right) return;

        int mid = left + (right - left) / 2;
        mergeSort(arr, left, mid); // 递归 左半边
        mergeSort(arr, mid+1, right); // 递归 右半边

        merge(arr, left, mid, right); // 合并两个有序的数组（参考合并两个有序的链表）
    }

    // 合并两个有序数组
    void merge(vector<int> &arr, int left, int mid, int right) {
        vector<int> tmp(right-left+1); // 开辟新的数组
        int i = left, j = mid+1, k = 0; // i左边数组的起始位置，j右边数组的起始位置，k已经放入新数组的个数

        while (i <= mid && j <= right) {  // 比较左右数组，数值小的放入新数组中
            tmp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
        }
        while (i <= mid) tmp[k++] = arr[i++];  // 如果左半边数组没有排序完，加入新数组
        while (j <= right) tmp[k++] = arr[j++]; // 如果右半边数组没有排序完，加入新数组

        for (i = left, k = 0; i <= right;) arr[i++] = tmp[k++]; // 新数组数据放回到原来的数组中
    }
    // 3、堆排序（通过）
    // 时间复杂度O(logn)。空间复杂度是O(n)。
    // 不稳定算法
    void heapSort(vector<int> &arr) {
        priority_queue<int,vector<int>,greater<int>> q; //小顶堆

        for (int i = 0; i < arr.size(); i++) {
            q.push(arr[i]);
        }
        for (int i = 0; i < arr.size(); i++) {
            arr[i] = q.top();
            q.pop();
        }
    }

    // 4、冒泡排序（超时）
    // 时间复杂度O(n2)，空间复杂度O(1)
    // 从后往前排
    // 两两比较交换，最大的放在后面，稳定排序
    void bubbleSort(vector<int>& arr) {

        for (int i = 0; i < arr.size(); i++) {
            for (int j = 0; j < arr.size()-i-1; j++) {
                if (arr[j]>arr[j+1]) {
                    swap(arr[j], arr[j+1]);
                }
            }
        }
    }

    // 5、选择排序（超时）
    // 时间复杂度O(n2)，空间复杂度O(1)
    // 从前往后排
    // 遍历数组，找出最小值，最小的放在前面，不稳定排序
    void selectionSort(vector<int>& arr) {
        int minIndex = 0;
        for (int i = 0; i < arr.size(); i++) {
            minIndex = i;
            for (int j = i+1; j < arr.size(); j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            swap(arr[i], arr[minIndex]);
        }
    }

    // 6、插入排序（超时）
    // 时间复杂度O(n2)，空间复杂度O(1)
    // 从前往后排
    // 遍历数组，找出一个值，往排好的数组里面插入合适的位置。稳定排序
    void insetionSort(vector<int>& arr) {
        int preIndex = 0;
        int currentVal = 0;

        for (int i = 1; i < arr.size(); i++) {
            preIndex = i - 1;
            currentVal = arr[i];

            while (preIndex >= 0 && arr[preIndex] > currentVal) {
                arr[preIndex+1] = arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1] = currentVal;
        }
    }

};