从零开始的CPP——(12)冒泡排序，选择排序，插入排序

题目源自于leetcode 88合并两个数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

首先把nums1和nums2直接合并

for (int i = 0; i < n; i++) {
    nums1[i + m] = nums2[i];
}

之后对nums1进行排序，可以使用排序函数sort

sort(nums1.begin(), nums1.end());

也可以自己手动排序

1.冒泡排序

冒泡排序的核心思想是比较相邻的元素并交换它们，一轮比较交换后，最大的元素会被 "冒泡" 到最后。 冒泡排序的时间复杂度是O(n^2)。

首先int l=m+n，即nums1现在的长度

for (int i = 0; i < l - 1; i++) {
    for (int j = 0; j < l - i - 1; j++) {
        if (nums1[j] > nums1[j + 1]) {
            int temp = nums1[j];
            nums1[j] = nums1[j + 1];
            nums1[j + 1] = temp;
        }
    }
}

外层遍历控制内层遍历执行次数，执行l-1次。内层遍历比较相邻元素并交换。 冒泡保证了内层一次遍历之后最大的一定被正确归位到最右侧，所以内层范围也从右侧逐渐缩小。

交换的部分也可以这么写 。

swap(nums1[j], nums1[j + 1]);

2.选择排序

选择排序的基本思想是在未排序的部分中选择最小（或最大）的元素，然后将其放到已排序部分的末尾。这个过程不断地重复，直到整个数组排序完成。选择排序的时间复杂度同样是O(n^2)。

for (int i = 0; i < l - 1; i++) {
    int minIndex = i;

    for (int j = i + 1; j < l; j++) {
        if (nums1[j] < nums1[minIndex]) {
            minIndex = j;
        }
    }

    if (minIndex != i) {
        swap(nums1[i], nums1[minIndex]);
    }
}

外层循环与冒泡一样，从0到l-1，用index记录最小项位置，内层遍历找到最小项位置，并于i替换。这保证了内层循环一次之后，最小的一定在最左侧，所以内层范围从左侧逐渐变小。

3.插入排序

插入排序的基本思想是将一个元素插入到已经排好序的部分，逐步扩大已排好序的部分，直至全部元素有序。对于小规模的数据或是基本有序的数据，插入排序是一个不错的选择。平均情况下，时间复杂度也是 O(n^2)。

for (int i = 1; i < l; i++) {
    int key = nums1[i];
    int j = i - 1;

    while (j >= 0 && nums1[j] > key) {
        nums1[j + 1] = nums1[j];
        j = j - 1;
    }

    nums1[j + 1] = key;
}

外层循环控制遍历整个数组，内层while让数组每一项都与key比较，让小的key永远被排到最左侧。这样被排好的队列会越来越长。如果初始队列就被排好了，插入排序什么都不会执行。

4.快速排序

快速排序基本思想是通过选择一个基准元素，将数组划分为两个子数组，使得左子数组的所有元素小于等于基准元素，右子数组的所有元素大于基准元素。然后，对左右子数组分别递归地进行快速排序。在平均情况下，快速排序的时间复杂度是 O(n log n)。在最坏情况下（例如，选择的基准总是最小或最大元素），时间复杂度为 O(n^2)。上述四种排序方式空间复杂度都是O(1)。

以下是对数组快速排序的方法

int partition(vector<int>& nums, int low, int high) {
    int pivot = nums[high];
    int i = low - 1;

    for (int j = low; j < high; j++) {
        if (nums[j] <= pivot) {
            i++;
            swap(nums[i], nums[j]);
        }
    }

    swap(nums[i + 1], nums[high]);
    return i + 1;
}

void quickSort(vector<int>& nums, int low, int high) {
    if (low < high) {
        int pi = partition(nums, low, high);

        quickSort(nums, low, pi - 1);
        quickSort(nums, pi + 1, high);
    }
}

分为两部分，一部分是分区排序，一部分是递归调用。

先看分区排序部分

pivot是选取的基准，在排序之后，基准会被放到正确的位置

之后传回更新基准位置，递归调用

main函数中传入的low为0，high为l-1

下面是主函数示例

void printVector(const vector<int>& nums) {
    for (int num : nums) {
        cout << num << " ";
    }
    cout << endl;
}

int main() {
    vector<int> nums1 = { 1, 2, 3, 4, 5, 6 };
    int n = nums1.size();

    cout << "Original array: ";
    printVector(nums1);

    quickSort(nums1, 0, n - 1);

    cout << "Sorted array: ";
    printVector(nums1);

    return 0;
}