C语言实现归并排序

写在前面

基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序算法的实现

需要解决的问题，

1. 怎么将两个块合并成一个块。merge函数实现
2. 怎么划分块。merge_sort函数实现

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <malloc.h>

const int MAXSIZE = 100;

void merge(int *, int, int, int);
void merge_sort(int *, int, int);

int main()
{
    int data[MAXSIZE];
    time_t t;
    srand((unsigned)time(&t));
    // 随机生成20个数
    for(int i=0;i<20;i++)
    {
        data[i] = rand() % 100;
    }
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    merge_sort(data, 0, 19);
    for(int i=0;i<20;i++)
    {
        printf("%d ", data[i]);
    }
    printf("\n");
    return 0;
}
/**
 * @param: data 数组第一个元素的地址
 * @param: left 第一个元素的下标
 * @param: right 最后一个元素的下标
 *
 */
void merge_sort(int *data, int left, int right)
{
    if (data == NULL || left >= right)
        return;
    int mid = (left + right) / 2;
    merge_sort(data, left, mid);
    merge_sort(data, mid + 1, right);

    merge(data, left, mid, right);
}

/**
 * @param: data 数组第一个元素的地址
 * @param: left 归并时第一块的第一个元素的下标
 * @param: mid 两块的交点
 * @param: right 归并时第二块的最后一个元素的下标
 */
void merge(int *data, int left, int mid, int right)
{
    int *tmp = (int *)malloc(sizeof(int) * (right - left + 1));
    int k = 0; // k记录在tmp中的下标
    int i=left, j=mid+1;
    while (i<=mid || j<=right)
    {
        if (i > mid)
        {
            tmp[k ++] = data[j ++];
        }
        else if (j > right)
        {
            tmp[k ++] = data[i ++];
        }
        else if (data[i]<data[j])
        {
            tmp[k ++] = data[i ++];
        }
        else
        {
            tmp[k ++] = data[j ++];
        }
    }
    for (int i=0;i < k; i++)
    {
        data[left + i] = tmp[i];
    }
    free(tmp);
}

归并排序效率分析

归并排序时间复杂度
归并排序的时间复杂度是$O(N\ast lgN)$.
假设被排序的数列中有N个数。遍历一趟的时间复杂度是$O(N)$，需要遍历多少次呢？
归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的可以得出它的时间复杂度是$O(N\ast lgN)$。

归并排序稳定性
归并排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 – 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！

参考内容：
归并排序

文中都是我个人的理解，如有错误的地方欢迎下方评论告诉我，我及时更正，大家共同进步