内部排序算法的比较和实现

排序是数据处理中经常使用的一种重要运算,在计算机及其应用系统中,花费在排序上的时间在系统运行时间中占有很大比重;并且排序本身对推动算法分析的发展也起很大作用。目前已有上百种排序方法，但尚未有一个最理想的尽如人意的方法，本文介绍常用的如下排序方法的C/C++实现，并对它们进行分析和比较。
更详细的算法思想的介绍可以 参考这里   

/*
   冒泡排序  插入排序 二路插入排序 希尔排序   快速排序 选择排序 归并排序  堆排序算法的
   C/C++实现。
   
   作者：feosun

   日期：2008年10月12日

   参考资料：数据结构(C语言版) 清华大学出版社

*/


#include <iostream>
using  namespace std;


// 交换两个数的值
void swap( int &a, int &b)
{
     int tmp;
    tmp=a;
    a=b;
    b=tmp;
}

// 屏幕输出数组
void display( int array[], int len)
{
    cout<<"the result is:"<<endl;
     for ( int i = 0 ;i < len;i++ )
    {
        cout<<array[i]<<"  ";
    }
    cout<<endl;
}

/*
冒泡排序

算法思想：将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。
          根据轻气泡不能在重气泡之下的原则，从下往上扫描数组 R：凡扫描到违反本原则的
          轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，
          重者在下为止。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2
*/
void bubble_sort( int array[], int len)
{
    
     for ( int i = len-1 ;i >= 0;i-- )
    {
         for( int j = 0;j < i;j++)
             if(array[j] > array[j+1])
                swap(array[j],array[j+1]);
    }
}


/*
直接插入排序

算法思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元
          素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它
          插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2
*/
void insert_sort( int array[], int len)
{
     int tmp,i,j;

     for(i = 1;i < len;i++)
    {
         if (array[i] < array[i-1])
        {
            tmp = array[i];
            array[i] = array[i-1];

             // 插入到相应位置
             for (j = i-2;j >= 0;j--)
            {
                 // 往后移
                     if (array[j] > tmp )
                        array[j+1] = array[j];
                     else
                    {
                        array[j+1] = tmp;
                         break;
                    }
            }
             if(j == -1)
            array[j+1] = tmp;
        }
    }
}


/*
2-路插入排序

算法思想：增加一个辅助空间d,把r[1]赋值给d[1]，并将d[1]看成是排好序后处于中间
          位置的记录。然后从r[2]开始依次插入到d[1]之前或之后的有序序列中。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2
*/

void bi_insert_sort( int array[], int len)
{
     int* arr_d = ( int *)malloc( sizeof( int) * len);

    arr_d[0] = array[0];
     int head = 0,tail = 0;
     for ( int i = 1;i < len; i++ )
    {
         if (array[i] > arr_d[0])
        {
             int j;
             for ( j= tail;j>0;j--)
            {
                 if (array[i] < arr_d[j])
                    arr_d[j+1] = arr_d[j];
                 else
                     break;
            }
            arr_d[j+1] = array[i];
            tail += 1;
        }

         else
        {
             if (head ==0)
            {
                arr_d[len-1] = array[i];
                head =len-1;
            }
             else
            {
                 int j;
                 for (j = head;j <= len-1;j++)
                {
                     if (array[i] > arr_d[j])
                        arr_d[j-1] = arr_d[j];
                     else
                         break;
                }
                arr_d[j-1] = array[i];
                head -= 1;
            }
        }

    }

     for ( int i = 0;i < len; i++)
    {
         int pos = (i + head );
         if(pos >= len) pos -= len;
        array[i] = arr_d[pos];
    }

    free(arr_d);
}


/*
希尔排序

算法思想：先将整个待排序记录分割成若干子序列分别进行直接插入排
          序，待整个序列中的记录基本有序时，再对全体记录进行一
          次直接插入排序

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 ?
*/

void shell_insert( int array[], int d, int len)
{
     int tmp,j;

     for ( int i = d;i < len;i++)
    {
         if(array[i] < array[i-d])
        {
            tmp = array[i];
            j = i - d;
             do 
            {
                array[j+d] = array[j];
                j = j - d;
            }  while (j >= 0 && tmp < array[j]);

            array[j+d] = tmp; 
        }
    }
}
void shell_sort( int array[], int len)
{

     int inc = len;

     do 
    {
        inc = inc/2;
        shell_insert(array,inc,len);
    }  while (inc > 1);
}




/*
快速排序

算法思想：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递
          归地解这些子问题，然后将这些子问题的解组合成为原问题的解。

时间复杂度 o(nlogn)

空间复杂度 o(logn)

比较次数  ?
*/

int partition( int array[], int low, int high)
{
     int  pivotkey = array[low];

     while (low < high)
    {
         while(low < high && array[high] >= pivotkey)
            --high;
        swap(array[low],array[high]);

         while(low < high && array[low] <= pivotkey)
            ++low;
        swap(array[low],array[high]);
    }

    array[low] = pivotkey;

     return low;
}


void quick_sort( int array[], int low, int high)
{
     if (low < high)
    {
         int pivotloc = partition(array,low,high);
        quick_sort(array,low,pivotloc-1);
        quick_sort(array,pivotloc+1,high);
    }
}



/*
直接选择排序

算法思想：每一趟在n-i+1个记录中选取关键字最小的记录作为有序序列中的第i个记录

时间复杂度 o(n^2)

空间复杂度 o(1) ?

比较次数  n(n+1)/2
*/

int SelectMinKey( int array[], int iPos, int len)
{
     int ret = 0;

     for ( int i = iPos; i < len; i++)
    {
         if (array[ret] > array[i])
        {
            ret = i;
        }
    }
     return ret;
}

void select_sort( int array[], int len)
{
     for ( int i = 0; i < len; i++)
    {
         int j = SelectMinKey(array,i,len);
         if (i != j)
        {
            swap(array[i],array[j]);
        }
    }
}





/*
归并排序

算法思想：设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先
          将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。

时间复杂度 o(nlogn)

空间复杂度 o(n) 

比较次数  ?
*/

void merge( int array[], int i, int m,  int n)
{
     int j,k;

     int iStart = i, iEnd = n;

     int arrayDest[256];

     for ( j = m + 1,k = i; i <= m && j <= n; ++k)
    {
         if (array[i] < array[j])
            arrayDest[k] = array[i++];
         else
            arrayDest[k] = array[j++];
    }

     if (i <= m)
         for (;k <= n; k++,i++)
            arrayDest[k] = array[i];
     if(j <= n)
         for (;k <= n; k++,j++)
            arrayDest[k] = array[j];

     for(j = iStart; j <= iEnd; j++)
        array[j] = arrayDest[j];
}



void merge_sort( int array[], int s, int t)
{
     int m;

     if (s < t) 
    {
        m = (s + t )/2;
        merge_sort(array,s,m);
        merge_sort(array,m+1,t);
        merge(array,s,m,t);

    }
}


/*
堆排序

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

时间复杂度 o(nlogn)

空间复杂度 o(1) 

比较次数  较多
*/

void heap_adjust( int array[], int i, int len)
{
     int rc = array[i];

     for( int j = 2 * i; j <len; j *= 2)
    {
         if(j < len && array[j] < array[j+1]) j++;
         if(rc >= array[j])  break;

        array[i] = array[j]; i = j;
    }
    array[i] = rc;
}





void heap_sort( int array[], int len)
{
     int i;
     for(i = (len-1)/2; i >= 0; i--)
        heap_adjust(array,i,len);
     for(  i = (len-1); i > 0; i--)
    {
        swap(array[0],array[i]);    // 弹出最大值，重新对i-1个元素建堆
        heap_adjust(array,0,i-1);
    }

}








int main() {

     int array[] = {45,56,76,234,1,34,23,2,3,55,88,100};

     int len =  sizeof(array)/ sizeof( int);



     // bubble_sort(array,len);            // 冒泡排序

     /* insert_sort(array,len); */          // 插入排序

     /* bi_insert_sort(array,len); */       // 二路插入排序
    
     /* shell_sort(array,len); */           // 希尔排序 

     /* quick_sort(array,0,len-1); */       // 快速排序
    
     /* select_sort(array,len); */          // 选择排序

     /* merge_sort(array,0,len-1); */       // 归并排序
    
    heap_sort(array,len);                // 堆排序
    display(array,len);



     return 0;
}

选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。


      首先，排序算法的稳定性大家应该都知道，通俗地讲就是能保证排序前2个相等的数其在序列的前后位置顺序和排序后它们两个的前后位置顺序相同。在简单形式化一下，如果Ai = Aj, Ai原来在位置前，排序后Ai还是要在Aj位置前。

    其次，说一下稳定性的好处。排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，对基于比较的排序算法而言，元素交换的次数可能会少一些(个人感觉，没有证实)。

     回到主题，现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。

   (1)冒泡排序

       冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

(2)选择排序

     选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 29，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

(3)插入排序
    插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

(4)快速排序
    快速排序有两个方向，左边的i下标一直往右走，当a[i] <=a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j]> a[center_index]。如果i和j都走不动了，i <= j,交换a[i]和a[j],重复上面的过程，直到i>j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 1011，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

(5)归并排序
   归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

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

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

(8)堆排序

  我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2,...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

转载：点击打开链接