【排序算法复习备忘】冒泡、选择、插入、归并、快排、堆排序

冒泡排序，最简单的排序，基本思想遍历数组n次，每一次选出当前最大（小）的元素，以近似起泡的方式将最值慢慢挪到边界，完成排序。时间复杂度 O（n^2）下面以升序为列

void bubbleSort(vector<int> &nums){
    for(int i=0; i<nums.size()-1; i++)
        for(int j=i+1; j<nums.size(); j++)
            if(nums[i] > nums[j])
                swap(nums[i], nums[j]);

简单选择排序，基本思想其实和冒泡类似，但是冒泡在排序过程中会进行大量无谓的swap浪费时间，选择排序在每趟时仅会记住当前趟后值最大（小）的元素的下标，最后再进行一次swap，时间复杂度依然是O(n^2)，下面以升序为例：

void selectSort(vector<int> &nums){
    for(int i=0; i<nums.size()-1; i++){
        int minIdx = i;
        for(int j=i+1; j<nums.size(); j++){
            if(nums[minIdx] > nums[j]) minIdx = j;
        }
        if(minIdx != i) swap(nums[minIdx], nums[i]);
    }
}

插入排序，插入排序的基本思想是，维护一个已经有序的前半部分数组，然后将新元素插入到有序部分，要求插入以后前半部分仍然保持有序；时间复杂度依然是O(n^2)，下面也以升序为例：

void insertSort(vector<int> &nums){
    int i = 0;
    while(i++ < nums.size()){
        for(int j=i; j>=0 && nums[j]>nums[j+1]; j--)
            swap(nums[j], nums[j+1]);
    }
}

归并排序，归并排序是分治的思想，具体地说，将数组一直平分两段下去，直到每段元素都仅包含一个元素，这时候左右数组的元素都只有一个，就可以认为左右都是有序的，然后进行merge操作，要求merge以后的数组依然要保持有序（即并的过程），归并排序可以用来解决像比如求逆序对这样的问题，可以将时间复杂度压缩到O(NlogN)，下面以升序为例：

递归版：

void merge(vector<int>& nums, int left, int mid, int right){
    int i=left, j=mid+1;
    vector<int> res;
    while(i<=mid && j<=right){
        if(nums[i] > nums[j]) {
            res.push_back(nums[j]);
            j++;
        }else{
            res.push_back(nums[i]);
            i ++;
        }
    }
    while(i<=mid){
        res.push_back(nums[i]);
        i ++;
    }
    while(j<=right){
        res.push_back(nums[j]);
        j ++;
    }
    for(int i=0; i<res.size(); i++){
        nums[i+left] = res[i];
    }
}

void mergeProcess(vector<int>& nums, int left, int right){
    if(left == right) return;
    int mid = left + ((right-left)>>1);
    mergeProcess(nums, left, mid);
    mergeProcess(nums, mid+1, right);
    merge(nums, left, mid, right);
}

void mergeSort(vector<int>& nums){
    if(nums.size() < 2) return ;
    mergeProcess(nums, 0, nums.size()-1);
}

int main() {
    vector<int> nums = {0,92,41,4,1,-1,1000,-9999,200,3,100,-1,-1,4,5,6,1,2,33,1000000};
    mergeSort(nums);
    for(auto n : nums) printf("%d ", n);

    return 0;
}

迭代版：

void mergeSort_nonrecur(vector<int>& nums){
    if(nums.size() < 2) return ;
    int mergeSize = 1, N = nums.size();
    while(mergeSize < N){
        int i=0;
        while(i < N){
            int M = i+mergeSize-1;
            if(M >= N) break;
            int j = M+mergeSize >= N-1? N-1 : M+mergeSize;
            merge(nums, i, M, j);
            i = j + 1;
        }
        mergeSize <<= 1;
    }
}

快速排序，基本思想是任意选择一个元素，将小于该元素的值移到该元素的左侧，大于的移到右侧，这样每趟进行完以后，可以认为该元素的值可以保持固定了（已排序），之后再对左数组和右数组进行同样的操作，直到数组长度为1时停止，该算法的时间复杂度为O（nlogn），下面是代码实现，依然是升序排列为例：

vector<int> partition(vector<int>& nums, int left, int right){
    vector<int> res;
    int n = nums[right];
    int i = left-1, j = right+1, cur=left;
    while(cur < j){
        if(nums[cur] == n)
            cur ++;
        else if(nums[cur] > n){
            swap(nums[cur], nums[j-1]);
            j --;
        }else{
            swap(nums[cur], nums[i+1]);
            i ++;
            cur ++;
        }
    }
    res.push_back(i+1);
    res.push_back(j-1);
    return res;
}

void process_quick(vector<int>& nums, int left, int right){
    if(left >= right) return;
    srand((unsigned)time(NULL));
    swap(nums[rand()%(right-left+1)+left], nums[right]);
    vector<int> m = partition(nums, left, right);
    process_quick(nums, left, m[0]-1);
    process_quick(nums, m[1]+1, right);
    return ;
}

void quickSort1(vector<int>& nums){
    if(nums.size() < 2) return ;
    process_quick(nums, 0, nums.size()-1);
}

堆排序，堆排序主要利用了1、完全二叉树可以利用数组来表示 2、大根堆、小根堆属于完全二叉树的 这两大特性。

首先完全二叉树就是从上到下从左到右依次排列的一种二叉树，因为其“按序满排”的特性可以用数组来表示，例如[1,2,3]，就可以表示一个根节点为1，左右子节点为2、3的完全二叉树；而大根堆小根堆是一种特殊的完全二叉树，也就是每个节点值大于等于（小于等于）其孩子节点值的完全二叉树就叫大根堆（小根堆），因此大根堆的根节点就是整个树中的最大值，小根堆同理，下面以大根堆为例。

同时我们应该知道我们可以对一个完全二叉树（就是数组）进行建堆操作，也就是[1,2,3]这样的数组如果建堆的话结果就是[3,1,2]或[3,2,1]，这个过程一般叫做heapify，一次heapify操作可以拿到当前数组中的最大值，因此n次操作就可以实现对整个数组的排序，又因为heapify操作其实是在对完全二叉树进行操作，我们可以直接对某个节点定位其孩子节点（比如左孩子节点的下标为i*2+1），因此heapify的操作可以认为是O(logN)的，因此整个堆排序的时间复杂度为O(NlogN)，同时堆排序所需的额外空间是常数O(1)级别的，这也是其优势所在，下面以大根堆（升序）为例展示堆排序的代码：

void heapify(vector<int>& nums, int index, int heapSize){
    int left = index * 2 + 1;
    while(left < heapSize){
        int largestIdx = index, right = left+1;
        if(right < heapSize){ // 有右孩子
            int tempIdx = nums[right] > nums[left] ? right : left;
            if(nums[tempIdx] > nums[largestIdx]) largestIdx = tempIdx;
        }else{ // 只有左孩子
            if(nums[left] > nums[largestIdx]) largestIdx = left;
        }
        if(largestIdx == index) break;
        swap(nums[largestIdx], nums[index]);
        index = largestIdx;
        left = index * 2 + 1;
    }
}

void heapSort(vector<int>& nums){
    if(nums.size() < 2) return ;
    for(int i=nums.size()-1; i>=0; i--){
        heapify(nums, i, nums.size());
    }
    int heapSize = nums.size();
    swap(nums[0], nums[--heapSize]);
    while(heapSize > 0){
        heapify(nums, 0, heapSize);
        swap(nums[0], nums[--heapSize]);
    }
}