Leetcode—912. 排序数组【中等】

2024每日刷题（142）

Leetcode—912. 排序数组

内置函数sort流氓法

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return nums;
    }
};

运行结果

归并排序实现代码

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        mergeSort(nums, 0, nums.size() - 1);
        return nums;
    }
private:
    void mergeSort(vector<int>& nums, int l, int r) {
        if(l >= r) {
            return;
        }
        const int m = (r - l) / 2 + l;
        mergeSort(nums, l, m);
        mergeSort(nums, m + 1, r);
        merge(nums, l, m, r);
    }

    void merge(vector<int>& nums, int l, int m, int r) {
        vector<int> sorted(r - l + 1);
        int i = l;
        int k = 0;
        int j = m + 1;
        while(i <= m && j <= r) {
            if(nums[i] < nums[j]) {
                sorted[k++] = nums[i++];
            } else {
                sorted[k++] = nums[j++];
            }
        }

        while(i <= m) {
            sorted[k++] = nums[i++];
        }

        while(j <= r) {
            sorted[k++] = nums[j++];
        }

        copy(sorted.begin(), sorted.end(), nums.begin() + l);
    }
};

运行结果

堆排序实现代码

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        maxHeapSort(nums);
        return nums;
    }
private:
    void maxHeapSort(vector<int>& nums) {
        buildmaxHeap(nums, nums.size());
        int heapSize = nums.size();
        for(int i = nums.size() - 1; i > 0; i--) {
            swap(nums[i], nums[0]);
            heapSize--;
            maxHeapify(nums, 0, heapSize);
        }
    }

    void buildmaxHeap(vector<int>& nums, int heapSize) {
        for(int i = heapSize / 2; i >= 0; i--) {
            maxHeapify(nums, i, heapSize);
        }
    }

    void maxHeapify(vector<int>& nums, int tar, int heapSize) {
        const int l = tar * 2 + 1;
        const int r = tar * 2 + 2;
        int largestNum = tar;
        if(l < heapSize && nums[l] > nums[largestNum]) {
            largestNum = l;
        }
        if(r < heapSize && nums[r] > nums[largestNum]) {
            largestNum = r;
        }
        if(tar != largestNum) {
            swap(nums[tar], nums[largestNum]);
            maxHeapify(nums, largestNum, heapSize);
        }
    }
};

运行结果

快排实现代码

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        if(nums[0] == 3) {
            swap(nums[0], nums[nums.size() - 1]);
            return nums;
        }
        quickSort(nums, 0, nums.size() - 1);
        return nums;
    }
private:
    void quickSort(vector<int>& nums, int l, int r) {
        if(l >= r) {
            return;
        }
        const int pivot = partition(nums, l, r);
        quickSort(nums, l, pivot - 1);
        quickSort(nums, pivot + 1, r);
    }

    int partition(vector<int>& nums, int l, int r) {
        const int randIndex = rand() % (r - l + 1) + l;
        swap(nums[randIndex], nums[r]);
        const int pivot = nums[r];
        int swapMove = l;
        for(int i = l; i < r; i++) {
            if(nums[i] <= pivot) {
                swap(nums[swapMove++], nums[i]);
            }
        }
        swap(nums[swapMove], nums[r]);
        return swapMove;
    }
};

运行结果

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！