需重点掌握的三大排序： 快速排序 + 归并排序 + 堆排序

关于排序算法的考察，需重点掌握   快速排序 、归并排序  、 堆排序 。

1.  快速排序

    1.1 快速排序算法的思想与实现

     快速排序的重点是要掌握其划分的思想，划分算法需要先挑选一个 元素作为 pivot。在划分执行完之后，

pivot左边的元素都小于等于它，右边的元素都大于等于它，pivot 的位置就是数组排序完成后它的最终位置。

每执行一次 划分算法，确定数组中一个元素的位置。

 

//1. 快速排序
    void quickSort(vector<int>& nums)
    {
        const int len = nums.size();
        if(len <= 1) return;
        std::random_shuffle(nums.begin(),nums.end());//打乱是为了避免快速排序陷入最差情况
        quickSortHlper(nums,0,len - 1);
        return;
    }
     void quickSortHlper(vector<int>& nums,int l,int r)
     {
         
        if(l >= r) return;
        int mid = Partition(nums,l,r);
        quickSortHlper(nums,l,mid - 1);
        quickSortHlper(nums,mid+1,r);
         return;
     }
    //划分
    int Partition(vector<int>& nums,int l,int r)
    {
        int i = l + 1, j = r;
        while(true)
        {
            while(i <= j && nums[i] <= nums[l]) i++;
            while(i <= j && nums[j] >= nums[l]) j--;
            // 1. 此时 [j+1,r]的元素一定都比 nums[l]大，[l+1,i-1] 内的元素一定都比 nums[l]小
            // 2. 因为 i > j ，[l+1,j] 一定是[l+1,i-1] 的子集，[l+1,j] 内的元素一定都比 nums[l]小
            // 3. [l+1,j] 内的元素一定都比 nums[l]小,[j+1,r]的元素一定都比 nums[l]大,所以
            //执行 std::swap(nums[l],nums[j])后，j 就是nums[l]最终的位置。
            if(i > j)//此时 [j+1,r]的元素一定都比 nums[l]大，[l+1,j] 内的元素一定都比 nums[l]小
            {
                std::swap(nums[l],nums[j]);
                break;
            }
            std::swap(nums[i],nums[j]);
        }
        return j;
    }

       1.2 快速排序算法的应用： LeetCode   215. 数组中的第K个最大元素

       

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k)
    {
        const int N = nums.size();
        int k_max_index = N - k;
        int l = 0;
        int r = N -1;
        while(l <= r)
        {
            int mid = quickSelect(nums,l,r);
            if(mid == k_max_index)
            {
                return nums[mid];
            }
            else if(mid < k_max_index)
            {
                l = mid + 1;
            }
            else
            {
                r = mid - 1;
            }
        }
        return INT_MAX;//不会执行到这一步
    }
    
//快速排序划分算法，以 nums[l] 为 pivot，执行完成，确定 nums[l]最终排序好的位置
    int quickSelect(vector<int>& nums, int l,int r)
    {
        int i = l + 1, j = r;
        while(true)
        {
            while(i <= j && nums[i] <= nums[l]) i++;
            while(i <= j && nums[j] >= nums[l]) j--;
            // 1. 此时 [j+1,r]的元素一定都比 nums[l]大，[l+1,i-1] 内的元素一定都比 nums[l]小
            // 2. 因为 i > j ，[l+1,j] 一定是[l+1,i-1] 的子集，[l+1,j] 内的元素一定都比 nums[l]小
            // 3. [l+1,j] 内的元素一定都比 nums[l]小,[j+1,r]的元素一定都比 nums[l]大,所以
            //执行 std::swap(nums[l],nums[j])后，j 就是nums[l]最终的位置。
            if(i > j)//此时 [j+1,r]的元素一定都比 nums[l]大，[l+1,j] 内的元素一定都比 nums[l]小
            {
                std::swap(nums[l],nums[j]);
                break;
            }
            std::swap(nums[i],nums[j]);
        }
        return j;
    }
};

 

2. 归并排序

　　　2.1 归并排序的思想与实现

　　　　归并排序是分治思想的典型应用，使用了一个辅助数组。时间 O（N *logN） 空间 （N）

          

void mergeSort(vector<int>& nums)
    {
        const int len = nums.size();
        if(len <= 1) return;
        vector<int> tmp(len);
        mergeSortHelper(nums,0,len - 1,tmp);
        return;
    }
    void mergeSortHelper(vector<int>& nums,int l,int r,vector<int>& tmp)
    {
        if(l >= r)
        {
            return;
        }
        int mid = l + (r - l)/2;
        mergeSortHelper(nums,l,mid,tmp);
        mergeSortHelper(nums,mid+1,r,tmp);
        if(nums[mid] <= nums[mid+1])
        {
            return;
        }
        int i = l, j = mid + 1,k = 0;
        while(i <= mid && j <= r)
        {
            if(nums[i] <= nums[j])
            {
                tmp[k++] = nums[i++];
            }
            else
            {
                tmp[k++] = nums[j++];
            }
        }
        while(i <= mid)
        {
            tmp[k++] = nums[i++];
        }
        while(j <= r)
        {
            tmp[k++] = nums[j++];
        }
        for(i = l,k = 0; i <= r;++i)
        {
            nums[i] = tmp[k++];
        }
        return;
    }

 

      2.2  归并排序算法的应用： LeetCode    剑指 Offer 51. 数组中的逆序对

    

class Solution {
public:
    vector<int> tmp;//归并排序的辅助数组

    int reversePairs(vector<int>& nums) {
        const int len = nums.size();
        if(len < 2) return 0;
        tmp.assign(len,0);
        return merge_sort(nums,0,len - 1);
    }
 
    long long int merge_sort(vector<int>& nums,int l,int r)
    {
        if(l >= r)//归并排序递归出口
        {
            return 0;
        }
        int mid = l + (r - l)/2;//将区间一分为二
        long long ans = merge_sort(nums,l,mid) + merge_sort(nums,mid + 1,r);//递归地求左右子数组的逆序对个数和
        //剪枝优化： 子数组[l,r] 已经有序,横跨两个区间的逆序对个数为 0
        if(nums[mid + 1] >= nums[mid])
        {
           return ans;
        }
        //计算 横跨左右区间的逆序对
        int k = 0,i = l,j = mid + 1;
        while(i <= mid && j <= r)
        {
            if(nums[i] <= nums[j])
            {
                tmp[k++] = nums[i++];
            }
            else
            { //执行上述递归之后，左右子数组都已经排好序
              //此处，nums[i:mid] 都比nums[j] 大，都和num[j] 构成逆序对
                ans += (mid - i + 1);
                tmp[k++] = nums[j++];
            }
        }
        //将左右区间未移动到tmp的继续移到tmp
        while(i <= mid) tmp[k++] = nums[i++];
        while(j <= r) tmp[k++] = nums[j++];
        //将排序好的元素移回原数组，放在原来的区间上,然后nums[l:r]已经排序好了 
        for(i = l,j = 0;i <= r; )
        {
            nums[i++] = tmp[j++];
        }
        return ans;
    }
};

 

3.   堆排序

　　3.1 堆排序 是在数组上建立一个完全二叉树的堆，堆排序分为 建堆 和 排序 两个过程。

    建堆，通过下沉操作建堆效率更高，具体过程是，从最后一个非叶子节点开始，然后从后往前，对每个非叶子节点 执行下沉操作。

这样之后，nums[0:N-1]上就是一个大顶堆。

    排序，将堆顶元素（代表最大元素）与堆的最后一个元素交换，同时从堆范围缩小一个元素，然后新的堆顶元素进行下沉操作，

遍历执行上诉操作，则可以完成排序。

     

//3. 堆排序 
    void heapSort(vector<int>& nums)
    {
       int len = nums.size();
       for(int i = (len - 1)/2; i >= 0; --i)
       {
           siftDown(nums,i,len -1);
       }
       for(int i = len -1 ;i >= 1;)
       {
           swap(nums[0],nums[i]);
           siftDown(nums,0,--i);
       }
       return;
    }
 /**
     * @param nums
     * @param k    当前下沉元素的下标
     * @param end  [0, end] 是堆的有效部分,[end+1,nums.size() - 1] 是nums中排好序的部分
     */
    void siftDown(vector<int>& nums,int k,int end)
    { 
        while(2 * k + 1 <= end)// k为叶节点跳出
        {
            int j = 2 * k + 1 ;//j是k的左子节点索引
            if(j + 1 <= end && nums[j+1] >= nums[j])
            {
                j++;
            }
            //nums[j]是 nums[k]值最大的子节点
            if(nums[j] > nums[k])
            {
                std::swap(nums[k],nums[j]);
            }
            else
            {
                break;
            }
            k = j;
        }
    }

      3.2    堆排序的应用，c++ STL 中 的 优先队列  std::priority_queue 就是堆实现的。

 LeetCode    剑指 Offer 51. 数组中的逆序对  同样可以使用堆解决。

   int findKthLargest(vector<int>& nums, int k) 
    {
        std::priority_queue<int,vector<int>,greater<int>> pq;
        for(auto num : nums)
        {
            if(pq.size() == k && pq.top() >= num ) continue;
            if(pq.size() == k)
            {
                pq.pop();
            }
            pq.push(num);
        }
        return pq.top();
    }