C 库函数 qsort

qsort() 整理

使用高速排序进行排序。		

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

base:待排序数组首地址/第一个元素的指针; nelem:待排序元素数量; width:元素的大小; fcmp:指向函数的指针，用于确定排序的顺序.

关键点：cmp函数形参已经确定：const void *，实参根据数组设定，实参转换类型的要点：指向数组元素的指针。

1. 一维数组

int compare(const void *p1, const void *p2) { 
      return (*(int *)p1) - (*(int *)p2); // 升序排序：返回值为正，则p1>p2，排在后面。
      //return (*(int *)p2) - (*(int *)p1); // 降序排序
  } 
int arr[5] = { 13, 17, 2, 7, 71 };
qsort(arr,5,sizeof(int),cmp);

arr:数组名作为函数的参数时，数组名会转化为指向该数组第一个元素的指针。
cmp的形参转换：由于数组元素是int,因此转换为（int*）.然后再取解引用为*(int *)p1 对int进行比较.

int compare(const void *p1, const void *p2) { 
      return (*(char *)p1) - (*(char *)p2); // 升序排序：返回值为正，则p1>p2，排在后面。
  } 
char c[] = {'c', 'd', 'a', 'A', 'f', 'B', 'w', 'v', 'W', 'V'};
qsort(c,sizeof(c)/sizeof(c[0]),sizeof(c[0]),cmp);

c:数组名作为函数的参数时，数组名会转化为指向该数组第一个元素的指针。
cmp的形参转换：由于数组元素是char,因此转换为（char*）.然后再取解引用为*(char*)p1 对char进行比较.

int compare(const void *p1, const void *p2) { 
      return (*(double*)p1) > (*(double*)p2)?1:-1; // 返回值为1,0，-1
  } 
double arr1[ARRAY_LEN] = {1.2, -1.2, 1.3, 33.3, 44.5, 77.5};
qsort(arr1,sizeof(arr1)/sizeof(arr1[0]),sizeof(arr1[0]),cmp);

cmp的形参转换：由于数组元素是double,因此转换为（double*）.然后再取解引用为*(double*)p1 对double进行比较.

2. 指针数组

int compare(const void *p1, const void *p2) { 
    	 char *a = *(char**)arg1;
      	char *b = *(char**)arg2;
      	return strcmp(a, b);
  } 
char *arr[5] = { "i", "love", "c", "programming", "language" };
qsort(arr,sizeof(arr1)/sizeof(arr[0]),sizeof(char *),cmp);

cmp的形参转换：由于数组元素是char*,因此转换为（char* *）.然后再取解引用为* (char* *)p1 对char *进行比较.

3. 二维数组

int compare(const void *p1, const void *p2) { 
     char *a = *((char (*)[])arg1);
     char *b = *((char (*)[])arg2);
     return strcmp(a, b);
  } 
char arr[4][8] = {"java", "c", "python", "peal"};
qsort(arr, 4, sizeof(arr[0]), cmp);

cmp的形参转换：由于数组元素是char[ ],因此转换为（char (*)[] ）.然后再取解引用为* (char ( *)[] )p1 对char[ ]进行比较.

int comp(const void *a,const void *b)
{
return (*(int *)a)[0]-(*(int *)b)[0];
}
int a[1000][2]; 
qsort(a,1000,sizeof(int)*2,comp);

当依照a[0]的大小进行一个总体的排序，当中a[1]必须和a[0]一起移动交换。因为a[0]是int类，因此转换为（int *）.即就是((int *)a)[0]

4. 结构体数组

struct In 
{ 
double data; 
int other; 
}s[100];

# 按照data值排序
int cmp( const void *a ,const void *b) 
{ 
return (*(In *)a).data > (*(In *)b).data ? 1 : -1; 
} 

qsort(s,100,sizeof(s[0]),cmp); 

int cmp( const void *a , const void *b ) 
{ 
# (In *)a指向a的指针
struct In *c = (In *)a; 
struct In *d = (In *)b; 
if(c->x != d->x) return c->x - d->x; 
else return d->y - c->y; 
} 

qsort(s,100,sizeof(s[0]),cmp);