【Leetcode刷题记录】各种排序算法

合集 - Leetcode(6)

1.【Leetcode刷题记录】四种买卖股票问题2023-09-042.【Leetcode刷题记录】1、买钢笔和铅笔的方案数；2、一个图中连通三元组的最小度数；3、带因子的二叉树2023-09-013.【Leetcode刷题记录】1、最多可以摧毁的敌人城堡数目；2、消灭怪物的最大数量；3、序列化和反序列化二叉搜索树2023-09-044.【Leetcode刷题记录】1、汇总区间；2、合并区间；3、插入区间2023-09-05

5.【Leetcode刷题记录】各种排序算法2023-09-05

6.【Leetcode刷题记录】1、统计参与通信的服务器；2、统计二叉树中好节点的数目；3、从两个数字数组里生成最小数字2023-09-06

收起

前言：这篇文章总结一下学习的几种排序算法，假设要对一个 vector<int> 数组进行降序排序，数组中一共有 n 个数。

1、冒泡排序

思想：冒泡排序的思想就是一共进行 n - 1 次循环，每次循环把范围内最小的数冒到最后面。

因此用内为双循环，外循环为冒泡的次数，内循环为每次冒泡的范围，通过比较和交换操作将最小值移到后面。

// 第一个循环表示一共要泡几次
// 第二个循环是冒泡
for (int i = 0; i < nums.size() - 1; ++i) {
    for (int j = 0; j < nums.size() -i; ++j) {
        if (nums[j] < nums[j + 1]) {
            int temp = nums[j];
            nums[j] = nums[j + 1];
            nums[j + 1] = temp;
        }
    }
}

2、简单选择排序

思想：简单选择排序非常粗暴！原理就是一共进行 n - 1 次循环，每次循环在范围内找到最大的数，然后把它移到前面！

同样是内外双循环，外循环为选择排序的次数，内循环每次找到范围内最大值，然后交换到最前面。

// 外循环为选择的次数
// 内循环为具体的选择操作
for(int i = 0; i < nums.size() - 1; ++i) {
    int max = i;
    for (int j = i + 1; j < nums.size(); ++j) {
        if (nums[j] > nums[i]) {
            max = j;
        }
    }
    if (max != i) {
        int temp = nums[i];
        nums[i] = nums[max];
        nums[max] = temp;
    }
}

3、直接插入排序

思想：直接插入排序的原理是当循环到下标 i 时，范围 [0,i-1] 已经保证有序，然后判断 nums[i] 是否大于 nums[i-1]，如果是，则往回找到第一个元素下标 j ，使得 nums[j] >= nums[i]，然后把 [j+1,i-1] 范围内元素后移一位，nums[j+1] = nums[i]。

// 直接插入排序（原型）
for (int i = 1; i < nums.size(); ++i) {
    if (nums[i] > nums[i - 1]) {
        int temp = nums[i];
        int j;
        for (j = i - 1; j >= 0 && nums[j] < temp; --j) {
            nums[j + 1] = nums[j];
        }
        nums[j + 1] = temp;
    }
}

4、希尔排序

 思想：希尔排序是直接插入排序的改进。其原理是先设置一个阈值宽度，在这个范围内进行直接插入排序，使数组处于大致有序的状态（大的数基本在前面，中间的数基本在中间，小的数基本在后面）。

然后不断缩小阈值宽度直到它等于 1，此方法可以减少移动次数，因此效率上要优于直接插入排序。

// 希尔排序（改进）
int index = nums.size();
do {
    index = index / 3 + 1;
    for (int i = index; i < nums.size(); ++i) {
        if (nums[i] > nums[i - index]) {
            int temp = nums[i];
            int j;
            for (j = i - index; j >= 0 && nums[j] < temp; j -= index) {
                nums[j + index] = nums[j];
            }
            nums[j + index] = temp;
        }
    }
} while (index > 1);

5、堆排序

思想：堆排序是简单选择排序的改进，其原理是首先把数组构造成一个小顶堆，然后每次将第一个元素与范围内最后一个元素交换，并重新构造小顶堆...

注意事项：构造小顶堆时，break 的条件不能有 = 。

// 将数组构造成小顶堆
for (int i = nums.size()/2 - 1; i >= 0; --i) {
    heapadjust(nums,i,nums.size() - 1);
}

// 堆排序，每次把最小的数移到最后面，然后重新构造堆
for (int i = nums.size() - 1; i > 0; --i) {
    swap(nums,0,i);
    heapadjust(nums,0,i-1);
}

// 构造小顶堆算法
void heapadjust(std::vector<int>& nums, int i, int n) {
    int temp = nums[i];
    for (int j = i * 2 + 1; j <= n; j = j * 2 + 1) {
        if (j <= n - 1 && nums[j] > nums[j + 1]) {
            ++j;
        }
        // 这里不能大于等于
        if (nums[j] > temp) {
            break;
        }
        nums[i] = nums[j];
        i = j;
    }
    nums[i] = temp;
}

void swap(std::vector<int>& nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}

6、归并排序

思想：归并排序用到了分治的思想。将待排序的数组分为两个子数组各自排序，子数组排好后合并到一起即可。注意划分字数组的时候的返回条件，当左端点大于等于右端点时，直接返回！

// nums2是一个中间变量，nums划分为两个有序子数组后，并入到nums2里面，然后再赋值给nums
std::vector<int> nums2 = nums;
sort(nums,nums2,0,nums.size()-1);

// 归并排序算法
void sort(std::vector<int>& nums1, std::vector<int>& nums2, int l, int r) {
    if (l >= r) {
        return;
    }
    int m = l + (r - l) / 2;
    sort(nums1, nums2, l, m);
    sort(nums1, nums2, m + 1, r);
    int k = l, ptr1 = l, ptr2 = m + 1;
    while (ptr1 <= m && ptr2 <= r) {
        nums2[k++] = nums1[ptr1] > nums2[ptr2] ? nums1[ptr1++] : nums2[ptr2++]; 
    }
    while (ptr1 <= m) {
        nums2[k++] = nums1[ptr1++];
    }
    while (ptr2 <= r) {
        nums2[k++] = nums1[ptr2++];
    }
    for (int i = l; i <= r; ++i) {
        nums1[i] = nums2[i];
    }
}

7、快速排序

思想：快速排序的思想是先选取一个中间数，然后通过交换操作将数组分为两个部分，大于等于中间数的数都在中间数的左边，小于等于中间数的数都在中间数的右边。然后对这两个区域分别进行快速排序。

具体的，每次就选取区域内的第一个元素作为中间数！

// 对数组作快速排序
quicksort(nums,0,nums.size()-1);

// 快速排序算法
void quicksort(std::vector<int>& nums, int l, int r) {
    if (l >= r) {
        return;
    }
    int m = getmid(nums,l,r);
    quicksort(nums,l,m-1);
    quicksort(nums,m+1,r);
}

// 将区域分为两部分，同时返回中间数下标
int getmid(std::vector<int>& nums, int l, int r) {
    int index = nums[l];
    while (l < r) {
        while (l < r && nums[r] <= index) {
            r--;
        }
        swap(nums,l,r);
        while (l < r && nums[l] >= index) {
            l++;
        }
        swap(nums,l,r);
    }
    return l;
}

void swap(std::vector<int>& nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}