手撕排序

快排

void quick_sort(vector<int>& nums, int l, int r){
    if(l < r){
        int i = l, j = r;
        while(i < j){
            while(i < j && nums[j] >= nums[l]) --j; //  nums[l] 作为分界
            while(i < j && nums[i] <= nums[l]) ++i;
            swap(nums[i], nums[j]);
        }
        swap(nums[l], nums[i]);
        quick_sort(nums, l, i - 1);
        quick_sort(nums, i + 1, r);
    }
}

归并排序

vector<int> tmp;
    void merge_sort(vector<int>& nums, int l, int r){
        if(l >= r) return;
        int mid = l + (r - l) / 2;
        merge_sort(nums, l, mid);
        merge_sort(nums, mid+1, r);
        int i = l, j = mid+1;
        int cur = 0;
        while(i<=mid && j<=r){
            if(nums[i] <= nums[j]){
                tmp[cur++] = nums[i++]; 
            }else{
                tmp[cur++] = nums[j++];
            }
        }
        while(i<=mid){
            tmp[cur++] = nums[i++];
        }
        while(j<=r){
            tmp[cur++] = nums[j++];
        }
        for(int i=0; i<r-l+1; ++i){
            nums[i+l] = tmp[i];
        }
    }

堆排序

void maxHeapify(vector<int>& nums, int i, int len) {
    for (; (i << 1) + 1 <= len;) {
        int lson = (i << 1) + 1;
        int rson = (i << 1) + 2;
        int large;
        if (lson <= len && nums[lson] > nums[i]) {
            large = lson;
        } else {
            large = i;
        }
        if (rson <= len && nums[rson] > nums[large]) {
            large = rson;
        }
        if (large != i) {
            swap(nums[i], nums[large]);
            i = large;
        } else {
            break;
        }
    }
}
void buildMaxHeap(vector<int>& nums, int len) {
    for (int i = len / 2; i >= 0; --i) {
        maxHeapify(nums, i, len);
    }
}
void heapSort(vector<int>& nums) {
    int len = (int)nums.size() - 1;
    buildMaxHeap(nums, len);
    for (int i = len; i >= 1; --i) {
        swap(nums[i], nums[0]);
        len -= 1;
        maxHeapify(nums, 0, len);
    }
}

• 时间复杂度：$O(nlogn)$。初始化建堆的时间复杂度为 $O(n)$，建完堆以后需要进行 n-1n−1 次调整，一次调整（即 maxHeapify） 的时间复杂度为 $O(logn)$，那么 n-1n−1 次调整即需要 $O(nlogn)$ 的时间复杂度。因此，总时间复杂度为 $O(n+nlogn)=O(nlogn)$。

• 空间复杂度：$O(1)$。只需要常数的空间存放若干变量。