c语言快排函数

⑴ 用c语言编程实现快速排序算法

给个快速排序你参考参考

/**********************快速排序****************************
基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录），
		以该记录为基准，将当前的无序区划分为左右两个较小的无
		序子区，使左边的记录均小于基准值，右边的记录均大于或
		等于基准值，基准值位于两个无序区的中间位置（即该记录
		最终的排序位置）。之后，分别对两个无序区进行上述的划
		分过程，直到无序区所有记录都排序完毕。
*************************************************************/

/*************************************************************
函数名称：staticvoidswap(int*a,int*b)
参数：int*a---整型指针
		int*b---整型指针
功能：交换两个整数的位置
返回值：无
说明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
staticvoidswap(int*a,int*b)
{
inttemp=*a;
*a=*b;
*b=temp;
}

intquickSortNum=0;//快速排序算法所需的趟数
/*************************************************************
函数名称：staticintpartition(inta[],intlow,inthigh)
参数：inta[]---待排序的数据
		intlow---无序区的下限值
		inthigh---无序区的上限值
功能：完成一趟快速排序
返回值：基准值的最终排序位置
说明：static关键字指明了该函数只能在本文件中使用
**************************************************************/
staticintpartition(inta[],intlow,inthigh)
{
intprivotKey=a[low];//基准元素
while(low<high)
	{//从表的两端交替地向中间扫描
while(low<high&&a[high]>=privotKey)//找到第一个小于privotKey的值
			high--;//从high所指位置向前搜索，至多到low+1位置
swap(&a[low],&a[high]);//将比基准元素小的交换到低端

while(low<high&&a[low]<=privotKey)//找到第一个大于privotKey的值
			low++;//从low所指位置向后搜索，至多到high-1位置
swap(&a[low],&a[high]);//将比基准元素大的交换到高端
}
	quickSortNum++;//快速排序趟数加1
	returnlow;//返回基准值所在的位置
}

/*************************************************************
函数名称：voidQuickSort(inta[],intlow,inthigh)
参数：inta[]---待排序的数据
		intlow---无序区的下限值
		inthigh---无序区的上限值
功能：完成快速排序算法，并将排序完成的数据存放在数组a中
返回值：无
说明：使用递归方式完成
**************************************************************/
voidQuickSort(inta[],intlow,inthigh)
{
if(low<high)
	{
intprivotLoc=partition(a,low,high);//将表一分为二
QuickSort(a,low,privotLoc-1);//递归对低子表递归排序
QuickSort(a,privotLoc+1,high);//递归对高子表递归排序
}	
}

⑵ 快排 C语言 原理

快排即qsort,包含在stdlib.h头文件里,函数一共四个参数,没返回值.一个典型的qsort的写法如下：qsort(s,n,sizeof(s[0]),cmp);
其中第一个参数是参与排序的数组名;
第二个参数是参与排序的元素个数; 第三个三数是
单个元素的大小,推荐使用sizeof(数组名)这样的表达式,下面也有说明 :)
;第四个参数就是
比较函数。
典型的cmp的定义是
int
cmp(const void *a,const void *b);
返回值必须是int,两个参数的类型必须都是const void
*.
假设是对int排序的话,如果是升序,那么就是如果a比b大返回一个正值,小则负值,相等返回
0,其他的依次类推,下面给出简单例子：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
ints[10000],n,i;
intcmp(constvoid*a,constvoid*b)
{
return(*(int*)a-*(int*)b);
}
intmain()
{
scanf("%d",&n);
for(i=0;i<n;i++);
scanf("%d",&s[i]);
qsort(s,n,sizeof(s[0]),cmp);
for(i=0;i<n;i++)printf("%d",s[i]);
return(0);
}

⑶ C语言快速排序函数怎么调用

你可以看看这个例子：
#include <stdio.h>
#include <stdlib.h>

int list[5] = {7,5,9,2,6};
int sort_function( const void *a, const void *b);

int main(void)
{
int x;
qsort((void *)list, 5, sizeof(int), sort_function);
for (x = 0; x < 5; x++)
printf("%d\\n", list[x]);
return 0;
}

int sort_function( const void *a, const void *b)
{
if(*(int*)a>*(int*)b)
return 1;
else if(*(int*)a<*(int*)b)
return -1;
else
return 0;
}

⑷ 用C语言编写函数实现快速排序（升序），在主函数中输入数组数据,并调用该数得到排序结果。

//希望对楼主有小小的帮助。。。
//排序的算法是二分法，N的对数时间复杂度。。。
//如果有疑问，我们可以再探讨。。。
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
bool merge(int * array,int p,int q,int r)
{
if(!(p<<q<r)&&p>=0&&r<=sizeof(array)/sizeof(array[0])-1)
{
return false;
}
int * left =new int[q-p+1];
int * right=new int[r-q];
memcpy(left,array+p,sizeof(int)/sizeof(char)*(q-p+1));
memcpy(right,array+q+1,sizeof(int)/sizeof(char)*(r-q));
int left_index=0,right_index=0,left_max_index,right_max_index;
left_max_index=q-p+1;
right_max_index=r-q;
for(int k=p;k<=r&&left_index<left_max_index&&right_index<right_max_index;++k)
{
if(left[left_index]<=right[right_index])
{
array[k]=left[left_index];
++left_index;
}
else
{
array[k]=right[right_index];
++right_index;
}
}
if(left_index==left_max_index)
{
for(;k<=r&&right_index<right_max_index;++k,++right_index)
{
array[k]=right[right_index];
}
}
else if(right_index==right_max_index)
{
for(;k<=r&&left_index<left_max_index;++k,++left_index)
{
array[k]=left[left_index];
}
}
delete left;
delete right;
return true;
}
void merge_sort(int * array,int p,int r)
{
if(p<r)
{
int q=(r+p)/2;
merge_sort(array,p,q);
merge_sort(array,q+1,r);
merge(array,p,q,r);
}
}
void main()
{
int size,index,* array;
//printf("请输入元素个数:");
scanf("%d",&size);
array=(int*)malloc(size*sizeof(int));
for(index=0;index<size;index++)
{
//printf("请输入第%d元素:",index+1);
scanf("%d",&array[index]);
}
merge_sort(array,0,size-1);
for(index=0;index<size;index++)
{
printf("%d ",array[index]);
}
printf("\n");

}

⑸ 用c语言编写函数QuickSort（）来实现快速排序

#include<stdlib.h>
#include<stdio.h>
#defineMAXN8
#defineMOD1024
voidQuickSort(int*arr,intlow,inthigh)
{
if(low>=high)return;
//保存排序区间的起始位置和终点位置
intleft=low,right=high;
//默认左边第一个元素为标志
intkey=arr[low];
while(low<high)
{
while(low<high&&arr[high]<=key)--high;
arr[low]=arr[high];
while(low<high&&arr[low]>=key)++low;
arr[high]=arr[low];
}
arr[low]=key;
//每次排序后都分成两部分[left,low)(low,right]
//arr[low]的位置是一定是有序的
QuickSort(arr,left,low-1);
QuickSort(arr,low+1,right);
return;
}
intmain(void)
{
intn;
scanf("%d",&n);

intarr[MAXN]={0};
inti;
for(i=0;i<n;++i)
scanf("%d",&arr[i]);

//输入是默认为生活中习惯的数组左边第一个为：编号1
ints,m;
scanf("%d%d",&s,&m);
//转成计算机数组第一个为：编号0
s--;m--;
//快排
QuickSort(arr,s,m);
//输出
for(i=s;i<=m;++i)
{
printf("%d",arr[i]);
}
return0;
}
//测试数据
//8
//12345678
//26

输出 6 5 4 3 2

⑹ C语言字符串快速排序函数

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedefcharstrLINE[2000];
intstrCMP(constvoid*a,constvoid*b)
{
	returnstrcmp((constchar*)a,(constchar*)b);
}
intmain(intargc,char*argv[])
{
	strLINE*p;
	inti,n;
	scanf("%d",&n);
	p=malloc(sizeof(strLINE)*n);
	for(i=0;i<n;i++)scanf("%s",p[i]);

	qsort(p,n,sizeof(strLINE),strCMP);

	for(i=0;i<n;i++)printf("%s
",p[i]);

	free(p);
	return0;
}

⑺ C语言，结构体快排

自定义一个比较函数，直接调用快排库函数qsort即可。举例如下：

//#include"stdafx.h"//Ifthevc++6.0,withthisline.
#include"stdio.h"
#include"stdlib.h"
#include"time.h"
structln{
intdata,score,math;
}ss[100];
intmycmp(constvoid*a,constvoid*b){//自定义比较函数
return((structln*)a)->data-((structln*)b)->data;//若要降序,-号前后变量交换
}//data改为score或math就可按相应要素排序
intmain(void){//测试一下……
inti;
srand((unsigned)time(NULL));
for(i=0;i<100;ss[i++].data=rand()%1000);
qsort(ss,100,sizeof(structln),mycmp);
for(i=0;i<100;printf("%4d",ss[i++].data));
printf("
");
return0;
}

⑻ 如何利用C语言中的qsort库函数实现快速排序

声明一个字符串指针数组存放每个字符串的首地址，调用库函数qusort按题目要求对字符串指针排序，不移动源字符串。关键是要设计一个好的比较函数，精巧地解决“按长度、长度相等时按大小”排序的问题。举例代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

//#include "stdafx.h"//If the <a href="https://www..com/s?wd=vc%2B%2B6.0&tn=44039180_cpr&fenlei=-bmH-y-bIi4WUvYETgN-TLwGUv3En1czrjDLn10v" target="_blank" class="-highlight">vc++6.0</a>, with this line.
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#define N 10 //字符串个数
#define LN 21 //限制字符串长度为20
int mycmp(const void *a,const void *b){//比较函数
char *pa=*(char **)a,*pb=*(char **)b;
int x=int(strlen(pa)-strlen(pb));//依长度比较
return x ? x : strcmp(pa,pb);//长度相等时依大小比较
}
int main(void){
int i=0,j=0;
char *f[N],w[LN*N];//声明<a href="https://www..com/s?wd=%E6%8C%87%E9%92%88%E6%95%B0%E7%BB%84&tn=44039180_cpr&fenlei=-bmH-y-bIi4WUvYETgN-TLwGUv3En1czrjDLn10v" target="_blank" class="-highlight">指针数组</a>f和字符串总空间
printf("Input %d string(s)(length<=%d)...\n",N,LN);
while(i<N){//输入并将字符串首址赋给f[i]
if(scanf(" %[1234567890]",f[i]=w+j)>0 && strlen(f[i])<LN)
i++,j+=LN;
else printf("Error, redo: Required length less than %d:",LN);
}
qsort(f,N,sizeof(char *),mycmp);//调用<a href="https://www..com/s?wd=%E5%BA%93%E5%87%BD%E6%95%B0&tn=44039180_cpr&fenlei=-bmH-y-bIi4WUvYETgN-TLwGUv3En1czrjDLn10v" target="_blank" class="-highlight">库函数</a>对字符串指针排序
for(i=0;i<N;printf("%s\n",f[i++]));//输出...
return 0;
}

⑼ C语言，快速排序算法

0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。
其中关键值key=a[low]。
用题目给定的数组模拟第一趟排序如下：
下标0123456789
值91647824661232551
low=0high=9
part_element=a[low]=9
进入for循环
进入第一个while
part_element<51，于是high--,high=8;
part_element<25，high--,high=7;
part_element>3,不满足，结束while
a[low]=a[0]=a[high]=a[7]=3,low++,low=1;
进入第二个while
part_element<16,不满足，结束while
a[high]=a[7]=a[low]=a[1]=16,high--,high=6
for第一个循环结束，数组如下
316478246612162551
low=1,high=6
for第二个循环同上，结束时数组如下
344782476612162551
low=2,high=3
for第三个循环，第一个while中high--以后，low==high，直接break跳出for循环，此时
344782476612162551
low=2,high=2
结束for以后
a[high]=a[2]=part_element=9,得到
34982476612162551
split函数returnhigh=2

quicksort函数中middle=2;
下面两句递归，仍然是调用split函数，对数组
0-2,3-9两部分分别重复上述操作

最后直到数组数据有序

⑽ C语言 快排函数

函数kuaipai1 进入了无限死循环。
递归函数没有一个节点判定递归结束，导致进入死循环
系统堆栈用完，程序崩溃。
程序调试报告有无限死循环危险，运行后就直接崩溃，导致栈溢出。