归并排序的递归实现

归并排序是一种很经典的算法。
原理就是 把一个数组按照五五开的方式分成小块,然后再一个一个的归并起来。
在归并的过程之中,也要保证两个区间内的数字在归并前的时候是有序的,并且在归并完成之后也是有序的。这样一直归并下去,直到数据的区间是数组头到数组尾。

#include <iostream>
#include <vector>
using namespace std;
vector<int> w;
void merges(int L1,int R1,int L2,int R2){
    int i = L1,j = L2;
    vector<int> temp;
    while(i <= R1 && j <= R2){
        if(w[i] < w[j]) temp.push_back(w[i++]);
        else temp.push_back(w[j++]);
    }
    while(i <= R1) temp.push_back(w[i++]);
    while(j <= R2) temp.push_back(w[j++]);
    for(i = 0;i < temp.size();i ++) w[L1 + i] = temp[i];
}
void mergesort(int left,int right){
    if(left < right){
        int mid = (right+left)/2;
        mergesort(left,mid);
        mergesort(mid+1,right);
        merges(left,mid,mid+1,right);
    }
}
int main(){
    int n,one;
    cin >> n;//先输入数字的个数N
    for(int i = 0;i < n;i ++){cin >> one;w.push_back(one);}//再输入N个数字
    mergesort(0,w.size()-1);
    for(int i = 0;i < w.size();i ++)   cout << w[i] << " ";
    return 0;
}
/*
sample input:
5
2 3 5 1 4
sample output:
1 2 3 4 5
*/
<think> 根据用户需求,用户想了解归并排序递归实现和非递归实现的具体方法。结合引用资料,我将详细解释这两种实现方式。 注意:按照要求,行内数学表达式用$...$,独立公式用$$...$$,使用中文回答,并生成相关问题。 引用资料中提供了归并排序的基本思想和步骤,我将整理如下: 1. 递归方法:采用分治思想,将数组分成两个子数组,分别递归排序,然后合并两个有序子数组。 2. 非递归方法:从底部向上,将数组看作由多个长度为1的子数组开始,然后两两归并,逐步扩大归并的子数组长度,直到整个数组有序。 接下来,我将详细说明两种实现的具体步骤,并给出代码示例(使用Python,因为用户之前的示例也是Python,但注意引用资料中可能是其他语言,我将用Python实现)。 同时,我会在适当的地方引用提供的资料。 </think> ### 归并排序实现方法详解 #### 一、递归实现 **核心思想**:采用分治策略(Divide and Conquer) 1. **分解**:将当前区间 $[left, right]$ 平分为两个子区间 $[left, mid]$ 和 $[mid+1, right]$,其中 $mid = \lfloor (left+right)/2 \rfloor$[^4] 2. **递归**:对左右子区间分别进行归并排序 3. **合并**:将两个有序子区间合并为一个有序区间 ```python def merge_sort_recursive(arr): if len(arr) <= 1: return arr # 分解步骤 mid = len(arr) // 2 left_arr = merge_sort_recursive(arr[:mid]) right_arr = merge_sort_recursive(arr[mid:]) # 合并步骤 return merge(left_arr, right_arr) def merge(left, right): result = [] i = j = 0 # 双指针合并有序数组 while i < len(left) and j < len(right): if left[i] < right[j]: result.append(left[i]) i += 1 else: result.append(right[j]) j += 1 # 添加剩余元素 result.extend(left[i:]) result.extend(right[j:]) return result ``` **时间复杂度分析**: - 递归树深度:$O(\log n)$ - 每层合并操作:$O(n)$ - 总时间复杂度:$O(n \log n)$[^2] **空间复杂度**:$O(n)$(需要额外存储空间) --- #### 二、非递归实现(迭代实现) **核心思想**:自底向上合并,避免递归调用 1. **初始化**:将每个元素视为长度为1的有序子序列 2. **迭代合并**: - 第一轮合并相邻长度为1的子序列 → 得到长度为2的有序序列 - 第二轮合并相邻长度为2的子序列 → 得到长度为4的有序序列 - 重复直到整个序列有序[^3] ```python def merge_sort_iterative(arr): n = len(arr) step = 1 # 初始子序列长度 while step < n: # 遍历所有子区间 for i in range(0, n, 2*step): left = i mid = min(i + step, n) right = min(i + 2*step, n) # 合并相邻子区间 left_arr = arr[left:mid] right_arr = arr[mid:right] merged = merge(left_arr, right_arr) # 使用上述merge函数 # 将合并结果写回原数组 arr[left:right] = merged step *= 2 # 子序列长度翻倍 return arr ``` **关键参数控制**: - `step`:当前有序子序列的长度 - `left/mid/right`:子序列边界计算 - 边界处理:`min(i + step, n)` 防止越界[^1] **性能对比**: | 特性 | 递归实现 | 非递归实现 | |--------------|------------------|------------------| | 时间复杂度 | $O(n \log n)$ | $O(n \log n)$ | | 空间复杂度 | $O(n)$ | $O(n)$ | | 栈空间 | $O(\log n)$ | $O(1)$ | | 稳定性 | 稳定 | 稳定 | | 适用场景 | 链表排序 | 大数据量排序 | **图解过程**(非递归示例): ``` 初始序列: [8, 3, 5, 1, 7, 4, 2, 6] step=1 → [3,8], [1,5], [4,7], [2,6] // 两两合并 step=2 → [1,3,5,8], [2,4,6,7] // 合并相邻4元组 step=4 → [1,2,3,4,5,6,7,8] // 合并完成 ``` > 非递归实现避免了递归调用的栈开销,特别适合处理超大规模数据(当递归深度过大可能导致栈溢出时)[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值