歸併排序的基本思想

-將兩個或兩個以上的有序序列合併成一個新的有序序列

    template < typename T>
    static void Merge(T src[] , T helper[],int begin,int mid,int end, bool min2max = true)
    {
        int i = begin;
        int j = mid + 1;
        int k = begin;

        while((i <= mid) && (j <= end))
        {
            if(min2max ? (src[i] < src[j]) : (src[i] > src[j]))
            {
                helper[k++] = src[i++];
            }
            else
            {
                helper[k++] = src[j++];
            }
        }

        while ( i <= mid)
        {
            helper[k++] = src[i++];
        }

        while(j <= end)
        {
            helper[k++] = src[j++];
        }

        for(i = begin;i<=end;i++)
        {
            src[i] = helper[i];
        }
    }

    template < typename T>
    static void Merge(T src[] , T helper[],int begin,int end, bool min2max = true)
    {
        if( begin < end)
        {
            int mid = (begin + end) / 2;


            Merge(src,helper,begin,mid,min2max);
            Merge(src,helper,mid+1,end,min2max);
            Merge(src,helper,begin,mid,end,min2max);
        }
    }

    template < typename T>
    static void Merge(T array[] , int len, bool min2max = true)
    {
        T* helper = new T[len];

        if(helper != NULL)
        {
            Merge(array,helper,0,len-1,min2max);
        }

        delete [] helper;
    }
 

快速排序的基本思想

-任取序列中的某個資料元素作為基準將整個序列劃分為左右兩個子序列

·左側子序列中所有元素都小於或等於基準元素

·右側子序列中所有元素都大於基準元素

·基準元素排在這兩個子序列中間

-分別對這兩個子序列重複進行劃分，知道所有資料元素都排在相應位置上位置

template <typename T>
    static int Partition(T array[] ,int begin,int end,bool min2max)
    {
        T pv = array[begin];
        while(begin< end)
        {
            while((begin < end) && (min2max ? (array[end] > pv) : (array[end] < pv)))
            {
                end--;
            }

            Swap(array[begin],array[end]);

            while((begin < end) && (min2max ? (array[begin] <= pv) : (array[begin] >= pv)))
            {
                begin++;
            }

            Swap(array[begin],array[end]);
        }

        array[begin] =  pv;

        return begin;
    }

    template <typename T>
    static void Quick(T array[],int begin , int end, bool min2max)
    {
        if(begin < end)
        {
            int pivot = Partition(array,begin,end,min2max);

            Quick(array,begin,pivot-1,min2max);
            Quick(array,pivot+1,end,min2max);
        }
    }
template<typename T>
    static void Quick(T array[], int len, bool min2max = true)
    {
        Quick(array,0,len-1,min2max);
    }
 

總結：

-歸併排序需要額外的輔助空間才能完成，空間複雜度為O(n)

-歸併排序的時間複雜度O(n*logn)，是一種穩定的排序法

-快速排序通過遞迴的方式對排序問題進行劃分

-快速排序的時間複雜度為O(n*logn)，是一種不穩定的排序法