数据结构 笔记：归并排序和快速排序

归并排序的基本思想

-将两个或两个以上的有序序列合并成一个新的有序序列

    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)，是一种不稳定的排序法