归并排序——二路归并排序

本文详细介绍了二路归并排序的基本概念与算法思想,包括其核心步骤——一趟归并的过程分析,以及如何通过多次调用一趟归并来实现整个排序过程。文中还提供了具体的C语言实现代码,帮助读者理解二路归并排序的时间复杂度和空间复杂度。

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

/*
 *归并:
 *  指将两个或者两个以上的有序表合并成一个新的有序表
 *
 *二路归并算法思想:
 *  将长度为n的待排序数据表看成是n个长度为1的有序表,并将这些有序表两两归并,
 *  便得到[n/2]个有序表;再将这[n/2]个有序表两两归并,如此反复,直到最后得到
 *  长度为n的有序表为止。
 */

/*
 *过程分析:
 *  若有序表A、B同属于一个数据表R,是R的两个有序区,并且R[low]~R[mid]为有序表A
 *  的存储区,R[mid+1]~R[high]为有序表的存储区。将其归并成为一个有序表C,存放在
 *  R1中,进行的算法描述如Merge(int R[],int R1[],int low,int mid,int high)函数。
 *
 *  在分析二路归并算法实现之前,首先分析一趟归并问题。假设待排序序列的长度为n,
 *  一趟归并时可能有3种情况。
 *      1.该趟归并前,R中参与归并的两个有序表的长度均为len
 *          这时相邻的两个有序表的下标范围是(i~i+len-1)和(i+len~i+len*2-1)。则调用为
 *              Merge(R,R1,i,i+len-1,i+len*2-1)
 *      2.最后一对参与归并的有序表中,其中一个长度小于len
 *          即i+len<n-1且i+len*2-1>n-1。也就是说最后一个有序表中最后一个元素的下标为n-1
 *          此时的调用为
 *              Merge(R,R1,i,i+len-1,n-1);
 *      3.参与归并的最后只剩下一个有序表R
 *          即i+len-1>n-1,则只需要把有序表R直接复制到R1中即可
 *
 *  二路归并的一趟归并的算法:
 *      对无序表进行二路归并就是调用上述一趟归并算法,对待排序序列进行若干趟归并。第一趟
 *      归并时,每个有序表的长度为1,即len=1,。归并后有序表的长度len就扩大一倍。即排序中len
 *      从1,2,4,……到[n/2],可以用while循环实现整个归并过程
 */

/*
 *性能分析:
 *  时间复杂度是O(nlog2n).空间复杂度是O(n)
 */
#include <stdio.h>
#define length 9

void Merge(int R[],int R1[],int low,int mid,int high)
{
    int i=low,j=mid+1,k=low;
    while(i<=mid && j<=high)//需要两个条件同时成立,因为两个序列的长度可能不一样
    {
        if(R[i]<=R[j])
        {
            R1[k]=R[i];
            ++i;
        }
        else
        {
            R1[k]=R[j];
            ++j;
        }
        ++k;
    }
    while(i<=mid)R1[k++]=R[i++];
    while(j<=high)R1[k++]=R[j++];
}
void MergePass(int R[],int R1[],int len)//进行一次归并排序
{
    int j,i=0;
    while(i+len*2<=length)
    {
        Merge(R,R1,i,i+len-1,i+len*2-1);
        i=i+len*2;
    }
    if(i+len-1<length-1)Merge(R,R1,i,i+len-1,length-1);
    else
        for(j=i;j<length;j++)R1[j]=R[j];
}
void MergeSort(int *order)
{
    int len=1;
    int *R1;
    R1=(int *)malloc(sizeof(int)*length);
    while(len<=(length/2+1))
    {
        MergePass(order,R1,len);
        len=2*len;
        MergePass(R1,order,len);//两次归并后,结果仍在order中
        len=2*len;
    }
    free(R1);
}

int main()
{
    int order[length]={0,49,52,65,97,35,13,27,49};
    MergeSort(order);
    int i;
    for(i=0;i<length;i++)printf("%d  ",order[i]);
    return 0;
}

### 堆排序二路归并排序特点 #### 堆排序特性 堆排序利用了最大堆的数据结构来达到排序的目的。最大堆是一个完全二叉树,在这个树中,父节点总是大于等于其子节点。通过构建这样的数据结构,可以方便地获取当前集合中的最大值或最小值[^1]。 #### 二路归并排序特性 二路归并排序基于分治策略工作,即将数组分成较小的部分分别处理后再合并起来形成最终的结果。此过程会递归地把待排序列分为两半直到不能再分割为止,之后再逐步将这些小部分按照顺序组合回去。这种方法能够保证即使是在最坏情况下也能保持 O(n log n) 的时间效率,并且具有稳定性——即相同数值不会改变相对位置关系[^2]。 ### 排序实现方式对比 #### 堆排序实现 以下是 Python 中简单的堆排序算法实现: ```python def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[i] < arr[l]: largest = l if r < n and arr[largest] < arr[r]: largest = r if largest != i: arr[i],arr[largest] = arr[largest],arr[i] heapify(arr, n, largest) def heapSort(arr): n = len(arr) for i in range(n // 2 - 1, -1, -1): heapify(arr, n, i) for i in range(n-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) ``` #### 二路归并排序实现 下面是同样使用Python编写的简单版本的二路归并排序函数: ```python def merge(left, right): result = [] while left and right: if left[0] <= right[0]: result.append(left.pop(0)) else: result.append(right.pop(0)) if left: result += left if right: result += right return result def mergesort(lst): if len(lst) <= 1: return lst mid = int(len(lst)/2) left = mergesort(lst[:mid]) right = mergesort(lst[mid:]) return merge(left,right) ``` ### 性能差异分析 对于平均情况下的时间复杂度而言,两者都达到了理论上的最优解 O(nlogn),但是实际运行时的表现可能会有所不同。具体来说: - **空间消耗**: 归并排序需要额外的空间用于存储临时数组来进行元素间的比较和交换操作,而堆排序则不需要这么多辅助性的储存单元因为它主要依赖于原位调整; - **缓存友好性**: 尽管两种方法理论上都能很好地适应现代计算机体系架构下CPU高速缓冲区的工作模式,但在实践中发现由于访问局部性和连续内存读取的优势,通常认为堆排序在这方面更胜一筹; - **稳定性质**: 如前所述,只有当涉及到相等键值项之间的原始次序保留需求时才会考虑这一点;显然,归并排序在这个方面做得更好一些,它属于一种稳定的排序方案,而标准形式下的堆排序不具备这一属性.
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值