c++ Qport函數應用大全中Qport（）排序函數的使用
七種qsort排序方法
& lt在本文中，排序是由小到大》的:
首先，對int類型數組進行排序
int num【100】；
樣本:
int cmp（常量void *a，常量void *b）
{
return *（int *）a-*（int *）b；
}
qsort（num，100，sizeof（num【0】），CMP）；
其次，對char類型的數組進行排序（與int類型相同）
char word【100】；
樣本:
int cmp（常量void *a，常量void *b）
{
return *（char *）a-*（int *）b；
}
qsort（word，100，sizeof（word【0】，CMP）；
第三，對double類型數組進行排序（要特別註意）
double in【100】；
int cmp（常量void *a，常量void *b）
{
return *（double *）a & gt；*（雙*）b？1 : -1;
}
qsort（in，100，sizeof（in【0】），CMP）；
第四，在第壹層對結構進行排序
結構輸入
{
雙數據；
int other
} s【100】
//根據數據的值從小到大對結構進行排序。結構中有多種類型的排序關鍵數據。請參照上面的例子來寫。
int cmp（常量void *a，常量void *B）
{
return（*（In *）a）-》；數據& gt（*（In *）B）-》；數據？1 : -1;
}
qsort（s，100，sizeof（s【0】），CMP）；
5.二階結構。
結構輸入
{
int x；
int y；
} s【100】；
//按X從小到大排序，當X相等時按Y從大到小排序。
int cmp（常量void *a，常量void *b）
{
*c中的結構=（In *）a；
結構In * d =（In *）b；
if（c-》；x！= d-》；x）返回c-》；x-d-》；x；
否則返回d-& gt；y-c-》；y；
}
qsort（s，100，sizeof（s【0】），CMP）；
第六，對字符串進行排序
結構輸入
{
int數據；
char str【100】；
} s【100】；
//根據結構中字符串str的字典順序進行排序。
int cmp（常量void *a，常量void *b）
{
return strcmp（*（In *）a）-& gt；str，（*（In *）B）-》；str）；
}
qsort（s，100，sizeof（s【0】），CMP）；
7.計算幾何中尋找凸包的cmp算法
int CMP（const void * a，const void * b）//key CMP函數，該函數按旋轉角度對除1以外的所有點進行排序。
{
結構點*c=（點*）a；
結構點*d=（點*）b；
if（calc（* c、*d，p【1】）& lt；0）返回1；
else if（！calc（* c，*d，p【1】）；& ampdis（c-》；x，c-》；y，p【1】。x，p【1】。y）& lt；dis（d-》；x，d-》；y，p【1】。x，p【1】。y））//如果妳在壹條直線上，把遠的放在前面。
返回1；
else返回-1；
}
：
在c++中加載頭文件“iostream”
c語言中的qsort函數包含在
/*六種qsort排序方法
ANSI C標準中提供了qsort函數。它在stdlib.h文件中聲明，並根據二進制分布編寫。其時間復雜度為n * log（n），其結構如下:
void qsort（void * base，size_t nelem，size_t width，int（* Comp）（const void *，const void *））；
其中包括:
*base是要排序的數組。
Nelem是要排序的數組的長度。
寬度是數組元素的大小（以壹個字為單位）。
（* comp）（const void * p 1，constvoid * p2）是判斷size函數的指針，需要自己定義。如果p 1》；P2，該函數返回-1；a & ltb、函數返回1；a==b函數返回0。
前段時間，我發現qsort函數非常好用，但有時不太好用，比如按結構排序、按字符串排序等。，所以我通過查閱資料整理了壹下。
以下是具體的分類和用法（除非另有說明，否則按升序排列）:
示例1:對壹維數組進行排序
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
int Comp（const void * p 1，const void *p2）
{
return *（int *）p 1）-*（（int *）p2）；
}
int main()
{
int list【100】；
for（int I = 0；我& lt10;i++)
scanf（“% d“，& amplist【I】）；
qsort（list，10，sizeof（int），Comp）；
for（int I = 0；我& lt10;i++)
printf（“% d“，list【I】）；
系統（“暫停”）；
返回0；
}
示例2:排序字符串
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
# include & ltstring.h & gt
int Comp（const void * p 1，const void *p2）
{
return strcmp（（char *）p 1，（char *）p2）；
}
int main()
{
char a【100】【100】；
for（int I = 0；我& lt3;i++)
get（a【I】）；
qsort（a，3，sizeof（a【0】），Comp）；
for（int I = 0；我& lt3;i++)
puts（a【I】）；
系統（“暫停”）；
返回0；
}
示例3:按結構中的關鍵字排序（在第壹層對結構排序）:
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
結構ab
{
int vote 1；
int id
} ABC【6】；
int cmp（常量void *a，常量void *b）
{
return（（struct ab *）a）-& gt；vote 1-（（struct ab *）b）-》；vote 1；
}
int main()
{
for(int I = 0；我& lt5;i++)
scanf（“% d“，& ampABC【I】。vote 1）；
qsort（（void *）ABC，5，sizeof（ABC【0】），CMP）；
for（int I = 0；我& lt5;i++)
printf（“% d“，ABC【I】）；
系統（“暫停”）；
返回0；
}
示例4:按結構中的多個關鍵字排序（結構的多級排序）【以第二級為例】:
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
結構ab
{
int x；
int y；
} ABC【6】；
int cmp（常量void *a，常量void *b）
{
if（（（struct ab *）a）-& gt；x！=（（struct ab *）b）-》；x)
return（（struct ab *）a）-& gt；x-（（struct ab *）b）-》；x；
其他
return（（struct ab *）a）-& gt；y-（（struct ab *）b）-》；y；
}
int main()
{
for(int I = 0；我& lt5;i++)
{
scanf（“% d % d“，& ampABC【I】。x & amp；ABC【I】。y）；
}
qsort（（void *）ABC，5，sizeof（ABC【0】），CMP）；
for（int I = 0；我& lt5;i++)
printf（“% d % d“，ABC【I】。x，ABC【I】。y）；
系統（“暫停”）；
返回0；
}
示例5:對結構中的字符串進行排序:
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
# include & ltstring.h & gt
結構ab
{
int x；
char AC【100】；
} ABC【6】；
int cmp（常量void *a，常量void *b）
{
return strcmp（（（struct ab *）a）-& gt；ac，（（struct ab *）b）-》；AC）；
}
int main()
{
for(int I = 0；我& lt5;i++)
{
獲取（ABC【I】。AC）；
}
qsort（（void *）ABC，5，sizeof（ABC【0】），CMP）；
for（int I = 0；我& lt5;i++)
看跌期權。AC）；
系統（“暫停”）；
返回0；
}
6.計算幾何中尋找凸包的代價。
//下面是我從別人那裏抄來的，還沒用過。
int Comp（const void * p 1，const void *p2）
//Key Comp函數，對除1以外的所有點的旋轉角度進行排序。
{
struct point * c =（point *）p 1；
結構點*d=（點*）p2；
if（CaCl（* c，*d，p【1】）& lt；0）返回1；
else if(！CaCl（* c，*d，p【1】）；& ampdis（c-》；x，c-》；y，p【1】。x，p【1】。y）& lt；dis（d-》；x，d-》；y，p【1】。x，p【1】。y）
//如果妳在壹條直線上，把遠的放在前面。
返回1；
else返回-1；
}
第三，ANSI C標準中提供了P.S.:qsort函數。它在stdlib.h文件中聲明，並根據二進制分布編寫。其時間復雜度為n * log（n），其結構如下:
void qsort（void * base，size_t nelem，size_t width，int（* Comp）（const void *，const void *））；
其中包括:
*base是要排序的數組。
Nelem是要排序的數組的長度。
寬度是數組元素的大小（以壹個字為單位）。
（* comp）（const void * p 1，constvoid * p2）是判斷size函數的指針，需要自己定義。如果p 1》；P2，該函數返回-1；a & ltb、函數返回1；a==b函數返回0。
//////////////
另請參見qsort - zju2727。
根據給定關鍵字的三級排序問題直接插入已總結的qsort模型中，它是AC。是上次總結的補充例子。
源代碼:
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
# include & ltstring.h & gt
結構節點{
字符名稱【100】；
int年，價格；
} Book【100】；
/* - */
/* int compy（const void * p 1，const void * p2）//首先按年份排序。
{
struct Node * c =（Node *）p 1；
struct Node * d =（Node *）p2；
if（c-》；年！= d-》；年份）返回c-》；公元年-》；年份；
else if（strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名））
返回strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名）；
否則返回c-& gt；價格-d-》；價格；
}
int compp（const void * p 1，const void * p2）//首先按價格排序。
{
struct Node * c =（Node *）p 1；
struct Node * d =（Node *）p2；
if（c-》；價格！= d-》；價格）返回c-& gt；價格-d-》；價格；
else if（strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名））
返回strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名）；
否則返回c-& gt；公元年-》；年份；
}
int compn（const void * p 1，const void * p2）//首先按名稱排序。
{
struct Node * c =（Node *）p 1；
struct Node * d =（Node *）p2；
if（strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名））
返回strcmp（*（Node *）p 1）。名稱，（*（節點*）p2）。姓名）；
else if（c-》；年！= d-》；年份）返回c-》；公元年-》；年份；
否則返回c-& gt；價格-d-》；價格；
}
/* - */
/* void outres（int n）
{
int I；
for(I = 0；我& ltn；i++)
printf（“% s % d % d \ n“，Book【I】。名，書【我】。年，書【我】。價格）；
}
/* - */
/*int main（）
{
int n；
char格式【15】；
//freopen（“in . txt“，“r“，stdin）；
scanf（“% d“，& ampn）；
當
{
for（int I = 0；我& ltn；i++)
scanf（“% s % d % d“，Book【I】。姓名& amp書【我】。年份和年份。書【我】。價格）；
scanf（“% s“，格式）；
if（format【0】= =‘Y‘）
{
qsort（Book，n，sizeof（Book【0】），CompY）；
}
else if（format【0】= =‘P‘）
{
qsort（Book，n，sizeof（Book【0】），CompP）；
}
其他
{
qsort（Book，n，sizeof（Book【0】），CompN）；
}
outres（n）；
scanf（“% d“，& ampn）；
if（n）printf（“\ n“）；
}
返回0；
}
*/
poj3664
# include & ltstdio.h & gt
# include & ltstdlib.h & gt
結構ab
{
int vote 1；
int vote2
int id
} ABC【1000000】；
int CMP 1（const void * a，const void *b）
{
return（（struct ab *）a）-& gt；vote 1-（（struct ab *）b）-》；vote 1；
}
int CMP 2（const void * a，const void *b）
{
return（（struct ab *）a）-& gt；vote 2-（（struct ab *）b）-》；vote2
}
int main()
{
int i，j，k；
scanf（“% d % d“，& ampj & amp；k）；
for(I = 0；我& ltj；i++)
{
scanf（“% d % d“，& ampABC【I】。vote 1。ABC【I】。vote 2）；
ABC【I】。id = I+1；
}
qsort（（void *）ABC，j，sizeof（ABC【0】），CMP 1）；
qsort（（void *）（& amp；ABC【j-k】）、k、sizeof（ABC【0】）、CMP 2）；
printf（“% d \ n“，ABC【j-1】。id)；
//system（“pause“）；
返回0；
}