排序算法（一）之归并排序，学不会你打我！（C语言）

排序算法一 之 归并排序

ps:需要函数的直接下边链接下载，注释也比较全。
程序下载无需积分！！！

这一篇只讲归并排序

为什么要用归并排序？

因为归并排序可以说是最稳定的一种排序，它的时间复杂度为O（cnlog₂n）。其中c为常数，n为排序个数。

想必会搜归并排序的朋友也一定做过大致的了解。那我这里就不做过多的赘述。直接开始原理！

如果你看到这篇博客，就不需要再翻看和浏览其他的归并排序的内容，请一定花十分钟耐心看完，看完保证能够彻底理解归并排序。

如上图所示，就是归并排序的一个例子，我们以一个数组

array【8】 = {3,6,7,7,8,2,1,5}为例子；

然后通过函数进行讲解。

首先看一个函数void merge(int* array, int start, int mid, int end)

下面这个函数是我写的，简单阐述一下原理，
这里举一个例子，比如输入的数组是

条件：假设array[2] = {8，2}，start为第一个数所以start=1，end为第二个数所以end=2；
则 mid = (start+end)/2 =1

第一步
根据中间部分创建左右两段Left[]和Right[]两个数组，这里两个数组中都只有一个整形数据
Left[1]={8}；Right[1]={2}；
第二步
取Left[]和Right[]中的数放到array中。比较Left[]和Right[]第一个数据，
发现Right[0]<Left[0]所以array[0]=Right[0]
然后Right中没有数据了就把Left[0]赋值给array[1];
此时array[2]={2,8}完成排序。

知道原理之后可以不看函数往下看，因为看完下边之后再整体看可以更加有助于对该排序方法的理解。

/*
 * 函数功能：将array数组中已经排序好的从第start到mid个数
 *			 和第mid+1到第end个数进行合并排序
 * 输入参数：array-待排序数组指针
 *			 start-开始排序的第i个数,比如从第1个开始排序则start=1
 *			 mid-mid=(start+end)/2
 *			 end-结束排序的第i个数,比如到第6个数结束排序则end=6
 * 输出参数：无
 * 函数返回：无
 */
void merge(int* array, int start, int mid, int end)
{
    //定义左段和右段的长度
    int Left_len, Right_len;
    int i, j, k;
    //定义左右段数组指针
    int* Left = NULL;
    int* Right = NULL;

    //计算左右段数组包含数的个数
    Left_len = mid - start + 1;
    Right_len = end - mid;

    //为左右段开辟空间
    Left = (int*)malloc((Left_len) * sizeof(int));
    Right = (int*)malloc((Right_len) * sizeof(int));

    //将已经排好的两段分别赋值给左段和右段
    for (i = 0; i < Left_len; i++) {
        Left[i] = array[start + i - 1];
    }
    for (j = 0; j < Right_len; j++) {
        Right[j] = array[mid + j];
    }

    //将i和j归0
    i = 0;
    j = 0;

    //将左右两段进行总排序
    for (k = start - 1; k < end; k++) {
        //如果左边的数已经排完，就一直将右边的数往后放
        if (i >= Left_len) {
            array[k] = Right[j];
            j = j + 1;
        }
        //右边的数先用完也同理
        else if (j >= Right_len) {
            array[k] = Left[i];
            i = i + 1;
        }
        //左边和右边的数字哪边小就先放那边
        else if (Left[i] <= Right[j]) {
            array[k] = Left[i];
            i = i + 1;
        } else if (Left[i] > Right[j]) {
            array[k] = Right[j];
            j = j + 1;
        }
    }

    //释放指针
    free(Right);
    free(Left);

    return;
}

再看另一个函数merge_sort(int* array, int start, int end)

这个函数可以对照上面的那个图进行理解，输入一个数组后，会将其分成两段，然后分别对两段中的数据进行排序，在对两段中的数排序的过程中又会分成两段，直到两段都被分成一个数，然后就保证了在排序两个具有多个数据的数组时，每个数组内部都是排好的顺序。

/*
 * 函数功能：排序数组中从start到end个数
 * 输入参数：array-待排序数组
 *			 start-开始排序的第i个数,比如从第1个开始排序则start=1
 *			 end-结束排序的第i个数,比如到第6个数结束排序则end=6
 * 输出参数：无
 * 函数返回：无
 */
void merge_sort(int* array, int start, int end)
{
    int mid;
    if (start < end) {
        mid = (start + end) / 2;
        //一直递归到左边全部排序排好
        merge_sort(array, start, mid);
        //同理一直递归到右边排序排好
        merge_sort(array, mid + 1, end);
        //将已经排好的两段进行排序
        merge(array, start, mid, end);
    }
}

这时候再举一个例子

条件：假设array[2] = {3,6,7,7,1,2,5,8}，start为第一个数所以start=1，end为第八个数所以end=8；
则 mid = (start+end)/2 =4

第一步
根据中间部分创建左右两段Left[]和Right[]两个数组，这里两个数组中都只有一个整形数据
Left[4]={3,6,7,7}；Right[4]={1,2,5,8}；
第二步
取Left[]和Right[]中的数放到array中。
比较Left[]的第一个数据和Right[]第一个数据，array[0]=Right[0]=1
比较Left[]的第一个数据和Right[]第二个数据，array[1]=Right[1]=2
比较Left[]的第一个数据和Right[]第三个数据，array[2]=Left[0]=3
…
以此类推完成排序。

两个函数分析完之后，以下是实现代码

代码

//归并排序

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

#define N 8

//打印数组
void printf_array(int* array, int num);
//归并排序
void merge_sort(int* array, int p, int r);
void merge(int* array, int p, int q, int r);

int main(int argc, char* argv[])
{
    int array[N] = { 3, 6, 7, 7, 8, 2, 1, 5 };
    printf_array(array, N);
    merge_sort(array, 1, N);
    printf_array(array, N);
}

/*
 * 函数功能：将array数组中已经排序好的从第start到mid个数
 *			 和第mid+1到第end个数进行合并排序
 * 输入参数：array-待排序数组指针
 *			 start-开始排序的第i个数,比如从第1个开始排序则start=1
 *			 mid-将array分为左右两段的中间数
 *			 end-结束排序的第i个数,比如到第6个数结束排序则end=6
 * 输出参数：无
 * 函数返回：无
 */
void merge(int* array, int start, int mid, int end)
{
    //定义左段和右段的长度
    int Left_len, Right_len;
    int i, j, k;
    //定义左右段数组指针
    int* Left = NULL;
    int* Right = NULL;

    //计算左右段数组包含数的个数
    Left_len = mid - start + 1;
    Right_len = end - mid;

    //为左右段开辟空间
    Left = (int*)malloc((Left_len) * sizeof(int));
    Right = (int*)malloc((Right_len) * sizeof(int));

    //将已经排好的两段分别赋值给左段和右段
    for (i = 0; i < Left_len; i++) {
        Left[i] = array[start + i - 1];
    }
    for (j = 0; j < Right_len; j++) {
        Right[j] = array[mid + j];
    }

    //将i和j归0
    i = 0;
    j = 0;

    //将左右两段进行总排序
    for (k = start - 1; k < end; k++) {
        //如果左边的数已经排完，就一直将右边的数往后放
        if (i >= Left_len) {
            array[k] = Right[j];
            j = j + 1;
        }
        //右边的数先用完也同理
        else if (j >= Right_len) {
            array[k] = Left[i];
            i = i + 1;
        }
        //左边和右边的数字哪边小就先放那边
        else if (Left[i] <= Right[j]) {
            array[k] = Left[i];
            i = i + 1;
        } else if (Left[i] > Right[j]) {
            array[k] = Right[j];
            j = j + 1;
        }
    }

    //释放指针
    free(Right);
    free(Left);

    return;
}

/*
 * 函数功能：排序数组中从start到end个数
 * 输入参数：array-待排序数组
 *			 start-开始排序的第i个数,比如从第1个开始排序则start=1
 *			 end-结束排序的第i个数,比如到第6个数结束排序则end=6
 * 输出参数：无
 * 函数返回：无
 */
void merge_sort(int* array, int start, int end)
{
    int mid;
    if (start < end) {
        mid = (start + end) / 2;
        //一直递归到左边全部排序排好
        merge_sort(array, start, mid);
        //同理一直递归到右边排序排好
        merge_sort(array, mid + 1, end);
        //将已经排好的两段进行排序
        merge(array, start, mid, end);
    }
}

//打印数组
void printf_array(int* array, int num)
{
    int i;
    for (i = 0; i < num; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

编译执行效果