公司企业网站免费建设,dede仿wordpress,wordpress获取用户名密码,关键词热度分析工具八大排序算法 发表于2012/7/23 16:45:18 662397人阅读 分类#xff1a; c/c 数据结构与算法 概述 排序有内部排序和外部排序#xff0c;内部排序是数据记录在内存中进行排序#xff0c;而外部排序是因排序的数据很大#xff0c;一次不能容纳全部的排序记录#xff0c;在排… 八大排序算法 发表于2012/7/23 16:45:18  662397人阅读 分类 c/c 数据结构与算法 概述 排序有内部排序和外部排序内部排序是数据记录在内存中进行排序而外部排序是因排序的数据很大一次不能容纳全部的排序记录在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。          当n较大则应采用时间复杂度为O(nlog2n)的排序方法快速排序、堆排序或归并排序序。    快速排序是目前基于比较的内部排序中被认为是最好的方法当待排序的关键字是随机分布时快速排序的平均时间最短   1.插入排序—直接插入排序(Straight Insertion Sort) 基本思想: 将一个记录插入到已排序好的有序表中从而得到一个新记录数增1的有序表。即先将序列的第1个记录看成是一个有序的子序列然后从第2个记录逐个进行插入直至整个序列有序为止。 要点设立哨兵作为临时存储和判断数组边界之用。 直接插入排序示例 如果碰见一个和插入元素相等的那么插入元素把想插入的元素放在相等元素的后面。所以相等元素的前后顺序没有改变从原无序序列出去的顺序就是排好序后的顺序所以插入排序是稳定的。 算法的实现 void print(int a[], int n ,int i){couti :;for(int j 0; j8; j){couta[j] ;}coutendl; }void InsertSort(int a[], int n) {for(int i 1; in; i){if(a[i] a[i-1]){ //若第i个元素大于i-1元素直接插入。小于的话移动有序表后插入int j i-1; int x a[i]; //复制为哨兵即存储待排序元素a[i] a[i-1]; //先后移一个元素while(x a[j]){ //查找在有序表的插入位置a[j1] a[j];j--; //元素后移}a[j1] x; //插入到正确位置}print(a,n,i); //打印每趟排序的结果}}int main(){int a[8] {3,1,5,7,2,4,9,6};InsertSort(a,8);print(a,8,8); }效率 时间复杂度On^2. 其他的插入排序有二分插入排序2-路插入排序。    2. 插入排序—希尔排序Shells Sort 希尔排序是1959 年由D.L.Shell 提出来的相对直接排序有较大的改进。希尔排序又叫缩小增量排序 基本思想 先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序待整个序列中的记录“基本有序”时再对全体记录进行依次直接插入排序。 操作方法 选择一个增量序列t1t2…tk其中titjtk1按增量序列个数k对序列进行k 趟排序每趟排序根据对应的增量ti将待排序列分割成若干长度为m 的子序列分别对各子表进行直接插入排序。仅增量因子为1 时整个序列作为一个表来处理表长度即为整个序列的长度。 希尔排序的示例 算法实现   我们简单处理增量序列增量序列d {n/2 ,n/4, n/8 .....1} n为要排序数的个数 即先将要排序的一组记录按某个增量dn/2,n为要排序数的个数分成若干组子序列每组中记录的下标相差d.对每组中全部元素进行直接插入排序然后再用一个较小的增量d/2对它进行分组在每组中再进行直接插入排序。继续不断缩小增量直至为1最后使用直接插入排序完成排序。 void print(int a[], int n ,int i){couti :;for(int j 0; j8; j){couta[j] ;}coutendl; } /*** 直接插入排序的一般形式** param int dk 缩小增量如果是直接插入排序dk1**/void ShellInsertSort(int a[], int n, int dk) {for(int i dk; in; i){if(a[i] a[i-dk]){ //若第i个元素大于i-1元素直接插入。小于的话移动有序表后插入int j i-dk; int x a[i]; //复制为哨兵即存储待排序元素a[i] a[i-dk]; //首先后移一个元素while(x a[j]){ //查找在有序表的插入位置a[jdk] a[j];j - dk; //元素后移}a[jdk] x; //插入到正确位置}print(a, n,i );}}/*** 先按增量dn/2,n为要排序数的个数进行希尔排序**/ void shellSort(int a[], int n){int dk n/2;while( dk 1 ){ShellInsertSort(a, n, dk);dk dk/2;} } int main(){int a[8] {3,1,5,7,2,4,9,6};//ShellInsertSort(a,8,1); //直接插入排序shellSort(a,8); //希尔插入排序print(a,8,8); }希尔排序时效分析很难关键码的比较次数与记录移动次数依赖于增量因子序列d的选取特定情况下可以准确估算出关键码的比较次数和记录的移动次数。目前还没有人给出选取最好的增量因子序列的方法。增量因子序列可以有各种取法有取奇数的也有取质数的但需要注意增量因子中除1 外没有公因子且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。 3. 选择排序—简单选择排序Simple Selection Sort 基本思想 在要排序的一组数中选出最小或者最大的一个数与第1个位置的数交换然后在剩下的数当中再找最小或者最大的与第2个位置的数交换依次类推直到第n-1个元素倒数第二个数和第n个元素最后一个数比较为止。 简单选择排序的示例   操作方法 第一趟从n 个记录中找出关键码最小的记录与第一个记录交换 第二趟从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换 以此类推..... 第i 趟则从第i 个记录开始的n-i1 个记录中选出关键码最小的记录与第i 个记录交换 直到整个序列按关键码有序。 算法实现 void print(int a[], int n ,int i){cout第i1 趟 : ;for(int j 0; j8; j){couta[j] ;}coutendl; } /*** 数组的最小值** return int 数组的键值*/ int SelectMinKey(int a[], int n, int i) {int k i;for(int ji1 ;j n; j) {if(a[k] a[j]) k j;}return k; }/*** 选择排序**/ void selectSort(int a[], int n){int key, tmp;for(int i 0; i n; i) {key SelectMinKey(a, n,i); //选择最小的元素if(key ! i){tmp a[i]; a[i] a[key]; a[key] tmp; //最小元素与第i位置元素互换}print(a, n , i);} } int main(){int a[8] {3,1,5,7,2,4,9,6};cout初始值;for(int j 0; j8; j){couta[j] ;}coutendlendl;selectSort(a, 8);print(a,8,8); }简单选择排序的改进——二元选择排序 简单选择排序每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素当前趟最大和最小记录的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序最多只需进行[n/2]趟循环即可。具体实现如下 void SelectSort(int r[],int n) {int i ,j , min ,max, tmp;for (i1 ;i n/2;i) { // 做不超过n/2趟选择排序 min i; max i ; //分别记录最大和最小关键字记录位置for (j i1; j n-i; j) {if (r[j] r[max]) { max j ; continue ; } if (r[j] r[min]) { min j ; } } //该交换操作还可分情况讨论以提高效率tmp r[i-1]; r[i-1] r[min]; r[min] tmp;tmp r[n-i]; r[n-i] r[max]; r[max] tmp; } } 4. 选择排序—堆排序Heap Sort 堆排序是一种树形选择排序是对直接选择排序的有效改进。 基本思想 堆的定义如下具有n个元素的序列k1,k2,...,kn),当且仅当满足 时称之为堆。由堆的定义可以看出堆顶元素即第一个元素必为最小项小顶堆。 若以一维数组存储一个堆则堆对应一棵完全二叉树且所有非叶结点的值均不大于(或不小于)其子女的值根结点堆顶元素的值是最小(或最大)的。如 a大顶堆序列96, 83,27,38,11,09)   (b)  小顶堆序列1236248547305391 初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树一维数组存储二叉树调整它们的存储序使之成为一个堆将堆顶元素输出得到n 个元素中最小(或最大)的元素这时堆的根节点的数最小或者最大。然后对前面(n-1)个元素重新调整使之成为堆输出堆顶元素得到n 个元素中次小(或次大)的元素。依此类推直到只有两个节点的堆并对它们作交换最后得到有n个节点的有序序列。称这个过程为堆排序。 因此实现堆排序需解决两个问题 1. 如何将n 个待排序的数建成堆 2. 输出堆顶元素后怎样调整剩余n-1 个元素使其成为一个新堆。 首先讨论第二个问题输出堆顶元素后对剩余n-1元素重新建成堆的调整过程。 调整小顶堆的方法 1设有m 个元素的堆输出堆顶元素后剩下m-1 个元素。将堆底元素送入堆顶最后一个元素与堆顶进行交换堆被破坏其原因仅是根结点不满足堆的性质。 2将根结点与左、右子树中较小元素的进行交换。 3若与左子树交换如果左子树堆被破坏即左子树的根结点不满足堆的性质则重复方法 2. 4若与右子树交换如果右子树堆被破坏即右子树的根结点不满足堆的性质。则重复方法 2. 5继续对不满足堆性质的子树进行上述交换操作直到叶子结点堆被建成。 称这个自根结点到叶子结点的调整过程为筛选。如图 再讨论对n 个元素初始建堆的过程。 建堆方法对初始序列建堆的过程就是一个反复进行筛选的过程。 1n 个结点的完全二叉树则最后一个结点是第个结点的子树。 2筛选从第个结点为根的子树开始该子树成为堆。 3之后向前依次对各结点为根的子树进行筛选使之成为堆直到根结点。 如图建堆初始过程无序序列4938659776132749                                                                  算法的实现 从算法描述来看堆排序需要两个过程一是建立堆二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数二是反复调用渗透函数实现排序的函数。 void print(int a[], int n){for(int j 0; jn; j){couta[j] ;}coutendl; }/*** 已知H[s…m]除了H[s] 外均满足堆的定义* 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选, ** param H是待调整的堆数组* param s是待调整的数组元素的位置* param length是数组的长度**/ void HeapAdjust(int H[],int s, int length) {int tmp H[s];int child 2*s1; //左孩子结点的位置。(i1 为当前调整结点的右孩子结点的位置)while (child length) {if(child1 length H[child]H[child1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)child ;}if(H[s]H[child]) { // 如果较大的子结点大于父结点H[s] H[child]; // 那么把较大的子结点往上移动替换它的父结点s child; // 重新设置s ,即待调整的下一个结点的位置child 2*s1;} else { // 如果当前待调整结点大于它的左右孩子则不需要调整直接退出break;}H[s] tmp; // 当前待调整的结点放到比其大的孩子结点位置上}print(H,length); }/*** 初始堆进行调整* 将H[0..length-1]建成堆* 调整完之后第一个元素是序列的最小的元素*/ void BuildingHeap(int H[], int length) { //最后一个有孩子的节点的位置 i (length -1) / 2for (int i (length -1) / 2 ; i 0; --i)HeapAdjust(H,i,length); } /*** 堆排序算法*/ void HeapSort(int H[],int length) {//初始堆BuildingHeap(H, length);//从最后一个元素开始对序列进行调整for (int i length - 1; i 0; --i){//交换堆顶元素H[0]和堆中最后一个元素int temp H[i]; H[i] H[0]; H[0] temp;//每次交换堆顶元素和堆中最后一个元素之后都要对堆进行调整HeapAdjust(H,0,i);} } int main(){int H[10] {3,1,5,7,2,4,9,6,10,8};cout初始值;print(H,10);HeapSort(H,10);//selectSort(a, 8);cout结果;print(H,10);} 分析: 设树深度为k。从根到叶的筛选元素比较次数至多2(k-1)次交换记录至多k 次。所以在建好堆后排序过程中的筛选次数不超过下式                                   而建堆时的比较次数不超过4n 次因此堆排序最坏情况下时间复杂度也为O(nlogn )。   5. 交换排序—冒泡排序Bubble Sort 基本思想 在要排序的一组数中对当前还未排好序的范围内的全部数自上而下对相邻的两个数依次进行比较和调整让较大的数往下沉较小的往上冒。即每当两相邻的数比较后发现它们的排序与排序要求相反时就将它们互换。 冒泡排序的示例   算法的实现 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[j1]){int tmp a[j] ; a[j] a[j1] ; a[j1] tmp;}}} } 冒泡排序算法的改进 对冒泡排序常见的改进方法是加入一标志性变量exchange用于标志某一趟排序过程中是否有数据交换如果进行某一趟排序时并没有进行数据交换则说明数据已经按要求排列好可立即结束排序避免不必要的比较过程。本文再提供以下两种改进算法 1设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。 改进后算法如下: void Bubble_1 ( int r[], int n) {int i n -1; //初始时,最后位置保持不变while ( i 0) { int pos 0; //每趟开始时,无记录交换for (int j 0; j i; j)if (r[j] r[j1]) {pos j; //记录交换的位置 int tmp r[j]; r[j]r[j1];r[j1]tmp;} i pos; //为下一趟排序作准备} } 2传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。 改进后的算法实现为: void Bubble_2 ( int r[], int n){int low 0; int high n -1; //设置变量的初始值int tmp,j;while (low high) {for (j low; j high; j) //正向冒泡,找到最大者if (r[j] r[j1]) {tmp r[j]; r[j]r[j1];r[j1]tmp;} --high; //修改high值, 前移一位for ( jhigh; jlow; --j) //反向冒泡,找到最小者if (r[j]r[j-1]) {tmp r[j]; r[j]r[j-1];r[j-1]tmp;}low; //修改low值,后移一位} } 6. 交换排序—快速排序Quick Sort 基本思想 1选择一个基准元素,通常选择第一个元素或者最后一个元素, 2通过一趟排序讲待排序的记录分割成独立的两部分其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。 3此时基准元素在其排好序后的正确位置 4然后分别对这两部分记录用同样的方法继续进行排序直到整个序列有序。 快速排序的示例 a一趟排序的过程 b排序的全过程 算法的实现  递归实现 void print(int a[], int n){for(int j 0; jn; j){couta[j] ;}coutendl; }void swap(int *a, int *b) {int tmp *a;*a *b;*b tmp; }int partition(int a[], int low, int high) {int privotKey a[low]; //基准元素while(low high){ //从表的两端交替地向中间扫描while(low high a[high] privotKey) --high; //从high 所指位置向前搜索至多到low1 位置。将比基准元素小的交换到低端swap(a[low], a[high]);while(low high a[low] privotKey ) low;swap(a[low], a[high]);}print(a,10);return low; }void quickSort(int a[], int low, int high){if(low high){int privotLoc partition(a, low, high); //将表一分为二quickSort(a, low, privotLoc -1); //递归对低子表递归排序quickSort(a, privotLoc 1, high); //递归对高子表递归排序} }int main(){int a[10] {3,1,5,7,2,4,9,6,10,8};cout初始值;print(a,10);quickSort(a,0,9);cout结果;print(a,10);} 分析 快速排序是通常被认为在同数量级O(nlog2n)的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时快排序反而蜕化为冒泡排序。为改进之通常以“三者取中法”来选取基准记录即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。   快速排序的改进 在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序然后再对整个基本有序序列用插入排序算法排序。实践证明改进后的算法时间复杂度有所降低且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下 void print(int a[], int n){for(int j 0; jn; j){couta[j] ;}coutendl; }void swap(int *a, int *b) {int tmp *a;*a *b;*b tmp; }int partition(int a[], int low, int high) {int privotKey a[low]; //基准元素while(low high){ //从表的两端交替地向中间扫描while(low high a[high] privotKey) --high; //从high 所指位置向前搜索至多到low1 位置。将比基准元素小的交换到低端swap(a[low], a[high]);while(low high a[low] privotKey ) low;swap(a[low], a[high]);}print(a,10);return low; }void qsort_improve(int r[ ],int low,int high, int k){if( high -low k ) { //长度大于k时递归, k为指定的数int pivot partition(r, low, high); // 调用的Partition算法保持不变qsort_improve(r, low, pivot - 1,k);qsort_improve(r, pivot 1, high,k);} } void quickSort(int r[], int n, int k){qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序//再用插入排序对基本有序序列排序for(int i1; in;i ){int tmp r[i]; int ji-1;while(tmp r[j]){r[j1]r[j]; jj-1; }r[j1] tmp;} } int main(){int a[10] {3,1,5,7,2,4,9,6,10,8};cout初始值;print(a,10);quickSort(a,9,4);cout结果;print(a,10);} 7. 归并排序Merge Sort 基本思想 归并Merge排序法是将两个或两个以上有序表合并成一个新的有序表即把待排序序列分为若干个子序列每个子序列是有序的。然后再把有序子序列合并为整体有序序列。 归并排序示例   合并方法 设r[i…n]由两个有序子表r[i…m]和r[m1…n]组成两个子表长度分别为n-i 1、n-m。 jm1kiii; //置两个子表的起始下标及辅助数组的起始下标若im 或jn转⑷ //其中一个子表已合并完比较选取结束//选取r[i]和r[j]较小的存入辅助数组rf 如果r[i]r[j]rf[k]r[i] i k 转⑵ 否则rf[k]r[j] j k 转⑵//将尚未处理完的子表中元素存入rf 如果im将r[i…m]存入rf[k…n] //前一子表非空 如果jn ,  将r[j…n] 存入rf[k…n] //后一子表非空合并结束。 //将r[i…m]和r[m 1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {int j,k;for(jm1,ki; im j n ; k){if(r[j] r[i]) rf[k] r[j];else rf[k] r[i];}while(i m) rf[k] r[i];while(j n) rf[k] r[j]; } 归并的迭代算法 1 个元素的表总是有序的。所以对n 个元素的待排序列每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表所得子表除最后一个子表长度可能为1 外其余子表长度均为2。再进行两两合并直到生成n 个元素按关键码有序的表。 void print(int a[], int n){for(int j 0; jn; j){couta[j] ;}coutendl; }//将r[i…m]和r[m 1 …n]归并到辅助数组rf[i…n] void Merge(ElemType *r,ElemType *rf, int i, int m, int n) {int j,k;for(jm1,ki; im j n ; k){if(r[j] r[i]) rf[k] r[j];else rf[k] r[i];}while(i m) rf[k] r[i];while(j n) rf[k] r[j];print(rf,n1); }void MergeSort(ElemType *r, ElemType *rf, int lenght) { int len 1;ElemType *q r ;ElemType *tmp ;while(len lenght) {int s len;len 2 * s ;int i 0;while(i len lenght){Merge(q, rf, i, i s-1, i len-1 ); //对等长的两个子表合并i i len;}if(i s lenght){Merge(q, rf, i, i s -1, lenght -1); //对不等长的两个子表合并}tmp q; q rf; rf tmp; //交换q,rf以保证下一趟归并时仍从q 归并到rf} }int main(){int a[10] {3,1,5,7,2,4,9,6,10,8};int b[10];MergeSort(a, b, 10);print(b,10);cout结果;print(a,10);} 两路归并的递归算法 void MSort(ElemType *r, ElemType *rf,int s, int t) { ElemType *rf2;if(st) r[s] rf[s];else{ int m(st)/2; /*平分*p 表*/MSort(r, rf2, s, m); /*递归地将p[s…m]归并为有序的p2[s…m]*/MSort(r, rf2, m1, t); /*递归地将p[m1…t]归并为有序的p2[m1…t]*/Merge(rf2, rf, s, m1,t); /*将p2[s…m]和p2[m1…t]归并到p1[s…t]*/} } void MergeSort_recursive(ElemType *r, ElemType *rf, int n) { /*对顺序表*p 作归并排序*/MSort(r, rf,0, n-1); } 8. 桶排序/基数排序(Radix Sort) 说基数排序之前我们先说桶排序 基本思想是将阵列分到有限数量的桶子里。每个桶子再个别排序有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候桶排序使用线性时间Θn。但桶排序并不是 比较排序他不受到 O(n log n) 下限的影响。          简单来说就是把数据分组放在一个个的桶中然后对每个桶里面的在进行排序。    例如要对大小为[1..1000]范围内的n个整数A[1..n]排序    首先可以把桶设为大小为10的范围具体而言设集合B[1]存储[1..10]的整数集合B[2]存储   (10..20]的整数……集合B[i]存储(   (i-1)*10,   i*10]的整数i     1,2,..100。总共有  100个桶。     然后对A[1..n]从头到尾扫描一遍把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序这时可用冒泡选择乃至快排一般来说任  何排序法都可以。   最后依次输出每个桶里面的数字且每个桶中的数字从小到大输出这  样就得到所有数字排好序的一个序列了。     假设有n个数字有m个桶如果数字是平均分布的则每个桶里面平均有n/m个数字。如果     对每个桶中的数字采用快速排序那么整个算法的复杂度是     O(n     m   *   n/m*log(n/m))     O(n     nlogn   -   nlogm)     从上式看出当m接近n的时候桶排序复杂度接近O(n)     当然以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中那就退化成一般的排序了。           前面说的几大排序算法 大部分时间复杂度都是On2也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现On的时间复杂度。但桶排序的缺点是         1首先是空间复杂度比较高需要的额外开销大。排序有两个数组的空间开销一个存放待排序数组一个就是所谓的桶比如待排序值是从0到m-1那就需要m个桶这个桶数组就要至少m个空间。         2其次待排序的元素都要在一定的范围内等等。        桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较但前提是要知道待排序列的一些具体情况。 分配排序的基本思想说白了就是进行多次的桶式排序。 基数排序过程无须比较关键字而是通过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶O(n)。 实例: 扑克牌中52 张牌可按花色和面值分成两个字段其大小关系为 花色 梅花 方块 红心 黑心   面值 2 3 4 5 6 7 8 9 10 J Q K A 若对扑克牌按花色、面值进行升序排序得到如下序列 即两张牌若花色不同不论面值怎样花色低的那张牌小于花色高的只有在同花色情况下大小关系才由面值的大小确定。这就是多关键码排序。 为得到排序结果我们讨论两种排序方法。 方法1先对花色排序将其分为4 个组即梅花组、方块组、红心组、黑心组。再对每个组分别按面值进行排序最后将4 个组连接起来即可。 方法2先按13 个面值给出13 个编号组(2 号3 号...A 号)将牌按面值依次放入对应的编号组分成13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)将2号组中牌取出分别放入对应花色组再将3 号组中牌取出分别放入对应花色组……这样4 个花色组中均按面值有序然后将4 个花色组依次连接起来即可。 设n 个元素的待排序列包含d 个关键码{k1k2…kd}则称序列对关键码{k1k2…kd}有序是指对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都满足下列有序关系                                                                 其中k1 称为最主位关键码kd 称为最次位关键码     。   两种多关键码排序方法 多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序分两种方法 最高位优先(Most Significant Digit first)法简称MSD 法 1先按k1 排序分组将序列分成若干子序列同一组序列的记录中关键码k1 相等。 2再对各组按k2 排序分成子组之后对后面的关键码继续这样的排序分组直到按最次位关键码kd 对各子组排序后。 3再将各组连接起来便得到一个有序序列。扑克牌按花色、面值排序中介绍的方法一即是MSD 法。 最低位优先(Least Significant Digit first)法简称LSD 法 1) 先从kd 开始排序再对kd-1进行排序依次重复直到按k1排序分组分成最小的子序列后。 2) 最后将各个子序列连接起来便可得到一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二即是LSD 法。 基于LSD方法的链式基数排序的基本思想 　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字可以看作由多个数位或多个字符构成的多关键字此时可以采用“分配-收集”的方法进行排序这一过程称作基数排序法其中每个数字或字符可能的取值个数称为基数。比如扑克牌的花色基数为4面值基数为13。在整理扑克牌时既可以先按花色整理也可以先按面值整理。按花色整理时先按红、黑、方、花的顺序分成4摞分配再按此顺序再叠放在一起收集然后按面值的顺序分成13摞分配再按此顺序叠放在一起收集如此进行二次分配和收集即可将扑克牌排列有序。    基数排序: 是按照低位先排序然后收集再按照高位排序然后再收集依次类推直到最高位。有时候有些属性是有优先级顺序的先按低优先级排序再按高优先级排序。最后的次序就是高优先级高的在前高优先级相同的低优先级高的在前。基数排序基于分别排序分别收集所以是稳定的。 算法实现 Void RadixSort(Node L[],length,maxradix) {int m,n,k,lsp;k1;m1;int temp[10][length-1];Empty(temp); //清空临时空间while(kmaxradix) //遍历所有关键字{for(int i0;ilength;i) //分配过程{if(L[i]m)Temp[0][n]L[i];elseLsp(L[i]/m)%10; //确定关键字Temp[lsp][n]L[i];n;}CollectElement(L,Temp); //收集n0;mm*10;k;} } 总结 各种排序的稳定性时间复杂度和空间复杂度总结  我们比较时间复杂度函数的情况                              时间复杂度函数O(n)的增长情况 所以对n较大的排序记录。一般的选择都是时间复杂度为O(nlog2n)的排序方法。 时间复杂度来说 (1)平方阶(O(n2))排序 　　各类简单排序:直接插入、直接选择和冒泡排序  (2)线性对数阶(O(nlog2n))排序 　　快速排序、堆排序和归并排序  (3)O(n1§))排序,§是介于0和1之间的常数。        希尔排序 (4)线性阶(O(n))排序 　　基数排序此外还有桶、箱排序。 说明 当原表有序或基本有序时直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数时间复杂度可降至On 而快速排序则相反当原表基本有序时将蜕化为冒泡排序时间复杂度提高为On2 原表是否有序对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。   稳定性 排序算法的稳定性:若待排序的序列中存在多个具有相同关键字的记录经过排序 这些记录的相对次序保持不变则称该算法是稳定的若经排序后记录的相对 次序发生了改变则称该算法是不稳定的。       稳定性的好处排序算法如果是稳定的那么从一个键上排序然后再从另一个键上排序第一个键排序的结果可以为第二个键排序所用。基数排序就是这样先按低位排序逐次按高位排序低位相同的元素其顺序再高位也相同时是不会改变的。另外如果排序算法稳定可以避免多余的比较 稳定的排序算法冒泡排序、插入排序、归并排序和基数排序 不是稳定的排序算法选择排序、快速排序、希尔排序、堆排序   选择排序算法准则 每种排序算法都各有优缺点。因此在实用时需根据不同情况适当选用甚至可以将多种方法结合起来使用。 选择排序算法的依据 影响排序的因素有很多平均时间复杂度低的算法并不一定就是最优的。相反有时平均时间复杂度高的算法可能更适合某些特殊情况。同时选择算法时还得考虑它的可读性以利于软件的维护。一般而言需要考虑的因素有以下四点 1待排序的记录数目n的大小 2记录本身数据量的大小也就是记录中除关键字外的其他信息量的大小 3关键字的结构及其分布情况 4对排序稳定性的要求。 设待排序元素的个数为n. 1当n较大则应采用时间复杂度为O(nlog2n)的排序方法快速排序、堆排序或归并排序序。    快速排序是目前基于比较的内部排序中被认为是最好的方法当待排序的关键字是随机分布时快速排序的平均时间最短        堆排序   如果内存空间允许且要求稳定性的        归并排序它有一定数量的数据移动所以我们可能过与插入排序组合先获得一定长度的序列然后再合并在效率上将有所提高。 2  当n较大内存空间允许且要求稳定性 》归并排序 3当n较小可采用直接插入或直接选择排序。     直接插入排序当元素分布有序直接插入排序将大大减少比较次数和移动记录的次数。     直接选择排序 元素分布有序如果不要求稳定性选择直接选择排序 5一般不使用或不直接使用传统的冒泡排序。 6基数排序 它是一种稳定的排序算法但有一定的局限性 　　1、关键字可分解。 　　2、记录的关键字位数较少如果密集更好 　　3、如果是数字时最好是无符号的否则将增加相应的映射复杂度可先将其正负分开排序。 本文转自大神作品