基本原理 從序列中任選一個數作為“基準”；所有小于“基準”的數，都挪到“基準”的左邊；所有大于等于“基準”的數，都挪到“基準”的右邊。 在這次移動結束之后，該“基準”就處于兩個序列的中間位置，不再參與后續的排序；針對“基準”左邊和右邊的兩個子

其實快速排序算法也可以理解為相鄰兩個比大小，然后換位置。將兩個指針i，j分別指向表的起始和最后的位置。

假設用戶輸入了如下數組： 下標 0 1 2 3 4 5 數據 6 2 7 3 8 9 創建變量i=0（指向第一個數據）, j=5(指向最后一個數據), k=6(賦值為第一個數據的值)。我們要把所有比k小的數移動到k的左面，所以我們可以開始尋找比6小的數，從j開始，從右往左找

反復操作以下兩步：

一、冒泡排序法待排序的數據source=>6,2,8,4,0,9,3,5,1,7排序后的數據sort=>0,1,2,3,4,5,6,7,8,9二、選擇排序法待排序的數據：source=>12,54,65,2,3,40,91,7,321,50排序后的數據：sort=>02,3,7,12,40,50,54,65,91,321三、Shell排序法待排序的數

（1）j逐漸減小，并逐次比較j指向的元素和目標元素的大小，若p(j)<T則交換位置。

時間復雜度為O(nlogn) n為元素個數 1. 快速排序的三個步驟： 1.1. 找到序列中用于劃分序列的元素 1.2. 用元素劃分序列 1.3. 對劃分后的兩個序列重復1,2兩個步驟指導序列無法再劃分 所以對于n個元素其排序時間為 T(n) = 2*T(n/2) + n （表示將長

（2）i逐漸增大，并逐次比較i指向的元素和目標元素的大小，若p(i)>T則交換位置。

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace test{ class QuickSort { static void Main(string[] args) { int[] array = { 49, 38, 65, 97, 76, 13, 27 }; sort(array, 0, array.Lengt

直到i，j指向同一個值，循環結束。

C語言程序： /* 快 速 排 序 */ #include "stdio.h" void QuickSort(int e[], int first, int end) { int i=first,j=end,temp=e[first]; while(i

方法

首先設置兩個變量i，j。

設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用數組的第一個數）作為關鍵數據，然后將所有比它小的數都放到它前面，所有比它大的數都放到它后面，這個過程稱為一趟快速排序。值得注意的是，快速排序不是一種穩定的排序算法，也

分別指向（代表）序列的首尾元素。

首先它是一種排序算法，排序算法是為了讓無序的數據組合變成有序的數據組合。 有序的數據組合最大的優勢是在于當你進行數據定位和采用時， 會非常方便，因為這個數據是有序的 從而在代碼設計的時候會讓你避免很多不必要的麻煩， 因為無序數據你

就是以第一個元素為基準，從小到大進行排列。

http://v.youku.com/v_show/id_XMjk2NzI4OTky.html 排序算法演示, 相信你再也找不到比這個還好的動畫演示了.

讓j從后向前進行查詢，直到找到第一個小于66的元素。

1、“快速排序法”使用的是遞歸原理，下面一個例子來說明“快速排序法”的原理。首先給出一個數組{53，12，98，63，18，72，80，46， 32，21}，先找到第一個數--53，把它作為中間值，也就是說，要把53放在一個位置，使得它左邊的值比它小，右邊的值

則將最后一個j指向的數23，和i指向的66交換位置。

0和N-1表示的是數組下標。快排每一趟排序的目的是使值比設定的key值小的數都排到數組前部分，大的都排到后部分；然后對這兩部分用新的關鍵值key分別重復上一步的操作；遞歸，直到數組有序。其中關鍵值key=a[low]。用題目給定的數組模擬第一趟排

然后將i從前向后查詢，直到找到第一個大于66的元素76.

給個快速排序你參考參考 /********************** 快速排序 ****************************基本思想：在待排序的n個記錄中任取一個記錄（通常取第一個記錄）， 以該記錄為基準，將當前的無序區劃分為左右兩個較小的無 序子區，使左邊的記錄均小于

將76和66位置互換。

快速排序的分割宗旨就是 1.在待排序序列中選定一個值 pivot 2.通過一輪快排，將小于pivot的值丟到其左邊，大于pivot的值丟到其右邊 3.以pivot為界，分割該序列，遞歸調用快排算法 int Partition ( SortData V[ ], int low, int high ) { int piv

讓j從后向前進行查詢，直到找到第一個小于66的元素57

#include using std::cout; using std::endl; int Partition( int *R, int low, int high){ // 對記錄子序列 R[low..high] 進行一趟快速排序，并返回樞軸記錄 // 所在位置，使得在它之前的記錄的關鍵字均不大于它的關鍵字， // 而在它之后的記錄

將57和66交換位置。

最壞情況下，是整個序列都已經有序或完全倒序 此時，快速排序退化為冒泡排序，要比較n2次才能完成

然后將i從前向后查詢，直到找到第一個大于66的元素81.

/* php中的快速排序，并且倒序輸出 */ function quickSort($array) { if(!isset($array[1])) return $array; $mid = $array[0]; //獲取一個用于分割的關鍵字，一般是首個元素 $leftArray = array(); $rightArray = array(); foreach($array as $

將81和66交換位置。

這不是一樣的嗎？ 遞歸也是一樣的輸出哦。 在do{}while()；之后循環把數組的打印出來不就行了。 for(int mm =low; mm

讓j從后向前進行查詢，直到找到第一個小于66的元素26

先說一下快速排序中最好的排序情況，最好的情況下，每次進行一次分區，我們會把一個序列剛好分為幾近相等的兩個子序列，這個情況也每次遞歸調用的是時候也就剛好處理一半大小的子序列。這看起來其實就是一個完全二叉樹，樹的深度為 O(logn)，所

將26和66交換位置。

打你，這么簡單的問題都不認真研究一下。 冒泡排序是最慢的排序，時間復雜度是 O(n^2)。 快速排序是最快的排序。關于快速排序，我推薦你看看《代碼之美》第二章：我編寫過的最漂亮的代碼。作者所說的最漂亮，就是指效率最高的。 -----------

此時i，j都同時指向了目標元素66.

快速排序法”使用的是遞歸原理，下面我結合一個例子來說明“快速排序法”的原理。首先給出一個數組{53，12，98，63，18，72，80，46， 32，21}，先找到第一個數--53，把它作為中間值，也就是說，要把53放在一個位置，使得它左邊的值比它小，右邊的

查找停止。

所得到的序列就是第一趟排序的序列

#include int partions(int l[],int low,int high) { int prvotkey=l[low]; l[0]=l[low]; while (low

擴展閱讀，以下內容您可能還感興趣。

用C語言編寫一個快速排序算法 輸入10個數

1、“快速排序法”使用的是遞歸原理，下面一個例子來說明“快速排序法”的原理。首先給出一個數組{53，12，98，63，18，72，80，46， 32，21}，先找到第一個數--53，把它作為中間值，也就是說，要把53放在一個位置，使得它左邊的值比它小，右邊的值比它大。{21，12，32， 46，18，53，80，72，63，98}，這樣一個數組的排序就變成了兩個小數組的排序--53左邊的數組和53右邊的數組，而這兩個數組繼續用同樣的方式繼續下去，一直到順序完全正確。一般來說，冒泡法是程序員最先接觸的排序方法，它的優點是原理簡單，編程實現容易，但它的缺點就是速度太慢。

2、快速排序代碼：#include<stdio.h>

void quicksort(int a[],int left,int right)

{

    int i,j,temp;

    i=left;

    j=right;

    temp=a[left];

    if(left>right)

        return;

    while(i!=j)

    {

        while(a[j]>=temp&&j>i)

            j--;

        if(j>i)

            a[i++]=a[j];

        while(a[i]<=temp&&j>i)

            i++;

        if(j>i)

            a[j--]=a[i];

    }

    a[i]=temp;

    quicksort(a,left,i-1);

    quicksort(a,i+1,right);

}

void main()

{

    int a[]={53,12,98,63,18,72,80,46,32,21};

    int i;

    quicksort(a,0,9);

    /*排好序的結果*/

    for(i=0;i<10;i++)

        printf("%4dn",a[i]);

}

C語言，快速排序算法

0和N-1表示的是數組下標。快排每一趟排序的目的是使值比設定的key值小的數都排到數組前部分，大的都排到后部分；然后對這兩部分用新的關鍵值key分別重復上一步的操作；遞歸，直到數組有序。

其中關鍵值key=a[low]。

用題目給定的數組模擬第一趟排序如下：

下標    0    1    2    3    4    5    6    7    8    9

值      9    16   47   82   4    66   12   3    25   51

low=0 high=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第一個循環結束，數組如下

3    16    47    82    4    66    12    16    25    51

low=1,high=6

for第二個循環同上，結束時數組如下

3    4    47    82    47    66    12    16    25    51

low=2,high=3

for第三個循環，第一個while中high--以后，low==high，直接break跳出for循環，此時

3    4    47    82    47    66    12    16    25    51

low=2,high=2

結束for以后

a[high]=a[2]=part_element=9,得到

3    4    9    82    47    66    12    16    25    51

split函數return high=2

quicksort函數中middle=2;

下面兩句遞歸，仍然是調用split函數，對數組

0-2,3-9兩部分分別重復上述操作

最后直到數組數據有序

用C語言編程實現快速排序算法

給個快速排序你參考參考

基本思想：在待排序的n個記錄中任取一個記錄（通常取第一個記錄），

  以該記錄為基準，將當前的無序區劃分為左右兩個較小的無

  序子區，使左邊的記錄均小于基準值，右邊的記錄均大于或

  等于基準值，基準值位于兩個無序區的中間位置（即該記錄

  最終的排序位置）。之后，分別對兩個無序區進行上述的劃

  分過程，直到無序區所有記錄都排序完畢。

*************************************************************/

/*************************************************************

函數名稱：static void swap(int *a, int *b)

參    數：int *a---整型指針

  int *b---整型指針

功    能：交換兩個整數的位置

返 回 值：無

說    明：static關鍵字指明了該函數只能在本文件中使用

**************************************************************/

static void swap(int *a, int *b)

{  

    int temp = *a;

    *a = *b;

    *b = temp;

}

int quickSortNum = 0; // 快速排序算法所需的趟數

/*************************************************************

函數名稱：static int partition(int a[], int low, int high)

參    數：int a[]---待排序的數據

  int low---無序區的下限值

  int high---無序區的上限值

功    能：完成一趟快速排序

返 回 值：基準值的最終排序位置

說    明：static關鍵字指明了該函數只能在本文件中使用

**************************************************************/

static int partition(int a[], int low, int high)

{

    int privotKey = 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

return low;  // 返回基準值所在的位置

}  

/*************************************************************

函數名稱：void QuickSort(int a[], int low, int high)

參    數：int a[]---待排序的數據

  int low---無序區的下限值

  int high---無序區的上限值

功    能：完成快速排序算法，并將排序完成的數據存放在數組a中

返 回 值：無

說    明：使用遞歸方式完成

**************************************************************/

void QuickSort(int a[], int low, int high)

{  

    if(low < high)

{

        int privotLoc = partition(a, low, high); // 將表一分為二  

        QuickSort(a, low, privotLoc-1);          // 遞歸對低子表遞歸排序  

        QuickSort(a, privotLoc+1, high);         // 遞歸對高子表遞歸排序  

    }

}

誰能仔細說說這段快速排序算法分割怎么回事

快速排序的分割宗旨就是

1.在待排序序列中選定一個值 pivot

2.通過一輪快排，將小于pivot的值丟到其左邊，大于pivot的值丟到其右邊

3.以pivot為界，分割該序列，遞歸調用快排算法

int Partition ( SortData V[ ], int low, int high ) {

int pivotpos = low; //選擇待排序序列的第一個數值為piovt

SortData pivot = V[low]; //得出pivot的值，存在SortData變量中

for ( int i = low+1; i <= high; i++ ) //開始循環

if ( V[i] < pivot ) { //如果遇到小于pivot的值，說明pivot的位置應該后移一位，因為已經找到一個比他小的了

pivotpos++; //pivot位置后移

if ( pivotpos != i )

Swap ( V[pivotpos], V[i] ); //交換兩個值

}

Swap ( V[low], V[pivotpos] ); //交換兩個值

return pivotpos; //完成排序，pivot前面都比他小，后面都比他大

}

如果你對于那兩個交換是如何保證小的在前面，大的在后面有疑問的話

冷靜下來手工操作一遍就明白了

如何理解快速排序算法的思想？

#include <iostream>

using std::cout;

using std::endl;

int Partition( int *R, int low, int high){

// 對記錄子序列 R[low..high] 進行一趟快速排序，并返回樞軸記錄

// 所在位置，使得在它之前的記錄的關鍵字均不大于它的關鍵字，

// 而在它之后的記錄的關鍵字均不小于它的關鍵字

R[0] = R[low]; // 將樞軸記錄移至數組的閑置分量

int pivotkey = R[low]; // 樞軸記錄關鍵字

cout << endl << "pivotkey : " << pivotkey << endl;

while(low < high){ // 從表的兩端交替地向中間掃描

while( low<high && R[high]>=pivotkey ){

--high;

}

if(low < high){//需要進行這樣的判斷，如果是由于low>=high而退出的循環，不需要移動數據

R[low++] = R[high]; // 將比樞軸記錄小的記錄移到低端

//cout << "移動的hign數據：" << R[high] << endl;

}

while (low<high && R[low]<=pivotkey )

++low;

if(low < high){

R[high--] = R[low]; // 將比樞軸記錄大的記錄移到高端

//cout << "移動的low數據：" << R[low] << endl;

}

} // while

R[low] = R[0]; // 樞軸記錄移到正確位置

//cout << "返回的pivotkey: " << low << endl;

for(int i = 1; i<=10; i++){

cout << R[i-1] << " ";

}

return low; // 返回樞軸位置

} // Partition

void QSort(int *R, int s, int t ){

// 對記錄序列 R[s..t] 進行快速排序

if (s < t){ // 長度大于1

int pivotloc = Partition(R, s, t);// 對 R[s..t] 進行一趟快排，并返回樞軸位置

QSort(R, s, pivotloc-1);//對低子序列遞歸進行排序

QSort(R, pivotloc+1, t);//對高子序列遞歸進行排序

}//if

}//Qsort

int main(){

int li[10] = {0,38,65,97,76,13,27,48,55,4};

cout<<"注意:R[0]為數組的閑置分量"<<endl;

for(int i = 1; i<=10; i++){

cout << li[i-1] << " ";

}

cout << endl;

QSort(li,1,9);

cout << endl;

for(int i = 1; i<=10; i++){

cout << li[i-1] << " ";

}

cout << endl;

return 0;

}

聲明：本網頁內容旨在傳播知識，若有侵權等問題請及時與本網聯系，我們將在第一時間刪除處理。TEL:177 7030 7066 E-MAIL:11247931@qq.com