顺序表封装归并排序输出不符，求助呀

#include<iostream>
#include<math.h>
#include<stdlib.h>
#define _CAPACITY 3
using namespace std;

//------------------------------------底层实现-----------------------------
typedef int Rank;
template<typename T>class Vector{
public:
    //构造函数
    Vector();                                       //无参构造函数，容量为_CAPACITY,规模为0,数据初始化为0(使用与int);  OK
    Vector(T const *A,Rank n);                      //T * 的前n项   OK
    Vector(T const *A,Rank lo,Rank hi);             //容量规模为hi-lo，范围是[lo,hi).  OK
    Vector(Vector<T> const &A);                     //拷贝构造函数  OK
    Vector(Vector<T> const &A,Rank lo,Rank hi);     //A中秩【lo，hi），数据容量与规模为lo-hi  OK

    //析构函数
    ~Vector(){delete []_elem;}

    //只读访问接口
    T& operator[](Rank n)const;                     //[]运算符的重载  OK
    int Size()const{return _size;}                  //返回规模 OK
    int capacity()const{return _capacity;}          //返回容量 OK
    bool Judgesort(Rank lo,Rank hi)const;           //判断是否有序<区间> OK x->d
    bool Judgesort()const{return Judgesort(0,_size);}//判断是否有序<整体> OK x->d
    void PrinT()const;                              //测试函数<int>

    //主体功能函数：
    Vector<T>& operator =(const Vector<T> &e);      //=运算符重载  OK
    Rank Push_back(T const &e){return Insert(_size,e);}//尾部插入操作 OK
    Rank Insert(Rank r,T const &e);                 //单个元素插入 OK
    int Remove(Rank lo,Rank hi);                    //删除指定区间内的元素，返回删除的个数 OK
    int Remove(Rank n){return Remove(n,n+1);}       //删除单个元素，返回删除元素的秩 OK
    void unsort(Rank lo,Rank hi);                   //区间置乱算法  OK
    void unsort(){unsort(0,_size);}                 //总体置乱算法  OK
    Rank Find(T const &e,Rank lo,Rank hi);          //无序向量查找算法<区间> OK
    Rank Find(T const &e){return Find(e,0,_size);}  //无序向量查找算法<整体> OK
    //Rank Search(T const &e,Rank lo,Rank hi);//有序向量区间查找算法
    //Rank Search(T const &e){Search(e,0,_size);}//有序向量整体查找算法
    void Sort(Rank lo,Rank hi);                     //排序器
    int deduplicate();                              //无序去重 OK
    int uniquify();                                 //高效版有序去重 OK

    void mergesort(Rank lo,Rank hi);
private:
    T* _elem;
    int _size;
    int _capacity;

    //私有的功能函数：
    void copyform(T const *A,Rank lo,Rank hi);       //拷贝功能函数  OK
    void expand();                                   //扩容函数 OK
    void shrink();                                   //缩容函数 OK
    void swaps(T&A,T&B);                             //交换函数 OK
    Rank Max(Rank lo,Rank hi);                       //返回最大元素的秩 OK
    void Merge(Rank lo,Rank mid,Rank hi);            //归并函数
    //私有排序算法函数：
    void bubblesort(Rank lo,Rank hi);                //冒泡排序算法
    void selectsort(Rank lo,Rank hi);                //选择排序算法
    //void mergesort(Rank lo,Rank hi);                //归并排序算法
    void heapsort(Rank lo,Rank hi);                  //堆排序算法
    void quicksort(Rank lo,Rank hi);                 //快速排序算法

};
template<typename T> void Vector<T>::copyform(T const *A,Rank lo,Rank hi){
    delete []_elem;
    _size=0;
    _elem=new T[_capacity=2*(hi-lo)];
    while(lo<hi) _elem[_size++]=A[lo++];
}
template<typename T>void Vector<T>::expand(){
    if(_size<_capacity) return;
    if(_capacity<_CAPACITY) _capacity=_CAPACITY;
    T*oldelem=_elem;
    _elem=new T[_capacity*=2];
    for(int i=0;i<_size;i++) _elem[i]=oldelem[i];
    delete []oldelem;
}
template<typename T> void Vector<T>::shrink(){
    if(_size>=_capacity>>2) return;
    T*oldelem=_elem;
    delete []_elem;
    _elem=new T[_capacity>>=1];
    for(int i=0;i<_size;i++) _elem[i]=oldelem[i];
    delete []oldelem;
}
template<typename T> Vector<T>::Vector(){
    _elem=new T[_CAPACITY];
    _capacity=_CAPACITY;
    _size=0;
}
template<typename T> T& Vector<T>::operator [](Rank n)const{
    if(n>=_size) cout<<"越界了";
    return _elem[n];
}
template<typename T> int Vector<T>::Remove(Rank lo,Rank hi){
    if(lo==hi) return 0;
    while(hi<_size)_elem[lo++]=_elem[hi++];
    _size=lo;
    shrink();
    return hi-lo;
}
template<typename T>void Vector<T>::swaps(T &A,T &B){
    T t=A;
    A=B;
    B=t;
}
template<typename T>void Vector<T>::unsort(Rank lo,Rank hi){
    T* A=_elem+lo; //[0,hi-lo)
    for(int i=hi-lo;i>0;i--){
        swaps(A[i-1],A[rand()%i]);
    }
}
template<typename T>Rank Vector<T>::Insert(Rank r,T const &e){
    expand();
    for(int i=_size;i>r;i--) _elem[i]=_elem[i-1];
    _elem[r]=e;
    _size++;
    return r;
}
template<typename T>bool Vector<T>::Judgesort(Rank lo,Rank hi)const{
    for(int i=lo;i<hi-1;i++) if(_elem[i]>_elem[i+1]) return false;
    return true;
}
template<typename T>Rank Vector<T>::Find(T const &e,Rank lo,Rank hi){
    if(lo==hi) return -1;
    for(int i=lo;i<hi;i++) if(_elem[i]==e) return i;
    return -1;
}
template<typename T>int Vector<T>::deduplicate(){
    Rank r=0;
    int oldsize=_size;
    while(r<_size){
        (Find(_elem[r],0,r)<0) ? r++: Remove(r);
    }
    return oldsize-_size;
}
template<typename T>int Vector<T>::uniquify(){
    int s=0;
    int oldsize=_size;
    for(int i=s;i<_size;i++) if(_elem[s]!=_elem[i]) _elem[++s]=_elem[i];
    _size=s+1;
    shrink();
    return oldsize-_size;
}
template<typename T>Vector<T>& Vector<T>::operator=(const Vector<T>&v){
    copyform(v._elem,0,v._size);
    return *this;
}
template<typename T> Rank Vector<T>::Max(Rank lo,Rank hi){
    int maxRank;
    T m=_elem[lo];
    for(int i=lo+1;i<hi;i++){
        if(_elem[i]>m){
            m=_elem[i];
            maxRank=i;
        }
    }
    return maxRank;
}
template<typename T>Vector<T>::Vector(T const *A,int n){
    copyform(A,0,n);
}
template<typename T>Vector<T>::Vector(T const *A,Rank lo,Rank hi){
    copyform(A,lo,hi);
}
template<typename T>Vector<T>::Vector(Vector<T>const &A){
    copyform(A._elem,0,A._size);
}
template<typename T>Vector<T>::Vector(Vector<T>const &A,Rank lo,Rank hi){
    copyform(A._elem,lo,hi);
}
template<typename T>void Vector<T>::PrinT()const{
    for(int i=0;i<_size;i++) cout<<_elem[i]<<" ";
    cout<<endl;
    cout<<"Size:"<<_size<<endl;
    cout<<"Capacity:"<<_capacity<<endl;
}
template<typename T>void Vector<T>::mergesort(Rank lo,Rank hi){
    if(lo+1==hi) return;//Rank 就是int
    int mid=(lo+hi)>>1;
    mergesort(lo,mid);
    mergesort(mid,hi);
    Merge(lo,mid,hi);
}
template<typename T>void Vector<T>::Merge(Rank lo,Rank mid,Rank hi){
    T*A=_elem+lo;//_elem是线性表头指针
    int lb=mid-lo;T*left=new T[lb];
    for(int i=0;i<lb;i++) left[i]=A[i];
    int lc=hi-mid;
    T*right=_elem+mid;
    int i,j,k;
    for(i=0,j=0,k=0;i<lb&&j<lc;){
        if(left[i]<=right[j]) A[k++]=left[i++];
        else A[k++]=right[j++];
    }
    while(i<lc) A[k++]=left[i++];
    delete []left;
}
//---------------------------------遇到的问题------------------------------
//--1.private 数据成员 初始化形参报错。
int main(void){
    Vector<int> k;
    for(int i=1;i<=5;i++) k.Push_back(i); //插入1~5
    k.unsort();//乱序
    k.PrinT();//测试打印
    k.mergesort(0,k.Size());//归并排序
    k.PrinT();//打印
    return 0;
}