数据结构学习笔记排序 (冒泡、插入、希尔、堆排序、归并排序)
前提void X_Sort ( ElementType A[], int N )
- 大多数情况下，为简单起见，讨论从小大的整数排序
- N是正整数
- 只讨论基于比较的排序（> = < 有定义）
- 只讨论内部排序
- 稳定性：任意两个相等的数据，排序前后的相对位置不发生改变
没有一种排序算法是任何情况下都表现最好的
冒泡排序
(从小到大排序)物理意义：大泡泡往下沉，小泡泡往上冒
每次比较相邻两个泡泡，符合条件，交换位置，每一轮比较完，最大的泡泡沉到最底下。
- 最好情况：顺序T = O( N )
最坏情况：逆序T = O( N^2 )
注意
- 设置交换标识
- 坏处：逆序复杂度比较大，好处：当时单向链表排序的时候，适合（从上到下，相邻交换）；严格大于的时候才交换，即有：稳定
实现
void Bubble_Sort(ElementType A[], int N)
{
for (int P = N - 1; P >= 0;P--)
{
int flag = 0;
for (int i = 0; i < P; i++) /*一趟冒泡排序*/
{
if (A[i]>A[i+1])
{
int temp = A[i];
A[i] = A[i + 1];
A[i + 1] = temp;
flag = 1;/*标识发生了交换*/
}
}
if (flag==0)
{
break; /*全程无交换*/
}
}
}
插入排序
(从小到大排序) 和打扑克摸牌差不多，每次摸牌从最后往前依次进行比较，需插入的牌小，往前比较，找到合适位置插入。
- 最好情况：顺序T = O( N )
最坏情况：逆序T = O( N^2 )
注意
- 稳定
实现
void Insertion_Sort(ElementType A[], int N)
{
for (int P = 1; P < N;P++) //第一张已在手
{
int temp = A[P];/*摸一下张*/
for (int i = P; i>0 && A[i - 1] > temp;i--)
{
A[i] = A[i - 1]; //依次与已排序序列中元素比较并右移
}
A[P] = temp;
}
}
时间复杂度下界（womiga）
- 逆序对（inversion）I逆序对的个数
- 交换2个相邻元素正好消去1个逆序对
- 插入排序：T(N+I)=O(N+I)
- 如果序列基本有序，则插入排序简单且高效
希尔排序
原始希尔排序DM = [N / 2]向下取整 , Dk = [D(k+1) / 2]向下取整
最坏情况： T =Ο( N^2 ) 不稳定
增量元素不互质，则小增量可能根本不起作用。
更多的增量序列
实现
//原始的shell排序--theta(N*N)
void Shell_Sort(ElementType A[], int N)
{
for (int D = N / 2; D > 0; D++) /*希尔增量序列*/
{
for (int P = D; P < N;P++) //插入排序
{
int temp = A[P];
for (int i = P; i >= D&&A[i - D]>temp;i-=D)
{
A[i] = A[i - D];
}
A[P] = temp;
}
}
}
void ShellSort(ElementType A[], int N)
{ /* 希尔排序 - 用Sedgewick增量序列 */
int Si, D, P, i;
ElementType Tmp;
/* 这里只列出一小部分增量 */
int Sedgewick[] = { 929, 505, 209, 109, 41, 19, 5, 1, 0 };
for (Si = 0; Sedgewick[Si] >= N; Si++)
; /* 初始的增量Sedgewick[Si]不能超过待排序列长度 */
for (D = Sedgewick[Si]; D > 0; D = Sedgewick[++Si])
for (P = D; P<N; P++) { /* 插入排序*/
Tmp = A[P];
for (i = P; i >= D && A[i - D]>Tmp; i -= D)
A[i] = A[i - D];
A[i] = Tmp;
}
}
堆排序
- 回顾选择排序
- 选择排序交换的最多N次；关键在每次找到最小元素位置，简单暴力或者最小堆
算法一，最小堆
算法二，最大堆
- 首先将堆调整为最大堆，堆顶元素为数组最大元素在A[0]位置，与A[N]交换位置。找到最大元素，将其放在最后。再调整为最大堆，且堆的大小-1，为N-1。依次执行。
- 定理：堆排序处理N个不同元素的随机排列的平均比较次数是2N logN – O(Nlog logN) 。
- 不稳定
- 虽然堆排序给出最佳平均时间复杂度，但实际效果不如用Sedgewick增量序列的希尔排序。
实现
- 注意和 堆的操作集比较，其中H[0]当哨兵用。
- 排序算法的实现（归并，快排，堆排，希尔排序 O(N*log(N))） 排序算法中，调整堆采样了递归和非递归的方法
void PercDown(ElementType A[], int p, int N)
{ /* 改编代码4.24的PercDown( MaxHeap H, int p ) */
/* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
int Parent, Child;
ElementType X;
X = A[p]; /* 取出根结点存放的值 */
for (Parent = p; (Parent * 2 + 1) < N; Parent = Child) {
Child = Parent * 2 + 1;
if ((Child != N - 1) && (A[Child] < A[Child + 1]))
Child++; /* Child指向左右子结点的较大者 */
if (X >= A[Child]) break; /* 找到了合适位置 */
else /* 下滤X */
A[Parent] = A[Child];
}
A[Parent] = X;
}
void Heap_Sort(ElementType A[], int N) //和堆的操作有点不一样：这里从0开始存储元素，堆的操作0位置为哨兵
{
for (int i = N / 2 - 1; i >= 0; i--) /*buildMaxHeap建立最大堆*/
{
PercDown(A, i, N);
}
for (int i = N - 1; i > 0;i--)
{
/*删除最大堆顶*/
int temp = A[0];
A[0] = A[i];
A[i] = temp;
PercDown(A, 0, i); //长度减1,依次建立
}
}
应用
找十个最小的，那你最简单的方法只要一个个比过去，用10N就好。
1万个数里面找最大的10个数，也就说只需要一个大小为10的最小堆就行了。
从第11个数开始，每次输入一个数，比堆顶大的话，就替换掉堆顶元素。
这样1w个数下来，最小堆中就保存了最大的10个数字。
复杂度是 1W * log（10）， 或者说 N log（k） 其中 k是一个远比N小的常数归并排序
归并排序一般不作内排序，在外排序中用
- 核心：有序子列的归并
稳定排序
有序子列的归并实现
/* L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置*/
void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
{ /* 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 */
int LeftEnd = R - 1; /* 左边终点位置 */
int temp = L; /* 有序序列的起始位置 */
int NumElements = RightEnd - L + 1;
while( L <= LeftEnd && R <= RightEnd ) {
if ( A[L] <= A[R] )
TmpA[temp++] = A[L++]; /* 将左边元素复制到TmpA */
else
TmpA[temp++] = A[R++]; /* 将右边元素复制到TmpA */
}
while( L <= LeftEnd )
TmpA[temp++] = A[L++]; /* 直接复制左边剩下的 */
while( R <= RightEnd )
TmpA[temp++] = A[R++]; /* 直接复制右边剩下的 */
for(int i = 0; i < NumElements; i++, RightEnd -- ) //细节处理
A[RightEnd] = TmpA[RightEnd]; /* 将有序的TmpA[]复制回A[] */
}
递归算法
void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd )
{ /* 核心递归排序函数 */
int Center;
if ( L < RightEnd ) {
Center = (L+RightEnd) / 2;
Msort( A, TmpA, L, Center ); /* 递归解决左边 */
Msort( A, TmpA, Center+1, RightEnd ); /* 递归解决右边 */
Merge( A, TmpA, L, Center+1, RightEnd ); /* 合并两段有序序列 */
}
}
void MergeSort( ElementType A[], int N )
{ /* 归并排序 */
ElementType *TmpA;
TmpA = (ElementType *)malloc(N*sizeof(ElementType));
if ( TmpA != NULL ) {
Msort( A, TmpA, 0, N-1 );
free( TmpA );
}
else printf( "空间不足" );
}非递归算法
/* 归并排序 - 循环实现 */
/* 这里Merge函数在递归版本中给出 */
/* length = 当前有序子列的长度*/
void Merge_pass( ElementType A[], ElementType TmpA[], int N, int length )
{ /* 两两归并相邻有序子列 */
int i, j;
for ( i=0; i <= N-2*length; i += 2*length )
Merge( A, TmpA, i, i+length, i+2*length-1 );
if ( i+length < N ) /* 归并最后2个子列*/
Merge( A, TmpA, i, i+length, N-1);
else /* 最后只剩1个子列*/
for ( j = i; j < N; j++ ) TmpA[j] = A[j];
}
void Merge_Sort( ElementType A[], int N )
{
int length;
ElementType *TmpA;
length = 1; /* 初始化子序列长度*/
TmpA = malloc( N * sizeof( ElementType ) );
if ( TmpA != NULL ) {
while( length < N ) {
Merge_pass( A, TmpA, N, length );
length *= 2;
Merge_pass( TmpA, A, N, length );
length *= 2;
}
free( TmpA );
}
else printf( "空间不足" );
}
