合并排序和快速排序执行时间比较

合并排序

合并排序的思路是：把数组分成两部分，分别进行排序，再把排好序的两部分合并成排序数组。合并排序对一个n个元素的数组排序所需时间是O(nlogn)。用合并排序排序{9, 4, 5, 2, 1, 7, 4, 6}过程如下：

算法C++实现：

//对n个数进行合并排序
void Merge(int A[], int low, int mid, int high)
{
    int B[];//辅助数组
    int s = low , t = mid + 1 , k = low;

    //将小元素添加到辅助数组
    while( s<=mid && t<=high )
    {
        if(A[s]<=A[t])
        {
            B[k] = A[s];
            s = s + 1;
        }
        else
        {
            B[k] = A[t];
            t = t + 1;
        }
        k = k + 1;
    }

    if(s == mid + 1)
    {
        //把A[t...high]中剩余的元素复制到B数组
        for(int i = k ; i <= high ; i++)
            B[i] = A[t++];
    }
    else
    {
        //把A[s...mid]中剩余的元素复制到B数组
        for(int i = k ; i <= high ; i++)
            B[i] = A[s++];
    }

    //把B数组复制到A数组
    for(int j = low ; j <= high ; j++)
        A[j] = B[j];
}

void mergesort(int A[] , int low ,int high)
{
    if(low < high)
    {
        //把数组分成两部分分别排序在合并
        int mid = (low+high)/2;
        mergesort(A , low , mid);
        mergesort(A , mid+1 , high);
        Merge(A , low , mid , high);
    }
}

快速排序

快速排序的思路是：通过Split算法划分数组A[low…high]，求得A[low]的位置w，使得小于或等于A[w]的元素所处位置为A[low…w-1]，大于或等于A[w]的元素的位置为A[w+1…high]，再对两个划分后的子数组递归排序。快速排序最好情形的时间复杂度为O(nlogn)，最坏的情形为O(n*n)，平均时间复杂度O(nlogn)。对数组{4, 6, 3, 1, 8, 7, 2, 5}排序过程如下：

算法C++实现如下：

 

QuickSortint Split(int A[], int low, int high)
{
    int i = low;
    int x = A[low];

    //从左往右扫描,围绕x划分数组
    for(int j = low+1 ; j <= high ; j++)
    {
        if(A[j] <= x)
        {
            i++;
            if(i != j)
            {
                A[0] = A[i];
                A[i] = A[j];
                A[j] = A[0];
            }
        }
    }

    //A[low]填入i位置
    A[0] = A[low];
    A[low] = A[i];
    A[i] = A[0];

    return i;
}

void quicksort(int A[], int low, int high)
{
    int w;
    if(low < high)
    {
        w = Split(A, low, high);//把数组划分成两部分
        quicksort(A, low, w-1);//对左半部分递归处理
        quicksort(A, w+1, high);//对有半部分递归处理
    }
}

合并排序和快速排序执行时间比较

随机产生20组数据，第一组500000个，第二组1000000个，以此类推，到第20组10000000个，数据范围为（0,100000），对同一组数据进行合并排序和快速排序，记录运行时间，程序如下：

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string>

using namespace std;

int A[10000001];//数据数组
int C[10000001];//复制数组
int B[10000001];//辅助数组

//初始化，随机产生n个数据保存在C数组中
void Initialize(int n)
{
    srand((unsigned)time(0));
    for(int i = 1 ; i <= n ; i++)
        C[i] = rand()%100000;
}

//复制C数组元素到A数组
void CopyCtoA(int n)
{
    for(int i = 1 ; i <= n ; i++)
        A[i] = C[i];
}


//Merge
void Merge(int A[], int low, int mid, int high)
{
    //int B[100001];//辅助数组
    int s = low , t = mid + 1 , k = low;

    //将小元素添加到辅助数组
    while( s<=mid && t<=high )
    {
        if(A[s]<=A[t])
        {
            B[k] = A[s];
            s = s + 1;
        }
        else
        {
            B[k] = A[t];
            t = t + 1;
        }
        k = k + 1;
    }

    if(s == mid + 1)
    {
        //把A[t...high]中剩余的元素复制到B数组
        for(int i = k ; i <= high ; i++)
            B[i] = A[t++];
    }
    else
    {
        //把A[s...mid]中剩余的元素复制到B数组
        for(int i = k ; i <= high ; i++)
            B[i] = A[s++];
    }

    //把B数组复制到A数组
    for(int j = low ; j <= high ; j++)
        A[j] = B[j];
}

//MergeSort
void MergeSort(int A[], int low, int high)
{
    if(low < high)
    {
        //把数组分成两部分分别排序在合并
        int mid = (low+high)/2;
        MergeSort(A , low , mid);
        MergeSort(A , mid+1 , high);
        Merge(A , low , mid , high);
    }
}

//Split
int Split(int A[],int low,int high)
{
     A[0]=A[low];    //把基准记录暂存在A[0]中
     int key=A[low];
     while(low<high)
     {
         while((low<high)&&(A[high]>=key))    //从右到左扫描
            high--;
         if(low<high)                    //low>=high而退出的循环，不需要移动数据
             A[low++]=A[high];         //记录，并将low往右移动一个单位
         while((low<high)&&(A[low]<=key))     //从左到右扫描
            low++;
         if(low<high)
            A[high--]=A[low];             //记录，并将up往左移动一个单位
     }
     A[low]=A[0];     //正确的位置填入基准位置
     return low;     //返回当前填入基准记录的所在位置
}

//QuickSort
void QuickSort(int A[], int low, int high)
{
    int mid;
    if(low < high)
    {
        mid = Split(A, low, high);//把数组划分成两部分
        QuickSort(A, low, mid-1);//对左半部分递归处理
        QuickSort(A, mid+1, high);//对有半部分递归处理
    }
}



//对n个数执行合并排序或快速排序，计算输出执行时间
void Sort_ExcutionTime(int n , string sort_type)
{
    CopyCtoA(n);
    clock_t start, end;
    double totaltime;

    if(sort_type == "MergeSort")
    {
        start = clock();
        MergeSort(A, 1, n);
        end = clock();
    }
    else if(sort_type == "QuickSort")
    {
        start = clock();
        QuickSort(A, 1, n);
        end = clock();
    }

    totaltime = (double)(end-start)/CLOCKS_PER_SEC*1000;
    //totaltime = end-start;
    cout<<sort_type<<" running time is: "<<totaltime<<" ms"<<'
';
}

//执行程序
void Excute()
{
    for(int i = 1 ; i <= 20 ; i++)
    {
        Initialize(500000*i);
        cout<<"n="<<500000*i<<'
';
        Sort_ExcutionTime(500000*i, "MergeSort");
        Sort_ExcutionTime(500000*i, "QuickSort");
        cout<<'
';
    }
}

int main()
{
    Excute();
    return 0;
}

执行结果：
      

                                            

　　排序同一组数据，当数据量较少时，QuickSort的运行时间比MergeSort的运行时间少，随着数据增加，MergeSort的运行时间比QuickSort的运行时间少。

可看出对同一组数据快速排序执行的时间少于合并排序，随着数据的增加，这种差距不断增大。