排序算法学习

冒泡排序

双层循环每次只找到一个最大的
优化方案：内层循环控制排序每次都可以减少一个

void popSort(std::vector<int>& nums)
{
    int size = nums.size();
    if (size < 2) return;
   
    for (int i = 0; i < size; i++) {
        for (int j = 1; j < size - i; j++) {
            if (nums[j] < nums[j - 1]) {
                std::swap(nums[j], nums[j - 1]);
            }
        }
    }
    return;
}

选择排序

每次循环都找到一个val最小的pos然后与这一趟最开始的位置交换
优化：加flag如果一次循环之后没有改变flag的值那么直接返回

void selectSort(std::vector<int>& nums)
{
    int size = nums.size();
    if (size < 2) return;

    for (int i = 0; i < size; i++) {
        int minpos = i;
        for (int j = i; j < size; j++) {
            if (nums[minpos] > nums[j]) {
                minpos = j;
            }
        }

        if (i != minpos) {
            std::swap(nums[i], nums[minpos]);
        }
    }
    return;
}

插入排序

类比插牌，取出张牌当前牌的位置是如果比此张牌大则当前位置的牌往后移一位
如果当前牌的位置比此张牌小，上一张牌的位置已经被保存过，因此插到上张牌的位置即可
优化：分组 = 希尔排序

void insertSort(std::vector<int>& nums)
{
    int size = nums.size();
    if (size < 2) return;

    for (int i = 0; i < size; i++) {
        int j = i - 1;
        int temp = nums[i];
        for (; j >= 0; j--) {
            if (nums[j] > temp) {
                nums[j + 1] = nums[j];
            }else {
                break;
            }
        }
        nums[j + 1] = temp;
    }
    return;
}

希尔排序

希尔排序是分组的插入排序，插入排序的比较的次数较多，分组排序更快速
{7，8，9，4，5，6，1，2，3}
如若3想插入排序，正常会比较 8 次，如果分组是3那么 6 9 7就够了

void shellSort(std::vector<int>& nums)
{
    int size = nums.size();
    if (size < 2) return;

    for (int group = size / 2; group > 0; group /= 2) {
        for (int i = group; i < size; i++) {
            int j = i - group;
            int temp = nums[i];
            for (; j >= 0; j -= group) {
                if (nums[j] > temp) {
                    nums[j + group] = nums[j];
                }else {
                    break;
                }
            }
            nums[j + group] = temp;
        }
    }
}

快速排序

//划分函数
int partition(std::vector<int>& nums, int left, int right)
{
	//优化方案


    //int index = left + rand() % (right - left);
    //std::swap(nums[left], nums[index]);
    if (left >= right) return left;
    int val = nums[left];
    while (left < right) {
        while (left < right && nums[right] > val) right--;
        nums[left] = nums[right];
        while (left < right && nums[left] <= val) left++;
        nums[right] = nums[left];
    }
    //退出的条件是left == right 为什么选择left去保存val呢？
    //退出的上一次left的值已经被保存了
    //left刚好也是划分点的值
    nums[left] = val;
    return left;
}
//排序
void quickSort(std::vector<int>& nums, int left, int right)
{
    if (left > right) return;

    int pos = partition(nums, left, right);
    
    quickSort(nums, left, pos - 1);
    quickSort(nums, pos + 1, right);
    return;
}```

![在这里插入图片描述](https://img-blog.csdnimg.cn/9f9d12e92da640bfb4f41c6981b26467.png)

# 待补充