冒泡排序算法 实现qsort函数

首先得懂的冒泡排序

这是一个很简单的算法，
int a[5] ={6,4,3,2,5};
6先和4比，如果大于则交换位置
{6,4,3,2,5}——>{4,6,3,2,5}；
{4,6,3,2,5}——>{4,3,6,2,5}；
{4,3,6,2,5}——>{4,3,2,6,5}；
{4,3,2,6,5}——>{4,3,2,5,6};
一次外循环结束；
…
然后6又和三比，就这样循环得到{4,3,2,5，6}，最大的来到了最后 ，然后 又从4开始向后比 如此循环。但6已近是最大，为了优化减少运算次数，所以内层循环减一，就是4 比到5 就结束

int i = 0;
int j = 0;
for(i = 0; i < 5; i++)
{
   for(j = 0; j < 5 - 1 -i; j++)
   {
      if(a[j] > a[j+1])
      {
         int tmp = a[j];
           a[j]  = a[j+1];
           a[j+1] = tmp;
      }
   }
}

然后就是自己实现qsort函数了

qsort()函数有四个参数；qsort(void *base,size_t num, size_t width ,int (*p)(const void ,const void )
提示一下 size_t 是 无符号整型 ,int (*p)(const void ,const void 是函数cmp的函数指针；

想利用指针来交换变量，自己写一个函数叫swap(),具体需要的参数等下请看代码理解；

你写一个函数，你并不知道用户给你传的是int char double 等类型，所以你就没办法确定＋1时候的所跳过的步长，如果你一个一个的判断，那就有永远写不完的代码，所以只能一劳永逸，用字节来交换，只需要用sizeof（）函数确定占几个字节；把初始类型强行转化成char类型就可以；j*width 到 （j+1）*width 就是需要跳过的下一个变量；
swap() 交换都是一个字节，一个字节交换，

int cmp(const void*a, const void*b)
{
	return *(int *)a - *(int *)b;
	//  详情可用msdn查看
	//可以自己写，亦可以自己写
	//下面是int类型数组，所以强制类型转化成整型
	//相似如果是double，那就强制类型转化double
}

void swap(char *p1, char *p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{    //因为不知道是什么类型，size表示需要交换的字符
	    //几个字节，所以强制类型转化成char型，一个字节一个
	    //字节交换
		char tmp = *((char *)p1 + i);
		*((char *)p1 + i) = *((char *)p2 + i);
		*((char *)p2 + i) = tmp;
	}
}

void my_qsort(void *base,size_t  num, size_t width ,int (*p)(const void *,const void* ))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < num; i++)
	{
		for (j = 0; j < num - i-1; j++)
		{   // j*wide是步长， width表示你这个类型所占的
		    // 字节大小  ，因为强制类型转换成int类型
		    //所以都是按字节来算；
			if (cmp((char *)base + j*width, (char *)base + (j + 1)*width)>0)
				swap((char *)base + j*width, (char *)base + (j + 1)*width, width);
		}
	}

}




int main()
{
	int a[10] = { 0 };
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		a[i] = i;
	}
  //调用自己编写的函数，10是元素个数。
	my_qsort(a, 10, sizeof(int), cmp);
	for (i = 0; i < 10; i++)
	{
		printf("%d ", a[i]);  
	}
	system("pause");
	return 0;
}


## 如有不足，请指出........
email ——[email protected]