午夜稻草人

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
排序算法总结

一、插入排序

 

直接插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

void insertSort(int *a, int length)
{
    int tmp,j;
    for (int i=1; i<length; ++i)
    {
        tmp = a[i];
        j = i-1;
        while (j>=0&&a[j]>tmp)
        {
            a[j+1] = a[j];
            --j;
        }
        a[j+1] = tmp;
    }
}
 
希尔排序(Shell Sort)是插入排序的一种，是针对直接插入排序算法的改进。该方法又称缩小增量排序。先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
该方法实质上是一种分组插入方法。
比较相隔较远距离（称为增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。
一般的初次取序列的一半为增量，以后每次减半，直到增量为1。
给定实例的shell排序的排序过程
假设待排序文件有10个记录，其关键字分别是：
49，38，65，97，76，13，27，49，55，04。
增量序列的取值依次为：
5，2，1






void ShellSort(int a[], int n)
{
　　int d, i, j, temp;
　　for(d = n/2;d >= 1;d = d/2)
　　{
　　　　for(i = d; i < n;i++)
　　　　{
　　　　　　temp = a[i];
　　　　　　for(j = i - d;(j >= 0) && (a[j] > temp);j = j-d)
　　　　　　{
　　　　　　　　a[j + d] = a[j];
　　　　　　}
　　　　　　a[j + d] = temp;
　　　　}
　　}
}

 

二、交换排序

 冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。







void bubbleSort(int a[], int length)
{
    bool flag;
    int tmp;
    for (int i=0; i<length; ++i)
    {
        flag = true;
        for (int j=length-1; j>i; --j)
        {
            if (a[j]<a[j-1])
            {
                tmp = a[j];
                a[j] = a[j-1];
                a[j-1] = tmp;
                flag = false;
                
            }
        }
        
        if (flag)
        {
            break;
        }
    }

}

 快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

 







int partition(int a[], int left, int right)
{
    
    int value = a[(left+right)/2];
    
    int i = left;
    int j = right;
    int tmp;

    while (true)
    {
        while (a[i]<value)
        ++i;
        while (a[j]>value)
        --j;
        if (i<j)
        {
            tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
        else
        {
            break;
        }
    }
    return i;
}

void quickSort(int a[], int left, int right)
{
    if (left<right)
    {
        int mid = partition(a,left,right);
        quickSort(a,left,mid);
        quickSort(a,mid+1,right);
    }
}

 上述方法在有重复数据的情况下可能出现排序错误，为了应对更一般的情况，应该尽量用《算法导论》中的快速排序方法，实现如下：

int partition(int a[], int left, int right)
{
    
    int value = a[right];
    int i = left - 1;
    int tmp;
    for(int j = left; j<right; ++j)
    {
        if(a[j] <= value)
        {
            i++;
            tmp = a[j];
            a[j] = a[i];
            a[i] = tmp;
            
        }
    }

    tmp = a[i+1];
    a[i+1] = value;
    a[right] = tmp;

    return i+1;
}

void quickSort(int a[], int left, int right)
{
    if (left<right)
    {
        int mid = partition(a,left,right);
        quickSort(a,left,mid-1);
        quickSort(a,mid+1,right);
    }
}

 

三、选择排序

直接选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾(目前已被排序的序列)。以此类推，直到所有元素均排序完毕。

 







void selectSort(int *a, int len)
{
     int i,j,min,mark,tmp;
   
     for(i=0;i<len;i++)
     {
        min=a[i];
        for(j=i+1;j<len;j++)
        {
             if(a[j]<min)
             {
                    min=a[j];
                    mark=j
             }
        }
        if(min!=a[i])
        {
    　　　　tmp = a[i];
  　　　　  a[i] = min;
   　　　　 a[mark] = tmp;
         }
     
     }
}

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

完全二叉树(Complete Binary Tree)

若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

“堆”定义

n个关键字序列Kl，K2，…，Kn称为（Heap），当且仅当该序列满足如下性质（简称为堆性质）：
(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶结点，K(2i）则是左孩子，k(2i+1）是右孩子
若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：
树中任一非叶结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字。

堆排序与直接选择排序的区别

直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。
堆排序可通过树形结构保存部分比较结果，可减少比较次数。

算法分析

堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。
堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。
由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。
堆排序是就地排序，辅助空间为O(1），
它是不稳定的排序方法。
void shift(int a[],int p, int length)
{
    int l = p*2+1;
    int r = p*2+2;
    int maxIndex = p;
    

    if (l<length&&a[l]>a[maxIndex])
    {
        maxIndex = l;
    }

    if (r<length&&a[r]>a[maxIndex])
    {
        maxIndex = r;
    }

    if (maxIndex != p)
    {
        swap(a[p],a[maxIndex]);
        shift(a,maxIndex,length);
    }


}

void buildMaxHeap(int a[], int length)
{
    for (int i=length/2; i>=0; --i)
    {
        shift(a,i,length);
    }
}

void heapSort(int a[],int length)
{
    buildMaxHeap(a,length);
    swap(a[0],a[length -1]);

    for (int i=length-1; i>0; --i)
    {
        shift(a,0,i);
        swap(a[0],a[i-1]);
    


    }
}

 

四、归并排序

归并排序（Merge sort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

算法描述

归并操作的过程如下：

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  4. 重复步骤3直到某一指针达到序列尾
  5. 将另一序列剩下的所有元素直接复制到合并序列尾
void merge(int a[], int left, int mid, int right)
{
    int len = right - left + 1;
    int *tmpArray = new int[len];

    int i = left;
    int j = mid + 1;
    int k = 0;
    while (i!=mid+1 && j!=right+1)
    {
        if (a[i]<a[j])
        {
            tmpArray[k++] = a[i++];
        }
        else
        {
            tmpArray[k++] = a[j++];
        }
    }

    while (i!=mid+1)
    {
        tmpArray[k++] = a[i++];
    }
    while (j!=right+1)
    {
        tmpArray[k++] = a[j++];
    }


    for (int t=0; t<len; t++)
    {
        a[left++] = tmpArray[t];
    }

    delete[] tmpArray;
}

void mergeSort(int a[], int left, int right)
{
    if (left < right)
    {
        mergeSort(a, left, (right+left)/2);

        mergeSort(a,(right+left)/2+1, right);

        merge(a, left, (right+left)/2, right);
    }
    
}

 五、线性时间排序

桶排序 假定：输入是由一个随机过程产生的[0, 1)区间上均匀分布的实数。将区间[0, 1)划分为n个大小相等的子区间（桶），每桶大小1/n：[0, 1/n)， [1/n, 2/n)， [2/n, 3/n)，…，[k/n, (k+1)/n )，…将n个输入元素分配到这些桶中，对桶中元素进行排序，然后依次连接桶输入0 ≤A[1..n] <1辅助数组B[0..n-1]是一指针数组，指向桶（链表）。

桶排序的算法如下(伪代码表示)，其中floor(x)是地板函数，表示不超过x的最大整数。

 


procedure Bin_Sort(var A:List);
begin
n:=length(A);
for i:=1 to n do
将A[i]插到表B[floor(n*A[i])]中;
for i:=0 to n-1 do
用插入排序对表B[i]进行排序;
将表B[0],B[1],...,B[n-1]按顺序合并;
end;

 计数排序是一个类似于桶排序的排序算法，其优势是对已知数量范围的数组进行排序。它创建一个长度为这个数据范围的数组C，C中每个元素记录要排序数组中对应记录的出现个数。 

//计数排序
void CountSort(int* pData, int nLen, int maxNum)
{
     //保存记数数据的指针
    int* pCout =  new int[maxNum+1];
    //初始化记数为0
    for (int i = 0; i < maxNum+1; ++i)
    {
        pCout[i] = 0;
    }

    //记录排序记数。在排序的值相应记数加1
    for (int i = 0; i < nLen; ++i)
    {
        ++pCout[pData[i]];       
    }

    //确定不比该位置大的数据个数
    for (int i = 1; i < maxNum+1; ++i)
    {
        //不比他大的数据个数为他的个数加上前一个的记数。
        pCout[i] += pCout[i - 1];    
    }

    //保存排序结果的指针
    int* pSort = new int[nLen];            

    //重原始数据靠后的位置开始遍历，以确保排序稳定性
    for (int i = nLen-1; i >= 0; --i)
    {
        pSort[pCout[pData[i]] - 1] = pData[i];
        //相同数据值的情况，要减一
        --pCout[pData[i]];  

    }

    //排序结束，复制到原来数组中。
    for (int i = 0; i < nLen; ++i)
    {
        pData[i] = pSort[i];
    }

    //最后要注意释放申请的空间。
    delete[] pCout;
    delete[] pSort;
}

基数排序(Radix sort)

计数排序的缺点很明显，需要额外的空间C来作为计数数组，虽然时间复杂度为O(n+k)，但当输入序列里元素取值很大的时侯，如k=O(n2)，时，此时时间复杂度已经达到n2数量级了，空间的消耗也是让人无法承受的。这里介绍一种另一种线性排序算法——基数排序，可以应对数值很大的情况。

基数排序，即一个数位一个数位地进行排序，平常生活中我们经常使用的一种算法思想：如要对一个日期进行排序，日期中由年、月、日组成的，对于这个问题，我们经常使用的是先比较年份，如果相同再比较月份，如果还相同就比较日。

同理，我们比较一组数，也可以采取这种思想。例如我们使用这种思想对下面四个数进行排序：123、312、245、531，第一次按百位排序：123、245、312、531；第二次按十位排序：312、123、531、245；第三次按个位数排序：531、312、123、245。咦？为什么最后排出来的结果并不是预期的那样？原因是我们从高位开始排序，已经差不多整体有序之后，再到低位时，又全部被打乱了。如果我们之后这样做就不会乱了：高位相同的数，再将它们的低位进行排序….不过这个实现一起比较困难一些。

这里，我们换成从最低有效位到最高有效位进行排序，那么还是上面那个例子：

个位 =>  十位 =>  百位

   531      312      123

　312      123      245

   123      531      312

   245      245      531

可以看到结果正确。通俗地讲，之所以先排低位再排高位，是因为越是后排的数位，其对结果次序的影响越大，很显然是高位比低位对数的大小影响大！

伪代码 

 

RADIX-SORT(A,d)
 for i <-- 1 to d

     do use a stable sort to sort array A on digit i

 

六、排序算法特点，算法复杂度和比较

直接插入排序

如果目标是把n个元素的序列升序排列，那么采用直接插入排序存在最好情况和最坏情况。最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。直接插入排序的赋值操作是比较操作的次数减去(n-1)次。平均来说直接插入排序算法复杂度为O(n2)。因而，直接插入排序不适合对于数据量比较大的排序应用。但是，如果需要排序的数据量很小，例如，量级小于千，那么直接插入排序还是一个不错的选择。 插入排序在工业级库中也有着广泛的应用，在STL的sort算法和stdlib的qsort算法中，都将插入排序作为快速排序的补充，用于少量元素的排序（通常为8个或以下）。

 

希尔排序

希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度为 O(N*(logN)2)， 没有快速排序算法快 
O(N*(logN))，因此中等大小规模表现良好，对规模非常大的数据排序不是最优选择。但是比O(N2）复杂度的算法快得多。并且希尔排序非常容易实现，算法代码短而简单。 此外，希尔算法在最坏的情况下和平均情况下执行效率相差不是很多，与此同时快速排序在最坏 的情况下执行的效率会非常差。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快， 再改成快速排序这样更高级的排序算法.

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的

 

冒泡排序

时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数为2），但是有两个优点：1.“编程复杂度”很低，很容易写出代码；2.具有稳定性。

其中若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1）/2次比较和记录移动。因此冒泡排序总的时间复杂度为O(n*n)。

 

快速排序 

在最好的情况，每次我们执行一次分割，我们会把一个数列分为两个几近相等的片段。这个意思就是每次递回调用处理一半大小的数列。因此，在到达大小为一的数列前，我们只要作 log n 次巢状的调用。这个意思就是调用树的深度是O(log n)。但是在同一阶层的两个程序调用中，不会处理到原来数列的相同部份；因此，程序调用的每一阶层总共全部仅需要O(n)的时间（每个调用有某些共同的额外耗费，但是因为在每一阶层仅仅只有O(n)个调用，这些被归纳在O(n)系数中）。结果是这个算法仅需使用O(n log n)时间。

另外一个方法是为T(n)设立一个递回关系式，也就是需要排序大小为n的数列所需要的时间。在最好的情况下，因为一个单独的快速排序调用牵涉了O(n)的工作，加上对n/2大小之数列的两个递回调用，这个关系式可以是：

T(n) = O(n) + 2T(n/2)

解决这种关系式型态的标准数学归纳法技巧告诉我们T(n) = O(n log n)。

事实上，并不需要把数列如此精确地分割；即使如果每个基准值将元素分开为 99% 在一边和 1% 在另一边，调用的深度仍然限制在 100logn，所以全部执行时间依然是O(n log n)。

然而，在最坏的情况是，两子数列拥有大各为 1 和 n-1，且调用树（call tree）变成为一个 n 个巢状（nested）呼叫的线性连串（chain）。第 i 次呼叫作了O(n-i)的工作量，且\sum_{i=0}^n (n-i) = O(n^2)递回关系式为：

T(n) = O(n) + T(1) + T(n - 1) = O(n) + T(n - 1)

这与插入排序和选择排序有相同的关系式，以及它被解为T(n) = O(n2)。

 

讨论平均复杂度情况下，即使如果我们无法随机地选择基准数值，对于它的输入之所有可能排列，快速排序仍然只需要O(n log n)时间。因为这个平均是简单地将输入之所有可能排列的时间加总起来，除以n这个因子，相当于从输入之中选择一个随机的排列。当我们这样作，基准值本质上就是随机的，导致这个算法与乱数快速排序有一样的执行时间。

更精确地说，对于输入顺序之所有排列情形的平均比较次数，可以借由解出这个递回关系式可以精确地算出来。

C(n) = n - 1 + \frac{1}{n} \sum_{i=0}^{n-1} (C(i)+C(n-i-1)) = 2n \ln n = 1.39n \log_2 n.

在这里，n-1 是分割所使用的比较次数。因为基准值是相当均匀地落在排列好的数列次序之任何地方，总和就是所有可能分割的平均。

这个意思是，平均上快速排序比理想的比较次数，也就是最好情况下，只大约比较糟39%。这意味着，它比最坏情况较接近最好情况。这个快速的平均执行时间，是快速排序比其他排序算法有实际的优势之另一个原因。

讨论空间复杂度时 被快速排序所使用的空间，依照使用的版本而定。使用原地（in-place）分割的快速排序版本，在任何递回呼叫前，仅会使用固定的額外空間。然而，如果需要产生O(log n)巢状递回呼叫，它需要在他们每一个储存一个固定数量的资讯。因为最好的情况最多需要O(logn)次的巢状递回呼叫，所以它需要O(log n)的空间。最坏情况下需要O(n)次巢状递回呼叫，因此需要O(n)的空间。

然而我们在这里省略一些小的细节。如果我们考虑排序任意很长的数列，我们必须要记住我们的变量像是left和right，不再被认为是占据固定的空间；也需要O(log n)对原来一个n项的数列作索引。因为我们在每一个堆栈框架中都有像这些的变量，实际上快速排序在最好跟平均的情况下，需要O(log2 n)空间的位元数，以及最坏情况下O(n log n)的空间。然而，这并不会太可怕，因为如果一个数列大部份都是不同的元素，那么数列本身也会占据O(n log n)的空间字节。

非原地版本的快速排序，在它的任何递回呼叫前需要使用O(n)空间。在最好的情况下，它的空间仍然限制在O(n)，因为递回的每一阶中，使用与上一次所使用最多空间的一半，且

\sum_{i=0}^{\infty} \frac{n}{2^i} = 2n.

它的最坏情况是很恐怖的，需要

\sum_{i=0}^n (n-i+1) = \Theta (n^2)

空间，远比数列本身还多。如果这些数列元素本身自己不是固定的大小，这个问题会变得更大；举例来说，如果数列元素的大部份都是不同的，每一个将会需要大约O(log n)为原来储存，导致最好情况是O(n log n)和最坏情况是O(n2 log n)的空间需求。

 

 

直接选择排序

选择排序的交换操作介于0和(n-1)次之间。选择排序的比较操作为n(n-1)/2次之间。选择排序的赋值操作介于0和3(n-1)次之间。

比较次数O(n^2),比较次数与关键字的初始状态无关，总的比较次数N=(n-1)+(n-2)+...+1=n*(n-1)/2。 交换次数O(n),最好情况是，已经有序，交换0次；最坏情况是，逆序，交换n-1次。 交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CPU时间多，n值较小时，选择排序比冒泡排序快。

 

堆排序

堆排序的平均时间复杂度为Ｏ(nlogn)，空间复杂度为Ｏ(1)。

由于它在直接选择排序的基础上利用了比较结果形成。效率提高很大。它完成排序的总比较次数为Ｏ(nlog2n)。它是对数据的有序性不敏感的一种算法。但堆排序将需要做两个步骤：－是建堆，二是排序（调整堆）。所以一般在小规模的序列中不合适，但对于较大的序列，将表现出优越的性能。

 

归并排序

归并排序是一种非就地排序，将需要与待排序序列一样多的辅助空间。在使用它对两个己有序的序列归并，将有无比的优势。其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlog2n)。对数据的有序性不敏感。若数据节点数据量大，那将不适合。

 

基数排序

基数排序的时间复杂度是 O(k·n)，其中n是排序元素个数，k是数字位数。注意这不是说这个时间复杂度一定优于O(n·log(n))，因为k的大小一般会受到 n 的影响。 以排序n个不同整数来举例，假定这些整数以B为底，这样每位数都有B个不同的数字，k就一定不小于logB(n)。由于有B个不同的数字，所以就需要B个不同的桶，在每一轮比较的时候都需要平均n·log2(B) 次比较来把整数放到合适的桶中去，所以就有：

  • k 大于或等于 logB(n)
  • 每一轮(平均)需要 n·log2(B) 次比较

所以，基数排序的平均时间T就是：

T ≥ logB(n)·n·log2(B) = log2(n)·logB(2)·n·log2(B) = log2(n)·n·logB(2)·log2(B) = n·log2(n)

所以和比较排序相似，基数排序需要的比较次数：T ≥ n·log2(n)。 故其时间复杂度为 Ω(n·log2(n)) = Ω(n·log n) 。

 

 七、不同条件下，排序方法的选择

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。     　

当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。

(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；

(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。     　

快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；     　

堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。     　

若要求排序稳定，则可选用归并排序。但本章介绍的从单个记录起进行两两归并的  排序算法并不值得提倡，通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件，然后再两两归并之。因为直接插入排序是稳定的，所以改进后的归并排序仍是稳定的。

(4)在基于比较的排序方法中，每次比较两个关键字的大小之后，仅仅出现两种可能的转移，因此可以用一棵二叉树来描述比较判定过程。     　

当文件的n个关键字随机分布时，任何借助于"比较"的排序算法，至少需要O(nlgn)的时间。     　

箱排序和基数排序只需一步就会引起m种可能的转移，即把一个记录装入m个箱子之一，因此在一般情况下，箱排序和基数排序可能在O(n)时间内完成对n个记录的排序。但是，箱排序和基数排序只适用于像字符串和整数这类有明显结构特征的关键字，而当关键字的取值范围属于某个无穷集合(例如实数型关键字)时，无法使用箱排序和基数排序，这时只有借助于"比较"的方法来排序。     　

若n很大，记录的关键字位数较少且可以分解时，采用基数排序较好。虽然桶排序对关键字的结构无要求，但它也只有在关键字是随机分布时才能使平均时间达到线性阶，否则为平方阶。同时要注意，箱、桶、基数这三种分配排序均假定了关键字若为数字时，则其值均是非负的，否则将其映射到箱(桶)号时，又要增加相应的时间。

(5)有的语言(如Fortran，Cobol或Basic等)没有提供指针及递归，导致实现归并、快速(它们用递归实现较简单)和基数(使用了指针)等排序算法变得复杂。此时可考虑用其它排序。

(6)本章给出的排序算法，输人数据均是存储在一个向量中。当记录的规模较大时，为避免耗费大量的时间去移动记录，可以用链表作为存储结构。譬如插入排序、归并排序、基数排序都易于在链表上实现，使之减少记录的移动次数。但有的排序方法，如快速排序和堆排序，在链表上却难于实现，在这种情况下，可以提取关键字建立索引表，然后对索引表进行排序。然而更为简单的方法是：引人一个整型向量t作为辅助表，排序前令t[i]=i(0≤i<n)，若排序算法中要求交换R[i]和R[j]，则只需交换t[i]和t[j]即可；排序结束后，向量t就指示了记录之间的顺序关系：        

R[t[0]].key≤R[t[1]].key≤…≤R[t[n-1]].key  

若要求最终结果是：       

R[0].key≤R[1].key≤…≤R[n-1].key

则可以在排序结束后，再按辅助表所规定的次序重排各记录，完成这种重排的时间是O(n)。

 

 

八、各排序算法时间复杂度和空间复杂度

 

       

 

 

 

posted on 2013-05-04 09:06  午夜稻草人  阅读(604)  评论(0)  编辑  收藏  举报