算法学习笔记（5.0）-基于比较的高效排序算法-归并排序

##时间复杂度O(nlogn)

##递归实现归并排序

##原理

##图例

##代码实现

##非递归实现归并排序

##释

#代码实现

##递归实现归并排序

##原理

是一种基于分治策略的基础排序算法。

1.划分阶段：通过不断递归地将数组从中点处分开，将长数组的排序问题转化成段数组的排序问题。

2.合并阶段：当子数组的长度为1时终止划分，开始合并，持续不断地将左右两个较短的有序数组合并为一个较长的有序数组，直到结束。

##图例

##代码实现

1.向下递归，对半分割

2.递归返回条件：递归到最小，1个就是有序【控制的是范围，归并的是区间】

3.递归到最深处，最小时，就递归回去，开始分割按对半分割出的范围，将已有子序列合并，在tmp里面进行合并

4.再将tmp里形成的有序序列，拷贝回原数组【因下一次递归回去上一层的归并过程中，会将数据在tmp中进行归并，会将tmp中的数据覆盖，因此要及时，拷】

//python代码示例
def Merge(a, start, mid, end) :tmp = [] #创建一个临时列表，用来存储合并的值#两段起点的开始l = startr = mid + 1#当两段都没到达末尾，则继续循环，将其添加到tmpwhile l <= mid and r <= end :if a[l] <= a[r] :tmp.append(a[l])l += 1else :tmp.append(a[r])r += 1#此时肯定只剩下，单一的一个值，即将剩余元素塞入到tmp中tmp.extend(a[l:mid+1])tmp.extend(a[r:end+1])#将合并完成的元素，赋值到a原数组中for i in range(start,end+1):a[i] = tmp[i - start]print(start,end,tmp)def MergeSort(a,start,end) :#利用递归来实现归并排序，将大的问题分解成小的子问题if start == end : #当递归到数组只有一个元素时，直接返回returnmid = (start + end) // 2 #计算出mid，找到递归点MergeSort(a,start,mid) #左递归MergeSort(a,mid+1,end) #右递归Merge(a,start,mid,end)#左递归，左合并，右递归，右合并，类似于树的后序遍历a = [7,3,2,6]
MergeSort(a,0,3)

//c++代码实现示例
#include<iostream>
#include<vector>
using namespace std;
//c++代码实现示例
void merge(vector<int> &a, int left, int mid, int right)
{int i = left ;int j = mid + 1 ;int k = left ;vector<int> tmp(right - mid + 1) ;while ( i <= mid && j <= right ){if ( a[i] <= a[j] ){tmp[k++] = a[i++] ;}else{tmp[k++] = a[j++] ;}}while ( i <= mid ){tmp[k++] = a[i++] ;}while ( j <= right ){tmp[k++] = a[j++] ;}for (int m = left ; m <= right ; m++){a[m] = tmp[m - left] ;}cout << left << right << " " ;for (int n = 0 ; n < tmp.size() ; ++n){cout << tmp[n] << " " ;}
}void mergeSort(vector<int> &a, int left, int right)
{if (left >= right){return ;}int mid = (left + right) / 2 ;mergeSort(a,left,mid) ;mergeSort(a,mid+1,right) ;merge(a,left,mid,right) ;
}int main()
{
//	vector<int> arr = {1,2,3,4,5};
//	vector<int> arr;arr.push_back(7);arr.push_back(3);arr.push_back(2);arr.push_back(6);
//    arr.push_back(5);mergeSort(arr,0,3) ;return 0 ;}

void _MergerSort(DataType* a ,DataType* tmp, int begin,int end)
{//递归返回条件，不正常的范围，或只剩下一个数 if (begin >= end){return ;}int mid = (begin + end) / 2 ;//递归过程 _MergeSort(a,tmp,begin,mid) ;_MergeSort(a,tmp,mid+1,end) ;//合并过程 //归并到tmp数组中，再拷贝回去 int begin1 = begin ;int end1 = mid ;int begin2 = mid + 1 ;int end2 = end ;//指向tmp,=begin是 根据要进行比较插入的数组的位置 找到其对应在tmp中所对应的位置，则不会覆盖前面已经排好序的数据int index = begin ;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[index++] = a[begin++] ;}else{tmp[index++] = a[begin2++] ;}}//剩下还没有插入进去的 while (begin1 <= end1){tmp[index++] = a[begin1++];}while (begin2 <= end2){tmp[index++] = a[begin2++] ;}//拷贝回去原数组a中memcpy(a+begin,tmp+begin,sizeof(DataType)*(end-begin+1)) ; 
}void MergeSort(DataType* a, int n)
{DataType* tmp = (DataType*)malloc(sizeof(DataType)*n) ;if (tmp == NULL){perror("malloc fail") ;return ;}_MergeSort(a,tmp,0,n-1) ;free(tmp) ;
}

对于链表，归并排序相较于其他排序算法具有显著优势，可以将链表排序任务的空间复杂度优化至 𝑂(1) 。

划分阶段：可以使用“迭代”替代“递归”来实现链表划分工作，从而省去递归使用的栈帧空间。
合并阶段：在链表中，节点增删操作仅需改变引用（指针）即可实现，因此合并阶段（将两个短有序链表合并为一个长有序链表）无须创建额外链表。

##非递归实现归并排序

##释

归并排序时二分的思想=>logN层=>递归不会太深、且现在编译器优化后，递归、非递归的性能差距没有特别大了=>所以可以不用考虑非递归。

递归的缺点：递归消耗栈帧，递归的层数太深，容易爆栈。

【栈的空间比较小，在x86(32位)环境下，只有8M。（对比同一环境下的堆，则有2G+）。因为平时函数调用开不了多少个栈帧。理论上递归深度>1w 可能就会爆，但实际上5k左右就爆掉了】，这时就需要改非递归了。

非递归改写方法：

1.改变循环

2.利用数据结构栈（本质是通过malloc在堆上开辟的存储空间，内存空间需要足够大）

3.递归逆着求-实际上也差不多也是递归思想（如斐波那契数列逆着来求也是可行的）

#代码实现

开辟新的数组（临时存放）用于归并排序过程
int gap=1；gap*=2【gap控制归并的范围：11归并，22归并，44归并】
for (int i = 0; i < n; i += 2 * gap) { 【i 控制进行比较轮到的组号，控制进行归并的组号】
归并完一轮，将归并好的有序数组拷贝回原数组memcpy 。
进入新的一轮归并，直至gap>n则归并完成

☆注意的两个情况

6. if (begin2 >= n) { break; } 第二组不存在，这一组不用归并了

7. if (end2 > n) { end2 = n - 1; } 第二组右边界越界问题，修正一下

void MergerSortNonR(DataType* a, int n)
{DataType* tmp = (DataType*)malloc(sizeof(DataType) * n);   //开辟新的数组（临时存放）用于归并排序过程if (tmp == NULL){perror("malloc fail") ;return ;}int gap = 1 ;while (gap < n) {for (int i = 0 ; i < n ; i += 2 * gap){
//            // 1 , 1 归并 
//            // 2 , 2 归并
//            //4 , 4 归并 
//            //[begin1,end1][begin2,end2]归并 int begin1 = i ;int end1 = i + gap - 1 ;int begin2 = i + gap ;int end2 = i + 2 * gap - 1 ;//            //如果第二组不存在，这一组不用归并了if (begin2 >= n) {break;}//第二组右边界越界问题，修正一下if (end2 > n) {end2 = n - 1;}
//            
//            //当beigin2 超过 n 的时候，直接break掉就OK了
//            //但end2 超过 n 的时候，需要修改边界问题 n - 1 
//            int index = i ;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] < a[begin2]){tmp[index++] = a[begin1++] ;}else{tmp[index++] = a[begin2++] ;}}while (begin1 <= end1){tmp[index++] = a[begin1++] ;}while (begin2 <= end2){tmp[index++] = a[begin2++];}
//            //为什么这里不能是，2 * gap呢，不一定是2*gap的数都拷贝过去，memcpy(a+i,tmp+i,sizeof(DataType)*(end2 - beigin1 + 1)) 错误 
//            // memcpy(a+i,tmp+i,sizeof(DataType)*(end2 - begin1 + 1)) ; 因为begin1++会发生改变的，因此不可以，错误 memcpy(a+i,tmp+i,sizeof(DataType)*(end2 - i + 1)) ;
//            
//        }printf("\n");
//        for (int k = 0 ; tmp.size() ; k ++)
//        {
//            printf("%d",tmp[k]) ;
//        }gap = gap * 2 ;}free(tmp);
}
}

def MergeSort(a, n) :tmp = [0] * (n+1)gap = 1while (gap < n) :z = gap * 2for i in range(0,n,z) :begin1 = iend1 = i + gap - 1begin2 = i + gapend2 = i + 2 * gap - 1if begin2 > n :breakif end2 > n :end2 = n - 1index = iwhile begin1 <= end1 and begin2 <= end2 :if a[begin1] < a[begin2] :tmp[index] = a[begin1]index += 1begin1 += 1else :tmp[index] = a[begin2]index += 1begin2 += 1while begin1 <= end1 :tmp[index] = a[begin1]index += 1begin1 += 1while begin2 <= end2 :tmp[index] = a[begin2]index += 1begin2 += 1for j in range(i,end2 + 1) :a[j] = tmp[j - i]print()# print(tmp)gap = gap * 2