【大话数据结构】几种排序算法

来源:互联网 发布:达克宁 兰美抒 知乎 编辑:程序博客网 时间:2024/05/16 00:47

这篇笔记主要是写写这些常见的排序算法。

冒泡排序

思想:两两比较相邻记录的关键字,反序则交换,直到没有反序为止。

#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++];elseL[k++] = right[j++];}for (; i < n1; i++) //如果左数组有元素剩余,则将剩余元素合并到LL[k++] = left[i];for (; j < n2; j++) //如果右数组有元素剩余,则将剩余元素合并到LL[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)。因为关键字的比较和交换是跳跃的,所以它是种不稳定的方法。


原创粉丝点击