在数据结构中，排序是一种将数据元素重新排列的过程，通常是为了使它们按照特定的顺序（如升序或降序）组织起来。排序在计算机科学中非常重要，下面是一些常见的数据结构排序方法和它们的特点
1.冒泡排序
- 原理：重复遍历待排序的列表，比较相邻元素并交换它们的顺序，使得较大的元素逐渐"冒泡"到列表的末端。
- 时间复杂度：O(n²)
- 空间复杂度：O(1)（原地排序）
冒泡排序的时间复杂度太高，处理大量数据消耗太长时间，通常只具有教学意义
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - i - 1; j++)
{
if (a[j] > a[j + 1])
{
Swap(&a[j], &a[j + 1]);
}
}
}
}
函数中参数的 int* a 是一个数组，n是数组的元素个数
这里的Swap是交换数据的函数
void Swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
2.选择排序
- 原理：不断从未排序部分选择最小（或最大）元素，放到已排序部分的末尾
- 时间复杂度：O(n²)
- 空间复杂度：O(1)（原地排序）
标准选择排序的代码演示：
void SelectSort(int* a, int n)
{
int begin = 0;
while (begin < n)
{
int mini = begin;
for (int i = begin + 1; i < n; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
++begin;
}
}
为了稍微提高一些效率，可以一趟排两个数，即最大值和最小值，如下：
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = begin + 1; i <= end; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if(a[i] > a[maxi])
{
maxi = i;
}
}
Swap(&a[begin], &a[mini]);
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
--end;
++begin;
}
}
3.插入排序
- 原理: 将数组分为已排序和未排序部分，逐步将未排序元素插入到已排序部分。
- 时间复杂度: O(n²)
- 空间复杂度: O(1)
插入排序的代码演示：
void InsertSort(int* a, int n)
{
for (int i = 1; i < n; i++)
{
int end = i;
int tmp = a[end];
while (end > 0)
{
if (a[end - 1] > tmp)
{
a[end] = a[end - 1];
--end;
}
else
{
break;
}
}
a[end] = tmp;
}
}
插入排序和冒泡排序是有区别的，通过动画可以看出，冒泡排序只是两两比较，大的数（或者小的数）两两交换位置，而插入排序是选定了一个数tmp，将它放在合适的位置，只是交换一次tmp，tmp并没有一直处在交换的状态
4.希尔排序
- 时间复杂度：O( n 的1.3次方) 希尔排序的时间复杂度计算复杂，主流认为是n的1.3次方
希尔排序是一种基于插入排序的排序算法，效率较高，它通过将数据集分成若干个子序列来改进插入排序的效率。这种分组的方式使得在每次插入时，数据元素的移动范围更小，从而加快了整体的排序速度
希尔排序是插入排序的进阶算法，与插入排序的区别是：有一个增量gap，对处在gap跨度的位置的数据看作一个整体，这时有多个整体，对其进行插入排序，gap逐渐变小，直至gap变为1，对其进行最后一次排序，并且这次排序就是插入排序
gap的变化：通常gap以 n/2 ，每次除2的形式变小，直至变为1，也有的以每次变为 1/3 的形式变小
希尔排序的代码演示：
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int j = 0; j < n - gap; j++)
{
int end = j;
int tmp = a[end + gap];
while (end >= 0)
{
if (a[end + gap] < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
5.堆排序
- 时间复杂度：n log n
堆排序同样是比较高效的排序，将数据看作完全二叉树，建立大堆(堆顶的值最大)或小堆(堆顶的值最小)再将堆顶的数据放到末尾，并缩小末尾一个数据的范围，再调整建堆，直到最后变得有序
重要性质：排序时若父节点的位置是 n ，则左子节点的位置是 2*n + 1，右子节点的位置是 2*n + 2 ，依靠这个性质寻找父子节点
堆排序需要以堆为基础，再进行排序，因此需要调整建堆，代码：
//向下调整建堆
void AdjustDown(int* a, int n, int parent) //n为数组有效数据
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && a[child + 1] > a[child])
{
++child;
}
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
堆排序代码：
void HeapSort(int* a, int n)
{
for (int i = (n - 2) / 2; i >= 0; i--) //大堆
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}
这里排升序，一般采用建大堆，再将大的数据放到后面，便完成排序
堆排序中的for循环
for (int i = (n - 2) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
实际上是从最末尾的小树调整建堆，最末尾可以形成树的父节点是 (n - 2 ) / 2
然后对父节点 - 1的节点依次建堆，直到以首元素为父节点的树进行建堆，便完成了整棵树的建堆
堆排序的while循环while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
是对堆顶元素放到末尾的操作，对剩余元素再调整建堆，重复操作，最后整个数组变得有序
6.快速排序
- 平均时间复杂度：O(n方)
快速排序并不好理解，以一趟为例：
选择一个数key（选择基准），放在头位置，两个指针分别从头位置和尾位置向中间移动
移动的规则是： 从头开始的指针向后移动如果遇到比key大的值就停下
从尾开始的指针向前移动，如果遇到比key小的值就停下
这两个指针都停下时，两个指针的值进行交换，如果两个指针相遇，则相遇的值与头位置的key的值交换（到这里，相遇左侧的值都比key小，相遇右侧的值都比key大）
然后以相遇位置为标记（分区），左侧进行同样的操作，右侧也进行同样的操作，（递归排序）
但是，真正的快速排序，还增加了小区间优化，和选择基准的优化
小区间优化简单来说就是，排序区间比较小时，采用插入排序完成，
选择基准的优化：对头、尾、和中间数进行比较，选择中值为基准，作为key，可避免有序时的栈溢出
void QuickSort(int* a, int left, int right)
{
if (left > right)
return;
if (right - left + 1 < 10)
{
InsertSort(a + left, right - left);
}
int midi = GetMidi(a, left, right);
Swap(&a[left], &a[midi]);
int keyi = left;
int begin = left;
int end = right;
while (begin < end)
{
while (begin < end && a[end] >= a[keyi])
{
--end;
}
while (begin < end && a[begin] <= a[keyi])
{
++begin;
}
Swap(&a[begin], &a[end]);
}
Swap(&a[keyi], &a[begin]);
keyi = begin;
QuickSort(a, left, keyi - 1);
QuickSort(a, keyi + 1, right);
}