測試環境 VS2017
思路：用qsort與sort分別對有n個隨機數的陣列進行m次排序。
平臺：x64

sort：

標頭檔案： algorithm
函式原型：

template< class RandomIt >
　　void sort( RandomIt first, RandomIt last );
　　
template< class RandomIt, class Compare >
　　void sort( RandomIt first, RandomIt last, Compare comp );

　　
sort作為STL庫的成員函式，肯定是本著庫通用的目的，採用模板超程式設計實現，可對STL庫提供的大部分（？不知道是不是所有，目前僅排序過vector，string（list有自己的sort））容器進行排序（我猜應該是隻能針對連續地址的資料進行排序）。
引數值：要排序的起始迭代器位置，尾後迭代器位置，比較函式（可選）。預設是升序排列。

如果想要降序排列，可以：1，過載要排序的元素型別的<操作符
2，傳遞一個比較函式，如果第一個引數小於第二個該函式,返回true（升序）。
如果第一個引數大於第二個該函式,返回true（降序）。

比較函式的原型為：

bool cmp(const Type1 &a, const Type2 &b);

qsort：

標頭檔案： cstdlib
函式原型：

void qsort(void *base , int nelem ,int width , int (*fcmp)(const void *,const void *));

qsort作為C語言標準庫函式，可對連續地址儲存的變數進行排序，沒有預設排序方式，必須傳入比較函式，並且相對於sort的操作符過載的方式改變排序規則的策略來講，qsort只能通過改變比較函式的方式進行排序，策略單一。
引數值：排序的起始地址，排序的元素長度，要排序元素在記憶體中的佔位值（即sizeof），比較函式指標

比較函式的原型為：

int compare( (void *) & elem1, (void *) & elem2 );

**這裡需要注意的是，不同於qsort的比較函式，fcmp返回的是一個int值型別，而不是單純的true和false
如果比較函式寫成**

int comp(const void*a, const void*b)
{
    return *(int*)a>*(int*)b;//當a<b時就會返回false，也就是0，那麼會被qsort認為二者相等，最終導致排序錯誤

    /*正確寫法*/
    //return *(int*)a-*(int*)b;
}

使用例項及效率比較：

最開始我是看到這篇文章中對於二者的比較：http://blog.csdn.net/pku_zzy/article/details/51462417
作者得出的結論是，qsort比sort的效率高，一般情況下前者的用時是後者的三分之一，所以他推薦在一般情況下我們應該選擇qsort而不是sort。

對這一結論我有疑惑：qsort只是實現了快速排序，而STL庫中的sort實現了快排，堆排，歸併排等多種排序，並且針對資料量的不同做了諸多優化，如果最終效率不及qsort，那麼STL實現sort的意義在哪兒？

而且，我本人對STL庫是抱著非常敬畏和尊敬的感情的，我不相信STL庫的開發者們會做出這樣沒有意義的事情，並且還把它加到C++的標準庫中。

帶著如上疑問，我決定自己動手寫一個測試，來看看qsort和sort的排序效率到底是怎樣的。

以下為測試程式碼：

#include <cstdio>
#include <windows.h>
#include <cstdlib>
#include<vector>
#include<iostream>
#include<algorithm>
#include<ctime>
using namespace std;

#define MAX_SIZE 1000
#define N_TIMES 10000

int inline comp(const void*a, const void*b)//當返回值大於0時，認為a>b,如果此時與實際情況相符，則按升序排列，相反則按降序排列
                                            //返回值等於0，認為a=b，返回值小於0認為a<b;
                                            //特別需要注意的是，這裡不能返回諸如(*(int*)a)  > (*(int*)b)的形式，因為這樣只會返回0和1，而0是被認為二者是相等的
{
    return *(int*)a - *(int*)b;
    //return 0;
}

inline bool comp_sort(int a, int b)//當返回值為true時，認為a>b,否則，認為a<=b
{
    return a < b;
    //return false;
}


int main(void)
{
    vector<vector<int> > collect_qsort;
    vector<vector<int> > collect_sort;
    vector<int> temp(MAX_SIZE);
    srand((unsigned)time(NULL));//置隨機種子
    for (int i = 0; i < MAX_SIZE; i++)//將temp填滿隨機數
    {
        temp[i] = rand();
    }
    for (int i = 0; i < N_TIMES; i++)//兩個測試樣例都填充N_TIMES次temp
                                    //這裡兩種排序的測試樣例是完全相同的，都是對temp進行N_TIMES次排序
    {
        collect_qsort.push_back(temp);
        collect_sort.push_back(temp);
    }
    //下面是計時操作一些相關變數的初始化
    LARGE_INTEGER nFreq;
    LARGE_INTEGER nBeginTime;
    LARGE_INTEGER nEndTime;
    double time;

    QueryPerformanceFrequency(&nFreq);//獲取系統時鐘頻率
    QueryPerformanceCounter(&nBeginTime);//獲取系統當前計數器計數值
    /***************************用qsort對樣例進行N_TIMES次排序***************************************/
    for(int i=0;i<N_TIMES;i++)
        qsort(&collect_qsort[i][0], MAX_SIZE,sizeof(collect_qsort[i][0]),comp);
    /****************************************************************************************/
    QueryPerformanceCounter(&nEndTime);//獲取系統當前計數器計數值
    time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//兩次獲取的計數器計數值的差值除以系統時鐘頻率即可得到時間，精確到微秒
    printf("cost of Qsort time(%dint data*%d):%f\n", MAX_SIZE,N_TIMES,time);


    QueryPerformanceFrequency(&nFreq);//獲取系統時鐘頻率
    QueryPerformanceCounter(&nBeginTime);//獲取系統當前計數器計數值
    /***************************用qsort對樣例進行N_TIMES次排序***************************************/
    for (int i = 0; i<N_TIMES; i++)
        sort(collect_sort[i].begin(), collect_sort[i].end(), comp_sort);
    /****************************************************************************************/
    QueryPerformanceCounter(&nEndTime);//獲取系統當前計數器計數值
    time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//兩次獲取的計數器計數值的差值除以系統時鐘頻率即可得到時間，精確到微秒
    printf("cost of sort time(%dint data*%d):%f\n", MAX_SIZE, N_TIMES, time);


    system("Pause");
    return 0;
}

在該項測試中，我們選取了1000個int型的隨機資料進行排列，分別用sort與qsort對其進行1e4次排列。

在debug模式下，我發現確實如上面那篇部落格的作者所言，sort的用時幾乎是qsort的三倍甚至更多

但是IDE在debug模式下對程式碼的監視是要耗費資源的，越大規模的演算法，在debug模式下對其監視所花費的資源也就越多，龐大如VS這樣的IDE，debug所消耗的資源更甚。

因此同樣的程式碼我又在release模式下跑了一遍：

可以看到，在release模式下，兩種排序的時間都大幅降低了，並且sort的用時是明確小於qsort的用時的。
所以，到這裡我可以肯定，上面那篇部落格的作者的測試就是在debug和release的選擇上出了問題。

為了得出一般性的結論，我們選擇不同的輸入規模，來看一看二者的效率是否會發生逆轉
修改測試程式碼中的MAX_SIZE 與 N_TIMES（N_TIMES的作用僅僅是在小規模輸入下增加對同樣的資料的排序次數，以消除計時誤差帶來的影響，不影響sort與qsort的效率的排名結果）
我們來看一看不同規模的輸入下，二者的相對錶現如何：

由上表我們可以看出，從10到1e8（即1億）的資料量級的比較中，雖然隨著資料量級的增長，qsort的效率越來越接近sort的效率，但是qsort：sort的值始終是大於1的。 因此不難得出結論，一般情況下而言，sort的效率始終是高於qsort的效率的

因為int是內建型別，我想可能會有影響，所以又定義了一個自定義型別Point

class Point
{
public:
    int x;
    int y;
};

以Point點到座標原點的距離作為排序的依據：
程式碼實現如下

#include <cstdio>
#include <windows.h>
#include <cstdlib>
#include<vector>
#include<iostream>
#include<algorithm>
#include<ctime>
using namespace std;

class Point
{
public:
    int x;
    int y;
};

int inline comp(const void*a, const void*b)//當返回值大於0時，認為a>b,如果此時與實際情況相符，則按升序排列，相反則按降序排列
                                           //返回值等於0，認為a=b，返回值小於0認為a<b;
                                           //特別需要注意的是，這裡不能返回諸如(*(Point*)a)  > (*(Point*)b)的形式，因為這樣只會返回0和1，而0是被認為二者相等的
{
    return ((Point*)a)->x* ((Point*)a)->x + ((Point*)a)->y* ((Point*)a)->y - ((Point*)b)->x* ((Point*)b)->x - ((Point*)b)->y* ((Point*)b)->y;
}

inline bool comp_sort(Point &a, Point &b)//當返回值為true時，認為a>b,否則，認為a<=b
{
    return a.x*a.x + a.y*a.y < b.x*b.x + b.y*b.y;
}




#define MAX_SIZE 10000
#define N_TIMES 10000
int main(void)
{
    vector<vector<Point> > collect_qsort;
    vector<vector<Point> > collect_sort;
    vector<Point> temp(MAX_SIZE);
    srand((unsigned)time(NULL));//置隨機種子
    for (int i = 0; i < MAX_SIZE; i++)//將temp填滿隨機數
    {
        temp[i].x = rand() % 100;
        temp[i].y = rand() % 100;
    }
    for (int i = 0; i < N_TIMES; i++)//兩個測試樣例都填充N_TIMES次temp
                                     //這裡兩種排序的測試樣例是完全相同的，都是對temp進行N_TIMES次排序
    {
        collect_qsort.push_back(temp);
        collect_sort.push_back(temp);
    }
    //下面是計時操作一些相關變數的初始化
    LARGE_INTEGER nFreq;
    LARGE_INTEGER nBeginTime;
    LARGE_INTEGER nEndTime;
    double time;

    QueryPerformanceFrequency(&nFreq);//獲取系統時鐘頻率
    QueryPerformanceCounter(&nBeginTime);//獲取系統當前計數器計數值
    /***************************用qsort對樣例進行N_TIMES次排序***************************************/
    for (int i = 0; i<N_TIMES; i++)
        qsort(&collect_qsort[i][0], MAX_SIZE, sizeof(collect_qsort[i][0]), comp);
    /****************************************************************************************/
    QueryPerformanceCounter(&nEndTime);//獲取系統當前計數器計數值
    time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//兩次獲取的計數器計數值的差值除以系統時鐘頻率即可得到時間，精確到微秒
    printf("cost of Qsort time(%dPoint data*%d):%f\n", MAX_SIZE, N_TIMES, time);


    QueryPerformanceFrequency(&nFreq);//獲取系統時鐘頻率
    QueryPerformanceCounter(&nBeginTime);//獲取系統當前計數器計數值
    /***************************用qsort對樣例進行N_TIMES次排序***************************************/
    for (int i = 0; i<N_TIMES; i++)
        sort(collect_sort[i].begin(), collect_sort[i].end(), comp_sort);
    /****************************************************************************************/
    QueryPerformanceCounter(&nEndTime);//獲取系統當前計數器計數值
    time = (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart;//兩次獲取的計數器計數值的差值除以系統時鐘頻率即可得到時間，精確到微秒

    printf("cost of sort time(%dPoint data*%d):%f\n", MAX_SIZE, N_TIMES, time);



    system("Pause");
    return 0;
}

最終結論沒有改變：

**

因此，任何情況下，我都推薦你使用sort。

**