内部排序之归并排序_归并排序序列里面用什么排序

1.归并排序

归并排序，顾名思义就是将两个序列合并到一起，并且使之有序。该算法是分治法的一个典型应用，其主要思想是将已有序的两个子序列合并，在这个过程中，对其元素进行比较排序，从而得到一个完整的有序的序列。也就是先要保证小范围的数据有序，再使大范围的序列有序。

因此，若要使用归并排序对一个序列进行排序，采用分治法思想，需要先将比较大的原始序列划分为较小的序列，使较小的序列有序。分出来的序列越小，对子序列的排序就越简单。例如，对于每个序列只包含两个数据的序列，只需要比较一次，就可以获得有序序列。

对于一个包含了n个记录的序列，通常现将序列视为n个小序列，使相邻的两个小序列两两比较并归并，如此就有了n/2个次小的序列。每次排序归并都使子序列的数量减半，当子序列的数量为2时，再执行一次排序归并，就可以使原始序列成功为一个有序序列。这种的方法称为2路归并排序。

归并排序需要一个原始序列大小的辅助空间，在排序过程中，将本轮排序过程中的元素赋值给中间变量，当排序结束之后，再从中间变量中取值赋给原始数据。若在排序过程中，一个序列的数据已经排序完毕，另外一个序列还有数据剩余，此时可以终止比较，将序列中剩余数据逐个赋值给中间变量。

假设需要归并排序的两个序列分别为sub1[]和sub2[]（这两个序列已经各自有序），设其中元素的下标分别为i和j，元素个数分别为a和b；设置辅助空间变量tmp[]，其中元素对应的下标为k。则归并步骤如下：
（1）初始时i=0，j=0，k=0。
（2）比较sub1[0]和sub2[0]:
若sub1[0]>sub2[0]，使tmp[0]=sub2[0],i=i+1,k=k+1;
若sub1[0]

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

//------------------方法一：递归实现------------------------
//归并两个序列的算法
void Merge(int* arr, int* tmp, int start, int mind, int end)
{
    int i = start;
    int j = mid + 1;
    int k = start;
    //比较排序并将值赋值给中间变量tmp
    while (i != mid + 1 && j != end + 1)
    {
        if (arr[i] >= arr[j])
            tmp[k++] = arr[j++];
        else
            tmp[k++] = arr[i++];
    }
    //若一个序列指针走到最后，另外一个指针未走到最后，直接复制
    while (i != mid + 1)
        tmp[k++] = arr[i++];
    while (j != end + 1)
        tmp[k++] = arr[j++];
    //将中间变量数组中存储的值赋值给原始数组
    for (i = start; i <= end; i++)
        arr[i] = tmp[i];
}

//2路归并排序
//递归调用归并排序
void MergeSort(int* arr, int* tmp, int start, int end)
{
    int mid;
    if (start < end)
    {
        //取中间值将原序列分为两组
        mid = (start + end) / 2;
        MergeSort(arr, tmp, start, mid);
        MergeSort(arr, tmp, mid + 1, end);
        Merge(arr, tmp, start, mid, end);

    }
}

//------------------非递归实现-------------------

void MergeSort(int* arr, int n)
{
    int i = 0;
    int next = 0;
    int left_min = 0;
    int left_max = 0;
    int right_min = 0;
    int right_max = 0;

    int* tmp = (int*)malloc(sizeof(int)*n);

    if (tmp == NULL)
    {
        printf("请重新分配内存！");
        return;
    }

    for (i = 1; i < n; i *= 2)
    {
        for (left_min = 0; left_min < n - i; left_min = right_max)
        {
            right_min = left_max = left_min + i;
            right_max = left_max + i;

            if (right_max>n)
            {
                right_max = n;
            }

            next = 0;
            while (left_min < left_max&&right_min < right_max)
            {
                if (arr[left_min] < arr[right_min])
                    tmp[next++] = arr[left_min];
                else
                    tmp[next++] = arr[right_min];
            }
            while (left_min < left_max)
                arr[--right_min] = tmp[--left_max];
            while (next>0)
                arr[--right_min] = tmp[--next];
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92