c語言的快速排序

⑴ c語言快速排序

排序快慢得看你提供了多少數據，因為數據量的不同，選擇最快的方法也不同。

⑵ C語言 快排

快速排序時冒泡排序的該井，基本原理是通過一趟排序將待排記錄分割成兩個部分，其中一部分記錄的關鍵字均比里一部分記錄的關鍵字小，則可對這兩個部分再繼續進行排序，使得整個序列有序。int T(Sqlist&L,int low, int high){L.r[0]=L.r[low];pivotkey=L.r[low].key;while(low<high){while(low<high&&L.r[high].key>=pivotkey) --high;L.r[low]=L.r[high];while(low<high&&L.r[low].key<=pivotkey)++low;L.r[high]=L.r[low];}L.r[low]=L.r[0];return low;} voud Sort(Sqlist,&L,int low, int high){if (low<high){pivotloc =T(L,low,high); Sort(L,low,pivtloc-1) Sort(L,pivtloc+1,high)}}}

⑶ 用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語言，快速排序演算法

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語言中排序方法

1、冒泡排序（最常用）
冒泡排序是最簡單的排序方法：原理是：從左到右，相鄰元素進行比較。每次比較一輪，就會找到序列中最大的一個或最小的一個。這個數就會從序列的最右邊冒出來。（注意每一輪都是從a[0]開始比較的）

以從小到大排序為例，第一輪比較後，所有數中最大的那個數就會浮到最右邊；第二輪比較後，所有數中第二大的那個數就會浮到倒數第二個位置……就這樣一輪一輪地比較，最後實現從小到大排序。

2、雞尾酒排序
雞尾酒排序又稱雙向冒泡排序、雞尾酒攪拌排序、攪拌排序、漣漪排序、來回排序或快樂小時排序, 是冒泡排序的一種變形。該演算法與冒泡排序的不同處在於排序時是以雙向在序列中進行排序。
原理：數組中的數字本是無規律的排放，先找到最小的數字，把他放到第一位，然後找到最大的數字放到最後一位。然後再找到第二小的數字放到第二位，再找到第二大的數字放到倒數第二位。以此類推，直到完成排序。

3、選擇排序
思路是設有10個元素a[1]-a[10]，將a[1]與a[2]-a[10]比較，若a[1]比a[2]-a[10]都小，則不進行交換。若a[2]-a[10]中有一個以上比a[1]小，則將其中最大的一個與a[1]交換，此時a[1]就存放了10個數中最小的一個。同理，第二輪拿a[2]與a[3]-a[10]比較，a[2]存放a[2]-a[10]中最小的數，以此類推。

4、插入排序
插入排序是在一個已經有序的小序列的基礎上，一次插入一個元素*
一般來說，插入排序都採用in-place在數組上實現。
具體演算法描述如下：
⒈ 從第一個元素開始，該元素可以認為已經被排序
⒉ 取出下一個元素，在已經排序的元素序列中從後向前掃描
⒊ 如果該元素（已排序）大於新元素，將該元素移到下一位置
⒋ 重復步驟3，直到找到已排序的元素小於或者等於新元素的位置
⒌ 將新元素插入到下一位置中
⒍ 重復步驟2~5

⑹ c語言怎樣實現快速排序

include<stdio.h>

int arr_num[];
int length;

void quick_sort(int left, int right)
{
int i, j, c, temp;
if(left>right)
return;

i= left;
j= right;
temp = arr_num[i]

while(i != j)
{
while(arr_num[j]>=temp && i<j)
{
j--;
}

while(arr_num[i]<=temp && i<j)
{
i++;
}

if(i<j)
{
c = arr_num[i];
arr_num[i] = arr_num[j];
arr_num[j] = c;
}
}

//left為起始值（參照值）此時的I為第一次排序結束的最後值，與參照值交換位置
arr_num[left] = arr_num[i];
arr_num[i] = temp;

//繼續遞歸直到排序完成
quick_sort(left, i-1);
quick_sort(i+1, right);
}

int main()
{
int i;
length = 7;
arr_num[length] = {23, 7, 17, 36, 3, 61, 49}

//快速排序調用
quick_sort(0, length-1);

//輸出排序後的結果
for(i=1;i<=length;i++)
printf("%d ",arr_num[i]);
getchar();getchar();
return 0;
}

⑺ 求助C語言快速排序

voidQuickSort(intA[],intn,intleft,intright)
{/*快速排序(升序)，n為數組元素個數，left/right為數組左/右邊界*/
	inti,j,t;
	if(left<right){/*一趟快速排序*/
		i=left+1;
		j=right;
		while(1){
			while(i<=right&&A[i]<=A[left])i++;/*向後搜索，降序>*/
			while(j>left&&A[j]>=A[left])j--;/*向前搜索，降序<*/
			if(i>=j||i>right||j<=left)break;
			t=A[i],A[i]=A[j],A[j]=t;/*交換*/
		}
		t=A[left];
		A[left]=A[j];
		A[j]=t;/*交換*/
		QuickSort(A,n,left,j-1);/*左半部分遞歸*/
		QuickSort(A,n,j+1,right);/*右半部份遞歸*/
	}
}

⑻ c語言編寫快速排序

int partition(int n[],int left,int right)
//int類型的方法，傳入參數(int類型的 數組n，int類型的參數left和right)
{
int lo,hi,pivot,t;//定義int類型的變數

pivot=n[left];//給變數pivot賦值，值為數組n中第left個數字
lo=left-1;//給lo賦值，這是n[left]前一位數字
hi=right+1;//給hi賦值，這是這是n[left]後一位數字

while(lo+1!=hi) {//循環，條件：lo+1不等於hi，意思就是判斷是否到數組的邊界了
if(n[lo+1]<=pivot)//判斷，如果n[lo+1]<=pivot
lo++;//則lo=lo+1
else if(n[hi-1]>pivot)//再如果n[hi-1]>pivot
hi--;//則hi=hi-1
else {//否則執行下面的語句
//這里就是一個冒泡法，不清楚的自己去查
t=n[lo+1];//給t賦值
n[++lo]=n[hi-1];//++在前面的意思是，lo先加1再代入n[]中使用
n[--hi]=t;//先減一
}
}

n[left]=n[lo];
n[lo]=pivot;
return lo;
}

⑼ C語言的快速排序的演算法是什麼啊

快速排序（Quicksort）是對冒泡排序的一種改進。由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。 演算法過程設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。值得注意的是，快速排序不是一種穩定的排序演算法，也就是說，多個相同的值的相對位置也許會在演算法結束時產生變動。 一趟快速排序的演算法是： 1）設置兩個變數I、J，排序開始的時候：I=0，J=N-1； 2）以第一個數組元素作為關鍵數據，賦值給key，即 key=A[0]； 3）從J開始向前搜索，即由後開始向前搜索（J=J-1），找到第一個小於key的值A[J]，並與key交換； 4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於key的A[I]，與key交換； 5）重復第3、4、5步，直到 I=J； (3,4步是在程序中沒找到時候j=j-1，i=i+1，直至找到為止。找到並交換的時候i， j指針位置不變。另外當i=j這過程一定正好是i+或j-完成的最後另循環結束。) 例如：待排序的數組A的值分別是：（初始關鍵數據：X=49） 注意關鍵X永遠不變，永遠是和X進行比較，無論在什麼位子，最後的目的就是把X放在中間，小的放前面大的放後面。 A[0] A[1] A[2] A[3] A[4] A[5] A[6]： 49 38 65 97 76 13 27 進行第一次交換後：27 38 65 97 76 13 49 ( 按照演算法的第三步從後面開始找) 進行第二次交換後：27 38 49 97 76 13 65 ( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時：I=3 ) 進行第三次交換後：27 38 13 97 76 49 65 ( 按照演算法的第五步將又一次執行演算法的第三步從後開始找 進行第四次交換後：27 38 13 49 76 97 65 ( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時：I=4,J=6 ) 此時再執行第三步的時候就發現I=J，從而結束一趟快速排序，那麼經過一趟快速排序之後的結果是：27 38 13 49 76 97 65，即所有大於49的數全部在49的後面，所有小於49的數全部在49的前面。 快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示： 初始狀態 {49 38 65 97 76 13 27} 進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65} 分別對前後兩部分進行快速排序 {27 38 13} 經第三步和第四步交換後變成 {13 27 38} 完成排序。 {76 97 65} 經第三步和第四步交換後變成 {65 76 97} 完成排序。

⑽ C語言快速排序代碼

採用快速排序，用遞歸實現
#include <stdio.h>
#define N 10 //定義排序數組元素個數
int Qsort(int start,int length,int a[])//start排序的起始，length是要排序序列長度
{
int x = a[start];
int i,j;
i = start;
j = length -1;
while(i < j)
{
if(x < a[j])
j--;
else if(x > a[j])
{
a[i] = a[j];
a[j] = x;
i++;
}
else if(x < a[i])
{
a[j] = a[i];
a[i] = x;
j--;
}
else
i++;
}
if(start < length-1)
{
Qsort(start,i,a);
Qsort(i+1,length,a);
}
}

void main()
{
int a[N] = {0};
int i;
for(i = 0;i < N;i++)
scanf("%d",&a[i]);
Qsort(0,N,a);
for(i = 0;i < N;i++)
printf("%d ",a[i]);
}
程序執行時輸入N個數，對這N個數進行排序，可以預設N的長度