2021年12月15日希尔排序&&归并排序（递归实现）_递归实现希尔排序-优快云博客

本文链接：https://blog.youkuaiyun.com/LEewhITe2003/article/details/121964421

本文介绍了两种经典的排序算法——希尔排序和归并排序。希尔排序通过设置增量序列来改进直接插入排序，提高了排序效率；归并排序则采用分治策略，将序列拆分为两部分，分别排序后再合并。文中提供了C++和C语言的实现代码，详细解释了每一步操作，是理解这两种排序算法的好资源。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

希尔排序

C++码

void shellSort(vector<int>& arr) {
        "初始化增量为数组长度的一半，并逐步缩小增量"
       for (int gap = arr.size() / 2; gap > 0; gap /= 2) {
           "从第gap个元素，逐个对其所在组进行直接插入排序操作"
           for (int i = gap; i < arr.size(); i++){
               int j = i;
               while (j - gap >= 0 && arr[j] < arr[j-gap]) {           
                   swap(arr[j], arr[j - gap]);
                   j -= gap;
               }
           }
       }
    }

C语言码（使用Sedgewick增量序列）

void ShellSort( ElementType A[], int N )
{ "希尔排序 - 用Sedgewick增量序列 "
     int Si, D, P, i;
     ElementType Tmp;
     " 这里只列出一小部分增量 "
     int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};
     
    "找到应该使用的初始Sedgewick增量,初始的增量Sedgewick[Si]不能超过待排序列长度"
     for ( Si=0; Sedgewick[Si]>=N; Si++ ) 
         ; 
    
     for ( D=Sedgewick[Si]; D>0; D=Sedgewick[++Si] )
         for ( P=D; P<N; P++ ) { " 插入排序 "
             Tmp = A[P];
             for ( i=P; i>=D && A[i-D]>Tmp; i-=D )
                 A[i] = A[i-D];
             A[i] = Tmp;
         }
}

归并排序

模块一Merge：实现两个“有序”线性表的归并。

" L = 左边起始位置, R = 右边起始位置, RightEnd = 右边终点位置 "
void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
{ " 将有序的A[L]~A[R-1]和A[R]~A[RightEnd]归并成一个有序序列 "
     int LeftEnd, NumElements, Tmp;
     int i;
     
     LeftEnd = R - 1;  "左边终点位置"
     Tmp = L;         "有序序列的起始位置"
     NumElements = RightEnd - L + 1;
     
     while( L <= LeftEnd && R <= RightEnd ) {
         if ( A[L] <= A[R] )
             TmpA[Tmp++] = A[L++];   "将左边元素复制到TmpA"
         else
             TmpA[Tmp++] = A[R++];  "将右边元素复制到TmpA "
     }

     while( L <= LeftEnd )
         TmpA[Tmp++] = A[L++]; "直接复制左边剩下的"
     while( R <= RightEnd )
         TmpA[Tmp++] = A[R++];  "直接复制右边剩下的"
         
     for( i = 0; i < NumElements; i++, RightEnd -- )
         A[RightEnd] = TmpA[RightEnd];  "将有序的TmpA[]复制回A[]"
}

模块二Msort：递归地分治每个小序列。

void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd )
{  " 核心递归排序函数 "
     int Center;
     
     if ( L < RightEnd ) {
          Center = (L+RightEnd) / 2;
          Msort( A, TmpA, L, Center );              "递归解决左边" 
          Msort( A, TmpA, Center+1, RightEnd );     "递归解决右边"  
          Merge( A, TmpA, L, Center+1, RightEnd );  "合并两段有序序列" 
     }
}

接口：

void MergeSort( ElementType A[], int N )
{ "归并排序"
     ElementType *TmpA;
     TmpA = (ElementType *)malloc(N*sizeof(ElementType));
     
     if ( TmpA != NULL ) {
          Msort( A, TmpA, 0, N-1 );
          free( TmpA );
     }
     else printf( "空间不足" );
}