数据结构 - 归并排序(merging sort)

归并排序(merging sort): 包含2-路归并排序, 把数组拆分成两段, 使用递归, 将两个有序表合成一个新的有序表.

归并排序(merge sort)的时间复杂度是O(nlogn), 实际效果不如快速排序(quick sort)和堆排序(heap sort),

但是归并排序是稳定排序, 而快速排序和堆排序则不是.

代码:

1. /*
2. * main.cpp
3. *
4. *  Created on: 2014.6.12
5. *      Author: Spike
6. */
7. /*eclipse cdt, gcc 4.8.1*/
8. #include <iostream>
9. #include <algorithm>
10. #include <iterator>
11. using namespace std;
12. /*参数: SR-输入数组, TR-输出数组, i至m:第一段有序, m+1至n:第二段有序*/
13. void Merge (const std::vector<int> SR, std::vector<int>& TR, int i, int m, int n)
14. {
15. int j , k;
16. for (j=m+1, k=i; i<=m && j<=n; ++k) {
17. if (SR[i] < SR[j])
18. TR[k] = SR[i++];
19. else
20. TR[k] = SR[j++];
21. }
22. if (i<=m)
23. std::copy((SR.begin()+i), (SR.begin()+m+1), TR.begin()+k);
24. if (j<=n)
25. std::copy((SR.begin()+j), (SR.begin()+n+1), TR.begin()+k);
26. }
27. /*参数: SR-输入数组, TR-输出数组, s:起始, t:末尾*/
28. void MSort (const std::vector<int> SR, std::vector<int>& TR, int s, int t)
29. {
30. std::vector<int> tempTR(SR.size());
31. if (s == t)
32. TR[s] = SR[s];
33. else {
34. int m = (s+t)/2; //平分SR, SR[s..m]和SR[m+1..t]
35. MSort(SR, tempTR, s, m); //前半段
36. MSort(SR, tempTR, m+1, t); //后半段
37. Merge(tempTR, TR, s, m, t); //排序
38. //copy(TR.begin(), TR.end(), ostream_iterator<int>(cout, " "));
39. //std::cout << std::endl;
40. }
41. }
42. void MergeSort (std::vector<int>& L) {
43. MSort(L, L, 0, L.size()-1);
44. }
45. int main (void)
46. {
47. std::vector<int> L = {49, 38, 65, 97, 76, 13, 27, 49};
48. MergeSort(L);
49. copy(L.begin(), L.end(), ostream_iterator<int>(cout, " "));
50. std::cout << std::endl;
51. return 0;
52. }

输出:

1. 13 27 38 49 49 65 76 97