归并排序算法

#include<iostream>
#include<cmath>
#include<ctime>
using namespace std;


template<typename T>
T* Merge(T*a,int size_a,T*b,int size_b);

template<typename T>
void Merge_sort(T*input_array,int size_input);

int main(){


    int input_array[10] = {1,9,6,3,11,4,7,8,2,10};
    cout<<"待排序数据：\t";
    for(int i=0;i<10;i++){
        cout<<input_array[i]<<"\t";
    }
    cout<<endl;
    cout<<"归并排序过程："<<endl;
    clock_t t;
    t = clock();
    Merge_sort<int>(input_array,10);
    cout<<"排序完成，耗时："<<float(float(clock()-t)/CLOCKS_PER_SEC)<<"s"<<endl;
    cout<<"排序完成数据：\t";
     for(int i = 0;i<10;i++){
        cout<<input_array[i]<<"\t";
    }
    cout<<endl;

    return 0;
}



template<typename T>
void Merge_sort(T*input_array,int size_input){

    if(size_input<1) throw"array number error!";

    if(size_input==1){
        return;
    }

    int left_size =size_input/2;
    int right_size =(size_input+1)/2;
    auto left_array = new T[left_size];
    auto right_array = new T[right_size];
    auto output_array = new T[size_input];
  //  cout<<"left_size:"<<left_size<<"\t"<<"right_size:"<<right_size<<"\t"<<"input_size:"<<size_input<<endl;

    memcpy(left_array,input_array,left_size*sizeof(T));
    memcpy(right_array,input_array+left_size,right_size*sizeof(T));

    Merge_sort<T>(left_array,left_size);
    Merge_sort<T>(right_array,right_size);

    output_array =Merge(left_array,left_size,right_array,right_size);
    for(int i=0;i<size_input;i++){
        cout<<output_array[i]<<"\t";
    }
    cout<<endl;

    memcpy(input_array,output_array,size_input*sizeof(T));
}





template<typename T>
T* Merge(T*a,int size_a,T*b,int size_b){

    if(size_a<=0||size_b<=0) throw"Size error!";
    auto merge_list = new T[size_a+size_b]();
    int a_ptr = 0,b_ptr = 0,merge_list_ptr = 0;

    for(int i = 0;i<size_a+size_b;i++){

        if(a_ptr>=size_a||b_ptr>=size_b){
            if(a_ptr>=size_a){
                for(int j = 0;j<size_b-b_ptr;j++){
                    merge_list[i+j] = b[b_ptr+j];
                }
                return merge_list;
            }
            if(b_ptr>=size_b){
                for(int j = 0;j<size_a-a_ptr;j++){
                    merge_list[i+j] = a[a_ptr+j];
                }
               return merge_list;
            }
        }
        else{

            if(a[a_ptr]<=b[b_ptr]){
                merge_list[i] = a[a_ptr];
                a_ptr++;
            }
            else{
                merge_list[i] = b[b_ptr];
                b_ptr++;
            }
        }

    }
    return merge_list;
}