十大排序算法

十大排序算法

排序代码都是以这个题为参照，可以直接提交ac

215. 数组中的第K个最大元素 - 力扣（LeetCode） (leetcode-cn.com)

冒泡排序

选择排序

插入排序

//插入排序就是从第二个数作为当前位置，假定左边有序，然后将右边的数找个合适位置放进去

class Solution {
public:
    void isort(vector<int>&nums){//数组插入要移动很多数，不像链表
        for(int i=1;i<nums.size();i++){
            int now = nums[i];
            int j = i-1;
            while(j>=0&&now>nums[j]){
                nums[j+1] = nums[j];
                j--;
            }
            nums[j+1] = now;
        }
    }
    int findKthLargest(vector<int>& nums, int k) {
        isort(nums);
        return nums[k-1];
    }
};

希尔排序 
桶排序 
计数排序
基数排序

归并排序

归并排序是分治思想，先分再合，分的时候分到单个元素就停止，合的时候保证左右两个分支都是有序序列，也就是有序序列的合并

class Solution {
public:
    void divide(vector<int>& nums,int l,int r){
        if(l>=r)
            return ;
        int mid = (l+r)/2;
        divide(nums,l,mid);
        divide(nums,mid+1,r);
        vector<int> t1(nums.size());
        vector<int> t2(nums.size());
        int len1=0,len2=0;
        for(int i=l;i<=mid;i++){
            t1[len1++] = nums[i];
        }
        for(int i = mid+1;i<=r;i++){
            t2[len2++] = nums[i];
        }
        int l1 = 0,l2 = 0;
        int i;
        for(i=l;i<=r&l1<len1&&l2<len2;i++){
            if(t1[l1]>t2[l2]){//从大到小排
                nums[i] = t1[l1++];
            }else{
                nums[i] = t2[l2++];
            }
        }
        while(l1<len1){
            nums[i++] = t1[l1++];
        }
        while(l2<len2){
            nums[i++] = t2[l2++];
        }
    }
    int findKthLargest(vector<int>& nums, int k) {
        divide(nums,0,nums.size()-1);
        return a[k-1];
    }
};
/*void divide(int nums[],int l,int r){void divide(int *nums,int l,int r) 这两种都是可以修改原数组，vector要加取地址符号才行*/

快速排序

//快排就是每次把第一个数放在它有序数组中的位置，左边的数都小于它右边的数都大于他

和归并排序区别就是只分不和

class Solution {
public:
    void qsort(vector<int>&nums,int l,int r){
        if(l>=r)
            return ;
        int cmp=l,j=l;
        for(int i=l+1;i<=r;i++){
            if(nums[i]>nums[cmp]){//这里决定排序方向
                swap(nums[i],nums[++j]);
            }
        }
        swap(nums[cmp],nums[j]);//j=k-1时就可以return了
        qsort(nums,l,j-1);
        qsort(nums,j+1,r);
    }
    int findKthLargest(vector<int>& nums, int k) {
        qsort(nums,0,nums.size()-1);
        return nums[k-1];
    }
};

class Solution {
public:
    void qsort(vector<int>&nums,int left,int right){
        if(left>=right)
            return ;
        int cmp = left,j=left;
        int randnum = rand() % (right - left + 1) + left; // 随机选一个作为我们的cmp，思路：选好了和left交换。不要把随机数直接作为cmp
        swap(nums[left], nums[randnum]);
        for(int i=left+1;i<=right;++i){
            if(nums[i]<nums[cmp]){//这里小于
                swap(nums[++j],nums[i]);
            }
        }
        swap(nums[cmp],nums[j]);
        qsort(nums,left,j-1);//这里是j
        qsort(nums,j+1,right);
    }
    vector<int> sortArray(vector<int>& nums) {
        qsort(nums,0,nums.size()-1);
        return nums;
    }
};

堆排序

堆是完全二叉树，父节点大于等于（或小于等于）子节点的值。公式：parent = (son-1)/2    lson = parent*2+1    rson = parent*2+2

你还别说这还是有几个步骤的，第一步是构建堆核心是从最后一个节点的父节点开始往上递归调整父子值的大小关系，第二步是取堆顶元素，取完后递归调整堆父子大小关系。注意调整堆和构建堆的关系，构建堆需要从下往上多次调整堆。

堆排序(heapsort)_哔哩哔哩_bilibili　　这个视频讲的透彻

class Solution {//parent = (son-1)/2    lson = parent*2+1    rson = parent*2+2
public:
    void adjust(vector<int>&nums,int n,int index){//递归调整当前节点
        if(index>=n)
            return;
        int lson = index*2+1,rson = index*2+2;
        int mx = index;
        if(lson<n&&nums[lson]>nums[mx]){
            mx = lson;
        }
        if(rson<n&&nums[rson]>nums[mx]){
            mx = rson;
        }
        if(mx!=index){
            swap(nums[mx],nums[index]);
            adjust(nums,n,mx);
        }
    }
    void build_heap(vector<int>&nums,int n){//大根堆，排序后是从小到大
        int last_node = n-1;
        int last_parent = (last_node-1)/2;
        for(int i=last_parent;i>=0;i--){//从最后一个节点的父节点（即最后一个非叶子节点进行调整）
            adjust(nums,n,i);
        }
    }
    void hsort(vector<int>&nums,int n){//在数组已经是堆的基础之上，拿到最大值赋值到数组末尾，调整堆顶，
        build_heap(nums,n);
        for(int i=n-1;i>=0;i--){
            swap(nums[i],nums[0]);
            adjust(nums,i,0);
        }
    }
    int findKthLargest(vector<int>& nums, int k) {
        int n=nums.size();
        hsort(nums,n);
        for(int i=0;i<nums.size();i++)
            cout<<nums[i]<<" ";
        return nums[n-k];
    }
};

class Solution {//parent = (son-1)/2    lson = parent*2+1    rson = parent*2+2
public:
    void adjust(vector<int>&nums,int n,int index){//递归调整当前节点
        if(index>=n)
            return;
        int lson = index*2+1,rson = index*2+2;
        int mn = index;
        if(lson<n&&nums[lson]<nums[mn]){//堆是大还是小就看这里符号
            mn = lson;
        }
        if(rson<n&&nums[rson]<nums[mn]){
            mn = rson;
        }
        if(mn!=index){
            swap(nums[mn],nums[index]);
            adjust(nums,n,mn);
        }
    }
    void build_heap(vector<int>&nums,int n){//小根堆，排序后是从大到小
        int last_node = n-1;
        int last_parent = (last_node-1)/2;
        for(int i=last_parent;i>=0;i--){//从最后一个节点的父节点（即最后一个非叶子节点进行调整）
            adjust(nums,n,i);
        }
    }
    void hsort(vector<int>&nums,int n){//在数组已经是堆的基础之上，拿到最小值赋值到数组末尾，调整堆顶，
        build_heap(nums,n);
        for(int i=n-1;i>=0;i--){
            swap(nums[i],nums[0]);
            adjust(nums,i,0);
        }
    }
    int findKthLargest(vector<int>& nums, int k) {
        int n=nums.size();
        hsort(nums,n);
        for(int i=0;i<nums.size();i++)
            cout<<nums[i]<<" ";
        return nums[k-1];
    }
};