本文介绍了排序的概念和稳定性，并详细讲解了多种内部排序算法，包括直接插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序以及计数排序。这些算法的时间复杂度和稳定性特点被逐一分析，帮助读者理解不同排序算法的适用场景。
一、排序的概念及其运用
- 排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字大小，递增或递减的排列起来的操作。
- 稳定性：如果能保证排序过程中不会改变相同数据的前后关系，就是稳定排序；否则就是不稳定排序。
- 内部排序：数据元素全部放在内存中的排序。
- 外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
二、常见排序算法的实现
1、插入排序：
- 基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
- 直接插入排序：
当插入第i（i>=1）个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。
直接插入排序的特性总结：
- 元素集合越接近有序，直接插入排序算法的时间效率越高
- 时间复杂度：O(N^2)
- 空间复杂度：O（1），它是一种稳定的排序算法
- 稳定性：稳定
- 适用场景：数据有序或接近有序（注意：有序或接近有序与用户所需要序列一致），数据量少，搬移元素个数比较少
直接插入排序代码：
//插入排序
void InsertSort(int array[], int size)
{
for (int i = 1; i < size; ++i)
{
int key = array[i];//要插入的数
int end = i - 1;
//在有序区间[0,1)中向前遍历，如果要插入的数小于有序数组中最后一个数，交换两个数，继续比较
while (key < array[end] && end >= 0)
{
array[end + 1] = array[end];
end--;
}
array[end + 1] = key;//新的要插入的值，有序数组最后一个数得下一个数
}
}
2、希尔排序（缩小增量排序）
希尔排序又称缩小增量法。希尔排序的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
希尔排序的特性总结：
- 希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。 - 希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间
- 复杂度：O(N^1.3 —N^2）
- 稳定性：不稳定
希尔排序代码：
//希尔排序
void ShellSort(int* array, int size)
{
int gap = size;
while (gap > 1)
{
gap = gap / 3 + 1;//gap=gap/2;
for (int i = gap; i < size; i++)
{
int key = array[i];
int end = i - gap;
while (key < array[end] && end >= 0)
{
array[end + gap] = array[end];
end -= gap;
}
array[end + gap] = key;
}
}
}
3、选择排序：
- 基本思想：每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
- 直接选择排序：
1）在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
2）若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
3）在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
直接选择排序的特性总结：
- 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- . 稳定性：不稳定
选择排序的代码：
//选择排序
void SelectSort(int* array, int size)
{
int begin = 0, end = size - 1;
//无序区间是[left,right]
//无序区间内只剩1个数或者没有数
while (begin < end)
{
//无序区间内最大最小
int minPos = begin;
int maxPos = begin;
int index = begin + 1;
while (index <= end)
{
if (array[index] > array[maxPos])
maxPos = index;
if (array[index] < array[minPos])
minPos = index;
++index;
}
//注意：最右侧位置可能存储得是当前最小值
if (maxPos != end)
{
Swap(&array[maxPos], &array[end]);//最大的数和最后一个数交换
}
//如果最右侧的位置可能存储得是当前的最小值，经过上述交换之后,最小值的位置已经发生改变
//必须要更新minPos
if (minPos == end)
{
minPos = maxPos;
}
if (minPos != begin)
{
Swap(&array[minPos], &array[begin]);//等于（a+min，a+left）最小的数和无序区间的第一个数交换
}
++begin;
--end;
}
}
void SelectSort(int* array, int size)
{
for (int i = 0; i < size - 1; i++)
{
int maxPos = 0;
for (int j = 1; j < size - i; ++j)
{
if (array[j] > array[maxPos])
{
maxPos = j;
}
}
if (maxPos != size - 1 - i)
{
Swap(&array[maxPos], &array[size - i - 1]);
}
}
}
4、堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是 通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
- 基本思想：
堆排序可以按照以下步骤来完成：
1、首先将序列构建称为大顶堆；（这样满足了大顶堆那条性质：位于根节点的元素一定是当前序列的最大值）
2、取出当前大顶堆的根节点，将其与序列末尾元素进行交换；（此时：序列末尾的元素为已排序的最大值；由于交换了元素，当前位于根节点的堆并不一定满足大顶堆的性质）
3、对交换后的n-1个序列元素进行调整，使其满足大顶堆的性质；
4、重复2.3步骤，直至堆中只有1个元素为止
直接选择排序的特性总结：
- 堆排序使用堆来选数，效率就高了很多。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(1)
- 稳定性：不稳定
堆排序代码：
//堆排序
void HeapAdjust(int* array, int size, int parent)
{
int child = parent * 2 + 1;
while (child<size)
{
//如果右子树的值大于左子树的值，则最大的数为右子树
if (child + 1 < size && array[child + 1] > array[child])
child += 1;
if (array[child] > array[parent])
{
Swap(&array[parent], &array[child]);
parent = child;
child = parent * 2 + 1;
}
else
return;
}
}
void HeapSort(int* array, int size)
{
int end = size - 1;
//1、建堆
//找到倒数第一个非叶子节点
for(int root = ((size - 2) >> 1); root >= 0; --root)
{
HeapAdjust(array, size, root);
}
//2、利用堆删除的思想来进行排序
while (end)
{
Swap(&array[0], &array[end]);//堆顶元素和无序区间的最后一个数交换
HeapAdjust(array, end, 0);
end--;
}
}
5、交换排序：
- 基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
- 冒泡排序
冒泡排序思路比较简单：
1）将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；（ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
2)对序列当中剩下的n-1个元素再次执行步骤1。
3)对于长度为n的序列，一共需要执行n-1轮比较（利用while循环可以减少执行次数）
冒泡排序的特性总结：
- 冒泡排序是一种非常容易理解的排序
- 时间复杂度：O(N^2)
- 空间复杂度：O(1)
- 稳定性：稳定
冒泡排序代码：
//冒泡排序
void BubbleSort(int* array, int size)
{
//外层循环控制的是冒泡排序的趟数，既需要冒泡多少次
for (int i = 0; i < size-1; ++i)
{
int isChange = 0;
//具体冒泡的方式：依次用相邻两个元素进行比较，将大的元素往后翻
//j:表示数组的下标--->j表示后一个元素的标志
for (int j = 1; j < size - i; ++j)
{
if (array[j-1] > array[j])
{
Swap(&array[j - 1], &array[j]);
isChange = 1;
}
}
//如果没有被修改，说明有序
if (!isChange)
{
return;
}
}
}
6、快速排序
概念：快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
将区间按照基准值划分为左右两半部分的常见方式有：
1. hoare版本 2. 挖坑法 3. 前后指针版本
基本思想 ：
1、在待排序区间[left,right]中选择一个基准值(pivot)
2、扫描整个待排序区间，将比基准值小的放在基准值的左面，比基准值大的放在基准值右边。（分组----->基准值最终所在的下标[pivotIndex]）
3、整个待排序区间被分为三部分：
比基准值小的[left,pivotIndex]；
基准值[pivotIndex];
比基准值大的[pivotIndex+1,right]；
4、按照同样方式处理左右两个小区间，直到小区间内数据为1个或0个
快速排序的特性总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
快速排序代码：
//找基准值
//hoare版本
int partition1(int a[], int left, int right)
{
int begin = left;
int end = right;
int pivot = a[right];
while (begin < end)
{
while (begin < end&&a[begin] <= pivot)
{
begin++;
}
while (beg in < end&&a[end] >= pivot)
{
end--;
}
swap(a + begin, a + end);
}
swap(a + begin, a + right);
return begin;
}
//挖坑法
int partition2(int a[], int left, int right)
{
int begin = left;
int end = right;
int pivot = a[right];
while (begin < end)
{
while (begin < end&&a[begin] <= pivot)
{
begin++;
}
a[end] = a[begin];
while (begin < end&&a[end] >= pivot)
{
end--;
}
a[begin] = a[end];
}
a[begin] = pivot;
return begin;
}
//前后指针版本
int partition3(int a[], int left, int right)
{
int div = left;
int i = left;
for (i = left; i < right; i++)
{
if (a[i] < a[right])
{
swap(a + i, a + div);
div++;
}
}
swap(a + div, a + right);
return div;
}
//待排序区间
void quickSortTnternal(int a[], int left, int right)
{
if (left >= right)
{
//[left,right]区间内只剩1个或者0个数
return;
}
//1.确定基准值，最右边 a[right]
//2.做partition，小的左，大的右，返回基准值最终得下标
int pivotIndex = partition3(a, left, right);
//3.分治处理左右两个小区间
quickSortTnternal(a, left, pivotIndex - 1);
quickSortTnternal(a, pivotIndex + 1, right);
}
//非递归
void quickSortNoR(int a[], int left, int right)
{
std::stack<int> s;
s.push(left);
s.push(right);
while (!s.empty())
{
int high = s.top();
s.pop();
int low = s.top();
s.pop();
if (low >= high)
{
continue;
}
int pivotIndex = partition3(a, low, high);
s.push(pivotIndex + 1);
s.push(high);
s.push(low);
s.push(pivotIndex - 1);
}
}
void quickSort(int a[], int size)
{
quickSortNoR(a, 0, size - 1);
}
7、归并排序
- **基本思想：**归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有 序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
- 归并排序其实要做两件事：
1）分解----将序列每次折半拆分
2）合并----将划分后的序列段两两排序合并
因此，归并排序实际上就是两个操作，拆分+合并
归并排序的特性总结：
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
归并排序代码：
void MergeData(int a[], int left, int mid, int right, int *temp)
{
int begin1 = left, end1 = mid;
int begin2 = mid, end2 = right;
int index = left;//临时空间的最左边
while (begin1 < end1&&begin1 < end2)//说明两个区间内都有元素
{
if (a[begin1] <= a[begin2])//升序
{
temp[index++] = a[begin1++];//搬移左边区间元素
}
else
{
temp[index++] = a[begin2++];//搬移右边区间元素
}
}
while (begin1 < end1)
{
temp[index++] = a[begin1++];
}
while (begin2 < end2)
{
temp[index++] = a[begin2++];
}
}
//归并排序
void _MergeSort(int a[], int left, int right, int* temp)
{
//只有一个元素
if (right - left <= 1)
{
return;
}
//先找中间位置
int mid = (left+((right - left) >> 1));
//[0,mid)[mid,size)
_MergeSort(a, left, mid,temp);
_MergeSort(a, mid, right, temp);
MergeData(a, left, mid, right, temp);//归并
memcpy(a + left, temp + left, (right - left) * sizeof(a[0]));
}
void MergeSort(int a[], int size)
{
int *temp = (int *)malloc(sizeof(a[0])*size);
if (temp == NULL)
{
return;
}
_MergeSort(a, 0, size, temp);
free(temp);
}
8、非比较排序
- 基本思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
1）统计相同元素出现次数
2）根据统计的结果将序列回收到原来的序列中
- 计数排序的特性总结：
1）. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2）. 时间复杂度：O(MAX(N,范围))
3）. 空间复杂度：O(范围)
4）. 稳定性：稳定
计数排序代码：
void CountSort(int a[], int size)
{
//1、计算数据范围
int minValue = a[0];
int maxValue = a[0];
for (int i = 0; i < size; ++i)
{
if (a[i] < minValue)
{
minValue = a[i];
}
if (a[i] > maxValue)
{
maxValue = a[i];
}
}
//2、获取计数的空间
int range = maxValue - minValue + 1;
int *temp = (int *)malloc(range * sizeof(int));
if (NULL == temp)
{
return;
}
//3、统计每个元素出现的次数
memset(temp, 0, sizeof(int)*range);//初始化为0，否则为随机值
for (int i = 0; i < size; ++i)
{
temp[a[i] - minValue]++;
}
//4、回收
int index = 0;
for (int i = 0; i < range; ++i)
{
while (temp[i])
{
a[index++] = i + minValue;
temp[i]--;
}
}
free(temp);
}
三、排序算法复杂度及稳定性分析
扫一扫
1375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
