LeetCode 912. 排序数组

思路：快速排序 or 堆排序

快速排序在最坏情况下，时间复杂度回归O(n^2)，所以不通过

class Solution {
public:
    int part_quick(vector<int>& nums, int low, int high)
    {
        int guard = nums[low];
        while(low<high)
        {
            while(low<high & nums[high]>=guard)
                high--;
            nums[low]=nums[high];

            while(low<high & nums[low]<=guard)
                low++;
            nums[high]=nums[low];
        }
        nums[low] = guard;
        return low;
    }
    void quicksort(vector<int>& nums, int low, int high)
    {
        if(low<high)
        {
            int guard_index = part_quick(nums,low,high);
            quicksort(nums,low,guard_index-1);
            quicksort(nums,guard_index+1,high);
        }
    }
    vector<int> sortArray(vector<int>& nums) {
        int len = nums.size();
        quicksort(nums,0,len-1);
        return nums;
    }
};

堆排序

1、建大顶堆：从最后一个非叶子节点开始构建大顶堆
2、排序：每次交换堆顶和堆尾，再从堆顶重构大顶堆

class Solution {
public:
    void heaptop(vector<int>& nums, int n, int i)
    {
    	// 获取父节点、左子节点、右子节点的最大值索引
        int max_index = i;
        int left = 2*i+1;
        int right = 2*i+2;
        if(left < n && nums[left] > nums[max_index])
            max_index = left;
        if(right < n && nums[right] > nums[max_index])
            max_index = right;
        
        // 如果父节点不是最大值，则进行交换，对交换后的子节点递归重构大顶堆
        if(max_index != i)
        {
            swap(nums[i], nums[max_index]);
            heaptop(nums,n, max_index);
        }
    }
    void heapsort(vector<int>& nums, int len)
    {
        // 建堆，从最后一个非叶子节点开始构建大顶堆（节点i的父节点为(i-2)/2, 最后一个节点的父节点：((len-1)-1)/2 = len/2-1 ）
        for(int i = len/2-1; i >= 0;i--)
        {
            heaptop(nums,len,i);
        }
        // 排序，每次将堆顶和堆尾交换，堆尾有序，不在参与大顶堆重构
        for(int i=len-1;i>0;i--)
        {
            swap(nums[0],nums[i]);
            heaptop(nums,i,0);
        }
    }
    vector<int> sortArray(vector<int>& nums) {
        int len = nums.size();
        heapsort(nums,len);
        return nums;
    }
};