经典排序算法

堆排序

堆排序详解

https://blog.youkuaiyun.com/weixin_43614026/article/details/104431417

堆排序代码实现

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        //堆排序
        for(int i=0;i<nums.size();i++)
        {
            HeapInsert(nums,i);
        }
        int heapsize = nums.size();
        swap(nums[0],nums[--heapsize]);
        // help.push_back(nums[0]);
        while(heapsize>0)
        {
            Heapify(nums,0,heapsize);
            swap(nums[0],nums[--heapsize]);
        }
        return nums;
    }
    void HeapInsert(vector<int>& nums,int index)
    {
        while(index>0 && nums[index]>nums[(index-1)>>1])
        {
            swap(nums[index],nums[(index-1)>>1]);
            index = (index-1)>>1;
        }
    }
    void Heapify(vector<int>& nums,int index,int heapsize)
    {
        int left = index*2+1;//左孩子下标
        while(left<heapsize)
        {
            int largest = left+1<heapsize && nums[left+1]>nums[left]?left+1:left;
            if(nums[index]>=nums[largest])  break;
            else{
                swap(nums[index],nums[largest]);
                index = largest;
                left = index*2+1;
            }
        }
    }
    void swap(int& a,int& b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
};

快速排序

快速排序详解

https://blog.youkuaiyun.com/weixin_46236591/article/details/123021397

快速排序代码实现

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        //快速排序
        QuickSort(nums,0,nums.size()-1);
        return nums;
    }
    void QuickSort(vector<int>& nums,int l,int r)
    {
        if(l>=r)    return;
        swap(nums[r],nums[l+rand()%(r-l+1)]);
        pair<int,int> equal_area = partition(nums,l,r);
        QuickSort(nums,l,equal_area.first-1);
        QuickSort(nums,equal_area.second+1,r);
    }
    pair<int,int> partition(vector<int>& nums,int l,int r)
    {
        int left = l;
        int right = r-1;
        int cur = left;
        while(cur<=right)
        {
            if(nums[cur]>nums[r])
            {
                swap(nums[cur],nums[right--]);
            }
            else if(nums[cur]<nums[r])
            {
                swap(nums[cur++],nums[left++]);
            }
            else
            {
                cur++;
            }
        }
        swap(nums[++right],nums[r]);
        return (pair<int,int>){left,right};
    }
    void swap(int& a,int& b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
};

归并排序

归并排序详解

https://zhuanlan.zhihu.com/p/124356219

归并排序代码实现

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        //归并排序
        MergeSort(nums,0,nums.size()-1);
        return nums;
    }
    void MergeSort(vector<int>& nums,int l,int r)
    {
        if(l>=r)    return;
        int m = (l+r)>>1;
        MergeSort(nums,l,m);
        MergeSort(nums,m+1,r);
        process(nums,l,m,r);
    }
    void process(vector<int>& nums,int l,int m,int r)
    {
        vector<int> help(r-l+1);
        int cur = 0;
        int p1 = l;
        int p2 = m+1;
        while(p1<=m && p2<=r)
        {
            help[cur++] = nums[p1]>nums[p2]?nums[p2++]:nums[p1++];
        }
        while(p1<=m)
        {
            help[cur++] = nums[p1++];
        }
        while(p2<=r)
        {
            help[cur++] = nums[p2++];
        }
        for(int i=0;i<r-l+1;i++)
        {
            nums[l+i] = help[i];
        }
    }
};