排序算法整理

汇总下（来源lc大佬: 骄阳似我）

冒泡排序

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

选择排序

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

快速排序

class Solution {
    void quickSort(vector<int>&nums, int startIndex, int endIndex) {
        if (startIndex >= endIndex) return;

        int x = rand()%(endIndex - startIndex + 1) + startIndex;
        swap(nums[startIndex], nums[x]);
        int firstNum = nums[startIndex];

        int l = startIndex, r = endIndex;
        while(l < r){
            while(l < r && nums[r] >= firstNum) --r;
            if(l < r){
                nums[l] = nums[r];
            }
            while(l < r && nums[l] <= firstNum) ++l;
            if(l < r){
                nums[r] = nums[l];
            }
        }
        nums[l] = firstNum;
        quickSort(nums, startIndex, l - 1);
        quickSort(nums, l + 1, endIndex);
    }

public:
    vector<int> sortArray(vector<int>& nums) {
        int n = nums.size();
        quickSort(nums, 0, n - 1);
        return nums;
    }
};

归并排序（添加个人注释版）

class Solution{
    vector<int> tmp;
    /*
    向量（vector）是标准模板库（STL）中的一种动态数组，它提供了类似于数组的功能，但具有动态调整大小的能力。
    vector<int>：表示一个存储 int 类型数据的动态数组。
    */
    void mergeSort (vector<int>& nums, int l, int r){
        if(l >= r) return;
        int mid = l + (r - l) / 2;
        mergeSort(nums, l, mid);
        mergeSort(nums, mid + 1, r);
        int i = l, j = mid + 1, pos = l;
        while(i <= mid && j <= r){
            if (nums[i] <= nums[j]){
                tmp[pos] = nums[i];
                ++i;
            }else{
                tmp[pos] = nums[j];
                ++j;
            }
            ++pos;
        }
        for (int k = i; k <= mid; ++k){
            tmp[pos++] = nums[k];
        }
        for (int k = j; k <= r; ++k){
            tmp[pos++] = nums[k];
        }
        /*
        关于for循环：在归并排序中，合并两个已排序子数组时，可能会出现一个子数组被完全遍历完，而另一个子数组还有剩余元素未被处理的情况。上一步的 while 循环仅处理了两个子数组的交集部分，确保每次都将两个子数组中的较小元素放入 tmp 中。当 while 循环结束时，至少有一个子数组中的所有元素已经被处理完并放入 tmp 中，而另一个子数组可能还有剩余元素。
        */
        copy(tmp.begin() + l, tmp.begin() + r + 1, nums.begin() + l);
        /*
        tmp.begin() + l: 返回 tmp 数组中从索引 l 开始的迭代器。
        tmp.begin() + r + 1: 返回 tmp 数组中从索引 r + 1 开始的迭代器。这表示的范围是 [l, r]，包括 r。
        nums.begin() + l: 返回 nums 数组中从索引 l 开始的迭代器，表示复制的目标位置。
        */
    }
public:
    vector<int> sortArray(vector<int>& nums){
        int n = nums.size();
        tmp = nums;
        mergeSort(nums, 0, n - 1);
        return nums;
    }
};