① c語言快速排序 誰能給我講講下面的代碼啥意思
設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用數組的第一個數）作為關鍵數據，
然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。
值得注意的是，快速排序不是一種穩定的排序演算法，也就是說，
多個相同的值的相對位置也許會在演算法結束時產生變動。
一趟快速排序的演算法是：
1）設置兩個變數i、j，排序開始的時候：i=0，j=N-1；
2）以第一個數組元素作為關鍵數據，賦值給key，即key=A[0]；
3）從j開始向前搜索，即由後開始向前搜索(j--)，找到第一個小於key的值A[j]，將A[j]和A[i]互換；
4）從i開始向後搜索，即由前開始向後搜索(i++)，找到第一個大於key的A[i]，將A[i]和A[j]互換；
5）重復第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,
4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。
找到符合條件的值，進行交換的時候i， j指針位置不變。
另外，i==j這一過程一定正好是i+或j-完成的時候，此時令循環結束）。
② c語言三種排序
常用的c語言排序演算法主要有三種即冒泡法排序、選擇法排序、插入法排序。
一、冒泡排序冒泡排序：
是從第一個數開始，依次往後比較，在滿足判斷條件下進行交換。代碼實現（以降序排序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp;
for (int i = 0; i < 10; i++)
{//循環次數
for (int j = 0; j <10 - i-1; j++)
{
if (array[j] < array[j+1])
{//前面一個數比後面的數大時發生交換 temp = array[j];
array[j] = array[j+1];
array[j + 1] = temp;
}
}
} //列印數組 for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}
二、選擇排序以升序排序為例：
就是在指定下標的數組元素往後（指定下標的元素往往是從第一個元素開始，然後依次往後），找出除指定下標元素外的值與指定元素進行對比，滿足條件就進行交換。與冒泡排序的區別可以理解為冒泡排序是相鄰的兩個值對比，而選擇排序是遍歷數組，找出數組元素與指定的數組元素進行對比。（以升序為例）
#include<stdio.h>
int main()
{
int array[10] = { 6,9,7,8,5,3,4,0,1,2 };
int temp, index;
for (int i = 0; i < 9; i++) {
index = i;
for (int j = i; j < 10; j++)
{
if (array[j] < array[index])
index = j;
}
if(i != index)
{
temp = array[i];
array[i] = array[index];
array[index] = temp;
}
for(int i=0;i<10:i++)
printf("%2d"array[i]）
return 0；
}
三、快速排序
是通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
void QuickSort(int* arr, int size)
{
int temp, i, j;
for(i = 1; i <size; i++)
for(j=i; j>0; j--)
{
if(arr[j] <arr[j-1])
{
temp = arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
③ 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語言快速排序的代碼
首先我贊成你直接要代碼的這種方法。
從你這個提問可以看出你對常用的排序演算法都接觸過，並且都沒搞懂到底是怎麼回事。
現在的電子平台資源都很豐富了，硬體平台的運行速度可以做到很高了，在大多數的情況下可以考慮用空間換時間的方法，也就是說你應該先搞懂演算法的本質，然後再自己去實現它，開始的時候可以不考慮時間上的損耗。
排序的本質就是兩個數比較大小，並根據其大小將其放到相應的位置。
記住其本質是什麼，你自己絕對可以使用相應的語言實現它。
⑤ 用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語言快速排序代碼
採用快速排序，用遞歸實現
#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的長度
⑦ C語言快速排序代碼
#include <stdio.h>
int partions(int l[],int low,int high)
{
int prvotkey=l[low];
l[0]=l[low];
while (low<high)
{
while (low<high&&l[high]>=prvotkey)
--high;
l[low]=l[high];
while (low<high&&l[low]<=prvotkey)
++low;
l[high]=l[low];
}
l[low]=l[0];
return low;
}
void qsort(int l[],int low,int high)
{
int prvotloc;
if(low<high)
{
prvotloc=partions(l,low,high); //將第一次排序的結果作為樞軸
qsort(l,low,prvotloc-1); //遞歸調用排序 由low 到prvotloc-1
qsort(l,prvotloc+1,high); //遞歸調用排序 由 prvotloc+1到 high
}
}
void quicksort(int l[],int n)
{
qsort(l,1,n); //第一個作為樞軸 ，從第一個排到第n個
}
void main()
{
int a[11]={0,2,32,43,23,45,36,57,14,27,39};
for (int b=1;b<11;b++)
printf("%3d",a[b]);
printf("\n");
quicksort(a,11);
for(int c=1;c<11;c++)
printf("%3d",a[c]);
}
⑧ 請編寫程序使用快速排序演算法對數組中的數據進行降序排序。
這是使用快速排序演算法對數組中的數據進行降序排序的代碼，每次運行隨機生成 10 個數，C 語言遞歸實現。
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
voidswap(int*x,int*y){
intt=*x;
*x=*y;
*y=t;
}
voidquick_sort_recursive(intarr[],intstart,intend){
if(start>=end)
return;
intmid=arr[end];
intleft=start,right=end-1;
while(left<right){
while(arr[left]>mid&&left<right)
left++;
while(arr[right]<=mid&&left<right)
right--;
swap(&arr[left],&arr[right]);
}
if(arr[left]<=arr[end])
swap(&arr[left],&arr[end]);
else
left++;
if(left){
quick_sort_recursive(arr,start,left-1);
}
quick_sort_recursive(arr,left+1,end);
}
voidquick_sort(intarr[],intlen){
quick_sort_recursive(arr,0,len-1);
}
intmain(){
intarr[10],i;
srand(time(NULL));
for(i=0;i<10;i++)
arr[i]=rand();
quick_sort(arr,10);
for(i=0;i<10;i++)
printf("%d",arr[i]);
}
⑨ C語言快速排序演算法問題，下面是我寫的程序，最後出來的全是第一個數，求大神解答。
intmain()
{
RecordNodea;
SortObject*pvector;
inti,k[8],l,r;
printf("pleaseinputnumbers: ");
pvector=createNullList(8);
if(pvector!=NULL)
{
for(i=0;i<8;i++)
{
scanf("%d",&k[i]);
a.info=k[i];
a.key=k[i];
insertPre(pvector,i,a);
}
l=k[0];
r=k[7];
}
quickSort(pvector,0,7);//錯誤1
for(i=0;i<8;i++)
{
a=pvector->record[i];//錯誤2
printf("%d",a.key);
}
return0;//解決請採納
}
⑩ 用C語言編寫函數，要實現快速排序演算法或者冒泡法
冒泡法排序函數如下：
void bubble(int a[],int n)
{int i,j,t;
for(i=0;i<n-1;i++)/*共進行n-1輪*/
for(j=0;j<n-1-i;j++)/*每輪在前n-i個數中比較*/
if(a[j]>a[j+1]) /*若相鄰元素逆序*/
{t=a[j]; a[j]=a[j+1];a[j+1]=t;}/*就交換*/
}
void sort(int *a, int left, int right)
{
if(left >= right)/*如果左邊索引大於或者等於右邊的索引就代表已經整理完成一個組了*/
{
return ;
}
int i = left;
int j = right;
int key = a[left];
while(i < j) /*控制在當組內尋找一遍*/
{
while(i < j && key <= a[j])
/*而尋找結束的條件就是，1，找到一個小於或者大於key的數（大於或小於取決於你想升
序還是降序）2，沒有符合條件1的，並且i與j的大小沒有反轉*/
{
j--;/*向前尋找*/
}
a[i] = a[j];
/*找到一個這樣的數後就把它賦給前面的被拿走的i的值（如果第一次循環且key是
a[left]，那麼就是給key）*/
while(i < j && key >= a[i])
/*這是i在當組內向前尋找，同上，不過注意與key的大小關系停止循環和上面相反，
因為排序思想是把數往兩邊扔，所以左右兩邊的數大小與key的關系相反*/
{
i++;
}
a[j] = a[i];
}
a[i] = key;/*當在當組內找完一遍以後就把中間數key回歸*/
sort(a, left, i - 1);/*最後用同樣的方式對分出來的左邊的小組進行同上的做法*/
sort(a, i + 1, right);/*用同樣的方式對分出來的右邊的小組進行同上的做法*/
/*當然最後可能會出現很多分左右，直到每一組的i = j 為止*/
}