归并排序（基于顺序容器vector_递归；基于数组array_递归_非递归）

代码1：基于顺序容器vector

  1 /*
  2  * FILE: merge_sort_vector.cpp
  3  * ---------------------------
  4  * DATE: 20170818
  5  * 归并排序，使用顺序容器vector
  6  *
  7  */
  8 
  9 #include <iostream>
 10 #include <vector>
 11 
 12 void merge(std::vector<int> &v, std::vector<int> &v1, std::vector<int> &v2);
 13 
 14 /* recursive 递归 一分两半 */
 15 void sort(std::vector<int> &v)
 16 {
 17         int n = v.size();
 18         if(n <= 1)
 19                 return;
 20         std::vector<int> v1;
 21         std::vector<int> v2;
 22         for(int i = 0; i < n; i++)
 23         {
 24                 if(i < n/2)
 25                         v1.push_back(v[i]);
 26                 else    
 27                         v2.push_back(v[i]);
 28         }               
 29         sort(v1);
 30         sort(v2);
 31         v.clear();
 32         merge(v, v1, v2);
 33 }       
 34 
 35 /* 合并 排序 */
 36 void merge(std::vector<int> &v, std::vector<int> &v1, std::vector<int> &v2)
 37 {
 38         int n1 = v1.size();
 39         int n2 = v2.size();
 40         int p1 = 0, p2 = 0;
 41         while(p1 < n1 || p2 < n2)
 42         {
 43                 if(p1 >= n1)
 44                         v.push_back(v2[p2++]);
 45                 else if(p2 >= n2)
 46                         v.push_back(v1[p1++]);
 47                 else if(v1[p1] < v2[p2])
 48                         v.push_back(v1[p1++]);
 49                 else
 50                         v.push_back(v2[p2++]);
 51         }
 52 }
 53 
 54 /* 使用vector的迭代器 打印输出 */
 55 void display(std::vector<int> &v)
 56 {
 57         for(std::vector<int>::iterator iter = v.begin(); iter != v.end(); iter++)
 58                 std::cout<< *iter <<"  ";
 59         std::cout<< std::endl;
 60 }
 61 
 62 int main()
 63 {
 64         int a[] = {3,4,2,1,7,5,8,9,0,6};
 65         int length = sizeof(a) / sizeof(int);
 66         std::vector<int> vec(a, a+length-1);
 67         sort(vec);
 68         display(vec);
 69         return 0;
 70 }

代码2：基于数组（递归法、非递归）

  1 /*
  2  * FIEL: merge_sort.cpp
  3  * --------------------
  4  * DATE: 20170818
  5  * 归并排序：先一分两半，分别进行排序；再合并两个已排好序的数组
  6  *
  7  */
  8 
  9 #include <iostream>
 10 
 11 /* 
 12  * merge two sorted sub-array
 13  * 合并两个已排好序的数组 
 14  */
 15 void merge(int a[], int result[], int begin, int middle, int length)
 16 {
 17         //int result[length];
 18         int left = begin, right = middle;
 19         int index = begin;
 20         while(left < middle || right < length)
 21         {
 22                 if(left >= middle)
 23                 {
 24                         result[index++] = a[right++];
 25                         //right++;
 26                 }
 27                 else if(right >= length)
 28                 {
 29                         result[index++] = a[left++];
 30                         //left++;
 31                 }
 32                 else if(a[left] < a[right])
 33                 {
 34                         result[index++] = a[left++];
 35                         //left++;
 36                 }
 37                 else    // a[left] >= a[right]
 38                 {
 39                         result[index++] = a[right++];
 40                         //right++;
 41                 }
 42                 //index++;
 43         }
 44         for(int i = begin; i < length; i++)
 45                 a[i] = result[i];
 46 }
 47 
 48 /* recursive 递归 */
 49 void mergeSort_recursive(int a[], int temp[], int begin, int length)
 50 {
 51         if(length - begin <= 1)
 52                 return;
 53         int middle = (begin + length) / 2;
 54         mergeSort_recursive(a, temp, begin, middle);
 55         mergeSort_recursive(a, temp, middle, length);
 56         merge(a, temp, begin, middle, length);
 57 
 58 }
 59 
 60 void mergeSort_recursive(int a[], int length)
 61 {
 62         int *temp = new int[length];
 63         mergeSort_recursive(a, temp, 0, length);
 64         delete []temp;
 65 }
 66 
 67 /* non_recursive 非递归 */
 68 void mergeSort(int a[], int length)
 69 {
 70         int *temp = new int[length];
 71         for(int step = 1; step < length; step = step * 2)
 72         {
 73                 for(int left = 0; left < length; left = left + 2 * step)
 74                 {
 75                         int middle = std::min(left + step, length);
 76                         int right = std::min(left + 2 * step, length);
 77                         merge(a, temp, left, middle, right);
 78                 }
 79         }
 80         delete []temp;
 81 }
 82 
 83 int main(int argc, char *argv[])
 84 {
 85         int a[] = {3,4,2,1,7,5,8,9,0,6};
 86         int length = sizeof(a) / sizeof(int);
 87         std::cout<< "递归法：";
 88         mergeSort_recursive(a, length); //递归法
 89         for(int i = 0; i < length; i++)
 90                 std::cout<< a[i] << "  ";
 91         std::cout<< std::endl;
 92 
 93         int b[] = {3,4,2,1,7,5,8,9,0,6};
 94         mergeSort(b, length);   //非递归
 95         std::cout<< "非递归：";
 96         for(int i = 0; i < length; i++)
 97                 std::cout<< b[i] << "  ";
 98         std::cout<< std::endl;
 99         return 0;
100 }