归并排序

转自：http://blog.youkuaiyun.com/f2016913/article/details/72782877?ref=myread

一:归并排序的思想是 
采用分治法,先将一组序列换分长小区间,使分隔区间有序,然后将这些小区间两两归并,最后成为一个有序的序列 
思路: 
设两个有序的子序列放到同一个序列中的相临的位置,如arr[left..key],arr[key+1…right],先将他们合并到一个临时序列tmp中,最后合并完成后tmp拷贝会原数组arr[left,right]中,这样最后得到的序列就是有序序列. 
如: 
待排序列: 
72 22 93 34 55 14 28 65 39 81 
主要经历了两个阶段一个是将这个无序的区间进行分割,第二个阶段就是将这些分隔好的小区间归并成一个有序的区间, 
如: 
 
二:实现:

 void _MergeSort(int *src, int *dst, int left, int right)
{
    int mid = left + ((right - left) >> 1);
    if (left >= right)
    {
        return;
    }
    ////小区间优化
    //if (right - left < 15)
    //{
    //    InSertSort(src + left, right - left + 1);
    //}
    //子问题[left,mid][mid+1,right]
    _MergeSort(src, dst, left, mid);//左区间
    _MergeSort(src, dst, mid+1, right);//右区间
    int begin1 = left, begin2 = mid + 1;
    int index = 0;
    //将两个有序区合并
    while (begin1 <= mid && begin2 <= right)
    {
        if (src[begin1] < src[begin2])
        {
            dst[index++] = src[begin1++];//临时空间保存有序区间
        }
        if (src[begin2]<src[begin1])
        {
            dst[index++] = src[begin2++]; //临时空间保存有序区间
        }
    }
    //表明还没有合并完
    while (begin1<=mid)
    {
        dst[index++] = src[begin1++];
    }
    while (begin2<=right)
    {
        dst[index++] = src[begin2++];
    }
    //将临时空间的数据拷贝会原数组中
    int  i = 0;
    for (; i <index; ++i)
    {
        src[left+i] = dst[i];
    }
}
void MergeSort(int *arr,int n)
{
    //临时空间来保存归并后的有序区间
    int *tmp = new int[n];
    assert(tmp);
    for(int i = 0; i < n; ++i)
    {
        tmp[i] = arr[i];
    }
    _MergeSort(arr, tmp,0,n-1);

    delete[] tmp;
}
void PrintSort(int *a, int n)
{
    for (int i = 0; i < n; ++i)
    {
        cout << a[i] << ' ';
    }
    cout << endl;
}
void TestSort()
{
int a[] = { 2, 5, 4, 9, 3, 6, 8, 7, 1, 0 };
int a1[] = { 72, 22 ,93 ,34 ,55 ,14 ,28, 65 ,39 ,81 };
MergeSort(a, sizeof(a) / sizeof(a[0]));
 PrintSort(a, sizeof(a) / sizeof(a[0]));
MergeSort(a, sizeof(a) / sizeof(a[0]));
 PrintSort(a, sizeof(a) / sizeof(a[0]));
}
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
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

 
当然当区间很小时,如果继续分割会造成空间的开销,我们可以使用小区间优化.在小区间内进行插入排序; 
由上面我们可以很容易知道归并排序的时间复杂度是O(N*lgN);lgN表示它的深度; 
三:排序的总结: 
 
 
各种排序的时间复杂度和空间复杂度: 
 
计数排序的时间复杂度是O(N),空间复杂度是range(最大值-最小值) 
基数排序的时间的复杂度是O(N*位数)),空间复杂度是O(N);