这篇笔记主要是写写这些常见的排序算法。
冒泡排序
思想:两两比较相邻记录的关键字,反序则交换,直到没有反序为止。
#include <stdio.h>
/*交换int型数组L中下标i和j的值*/
void swap(int *L, int i, int j)
{
int temp = L[i];
L[i] = L[j];
L[j] = temp;
}
void BubbleSort(int *L)
{
int i, j;
int len = sizeof(L) / sizeof(int);
for (i = 0; i < len; i++)
{ /*i前面是排好序的*/
for (j = len-1; j > i; j--) /*从后向前比,小的在前,大的在后*/
{
if (L[j] < L[j-1])
{
swap(L, j, j-1);
}
}
}
}
分析:最好的情况比较n-1次,时间复杂度O(n);最坏的情况比较n(n-1)/2次,时间复杂度O(n2)。
选择排序
思想:每趟在n-i+1次比较里,选择关键字最小的记录与第i个记录交换。
void SelectionSort(int *L)
{
int i, j, min;
int len = sizeof(L)/sizeof(int);
for (i = 0; i < len; i++)
{
min = i;
for (j = i + 1; j < len; j++) /*i+1前面是排好序的*/
{
if (L[j] < L[min])
{
min = j;
}
}
if (i != min)
swap(L, i, min);
}
}
分析:比较次数,最好最坏都是n(n-1)/2次;交换次数,最好0次,最坏n-1次,综合起来时间复杂度是O(n2)。性能比冒泡好一点。
插入排序
思想:将一个记录插入到已经排好序的有序表中,表记录数加1。
void InsertiontSort(int *L)
{
int i, j;
int len = sizeof(L)/sizeof(int);
for (i = 0; i < len-1; i++)
{
int temp = L[i+1];
for (j = i; j >= 0; j--) /*i+1前面就是排好序的*/
{
if (temp < L[j])
L[j+1] = L[j]; /*后移*/
}
L[j] = temp; /*插入到正确的位置*/
}
}
分析:如果记录顺序是随机的,平均比较和移动的次数为n2/4,时间复杂度是O(n2)。性能比冒泡和选择要好一点。
希尔排序
思想:(也称缩小增量排序)给出一个增量increment,让相隔增量的记录跳跃式的移动,这增加了效率。最后的increment必须为1。
void ShellSort(int *L)
{
int i, j,increment;
int len = sizeof(L) / sizeof(int);
for (increment = len / 2; increment >= 1; increment = increment / 2) /*定增量,并不断减小*/
{
for (i = increment; i < len; i++)
{
if (L[i] < L[i - increment])
swap(L, L[i], L[i - increment]);
}
}
}
分析:确定增量的取值也是一个问题,大量实验证明,其平均时间复杂度O(n3/2)。希尔排序的出现突破了慢速排序(O(n2))的时代,更为高效的算法陆续出现。
堆排序
思想:堆是一种特殊的完全二叉树,它只有两种:每个结点大于等于它子结点的是大顶堆,小于等于它子结点的是小顶堆。堆排序就是通过构造堆来排序。将待排序数组构成一个大顶堆,把堆顶的根结点(最大值)移走,也就是和堆数组末尾交换,最大值就到了数组最后,再将剩下n-1个数重新构造成一个堆,找到n个元素中第二大值,重复执行。
关键:1如何将原始无序数组构建成一个堆
2输出堆顶元素后,如何调整剩余元素成为新堆
void swap(int *L, int i, int j)
{
int temp = L[i];
L[i] = L[j];
L[j] = temp;
}
void HeapSort(int *L)
{
int i;
int len = sizeof(L) / sizeof(int);
for (i = len / 2; i > 0; i--) //完全二叉树调成堆,并不需要len次,只需要交换反了的结点
HeapAdjust(L, i, len);
for (i = len-1; i > 0; i--)
{
swap(L, 0, i); //堆顶结点和序列最后一个元素交换
HeapAdjust(L, 0, i - 1); //将L[0...i-1]重新调整为大顶堆
}
}
void HeapAdjust(int *L, int i, int j)
{
int temp, k;
temp = L[i];
for (k = 2 * i; k <= j; k *= 2)
{
if (k < j && L[k] < L[k + 1])
++j; //k为关键字中较大记录的下标
if (temp >= L[k])
break;
L[i] = L[k];
i = k;
}
L[i] = temp;
}
分析:能提高效率是因为充分利用了二叉树深度是 ⌊log2n⌋+1 的性质。构建堆的时间复杂度O(n),重建堆的时间复杂度是O(nlogn),所以总的时间复杂度是O(nlogn)。
归并排序
思想:将一个无序的数组,两两合并排序后再合并,最终得到有序数组。
#include <stdio.h>
#include <stdlib.h>
void MergeSort(int *L, int p, int r) //用归并的方式把数组不断二分
{
int q;
if (p < r)
{
q = (int)((p + r) / 2);
MergeSort(L, p, q);
MergeSort(L, q + 1, r);
Merge(L, p, q, r);
}
}
void Merge(int *L, int p, int q, int r) //合并函数
{
int i, j, k;
int n1 = q - p + 1;
int n2 = r - q + 1;
int *left = (int *)malloc(sizeof(int)*n1);
int *right = (int *)malloc(sizeof(int)*n2);
for (i = 0; i < n1; i++) //对左数组赋值
left[i] = L[p + i];
for (j = 0; j < n2; j++) //对右数组赋值
right[j] = L[q + 1 + j];
i = j = 0;
k = p; //k从L的起点开始
while (i < n1 && j < n2) //将左右数组的元素两两比较,并合并到L
{
if (left[i] <= right[j])
L[k++] = left[i++];
else
L[k++] = right[j++];
}
for (; i < n1; i++) //如果左数组有元素剩余,则将剩余元素合并到L
L[k++] = left[i];
for (; j < n2; j++) //如果右数组有元素剩余,则将剩余元素合并到L
L[k++] = right[j];
}
分析:结构类似于颠倒的完全二叉树,整个归并排序需要进行 ⌈log2n⌉ 次,则总的时间复杂度是O(nlogn);但因为过程中需要与原数组同大小的空间存放递归结果,并且要递归深度是 log2n 的栈空间,则空间复杂度是O(n+logn)。它是一种比较占内存、但效率高且稳定的排序算法。
快速排序
思想:选取一个关键字(开始一般key=SqList[0]),找到它在数组中的位置,也就是从两端向中间扫描数组,通过交换把<key的放前面,>key的放后面;一次遍历终了相当于把整个数组partition成两部分(被key分开,未必平均分),递归每部分。
#include<iostream>
void QuickSort(int *A, int p, int r){
int x = A[p];
int i = p;
int j = r;
if (p < r){
while (i < j)
{
for (; A[j] >= x && j > i; j--){}
for (; A[i] <= x && i < j; i++){}
if (i < j)
{
int temp = A[i];
A[i] = A[j];
A[j] = temp;
}
else{
int temp = A[j];
A[j] = x;
A[p] = temp;
}
}
QuickSort(A, p, j - 1);
QuickSort(A, j + 1, r);
}
}
还有一种比较优美的写法,
void QuickSort(int A[], int left, int right){
if (left >= right)
return;
int i = left;
int j = right;
int key = A[left];
while (i < j){
while (i < j && key <= A[j])
j--;
A[i] = A[j];
while (i < j && key >= A[i])
i++;
A[j] = A[i];
}
A[i] = key;
QuickSort(A, left, i - 1);
QuickSort(A, i + 1, right);
}
分析:平均时间复杂度是O(nlogn),少数最差情况虽然也能达到O(n2);因为递归使用栈空间,平均情况的空间复杂度是O(logn)。因为关键字的比较和交换是跳跃的,所以它是种不稳定的方法。