【基础知识】内排序算法

 

内排序【排序部分基本都是直接插入来实现】

 

 

• 稳定排序的概念

排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。

稳定度（稳定性）

一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。

（4,1）（3,1）（3,7）（5,6）在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：

（3,1）（3,7）（4,1）（5,6） （维持次序)

（3,7）（3,1）（4,1）（5,6） （次序被改变)

不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地实现为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较，就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。

在计算机科学所使用的排序算法通常被分类为：

(a)计算的复杂度（最差、平均、和最好性能），依据列表(list)的大小(n)。

一般而言，好的性能是 O(nlogn)，且坏的性能是 O(n^2)。对于一个排序理想的性能是 O(n)。

而仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要 O(nlogn)。

(b)存储器使用量（空间复杂度）（以及其他电脑资源的使用）

(c)稳定度：稳定的排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。

(d)一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序和快速排序。插入排序包含希尔排序，选择排序包括堆排序等。

 

 

• 直接插入排序的过程

 

初始记录的关键字： [7]     4    -2    19    13    6

第一趟排序： [4    7]    -2    19    13     6

第二趟排序： [-2    4    7]     19    13    6

第三趟排序： [-2    4     7     19]    13    6

 

void straight_insert_sort(Sqlist *L)

{   int i, j ;

for (i=2; i<=L->length; i++)

{  L->R[0]=L->R[i]; j=i-1;     /*   设置哨兵   */

while( LT(L->R[0].key, L->R[j].key) )

    {   L->R[j+1]=L->R[j];

         j--;

     }          /*   查找插入位置   */

L->R[j+1]=L->R[0];      /*   插入到相应位置   */

}

}

 

• 折半插入排序

类似于直接插入，只不过前面已排序的部分使用二分查找，降低了查找的消耗并没有减少记录的移动次数。

 

• 表插入，不移动记录，申请n个辅助空间，借助数组下标的记录完成排序。

 

 

• 希尔排序

 

 

 

• 快速排序 : 【典型的就是冒泡排序】

交换一次相邻的两个记录，需要n-1趟排序，最后的记录都是排好序的记录了。

void Bubble_Sort(Sqlist *L)

{  int j ,k , flag ;

for (j=0; j<L->length; j++)       /*   共有n-1趟排序   */

{  flag=TRUE ;

for (k=1; k<=L->length-j; k++)   /*   一趟排序   */

    if (LT(L->R[k+1].key, L->R[k].key ) )

        {   flag=FALSE ; L->R[0]=L->R[k] ;

            L->R[k]=L->R[k+1] ;

            L->R[k+1]=L->R[0] ; 

         }

    if  (flag==TRUE)  break ;

}

}

 

• 选择排序(Selection Sort)【有重复值的处理不是很友好】

选择排序(Selection Sort)的基本思想是：每次从当前待排序的记录中选取关键字最小的记录表，然后与待排序的记录序列中的第一个记录进行交换，直到整个记录序列有序为止。

 

• 堆排序

 

 

堆排序是一种树形选择排序，是对直接选择排序的有效改进。
 

基本思想：

堆的定义如下：具有n个元素的序列（k1,k2,...,kn),当且仅当满足

 

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

 

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

因此，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法 （2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法 （2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）
                              

                              

 

 算法的实现：

从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

[cpp] view plain copy print?

void print(int a[], int n){ 

    for(int j= 0; j<n; j++){ 

        cout<<a[j] <<"  "; 

    } 

    cout<<endl; 

} 

 

 

  

/**

 * 已知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*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置) 

    while (child < length) { 

        if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点) 

            ++child ; 

        } 

        if(H[s]<H[child]) {  // 如果较大的子结点大于父结点 

            H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点 

            s = child;       // 重新设置s ,即待调整的下一个结点的位置 

            child = 2*s+1; 

        }  else {            // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出 

             break; 

        } 

        H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上 

    } 

    print(H,length); 

} 

 

 

/**

 * 初始堆进行调整

 * 将H[0..length-1]建成堆

 * 调整完之后第一个元素是序列的最小的元素

 */ 

void BuildingHeap(int H[], int length) 

{  

    //最后一个有孩子的节点的位置 i=  (length -1) / 2 

    for (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 )。

 

• 归并排序

归并(Merging) ：是指将两个或两个以上的有序序列合并成一个有序序列。若采用线性表(无论是那种存储结构)易于实现，其时间复杂度为O(m+n) 。

归并思想实例：两堆扑克牌，都已从小到大排好序，要将两堆合并为一堆且要求从小到大排序。

◆  将两堆最上面的抽出(设为C1，C2)比较大小，将小者置于一边作为新的一堆(不妨设C1<C2)；再从第一堆中抽出一张继续与C2进行比较，将较小的放置在新堆的最下面；

◆ 重复上述过程，直到某一堆已抽完，然后将剩下一堆中的所有牌转移到新堆中。

 

• 桶排序/基数排序(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个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

        前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        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 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，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摞（分配），再按此顺序叠放在一起（收集），如此进行二次分配和收集即可将扑克牌排列有序。   

基数排序:

是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

算法实现：

[cpp] view plain copy print?

Void RadixSort(Node L[],length,maxradix) 

{ 

   int m,n,k,lsp; 

   k=1;m=1; 

   int temp[10][length-1]; 

   Empty(temp); //清空临时空间 

   while(k<maxradix) //遍历所有关键字 

   { 

     for(int i=0;i<length;i++) //分配过程 

    { 

       if(L[i]<m) 

          Temp[0][n]=L[i]; 

       else 

          Lsp=(L[i]/m)%10; //确定关键字 

       Temp[lsp][n]=L[i]; 

       n++; 

   } 

   CollectElement(L,Temp); //收集 

   n=0; 

   m=m*10; 

  k++; 

 } 

}

 

• 排序总结

各种排序的稳定性，时间复杂度和空间复杂度总结：

 

 

附链接，有动画演示，比较直观    http://blog.jobbole.com/11745/