合并排序-----数据结构

归并排序

设计思路：

1.递归版本合并排序：

        a）判断数组元素个数，如果数组元素个数小于等于1，无需进行排序，直接返回；

        b）若元素个数大于1，进入递归函数，进行合并排序；

        c）进入递归函数后，判断传入数组元素个数，判断条件同上；

        d）若大于1，将数组分成俩个数据，分别进入递归函数；

        e）如果俩个数组的元素个数都小于等于1时，进行调用_MergeArray函数回溯合并数组。

        d) 递归函数结束后 ，现数组就是一个有序数组。

2.非递归版本合并排序 ：

        a）判断数组元素个数，如果数组元素个数小于等于1，无需进行排序，直接返回；

        b）如果数组元素个数大于1，动态开辟数组空间，大小同传入数组大小；

        c）定义一个步长gap初始为1，每次合并俩个长度为gap的有序区间；

        d）将数组中元素都进行合并之后 ，gap++进行下一轮合并；

        e）当gap值等于数组元素个数size时，循环结束；

        f）此时的数组就是一个有序数组。

3._MergeArray函数的实现

        a）对给定的俩段有序数据进行二路合并至新数组tmp中；

        b）待二路合并结束，将数组tmp中的相应数据拷贝回元素组。

递归版本-合并函数程序代码：

//递归版本
void _MergeSort(int array[],int64_t beg,int64_t end,int *tmp){
    if(end - beg <=1){
        return;
    }
     int64_t mid =beg+(end-beg)/2;
    //此时有俩个区间
    //[beg,mid),[mid,end)
    _MergeSort(array,beg,mid,tmp);
    _MergeSort(array,mid,end,tmp);
    _MergeArray(array,beg,mid,end,tmp);
}
//归并排序函数实现
void MergeSort(int array[],int64_t size){
    int *tmp = (int *)malloc(sizeof(int)*size);
    _MergeSort(array,0,size,tmp);
    free(tmp);
}

非递归版本-合并函数程序代码：

//非递归版本
void MergeSortByLoop(int array[],int64_t size){
    if(size<=1){
        return;
    }
    int *tmp = (int*)malloc(sizeof(int)*size);
    //定义一个步长gap，初始为1，每次合并俩个长度为gap的有序区间
    int64_t gap = 1;
    for(;gap<size;++gap){
        int64_t i=0;
        for(;i<size;i+=2*gap){
            int64_t beg = i;
            int64_t mid = i+gap;
            if(mid >size){
                mid = size;
            }
            int64_t end = i+2*gap;
            if(end >size){
                end = size;
            }
            _MergeArray(array,beg,mid,end,tmp);
        }
    }
    free(tmp);
}

MergeArray函数的程序代码：

void _MergeArray(int array[],int64_t beg,int64_t mid,int64_t end,int* tmp){
    int64_t cur1 = beg;
    int64_t cur2 = mid;
    int64_t tmp_index = beg;
    while(cur1<mid&&cur2<end){
        if(array[cur1]<array[cur2]){
            tmp[tmp_index++] = array[cur1++];
        }else{
            tmp[tmp_index++] = array[cur2++];
        }
    }
    while(cur1<mid){
        tmp[tmp_index++] = array[cur1++];
    }
    while(cur2 <end){
        tmp[tmp_index++] = array[cur2++];
    }
    //将tmp中的内容拷贝到array中
    memcpy(array+beg,tmp+beg,sizeof(int)*(end-beg));
}

测试函数程序代码：

//测试函数
void TestMergeSortByLoop(){
    int array[] = {1,3,2,6,5,9};
    int64_t size = sizeof(array)/sizeof(array[0]);
    int i = 0;
    for(;i<size;++i){
        printf("%d ",array[i]);
    }
    printf("\n");
    MergeSortByLoop(array,size);
    i = 0;
    for(;i<size;++i){
        printf("%d ",array[i]);
    }
    printf("\n");
    return;
}
//主函数
int main(){
    TestMergeSortByLoop();
    return 0;
}

检测结果显示：