目录
题目：第K个最大元素. - 力扣（LeetCode）
题解
方法一 快速排序
方法二 桶排序
思考：各个排序的思路，以及时间复杂度是多少？
1. 冒泡排序（Bubble Sort）
2. 选择排序（Selection Sort）
3. 插入排序（Insertion Sort）
4. 快速排序（Quick Sort）
5. 归并排序（Merge Sort）
6. 堆排序（Heap Sort）
题目：第K个最大元素. - 力扣（LeetCode）
题解
方法一 快速排序
第K大数本身，这是一个经典的快速排序问题，以此做一个快速排序的复习。
需要注意的是，这个题严格规定时间为O(N)，快排则是期望为线性O（N）的。
快速排序的思路：
选取一个基准（pivot），通过一趟排序将数据分成两部分：左边的都小于等于基准，右边的都大于基准。然后递归地对左右两部分进行快速排序。
举例(如果有错，理解就可以）：
6 5 3 4 2 1
l = 0, r = 5
i = -1， j = 6
x = q[0] = 6
while循环结束
i = 0 j = 5
swap(q[0], q[5])
k=4<=5,继续,递归走if
1 5 3 4 2 6
l = 0, r = 5
i = - 1，j = 6
x = q[0] = 1
while(i < j)
while(q [ ++ i ] < 1) 不存在 i = 0
while(q [ - - j ] > 1) j = 0
k = 4 >= 0
走else l = j + 1 = 1, r = 5
1 5 3 4 2 6
l = 1, r = 5
x = q[1] = 5
i = 0, j = 6
while(i < j)
while(q [ ++ i ] < 5) 不存在 i = 1
while(q [ - - j ] > 1) j = 4
swap(q[1], q[4])
1 2 3 4 5 6
l = 1, r = 4
i = 0, j = 5
x = q[1] = 2
i = j = 1
l = 2 ,r = 4
···
l = 4, r = 4 return q[4]
代码：
class Solution {
public:
int quick_select(vector<int>& q, int l, int r, int k) {
if (l == r) return q[l]; // 只有一个元素时直接返回
int i = l - 1, j = r + 1;
int x = q[l]; // 选择第一个元素作为基准
while (i < j) {
while (q[++i] < x); // 向右找第一个不小于 x 的元素
while (q[--j] > x); // 向左找第一个不大于 x 的元素
if (i < j) swap(q[i], q[j]); // 交换
}
// 判断 k 在左半部分还是右半部分
if (k <= j) return quick_select(q, l, j, k); // 在左半部分查找
else return quick_select(q, j + 1, r, k); // 在右半部分查找
}
int findKthLargest(vector<int>& nums, int k) {
int n = nums.size();
return quick_select(nums, 0, n - 1, n - k); // 查找第 n-k 个最小的元素
}
};
方法二 桶排序
该题给出的数据范围以及时间限制，实际上桶排序更符合要求。
代码：
class Solution {
public:
int findKthLargest(vector<int>& nums, int k) {
vector<int> s(20010, 0); // 初始化计数数组，大小为20010，用于存储[-10000, 10000]范围内的数字频率
// 统计每个元素出现的次数
for (int num : nums) {
s[num + 10000]++; // 将原数组元素映射到[0, 20010)的范围
}
// 从大到小遍历查找第k大元素
for (int i = 20009; i >= 0; i--) { // 从最大值开始遍历
k -= s[i];
if (k <= 0) {
return i - 10000; // 将索引还原为原数组的数值
}
}
return -1; // 如果没有找到（理论上不应到达这里）
}
};
思考：各个排序的思路，以及时间复杂度是多少？
1. 冒泡排序（Bubble Sort）
- 思路：重复地遍历要排序的列表，每次比较相邻的两个元素，如果它们的顺序错误就交换它们。每一轮遍历后，最大的元素都会“冒泡”到未排序部分的最后。
- 时间复杂度：最坏情况下是 O(n^2)。
- 稳定性：稳定（相同元素的相对位置不会改变）。
- 特点：实现简单，但效率较低，适合小规模数据或教学用途。
2. 选择排序（Selection Sort）
- 思路：每次从未排序部分选出最小（或最大）的元素，放到已排序部分的末尾。通过遍历找到最小值或最大值的位置，然后交换到正确的位置。
- 时间复杂度：最坏情况下是 O(n^2)。
- 稳定性：不稳定（相同元素的相对位置可能改变）。
- 特点：比较次数固定为 n(n−1)/2，交换次数较少。
3. 插入排序（Insertion Sort）
- 思路：将元素逐一插入到已排序部分的合适位置。初始时只有一个元素是已排序的，然后依次将未排序元素插入到前面已排序的部分。
- 时间复杂度：最坏情况下是O(n^2)，最优情况下是 O(n)（当输入已经有序）。
- 稳定性：稳定。
- 特点：适合小规模或基本有序的数据。
4. 快速排序（Quick Sort）
- 思路：选取一个基准（pivot），通过一趟排序将数据分成两部分：左边的都小于等于基准，右边的都大于基准。然后递归地对左右两部分进行快速排序。
- 时间复杂度：平均是 O(nlogn)，最坏情况下是 O(n^2)（当每次选的基准都是最大或最小值）。
- 稳定性：不稳定。
- 特点：在大多数情况下是最快的基于比较的排序算法，广泛使用。
5. 归并排序（Merge Sort）
- 思路：将待排序数组分成两部分，递归地对两部分进行归并排序，然后将两部分合并成一个有序数组。
- 时间复杂度：始终是O(nlogn)。
- 稳定性：稳定。
- 特点：适合大规模数据排序，特别是外部排序（如磁盘数据），但需要额外的空间来存储临时数据。
6. 堆排序（Heap Sort）
- 思路：利用堆这种数据结构（通常是大顶堆或小顶堆）来排序。首先构造一个大顶堆（或小顶堆），然后反复将堆顶元素取出并重新调整堆，直到所有元素有序。
- 时间复杂度：最坏情况下是 O(nlogn)。
- 稳定性：不稳定。
- 特点：不需要额外的空间，适合大数据的内存排序。
