数据结构 — 归并排序

一、归并排序算法

1、归并：将两个以上的顺序表合并成一个新的有序表。

2、归并排序：假设有n个记录，看成n个有序序列（每个序列的长度是1），将其两两有序合并成 n/2 个含有两个或者一个元素的有序序列，之后不断重复合并这个动作，直至合并成一个含有n个元素的有序序列。

（引用大话数据结构中的排序树）

二、递归实现

#include<iostream>
using namespace std;

#define max_size 16

void merge(int list2[] ,int ans[], int lower, int middle,int upper);
void mergeSort(int list[], int ans[], int lower, int upper);


/*
 * 将list2中的所有元素按照 lower,middle,upper, 分为两组，归并到 ans
 */
void merge(int list2[] ,int ans[], int lower, int middle,int upper) {
    int i, j, k;
    i = k = lower;
    j = middle + 1;
    while(i <= middle && j <= upper) {
        if(list2[i]<list2[j]) {
            ans[k++] = list2[i++]; 
        } else {
            ans[k++] = list2[j++];
        }   
    }
    if(i <= middle) {
        for(int l = 0; l <= middle-i; l++) {
            ans[k++] = list2[i+l];
        }
    }
    if(j <= upper) {
        for(int l = 0; l <= upper-j; l++) {
            ans[k++] = list2[j+l];
        }
    }
}
/*
 * 归并排序
 * 1.将list 按照 middle 分成两组 分别存在 list2 中
 * 2.将 list2 的 两个分组 归并到 ans
 */
void mergeSort(int list[], int ans[], int lower, int upper) {
    int list2[max_size];
    int middle;
    if(lower == upper) {	
        ans[lower] = list[lower];
    } else {
        middle = (lower + upper)/2;
        mergeSort(list, list2, lower, middle);
        mergeSort(list, list2, middle+1, upper);
        merge(list2, ans, lower, middle, upper);
    }
}

   int main() {
       int list[max_size];
       int ans[max_size];
       list[0] = 16;
       list[1] = 7;
       list[2] = 13;
       list[3] = 10;
       list[4] = 9;
       list[5] = 15;
       list[6] = 3;
       list[7] = 2;
       list[8] = 5;
       list[9] = 8;
       list[10] = 12;
       list[11] = 1;
       list[12] = 11;
       list[13] = 4;
       list[14] = 6;
       list[15] = 14;
 	   for(int i = 0; i<max_size; i++) {
           cout<<list[i]<<" ";
        //   ans[i] = list[i];
       }
       cout<<endl;
       mergeSort(list, ans, 0, max_size-1);
       for(int i = 0; i<max_size; i++) {
           cout<<ans[i]<<" ";
       }
       cout<<endl;
       return 0;
   }

3、非递归实现

#include<iostream>
using namespace std;
#define max_size 16

const int n = max_size;

void merge(int list[], int sorted[], int lower, int middle, int upper) {
    int i,j,k;
    i = k = lower;
    j = middle + 1;

    while(i<=middle && j<=upper) {
        if(list[i]<=list[j]) {
            sorted[k++] = list[i++];
        } else {
            sorted[k++] = list[j++];
        }
    }
    if(i > middle){
        for(int t = 0; t<=upper-j; t++) {
            sorted[k++] = list[j+t];
        } 
    } else {
        for(int t = 0; t<=middle-i; t++) {
            sorted[k++] = list[i+t];
        }
    }
}

/*
 *直接归并，省去了“分”的过程
 */
void mergePass(int list[], int sorted[], int length) {
    int i, j;
    for(i = 0; i<=n-2*length; i+=2*length) {
        merge(list, sorted, i, i+length-1, i+2*length-1);
    }
    if(i+length < n){
        merge(list, sorted, i, i+length-1, n-1);
    } else {
        for(j = i; j<n; j++) {
            sorted[j] = list[i];
        }
    }
}

/*分层次，从length = 1 开始， 2^(i -1)
 */
void mergeSort(int list[]) {
    int length = 1;
    int extra[max_size];
    while(length < n) {
        mergePass(list, extra, length);
        length *= 2;
        mergePass(extra, list, length);
        length *= 2;
    }    
}

 int main() {  
       int list[max_size];  

       list[0] = 16;  
       list[1] = 7;  
       list[2] = 13;  
       list[3] = 10;  
       list[4] = 9;  
       list[5] = 15;  
       list[6] = 3;  
       list[7] = 2;  
       list[8] = 5;  
       list[9] = 8;  
       list[10] = 12;  
       list[11] = 1;  
       list[12] = 11;  
       list[13] = 4;  
       list[14] = 6;  
       list[15] = 14;  
       for(int i = 0; i<max_size; i++) {  
           cout<<list[i]<<" ";    
       }  
       cout<<endl;  
       mergeSort(list);  
       for(int i = 0; i<max_size; i++) {  
           cout<<list[i]<<" ";    
       }  
       cout<<endl;  
       return 0;  
   }