目录
1. 基本思想
所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
2.冒泡排序
2.1 基本思想
2.2 代码示例
//交换
void Swap(int* p, int* q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
//冒泡排序
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
//标志位，用于记录本轮是否发生了元素交换
bool flag = false;
for (int j = 0; j < n - i - 1; j++)
{
if (a[j + 1] < a[j])
{
//交换相邻元素
Swap(&a[j + 1], &a[j]);
flag = true;
}
}
//如果本轮没有发生元素交换，说明数组已经有序，提前结束排序
if (!flag)
break;
}
}
//打印
void PrintSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
//测试
int main()
{
int a[] = { 1, 5, 7, 9, 0, 2, 4, 8, 3, 8, 6 };
BubbleSort(a, sizeof(a) / sizeof(int));
PrintSort(a, sizeof(a) / sizeof(int));
return 0;
}
2.3 冒泡排序的特性总结
- 时间复杂度：冒泡排序的平均时间复杂度为O(n^2)，最坏情况下为O(n^2)，最好情况下为O(n)。因此，冒泡排序对于大规模数据集并不是一个高效的选择。
- 空间复杂度：冒泡排序的空间复杂度为O(1)，因为它只需要一个额外的临时变量来进行元素交换。
- 稳定性：冒泡排序是一种稳定的排序算法，相同元素的相对位置在排序前后不会改变。
- 适用场景：由于冒泡排序的效率较低，通常不推荐在实际应用中使用。但对于小规模数据集或者教学目的，冒泡排序是一个很好的入门算法。
- 优缺点：冒泡排序的优点是实现简单，代码易于理解；缺点是效率低下，不适用于大规模数据集。
3.快速排序
3.1 基本思想
将区间按照基准值划分为左右两半部分的常见方式有：
🌵hoare版本
//交换
void Swap(int* p, int* q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
//如果子数组长度为1或0，则直接返回
if (begin >= end)
return;
//初始化左右指针和基准值
int left = begin, right = end;
int keyi = begin;
while (left < right)
{
//从右向左找第一个小于基准值的元素
while (left < right && a[right] >= a[keyi])
{
--right;
}
//从左向右找第一个大于基准值的元素
while (left < right && a[left] <= a[keyi])
{
++left;
}
//将找到的元素位置进行交换
Swap(&a[right], &a[left]);
}
//将基准元素放到正确的位置上
Swap(&a[left], &a[keyi]);
keyi = left;
//递归的对基准元素左右两侧的子数组进行快速排序
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
//打印
void PrintSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
//测试
int main()
{
int a[] = { 1, 5, 7, 9, 0, 2, 4, 8, 3, 8, 6 };
QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
PrintSort(a, sizeof(a) / sizeof(int));
return 0;
}
🌵挖坑法
// 挖坑法
int PartSort(int* a, int begin, int end)
{
//选择第一个元素作为基准元素
int key = a[begin];
int hole = begin;
while (begin < end)
{
//从右往左找到第一个小于基准元素的元素
while (begin < end && a[end] >= key)
{
--end;
}
//将找到的元素填入左边的坑
a[hole] = a[end];
//更新坑的位置
hole = end;
//从左往右找到第一个大于基准元素的元素
while (begin < end && a[begin] <= key)
{
++begin;
}
//将找到的元素填入右边的坑
a[hole] = a[begin];
//更新坑的位置
hole = begin;
}
//将基准元素放入最终的坑
a[hole] = key;
return hole;
}
void QuickSort(int* a, int begin, int end)
{
//如果子数组长度为1或0，则直接返回
if (begin >= end)
return;
int keyi = PartSort(a, begin, end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
//打印
void PrintSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
//测试
int main()
{
int a[] = { 1, 5, 7, 9, 0, 1, 2, 4, 8, 1, 3, 8, 6 };
QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
PrintSort(a, sizeof(a) / sizeof(int));
return 0;
} 
🌵前后指针版本
//交换
void Swap(int* p, int* q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
//前后指针法
int PartSort(int* a, int begin, int end)
{
int key = begin;
int prev = begin;
int cur = prev + 1;
while (cur <= end)
{
//如果cur位置的值小于key位置的值，
//并且prev位置++后的值如果和cur位置的值不相等，
//就交换prev位置和cur位置的值
if (a[cur] < a[key] && ++prev != cur)
Swap(&a[prev], &a[cur]);
++cur;
}
Swap(&a[prev], &a[key]);
key = prev;
return key;
}
void QuickSort(int* a, int begin, int end)
{
//如果子数组长度为1或0，则直接返回
if (begin >= end)
return;
int keyi = PartSort(a, begin, end);
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
3.2 快速排序优化
🌻三数取中法选key
🍂代码示例：
//交换
void Swap(int* p, int* q)
{
int tmp = *p;
*p = *q;
*q = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
//选择三个元素的中间值作为基准元素
int midi = (begin + end) / 2;
//确保 a[begin] <= a[midi] <= a[end]
if (a[begin] < a[midi])
{
if (a[midi] < a[end])
return midi;
else if (a[begin] > a[end])
return begin;
else
return end;
}
else //a[begin] > a[midi]
{
if (a[midi] > a[end])
return midi;
else if (a[begin] < a[end])
return begin;
else
return end;
}
}
//快速排序
void QuickSort(int* a, int begin, int end)
{
//如果子数组长度为1或0，则直接返回
if (begin >= end)
return;
int midi = GetMidi(a, begin, end);
Swap(&a[midi], &a[begin]);
//初始化左右指针和基准值
int left = begin, right = end;
int keyi = begin;
while (left < right)
{
//从右向左找第一个小于基准值的元素
while (left < right && a[right] >= a[keyi])
{
--right;
}
//从左向右找第一个大于基准值的元素
while (left < right && a[left] <= a[keyi])
{
++left;
}
//将找到的元素位置进行交换
Swap(&a[right], &a[left]);
}
//将基准元素放到正确的位置上
Swap(&a[left], &a[keyi]);
keyi = left;
//递归的对基准元素左右两侧的子数组进行快速排序
QuickSort(a, begin, keyi - 1);
QuickSort(a, keyi + 1, end);
}
//测试
int main()
{
int a[] = { 1, 5, 7, 9, 0, 2, 4, 8, 3, 8, 6 };
QuickSort(a, 0, sizeof(a) / sizeof(int) - 1);
PrintSort(a, sizeof(a) / sizeof(int));
return 0;
}
