在数据结构中,排序是一种将数据元素重新排列的过程,通常是为了使它们按照特定的顺序(如升序或降序)组织起来。排序在计算机科学中非常重要,下面是一些常见的数据结构排序方法和它们的特点
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);
}