十大排序之归并排序

十大排序之归并排序

---

汇总在这里 十大排序汇总

---

归并排序（Merge Sort）

算法介绍:
1945年，约翰·冯·诺依曼（John von Neumann）发明了归并排序，这是典型的分治算法的应用.

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法思路：
我认为体现在两个字上————分治
**分：**把原数组划分成两个子数组的过程
**治：**它将两个有序数组合并成一个更大的有序数组。

• 当我们进行多次分操作时，待排序的线性表不断地被切分成若干个子表，直到每个子表只包含一个元素，这时，可以认为只包含一个元素的子表是有序表。
• 当我们进行多次治操作时，将子表两两合并，每合并一次，就会产生一个新的且更长的有序表，重复这一步骤，直到最后只剩下一个子表，这个子表就是排好序的线性表。

---

---

算法性能
速度仅次于快速排序。

时间复杂度

归并排序的时间复杂度为 O(nlogn)。

在归并排序中，每次将数组分成两个子数组，然后递归地对子数组进行排序，最后再将排序后的子数组合并成一个有序数组。在每一层递归中，需要对 n 个元素进行合并操作，而递归的层数为 logn，因为每次都将数组分成两半。所以，总的时间复杂度可以表示为 O(nlogn)。

归并排序的时间复杂度是稳定的，不会受到输入数据的影响。无论输入数组是有序的、逆序的还是随机的，归并排序始终需要进行 nlogn 次比较和移动操作。

空间复杂度

归并排序的空间复杂度为 O(n)，因为在合并过程中需要使用额外的临时数组来存储合并结果。

稳定性

当归并排序中的两个子数组都有相等的元素时，会先将左边子数组的元素放入结果数组，这样保证了左边子数组的元素在结果数组中的相对顺序与原始数组中的相对顺序一致。因此，归并排序是一种稳定的排序算法。

归并排序的实现（递归 | 迭代）

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

• 自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
• 自下而上的迭代；

递归实现

参考算法基础课 归并排序写法

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;
int len;
int arr[N], temp[N];

void merge_sort(int arr[], int l, int r)
{
    if (l >= r)
        return;

    int mid = l + r >> 1;

    // 递归排序左右两个子数组
    merge_sort(arr, l, mid);
    merge_sort(arr, mid + 1, r);

    int k = 0, i = l, j = mid + 1;

    // 合并两个有序子数组
    while (i <= mid && j <= r)
    {
        if (arr[i] < arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i <= mid)
        temp[k++] = arr[i++];
    while (j <= r)
        temp[k++] = arr[j++];

    // 将合并后的数组复制回原数组
    for (i = l, j = 0; i <= r; i++, j++)
        arr[i] = temp[j];
}

int main()
{
    cin >> len;

    for (int i = 0; i < len; i++)
        cin >> arr[i];

    // 调用归并排序算法对数组进行排序
    merge_sort(arr, 0, len - 1);

    // 输出排序后的数组
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";

    return 0;
}

---

下面这段代码实现了迭代版本的归并排序。在 merge_sort 函数中，使用 step 变量表示每次迭代合并的步长。初始步长为 2，然后每次迭代步长乘以 2，直到步长大于数组长度。在每个步长内，通过循环遍历数组并调用 merge 函数进行合并操作。

迭代实现

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 100010;
int len;
int arr[N], temp[N];

void merge(int arr[], int l, int mid, int r)
{
    int k = 0, i = l, j = mid + 1;

    // 合并两个有序子数组
    while (i <= mid && j <= r)
    {
        if (arr[i] < arr[j])
            temp[k++] = arr[i++];
        else
            temp[k++] = arr[j++];
    }
    while (i <= mid)
        temp[k++] = arr[i++];
    while (j <= r)
        temp[k++] = arr[j++];

    // 将合并后的数组复制回原数组
    for (i = l, j = 0; i <= r; i++, j++)
        arr[i] = temp[j];
}

void merge_sort(int arr[], int len)
{
    // 迭代合并的步长
    for (int step = 2; step / 2 <= len; step *= 2)
    {
        // 每个步长内进行合并
        for (int i = 0; i < len; i += step)
        {
            int mid = i + step / 2 - 1;
            int r = min(i + step - 1, len - 1);
            merge(arr, i, mid, r);
        }
    }
}

int main()
{
    cin >> len;

    for (int i = 0; i < len; i++)
        cin >> arr[i];

    // 调用归并排序算法对数组进行排序
    merge_sort(arr, len);

    // 输出排序后的数组
    for (int i = 0; i < len; i++)
        cout << arr[i] << " ";

    return 0;
}

持续更新中，加油！！！