部分排序算法

最新推荐文章于 2024-07-12 18:56:03 发布

九九码龙

最新推荐文章于 2024-07-12 18:56:03 发布

阅读量45

点赞数

文章标签：排序算法算法 leetcode

本文链接：https://blog.csdn.net/m0_48469060/article/details/133892832

版权

1 冒泡排序（改进版）

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            bool swapped = false;
            for (int j = 0; j < n- i - 1; j++) {
                if (nums[j] > nums[j + 1]) {
                    swap(nums[j], nums[j + 1]);
                    swapped = true;
                }
            }
            if (!swapped) break;
        }
        return nums;
    }
};

2 快速排序

class Solution {
private:
    int partition(vector<int> &nums, int left, int right) {
        int pivot = nums[left];
        while(left < right) {
            while(left < right && nums[right] >= pivot) --right;
            nums[left] = nums[right];
            while(left < right && nums[left] <= pivot) left++;
            nums[right] = nums[left]; 
        }
        nums[left] = pivot;
        return left;
    }

    void quickSort(vector<int> &nums, int left, int right) {
        if (left < right) {
            int random = (int)rand() % (right - left + 1) + left;
            swap(nums[left], nums[random]);
            int middle = partition(nums, left, right);
            quickSort(nums, left, middle - 1);
            quickSort(nums, middle + 1, right);
        }

    }
public:
    vector<int> sortArray(vector<int>& nums) {
        srand((unsigned)time(NULL));
        quickSort(nums, 0, nums.size() - 1);
        return nums;
    }
};

不要总是选择数组的第一个元素或最后一个元素作为基准元素。而是随机选择基准元素，这样可以避免在有序情况下出现最坏的时间复杂度。随机选择可以通过生成一个随机索引来实现。

3路快排加随机基准

class Solution {
private:
    void quickSort3Way(vector<int>&nums, int l, int r) {
        if (l < r) {
            int randIndex = rand() % (r - l + 1) + l;
            swap(nums[l], nums[randIndex]);
            int lt = l, gt = r, i = l + 1;
            int pivot = nums[l];
            while(i <= gt) {
                if (nums[i] < pivot) {
                    swap(nums[i++], nums[lt++]);
                } else if (nums[i] > pivot) {
                    swap(nums[i], nums[gt--]);
                } else {
                    i++;
                }
            }
            quickSort3Way(nums, l, lt - 1);
            quickSort3Way(nums, gt + 1, r);
        }
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        srand((unsigned)time(NULL));
        quickSort3Way(nums, 0, nums.size() - 1);
        return nums;
    }
};