【算法】归并排序

为什么使用归并排序？

1 效率高，时间复杂度为 O(nlogn) 

2 培养一种分而治之的思维方式

归并排序就是对两个已经有序的数组进行的排序，但是一开始的时候，很可能待排序的数组是无序的。

比如这样的一个数列

34  56  2  45  4  789   43  222   3  567

对这十个元素进行排序，因为归并排序是用来对已经排好序的两个数列进行排序的，所以需要先把这个数列变成有序数列，由此想到对这个数列进行分割，使其局部有序，这样一来，局部逐渐扩大，最后只剩下了两个局部，即左右都是5个有序数列，这是再对这个有序数列进行排序，就OK!

排序过程为：

1 对这个数列进行分割，使其局部足够下，而成为一个有序数列，

34  56  2  45  4  789   43  222   3  567

分割为: 34  56 2  45  4和 789   43  222   3  567

还不是有序继续分割(按中间值进行分割): (start + end)/2 

先看左边，右边是一个道理

分割为：34 56 2和45 4

还不是有序，继续分割：

分割左边右边相同道理

分割为34 56 和 2

这时右边有序，左边还是无序的，继续分割

分割为:34和56

这时两个数列有序了，可以对其进行排序了

当把“34 和 56”排好序之后，就将其和上一步分割出来的2进行排序，因为这时{34 56}和{2}都是有序序列。。。

以此类推，最终排序成功：

对两个有序的数列进行排序的算法如下：

假设 int data[10] ={34  56  2  45  4  789   43  222   3  567}  data里面下标p到q是有序序列，q+1到r是有序序列，那么其排序算法为

1 首先创建两个数组，用来存放data数组中的两个有序序列

2 两个有序序列相互比较，按升序或者降序将值放到 data数组相应位置中，这样，data哪个位置赋值了，就说明有该位置是当前局部有序的了。

3 继续下一趟排序。

代码：

void merge_partSort(int *data, int p, int q, int r)
{
    int nFront = q - p + 1;
    int nBack = r - q;
    int front[nFront];
    int back[nBack];
    int i = 0;
    int j = 0;
    //int arranged[lengthOfArranged];
    int k = 0;
    
    for (int i = 0 ; i < nFront ; i ++) {
        front[i] = data[p+i-1];
    }
    
    for (int j = 0; j < nBack; j ++) {
        back[j] = data[q+j];
    }
    
    //mergingSort(data,front, back,nFront,nBack);

    i = 0;
    j = 0;
    //int arranged[lengthOfArranged];
    k = p - 1;
    
    while(i < nFront && j < nBack)
    {
        if (front[i] < back[j]) {
            data[k] = front[i];
            i ++;
            
        }
        else
        {
            
            data[k] = back[j];
            j ++;
            
        }
        k ++;
    }
    
    if (i == nFront) {
        for (; j < nBack; j ++) {
            data[k] = back[j];
            k ++;
                 }
    }
    else{
        
        for (; i < nFront; i ++) {
            data[k] = front[i];
            k ++;
            
        }
    }
    
    
    printf("sorted data:\n");
    printIntegerArray(data, 10, 10);
    
    
}

递归调用该局部排序函数进行，整体数组的排序。

void merge_sort(int *data, int p, int r)
{
    int q = 0;
    if (p < r) {
        q = ((p + r) / 2);
        merge_sort(data,p,q);
        merge_sort(data,q + 1, r);
        merge_partSort(data,p,q,r);
        //printIntegerArray(data, r, r);
        //printf("\n");
    }
}

这样基本就有序了。

其每一次排序结果为:

sorted data:
 34  56   2  45   4 789  43 222   3 567 

sorted data:
  2  34  56  45   4 789  43 222   3 567 

sorted data:
  2  34  56   4  45 789  43 222   3 567 

sorted data:
  2   4  34  45  56 789  43 222   3 567 

sorted data:
  2   4  34  45  56  43 789 222   3 567 

sorted data:
  2   4  34  45  56  43 222 789   3 567 

sorted data:
  2   4  34  45  56  43 222 789   3 567 

sorted data:
  2   4  34  45  56   3  43 222 567 789 

sorted data:
  2   3   4  34  43  45  56 222 567 789