排序算法C++实现 理论部分自己理解

/////交换两个数据template <typename T>
 void Swap(T &a,T &b)
{
    a=a^b;
    b=a^b;
    a=a^b;
}

template <typename T>
void prin(T Arr[], int len)
{
    for (int i=0; i<len; i++)
    {
        cout<<Arr[i]<<"  ";
    }
    cout<<endl;
}

/////直接插入排序
template <typename T>
void InsertSort(T* pt, int len)
{
    if ((pt == NULL) || (len <=0))
    {
        cout<<"input parameter error"<<endl;
        return;
    }
    for (int i=0; i<len-1 ; i++)//////需要比较测试：len-1次,即[0, len-1)
    {
        for (int j=i+1; j>=1; j--)
        {
            if (pt[j-1] >pt[j])
                Swap(pt[j-1], pt[j]);
        }
    }
}
/////shell排序是直接插入排序的改进
template <typename T>
void shell(T* Arr, int len, int incr)
{
    if ((Arr == NULL) || (len<=0) ||(incr<=0))
    {
        return;
    }
    int i=0;
    for ( i=0; i < len-incr; i++)
    {
        ////i = [0-incr),倍数相邻的两个元素比较排序.
        ////i = [incr, 2*incr)倍数相邻的三个元素排序　　　　　////依次类推　　    for (int j = i+incr; j>=incr; j-=incr)
        {
            if (Arr[j-incr] >Arr[j] )
                Swap(Arr[j-incr], Arr[j]);
        }
    }

}
template <typename T>
void ShellSort(T* Arr, int len)
{
    if (Arr = NULL || len <=0)
        return;
    int incr = len;
    do
    {
        incr = incr/3+1;
        shell<T>(Arr, len, incr);
    } while (incr >1);
}

template <typename T>

void bubbleSort(T* Arr, int len)
{
    bool exchang = false;
    for (int i=0; i<len-1; i++)
    {
        exchang = false;
        for (int j=0 ; j<len-1-i; j++)
        {
            if (Arr[j] > Arr[j+1])
            {
                exchang = true;
                Swap(Arr[j], Arr[j+1]);
            }
        }
        if (!exchang)
            break;
    }
}

template <typename T>
void SelectSort(T* Arr, int len)
{
    for (int i=0; i<len; i++)
    {
        int k= i;
        for (int j=i+1; j<len; j++)
        {
            if (Arr[k] >Arr[j])
                k = j;
        }
        Swap(Arr[k], Arr[i]);
    }
}

/////创建堆
////数组的非降序排列  大根堆
////数组的非升序排列  小根堆
template <typename T>
void HeapAdjust(T* Arr, int s, int length)
{
    T temp = Arr[s];
    //s代表带调整的根节点
    int child = 2*s+1;
    while (child< length)
    {
        //创建小堆  非升序排列
        if (child+1<length && Arr[child + 1]   < Arr[child])
        {
            ++child;/////child为左右孩子中值较小的孩子的位置
        }
        if (Arr[child] < Arr[s])
        {
            Arr[s] = Arr[child];
            s= child;
            child = 2*s+1;
        }
        else
            break;
        Arr[s] = temp;
    }
}
template <typename T>
void BuildingHeap(T H[], int length)  ///length 下标的位置
{
    //最后一个有孩子结点的节点位置 i=  length/ 2  -1
    ///从下到上，一次筛选，构建堆
    for (int i = length / 2 -1; i >= 0; --i)
        HeapAdjust(H,i,length);  

}
template <typename T>
void HeapSort(T* Arr, int len)
{
    BuildingHeap(Arr, len);
    cout<<"BuildHeap:"<<endl;
    prin(Arr, len);
    ////堆顶元素和堆中最后一个元素交换之后，对堆进行调整
    for (int i= len -1; i>0; --i)
    {
        Swap<T>(Arr[i], Arr[0]);
         /*T temp = Arr[i]; Arr[i] = Arr[0]; Arr[0] = temp; */////////////////
        HeapAdjust<T>(Arr, 0, i);
    }
}

template <typename T>
void QuickSort(T* Arr, int left, int right)
{
    if (left >right)
        return;
    int low = left;
    int high = right;
    T temp = Arr[left];
    while(low < high)
    {
        while((low < high)&& (Arr[high] >= temp))
            high--;
        while((low < high)&& (Arr[low] <= temp))
            low++;
        if (low <high)
            Swap(Arr[low], Arr[high]);
    }
    Arr[left] = Arr[low];
    Arr[low] = temp;

    QuickSort(Arr, left, low-1);
    QuickSort(Arr, low+1, right);
}
template <typename T>
void Merge(T* Arr, int st, int md, int ed, T* temp)
{
    int s= st;  int m = md;   int e = ed;
    int mm = md+1;
    int index = 0;
    while (s<=m && mm <=e)
    {
        if (Arr[s] < Arr[mm])
            temp[index++] = Arr[s++];
        if (Arr[mm] < Arr[s])
            temp[index++] = Arr[mm++];
    }
    while (s<=m)
        temp[index++] = Arr[s++];
    while (mm<=e)
        temp[index++] = Arr[mm++];
    for (int i=0; i<index; i++)
        Arr[st+i] = temp[i];
}
template <typename T>
void MgerSort(T* Arr, int st, int ed, T* temp)
{
    if (Arr == NULL ||st<0 || ed <0 || temp == NULL)
    {
        return ;
    }
    if (st < ed)
    {
        int md = (st+ed)/2;
        MgerSort(Arr, st, md, temp );
        MgerSort(Arr, md+1, ed, temp);
        Merge(Arr, st, md, ed, temp);
    }
}