学习归幷排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路 归并。

归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

归并操作(merge)，也叫归并算法，指的是将两个顺序序列合并成一个顺序序列的方法。

如　设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8，1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；

总的比较次数为：3+4+4=11,；

逆序数为14；

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经 排序序列之和，该空间用来存放合并后的序列

第二步：设定两个 指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

数组代码示例：

#include<iostream>
using namespace std;
 void merge(int a[], int t[], int s, int m, int e) {
 	int i= s, k= s, j= m+ 1;
 	while (i!= m+ 1&&j!= e+ 1) {
 		if (a[i]>= a[j]) {
 			t[k++]= a[j++];
		 } else {
		 	t[k++]= a[i++];
		 }
	 }
	 while (i!= m+ 1) t[k++]= a[i++];
	 while (j!= e+ 1) t[k++]= a[j++];
	 for (int i= s; i< e+ 1; i++) {
	 	a[i]= t[i];
	 }
 }
 void mergesort(int a[], int t[], int s, int e) {
 	if (s< e) {
 		int m= (s+ e)/ 2;
 		mergesort(a, t, s, m);
 		mergesort(a, t, m+ 1, e);
 		merge(a, t, s, m, e);
	 }
 }
main() {
 	int a[6]= {7, 3, 4, 1, 8, 0};
 	int t[6];
 	mergesort(a, t, 0, 5);
 	for (int i= 0; i< 6; i++) cout<< a[i]<< "-";
 	cout<< endl;
 	for (int i= 0; i< 6; i++) cout<< a[i]<< "-";
 }

链表代码示例：

void LinkedList::sort(void) {
  if (this->size() > 1) {
    node* fast = this->head;
    node* slow = this->head;
    LinkedList li_left;
    LinkedList li_right;
 
    li_left.head = this->head;
    while (fast != NULL && fast->next != NULL) {
      li_left._size++;
      fast = fast->next->next;
      slow = slow->next;
    }
    li_left.tail = slow->prev;
    li_left.tail->next = NULL;
 
    li_right.head = slow;
    li_right.head->prev = NULL;
    li_right.tail = this->tail;
    li_right._size = this->_size - li_left._size;
 
    this->head = NULL;
    this->tail = NULL;
 
    li_left.sort();
    li_right.sort();
 
    node* pointer_left = li_left.head;
    node* pointer_right = li_right.head;
 
    node* pointer_head = NULL;
    node* pointer_tail = NULL;
 
    while (pointer_left != NULL && pointer_right != NULL) {
      node* temp;
      if (pointer_left->data <= pointer_right->data) {
        temp = pointer_left;
        pointer_left = pointer_left->next;
      } else {
        temp = pointer_right;
        pointer_right = pointer_right->next;
      }
      if (pointer_head == NULL) {
        pointer_head = pointer_tail = temp;
      } else {
        pointer_tail->next = temp;
        temp->prev = pointer_tail;
        pointer_tail = temp;
      }
      pointer_head->prev = NULL;
      pointer_tail->next = NULL;
    }
 
    while (pointer_left != NULL) {
      pointer_tail->next = pointer_left;
      pointer_left->prev = pointer_tail;
      pointer_tail = pointer_left;
      pointer_left = pointer_left->next;
    }
 
    while (pointer_right != NULL) {
      pointer_tail->next = pointer_right;
      pointer_right->prev = pointer_tail;
      pointer_tail = pointer_right;
      pointer_right = pointer_right->next;
    }
 
    this->head = pointer_head;
    this->tail = pointer_tail;
 
    li_left.head = li_left.tail = NULL;
    li_right.head = li_right.tail = NULL;
  }
}

--baidu百科