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 進入了無限死循環。
遞歸函數沒有一個節點判定遞歸結束，導致進入死循環
系統堆棧用完，程序崩潰。
程序調試報告有無限死循環危險，運行後就直接崩潰，導致棧溢出。