排序算法集合

Shell 排序

Shell 排序实现的原理就是依据不断地缩小增量排序最终达到目的；

这里的实现方式增量序列的选择：ht = [N / 2], hk = [h(k + 1) / 2]

        void        Shellsort( ElementType A[ ], int N )        {            int i, j, Increment;            ElementType Tmp;/* 1*/      for( Increment = N / 2; Increment > 0; Increment /= 2 )/* 2*/          for( i = Increment; i < N; i++ )                {/* 3*/              Tmp = A[ i ];/* 4*/              for( j = i; j >= Increment; j -= Increment ) /* 5*/                  if( Tmp < A[ j - Increment ] )  // 这个地方就是插入排序的操作/* 6*/                      A[ j ] = A[ j - Increment ];                        else/* 7*/                      break;/* 8*/              A[ j ] = Tmp;                }        }

堆排序

优先队列的排序时间是O(NlogN)，基于该思想的算法叫做堆排序(heapsort)。

默认的二叉堆实现表达一个优先队列（堆），例如一个小堆，deletemin之后，每操作一次这个元素放到数组的末尾，直到N个都删除之后也就建立了一个递减序列。

如果预先建立一个大堆，N次deletemax之后，结果就是一个递增序列了。

        typedef int ElementType;        void        Swap( ElementType *Lhs, ElementType *Rhs )        {            ElementType Tmp = *Lhs;            *Lhs = *Rhs;            *Rhs = Tmp;        }        #define LeftChild( i )  ( 2 * ( i ) + 1 )        void        PercDown( ElementType A[ ], int i, int N )        {            int Child;            ElementType Tmp;/* 1*/      for( Tmp = A[ i ]; LeftChild( i ) < N; i = Child )            {/* 2*/          Child = LeftChild( i );/* 3*/          if( Child != N - 1 && A[ Child + 1 ] > A[ Child ] )/* 4*/              Child++;/* 5*/          if( Tmp < A[ Child ] )/* 6*/              A[ i ] = A[ Child ];                else/* 7*/              break;            }/* 8*/      A[ i ] =Tmp;        }        void        Heapsort( ElementType A[ ], int N )        {            int i;/* 1*/      for( i = N / 2; i >= 0; i-- )  /* BuildHeap *//* 2*/          PercDown( A, i, N );/* 3*/      for( i = N - 1; i > 0; i-- )            {/* 4*/          Swap( &A[ 0 ], &A[ i ] );  /* DeleteMax *//* 5*/          PercDown( A, 0, i );            }        }