排序算法-归并排序


将n个数分成n/2组，排序好，再两两合并，分成n/4组，再依次上去，因为已经排序好了，合并起来很快。

每次需要对比的次数为n次

比如n=64时

当n/4时，每队有4个数，总共有16组，第一队的4个数与第二队的4个数对比，需要最多8次。总共有8组(每组2对)需要对比，即对比64次，也就是n

即分解后都需要对比n次，那需要分解多少次呢？

64/2, 64/2/2, 64/2/2/2

就是需要分解log2^n次，64可以分解6次,2,4,8,16,32,64

所以归并排序的复杂度为O(nlgn)，算法中log2#n(2为底)直接写成lgn即可，底数一般不考虑，因为n很大时，底数已经不是英雄数目的关键了

归并排序还有个好处，可以多线程分开执行，效率更高。

有点像平时打牌，左边一堆已经排好序的，右边已经排好序列，这两堆要排序，只需要依次比较他们最小的值，最多比较n次就结束了。好的情况，第一堆比较完了，第二堆很快与"空"比较。

int sort_merge(int* ptr_data, int start_index, int mid_index, int stop_index)

{

    int n1 = mid_index - start_index + 1; //

    int n2 = stop_index - mid_index;

    int* ptr_data1 = (int*)malloc(sizeof(int) * (n1 + 1));

    int* ptr_data2 = (int*)malloc(sizeof(int) * (n2 + 1));

    int i = 0;

    for(i = 0; i < n1; ++i)

    {

        ptr_data1[i] = ptr_data[i + start_index];

    }

    ptr_data1[n1] = 65535; // 设置一个最大的“空"值，这样ptr_data2对比起来肯定比它小

    for(i = 0; i < n2; ++i)

    {

        ptr_data2[i] = ptr_data[i + mid_index + 1];

    }

    ptr_data2[n2] = 65535;

    int data1_index = 0;

    int data2_index = 0;

    for(i = start_index; i < stop_index; ++i)

    {

        if (data1_index > n1 || data2_index > n2)

        {

            assert(0);

        }

        if (ptr_data1[data1_index] > ptr_data2[data2_index])

        {

             ptr_data[i] = ptr_data2[data2_index];

             ++data2_index;

        }

        else

     {

         ptr_data[i] = ptr_data1[data1_index];

            ++data1_index;

     }

    }

}