下面的原始碼是修改的了時間差精確到了納秒級別的了，但是還是感覺很有誤差。無論怎麼測，總是快排比歸併快，即使是測試資料的陣列長度在10以內。

        前面一樣的程式寫的是時間精確到微秒級的，陣列長度大概在一萬以內的，就是歸併排序快了，大於這個長度的快速排序比較快。綜合上面的情況，陣列小時，二者時間差也不會太多，所以個人認為還是快速排序比較好了，唉還是覺得歸併比較簡單好寫，弱爆了啊。。。

#include<cstdio>
#include<Windows.h>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<iostream>
using namespace std;

const int maxn = 100000000;     /* maxn 為陣列最大值 */
/*
*a[]為隨機產生的陣列 , b[]複製隨機陣列,t[]用於歸併排序,暫時儲存a[]
*/
int a[maxn];
int b[maxn], t[maxn];
int n;                        /* n為要比較的數的個數 */

/*
*對陣列下標從 p到r之間的數進行排序
*使得前面的數全都不大於基準元, 後面的數不小於基準元
*/
int partition(int p, int r)
{
	int i = p;
	int j = r+1;
	int x = a[p];

	while(true)
	{
		while(a[++i] < x && i < r);
		while(a[--j] > x);

		if(i >= j) break;

		//swap(a, i, j);
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	a[p] = a[j];
	a[j] = x;
	return j; /* 返回基準元排好序後的位置 */
}

int randomizedPartition(int p, int r) /* 對基準元進行處理 */
{
	int i = rand() % (r-p+1) + p; /* 產生p 到 q 之間的隨機數 i */

	int temp = a[i];    /* 交換隨機位置到開始位置,使其成為基準元 */
	a[i] = a[p];
	a[p] = temp;

	return partition(p, r);
}

void randomizedQuickSort(int p, int r) /* 快速排序 */
{
	if(p < r)
	{
		int q = randomizedPartition(p, r); /* 分割 */
		randomizedQuickSort(p, q-1);      /* 從兩邊分別排序 */
		randomizedQuickSort(q+1, r);
	}
}

void merge_sort(int *a, int x, int y, int *t) /* 歸併排序 */
{
	if(y-x > 1)
	{
		int m = (y-x)/2 + x;       /* 取中間 */
		int p = x, q = m, i = x;

		merge_sort(b, p, m, t);   /* 兩邊分別排序 */
		merge_sort(b, m, y, t);

		while(p < m && q < y)
		{
			if(b[p] <= b[q]) t[i++] = b[p++];
			else t[i++] = b[q++];
		}

		while(p < m) t[i++] = b[p++];
		while(q < y) t[i++] = b[q++];

		for(i = x; i < y; i++) /* 將排序好的部分重新存入陣列 a[]*/
			b[i] = t[i];
	}
}

int main()
{
    printf("請輸入要排序比較的個數 n ( n <= 100000000 ): ");
    while(scanf("%d", &n) != EOF)
    {
        LARGE_INTEGER begin, end;
        //double tstart, tend, MergeSortCost, QuickSortCost;
        long long  MergeSortCost, QuickSortCost;

        memset(a, 0, sizeof(a));       /* 清空陣列為0 */
        for(int i = 0; i < n; i++)    /* 生成隨機數 */
        {
            a[i] = rand();
            b[i] = a[i];
        }

        QueryPerformanceCounter(&begin); // tstart = clock();
        randomizedQuickSort(0, n-1); /* 快速排序 */
        QueryPerformanceCounter(&end); //tend = clock();

        QuickSortCost = end.QuadPart - begin.QuadPart; //tend - tstart;
        //for(int i = 0; i < n; i++) printf("%d ", a[i]);


        QueryPerformanceCounter(&begin); //tstart = clock();
        merge_sort(b, 0, n, t); /* 歸併排序 */
        QueryPerformanceCounter(&end); //tend = clock();

        MergeSortCost = end.QuadPart - begin.QuadPart; //tend - tstart;
        //for(int i = 0; i < n; i++) printf("%d ", b[i]);

        printf("快速排序耗時：%lld ns,歸併排序耗時：%lldns\n\n\n", QuickSortCost*100, MergeSortCost*100);


        printf("如果要繼續比較請繼續輸入比較的個數 n : ");

    }
    return 0;
}
 

通過此次演算法分析兩種排序方法的比較,我還學到了一些簡單的頭函式的使用.

一、關於隨機數的產生。

/*
*產生區間[a , b]之間的隨機整數
*/
#include<cstdio>
#include<cstdlib>
int main()
{
	int a,b;
	while(scanf("%d%d", &a, &b) != EOF)
	{
		int ans = rand()%(b-a+1) + a;
		printf("%d\n", ans);
	}
	return 0;
	
}

二、如何測試系統當前時間。

/*
*微秒級時間測試
*/
#include <time.h>  //time.h是C/C++中的日期和時間標頭檔案
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
    double tstart, tend, tcost;

    tstart = clock();
    for(int i=0;i<10000000;i++); //do something
        tend = clock();
    tcost = (double)(tend-tstart)/CLOCKS_PER_SEC;

    printf("%lf\n", tcost);
    cout<<CLOCKS_PER_SEC; // == 1000 ms
    return 0;
}
 

/*
*納秒級時間測試一 ,來自周杰學長
*/
#include <Windows.h>
#include <stdio.h>

int main()
{
	LARGE_INTEGER li;
	QueryPerformanceCounter(&li);
	printf("%lld\n", li);
	QueryPerformanceCounter(&li);
	printf("%lld\n", li);
	return 0;
}

/*
*納秒級時間測試二 :測試用時 ,來自周杰學長
*/
#include <Windows.h>
#include <stdio.h>

int main()
{
	LARGE_INTEGER begin, end;
	QueryPerformanceCounter(&begin);
	Sleep(0); // do something
	QueryPerformanceCounter(&end);
	long long duration = end.QuadPart - begin.QuadPart;
	printf("duration: %lldns\n", duration * 100);
    return 0;
}