LeetCode912:排序数组

主要的排序算法实现：

class Solution {
public:
    //快排 时间复杂度:O(nlgn) 空间复杂度:O(lgn)
    void func(vector<int>& nums, int low, int high){
        if(low < high){
            int mid = func1(nums, low, high);
            func(nums, low, mid);
            func(nums, mid+1, high);
        }
    }
    int func1(vector<int>& nums, int low, int high){
        int key = nums[low];
        while(low < high){
            while(low < high && key <= nums[high]) high--;
            nums[low] = nums[high];
            while(low < high && key >= nums[low]) low++;
            nums[high] = nums[low];
        }
        nums[low] = key;
        return low;
    }
    //插入排序 时间复杂度:O(n2-n) 空间复杂度:O(1)
    void insertSort(vector<int>& nums){
        for(int i = 1; i < nums.size(); i++){
            int temp = nums[i];
            for(int j = i-1; j >= 0; j--){
                if(temp < nums[j]){
                    nums[j+1] = nums[j];
                    nums[j] = temp;
                }
                else{
                    break;
                }
            }
        }
    }
    //希尔排序 时间复杂度:O(n2-n) 空间复杂度:O(1)
    void shellSort(vector<int>& nums){
        for(int d = nums.size()/2; d>=1; d = d/2){
            for(int i = d; i < nums.size(); i++){
            int temp = nums[i];
            for(int j = i-d; j >= 0; j-=d){
                if(temp < nums[j]){
                    nums[j+d] = nums[j];
                    nums[j] = temp;
                }
                else{
                    break;
                }
            }
            }
        }
    }
    //选择排序 时间复杂度:O(n2) 空间复杂度:O(1)
    void selectSort(vector<int>& nums){
        int min = 0;
        for(int i = 0; i < nums.size(); i++){
            int min = i;
            for(int j = i+1; j < nums.size(); j++){
                if(nums[min] > nums[j]){
                    min = j;
                }
            }
            if(min != i) swap(nums[min], nums[i]);
        }
    }
    //冒泡排序 时间复杂度:O(n2) 空间复杂度:O(1)
    void bubleSort(vector<int>& nums){
        for(int i = 0; i < nums.size(); i++){
            for(int j = 1; j < nums.size(); j++){
                if(nums[j] < nums[j-1]) {
                    swap(nums[j], nums[j-1]);
                }
            }
        }
    }
    //归并排序 时间复杂度:O(nlgn) 空间复杂度:O(n)
    void merge(vector<int>& nums, int low, int high){
        if(low >= high) return;
        int mid = low + (high - low) / 2;
        merge(nums, low, mid);
        merge(nums, mid+1, high);
        mergeSort(nums, low, mid, high);
    }
    void mergeSort(vector<int>& nums, int low, int mid, int high){
        int l = low, m = mid+1, h = high;
        vector<int> temp(high - low + 1);
        int k = 0;
        while(l <= mid && m <= high){
            if(nums[l] < nums[m]){
                temp[k++] = nums[l++];
            }else{
                temp[k++] = nums[m++];
            }
        }
        while(l <= mid) temp[k++] = nums[l++];
        while(m <= high) temp[k++] = nums[m++];
        for(int i = 0; i < temp.size(); i++){
            nums[i+low] = temp[i];
        }
    }
    //桶排 时间复杂度:O(n+c) 空间复杂度:O(n)
    void bucketSort(vector<int>& nums){
        vector<int> bk(50000);
        for(auto num : nums){
            bk[num]++;
        }
        int k = 0;
        for(int i = 0; i < bk.size(); i++){
            while(bk[nums[i]]){
                nums[k++] = bk[i];
                bk[i]--;
            }
        }
    }
    //基数排序 时间复杂度:O(d(r+n)-d(n+rd)) 空间复杂度:O(n+rd)
    void countSort(vector<int>& nums){
        int max = INT_MIN, min = INT_MAX;
        for(int num : nums){
            if(num > max) max = num;
            if(num < min) min = num;
        }
        vector<int> bk(max-min+1);
        for(int num : nums){
            bk[num-min]++;
        }
        int k = 0;
        for(int n = min; n <= max; n++){
            int cnt = bk[n-min];
            while(cnt--){
                nums[k++] = n;
            }
        }
    }
    //堆排序 时间复杂度:O(nlgn) 空间复杂度:O(1)
    void heapify(vector<int>& nums, int index, int len){
        int left = 2*index+1, right = 2*index+2;
        int maxindex = index;
        if(left < len && nums[left] > nums[maxindex]) maxindex = left;
        if(right < len && nums[right] > nums[maxindex]) maxindex = right;
        if(index != maxindex){
            swap(nums[index], nums[maxindex]);
            heapify(nums, maxindex, len);
        }else{
            return;
        }
    }
    void heapSort(vector<int>& nums){
        int n = nums.size();
        for(int i = n/2; i >=0; i--){
            heapify(nums, i, n);
        }
        for(int j = n-1; j >= 1; j--){
            swap(nums[0], nums[j]);
            heapify(nums, 0, j);
        }
    }

    
    vector<int> sortArray(vector<int>& nums) {
        if(nums.empty()) return nums;
        //func(nums, 0, nums.size()-1);
        //insertSort(nums);
        //selectSort(nums);
        //bubleSort(nums);
        //merge(nums, 0, nums.size()-1);
        //bubleSort(nums);
        //countSort(nums);
        //heapSort(nums);
        shellSort(nums);
        return nums;
    }
};