归并排序(非递归实现)

我们知道,递归实现的缺点就是会一直调用栈,而栈内存往往是很小的。所以,我们尝试着用循环的办法去实现归并排序。

之气提到过,归并排序的基本思路是将待排序序列R[0…n-1]看成是n个长度为1的有序序列,将相邻的有序表成对归并,得到n/2个长度为2的有序表;将这些有序序列再次归并,得到n/4个长度为4的有序序列;如此反复进行下去,最后得到一个长度为n的有序序列。

综上可知:

归并排序其实要做两件事:

(1)“分解”——将序列每次折半划分。

(2)“合并”——将划分后的序列段两两合并后排序。

具体过程如下图所示:

这里写图片描述

1.待排序序列R[0…n-1] 一共有n个有序的子序列,每个子序列里都只含有一个元素。
2. 某趟归并中,设各子表的长度为length,则归并前R[0…n-1]中共有n/length个有序的子表:R[0…length-1], R[gap…2*length-1], … , R[(n/length)*length … n-1]。
3. 在上面归并的时候,我们遇到的length(1,2,4,8…)很可能不会在最终结果等于n。比如:n=7。这时候,我们采取的一种办法是只归并前面最接近n的那个位置(i+2*length<=n,即i<=n-2*length,处理到倒数第二对)。剩下的就通过下面代码来实现:

if ( i+length < N ) /*说明i+一个子序列的长度*/
         Merge( A, TmpA, i, i+length, N-1);/* 归并最后2个子列*/
     else /* 最后只剩1个子列*/
         for ( j = i; j < N; j++ ) TmpA[j] = A[j];

n=7的示意图:

这里写图片描述

完整代码:

#include "stdio.h"
#include "stdlib.h"

void Merge( int A[], int 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[] */
}

/* length = 当前有序子列的长度*/
void Merge_pass( int A[], int TmpA[], int N, int length )
{ /* 两两归并相邻有序子列 */
     int i, j;

     for ( i=0; i <= N-2*length; i += 2*length )
         Merge( A, TmpA, i, i+length, i+2*length-1 );
     if ( i+length < N )  
     /*  i+一个序列还是小于n,意味着有两个长度不等的子序列,其中一个为length,后一个小于length */
         Merge( A, TmpA, i, i+length, N-1);  /* 归并最后2个子列*/
     else /* 最后只剩1个子列*/
         for ( j = i; j < N; j++ ) TmpA[j] = A[j];
}

void Merge_Sort( int A[], int N )
{
     int length;
     int *TmpA;

     length = 1; /* 初始化子序列长度*/
     TmpA = (int*)malloc( N * sizeof( int ) );
     if ( TmpA != NULL ) {
          while( length < N ) {
              Merge_pass( A, TmpA, N, length );
              length *= 2;
              Merge_pass( TmpA, A, N, length );
              length *= 2;
          }
          free( TmpA );
     }
     else printf( "空间不足" );
}

int main()
{
    int a[10]={3,1,7,10,9,2,5,4,6,8};
    //int a[10]= {13,53,0,21,89,76,91,23,44,32};
    Merge_Sort(a,10);
    for(int i = 0;i<10;i++)
        printf("%d ",a[i]);
    return 0;
}

当然,我们在上面代码的第24行中,将原先递归实现时每次归并后保存在TempA[]数组的值传回给A[] 的步骤注释了,同时在 Merge_Sort( int A[], int N ) 函数中,我们每次循环都 Merge_pass 两次:

while( length < N ) {
      Merge_pass( A, TmpA, N, length );
      length *= 2;
      Merge_pass( TmpA, A, N, length );
      length *= 2;
 }

这样可以确保我们将序列归并排序后的数据一定是保存在数组A[]中。
如果每次都在每次归并的时候,加上那句for语句,那么也就是每次都将排序结果传回给数组A[],也能确保排序后的值在数组A[]中。但是这样处理的过程和原先的过程是有却别的,现在的过程是:

  1. 归并
  2. 调用Merge将相邻的子表归并时,必须对表的特殊情况进行特殊处理:
    若子表个数为奇数,则最后一个子表无须和其他子表归并(即本趟处理轮空):若子表个数为偶数,则要注意到最后一对子表中后一个子表区间的上限为n-1。
    示意图如下:
    这里写图片描述

从n=7和n=9的两幅图就可以看出,一个是每次所有元素都进行归并了,一个是将残留项(最后一项的长度小于length)保留,直到最后再归并。

所以也可以将代码改写如下:

#include "stdio.h"
#include "stdlib.h"

void Merge( int A[], int 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[] */
}

/* length = 当前有序子列的长度*/
void Merge_pass( int A[], int TmpA[], int N, int length )
{ /* 两两归并相邻有序子列 */
     int i, j;

     for ( i=0; i <= N-2*length; i += 2*length )
         Merge( A, TmpA, i, i+length, i+2*length-1 );
     if ( i+length < N ) /* 归并最后2个子列*/
         Merge( A, TmpA, i, i+length, N-1);
     //else /* 最后只剩1个子列*/
       //  for ( j = i; j < N; j++ ) TmpA[j] = A[j];
}

void Merge_Sort( int A[], int N )
{
     int length;
     int *TmpA;

     length = 1; /* 初始化子序列长度*/
     TmpA = (int*)malloc( N * sizeof( int ) );
     if ( TmpA != NULL ) {
          while( length < N ) {
              Merge_pass( A, TmpA, N, length );
              length *= 2;
              //Merge_pass( TmpA, A, N, length );
              //length *= 2;
          }
          free( TmpA );
     }
     else printf( "空间不足" );
}

int main()
{
    int a[10]={3,1,7,10,9,2,5,4,6,8};
    //int a[10]= {13,53,0,21,89,76,91,23,44,32};
    Merge_Sort(a,10);
    for(int i = 0;i<10;i++)
        printf("%d ",a[i]);
    return 0;
}

  • 23
    点赞
  • 75
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
归并排序是一种经典的排序算法,它采用分治的思想,将一个大问题分解成若干个小问题,然后合并小问题的解来得到大问题的解。归并排序递归实现非常简单,但实际上我们也可以使用非递归的方式来实现归并排序非递归归并排序算法可以使用迭代的方式来实现。具体的实现思路是,先将原数组分成若干个长度为1的子数组,然后将相邻的子数组合并成长度为2的子数组,再将相邻的长度为2的子数组合并成长度为4的子数组,以此类推,直到将整个数组排好序为止。 下面是归并排序非递归算法的代码实现: ```python def merge_sort(arr): n = len(arr) step = 1 while step < n: for i in range(0, n, step * 2): left = i right = min(i + step, n) end = min(i + step * 2, n) merge(arr, left, right, end) step *= 2 return arr def merge(arr, left, right, end): left_arr = arr[left:right] right_arr = arr[right:end] k = left i = j = 0 while i < len(left_arr) and j < len(right_arr): if left_arr[i] <= right_arr[j]: arr[k] = left_arr[i] i += 1 else: arr[k] = right_arr[j] j += 1 k += 1 while i < len(left_arr): arr[k] = left_arr[i] i += 1 k += 1 while j < len(right_arr): arr[k] = right_arr[j] j += 1 k += 1 ``` 在上面的代码中,`merge_sort` 函数使用一个变量 `step` 来表示当前合并的子数组的长度,初始值为1。然后在一个 `while` 循环中,每次将相邻的两个长度为 `step` 的子数组合并成一个长度为 `step*2` 的子数组,直到 `step` 大于等于数组长度为止。在合并子数组的时候,我们使用 `merge` 函数将两个子数组合并成一个有序的子数组。 需要注意的是,在 `merge` 函数中,我们使用了一个 `left` 变量来表示左子数组的起始位置,使用一个 `right` 变量来表示右子数组的起始位置,使用一个 `end` 变量来表示右子数组的结束位置。这是因为在合并子数组的时候,右子数组的起始位置并不是固定的,而是根据 `left` 和 `step` 来计算的。 归并排序非递归实现虽然比递归实现稍微复杂一些,但它具有更好的空间复杂度和更好的稳定性,是一种非常实用的排序算法。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值