java快速排序演算法代碼

1. 如何用java實現快速排序，簡答講解下原理

快速排序思想：
通過對數據元素集合Rn 進行一趟排序劃分出獨立的兩個部分。其中一個部分的關鍵字比另一部分的關鍵字小。然後再分別對兩個部分的關鍵字進行一趟排序，直到獨立的元素只有一個，此時整個元素集合有序。
快速排序的過程，對一個元素集合R[ low ... high ] ,首先取一個數（一般是R[low] ）做參照 ， 以R[low]為基準重新排列所有的元素。
所有比R[low]小的放前面，所有比R[low] 大的放後面，然後以R[low]為分界，對R[low ... high] 劃分為兩個子集和，再做劃分。直到low >= high 。
比如：對R={37, 40, 38, 42, 461, 5, 7, 9, 12}進行一趟快速排序的過程如下(注:下面描述的內容中元素下表從 0 開始)：
開始選取基準 base = 37，初始位置下表 low = 0 ， high = 8 ， 從high=8，開始如果R[8] < base , 將high位置中的內容寫入到R[low]中, 將high位置空出來, low = low +1 ;
從low開始探測，由於low=1 ， R[low] > base ,所以將R[low]寫入到R[high] , high = high -1 ;
檢測到low < high ,所以第一趟快速排序仍需繼續:
此時low=1，high=7，因為 R[high] < base ,所以將 R[high] 寫入到到R[low]中,low = low + 1;
從low開始探測,low = 2 , R[low] >base ,所以講R[low]寫入到R[high]，high=high-1;
繼續檢測到 low 小於high
此時low=2，high=6，同理R[high] < base ,將R[high] 寫入到R[low]中，low=low+1;
從low繼續探測,low = 3 , high=6 , R[low] > base , 將R[low]寫入到R[high]中，high = high-1;
繼續探測到low小於high
此時low=3，high=5，同理R[high] < base,將R[high]寫入到R[low]中，low = low +1；
從low繼續探測，low = 4，high=5，由於R[low] > base , 將R[low]寫入到R[high]中，high = high -1 ;
此時探測到low == high == 4 ；該位置即是base所在的位置，將base寫入到該位置中.
然後再對子序列Rs1 = {12,9,7,5} 和 Rs2={461,42,38,40}做一趟快速排序，直到Rsi中只有一個元素，或沒有元素。
快速排序的Java實現：
private static boolean isEmpty(int[] n) {

return n == null || n.length == 0;
}

// ///////////////////////////////////////////////////
/**
* 快速排序演算法思想——挖坑填數方法：
*
* @param n 待排序的數組
*/
public static void quickSort(int[] n) {
if (isEmpty(n))
return;
quickSort(n, 0, n.length - 1);
}

public static void quickSort(int[] n, int l, int h) {
if (isEmpty(n))
return;
if (l < h) {
int pivot = partion(n, l, h);
quickSort(n, l, pivot - 1);
quickSort(n, pivot + 1, h);
}
}

private static int partion(int[] n, int start, int end) {
int tmp = n[start];
while (start < end) {
while (n[end] >= tmp && start < end)
end--;
if (start < end) {
n[start++] = n[end];
}
while (n[start] < tmp && start < end)
start++;
if (start < end) {
n[end--] = n[start];
}
}
n[start] = tmp;
return start;
}
在代碼中有這樣一個函數：
public static void quickSortSwap(int[] n, int l, int h)
該函數可以實現，元素集合中特定的 l 到 h 位置間的數據元素進行排序。

2. java快速排序簡單代碼

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序演算法是《數據結構與演算法》中最基本的演算法之一。排序演算法可以分為內部排序和外部排序，內部排序是數據記錄在內存中進行排序，而外部排序是因排序的數據很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內部排序演算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸並排序、快速排序、堆排序、基數排序等。以下是快速排序演算法：

快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞譽渣宏狀況下則需要 Ο(n2) 次比較，但這種狀況並不常見。事實上，快速排序梁灶通常明顯比其他 Ο(nlogn) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。

快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。

快速排序又是一種分而治之思想在排序演算法上的典型應用。本質上來看，快速排序應該算是在冒慶冊泡排序基礎上的遞歸分治法。

快速排序的名字起的是簡單粗暴，因為一聽到這個名字你就知道它存在的意義，就是快，而且效率高！它是處理大數據最快的排序演算法之一了。雖然 Worst Case 的時間復雜度達到了 O(n?)，但是人家就是優秀，在大多數情況下都比平均時間復雜度為 O(n logn) 的排序演算法表現要更好，可是這是為什麼呢，我也不知道。好在我的強迫症又犯了，查了 N 多資料終於在《演算法藝術與信息學競賽》上找到了滿意的答案：

快速排序的最壞運行情況是 O(n?)，比如說順序數列的快排。但它的平攤期望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數因子很小，比復雜度穩定等於 O(nlogn) 的歸並排序要小很多。所以，對絕大多數順序性較弱的隨機數列而言，快速排序總是優於歸並排序。
1. 演算法步驟
從數列中挑出一個元素，稱為 "基準"（pivot）;

重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作；

遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序；
2. 動圖演示
代碼實現 JavaScript 實例 function quickSort ( arr , left , right ) {
    var len = arr. length ,
        partitionIndex ,
        left = typeof left != 'number' ? 0 : left ,
        right = typeof right != 'number' ? len - 1 : right ;

    if ( left

3. java中快速排序的演算法舉個例子

package person.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;

/**
* class name: RapidSort
* description: Java快速排序法：數組和集合
* @author Jr
*
*/
public class RapidSort {
private Random ran = new Random(); // 聲明一個全局變數ran，用來隨機生成整數

/**
* method name: sortArray
* description: 對數組的快速排序，只能用於int[]類型的數組
* @return
*/
private void sortArray() {
int[] array = new int[10]; // 聲明數組長度為10
for (int i = 0 ; i < array.length; i++) {
array[i] = ran.nextInt(10) + 1; // 數組賦值
}
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}

/**
* method name: sortList
* description: 對集合的快速排序，可以用於List<Object>類型數組，
* 隱含意思就是對所有類型數組都適用
* @return
*/
private void sortList() {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0 ; i < 10; i++) {
list.add(ran.nextInt(10) + 1); // 給集合賦10個值
}
Collections.sort(list);
System.out.println(list);
}

public static void main(String[] args) {
RapidSort rs = new RapidSort();
rs.sortArray();
rs.sortList();
}
}

4. java問題

只要加到比較方法之中就可以
如：比較方法如下
for(int i=0;i<100;i++)
for(int j=i;j<100;j++){
if(array[i]>array[j]){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
把：：
比較次數compare_count、交換次數exchange_count、探測次數probe_count）加到裡面就可以

for(int i=0,compare_count=0;i<100;i++)
for(int j=i;j<100;j++){
if(array[i]>array[j]){
compare_count++;
int temp=array[i];
array[i]=array[j];
array[j]=temp;
exchange_count++;
}
}

就可以了
各種排序方法的綜合比較

一、時間性能

按平均的時間性能來分，有三類排序方法：
時間復雜度為O(nlogn)的方法有：快速排序、堆排序和歸並排序，其中以快速排序為最好；

時間復雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特別是對那些對關鍵字近似有序的記錄序列尤為如此；

時間復雜度為O(n)的排序方法只有，基數排序。

當待排記錄序列按關鍵字順序有序時，直接插入排序和起泡排序能達到O(n)的時間復雜度;而對於快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應該盡量避免的情況。
簡單選擇排序、堆排序和歸並排序的時間性能不隨記錄序列中關鍵字的分布而改變。
二、空間性能

指的是排序過程中所需的輔助空間大小。

1. 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間復雜度為O(1)；

2. 快速排序為O(logn )，為棧所需的輔助空間;

3. 歸並排序所需輔助空間最多，其空間復雜度為O(n );

4.鏈式基數排序需附設隊列首尾指針，則空間復雜度為O(rd )。

三、排序方法的穩定性能

1. 穩定的排序方法指的是，對於兩個關鍵字相等的記錄，它們在序列中的相對位置，在排序之前和經過排序之後，沒有改變。

2. 當對多關鍵字的記錄序列進行LSD方法排序時，必須採用穩定的排序方法。

3. 對於不穩定的排序方法，只要能舉出一個實例說明即可。

4. 快速排序和堆排序是不穩定的排序方法。

四、關於「排序方法的時間復雜度的下限」

本章討論的各種排序方法，除基數排序外，其它方法都是基於「比較關鍵字」進行排序的排序方法，可以證明，這類排序法可能達到的最快的時間復雜度為O(n logn )。(基數排序不是基於「比較關鍵字」的排序方法,所以它不受這個限制)。

可以用一棵判定樹來描述這類基於「比較關鍵字」進行排序的排序方法。

例如，對三個關鍵字進行排序的判定樹如下：

描述排序的判定樹有兩個特點：

1.樹上的每一次「比較」都是必要的;

2.樹上的葉子結點包含所有可能情況。

則由上圖所示「判定樹的深度為4」可以推出「至多進行三次比較」即可完成對三個關鍵字的排序。反過來說，由此判定樹可見，考慮最壞情況，「至少要進行三次比較」才能完成對三個關鍵字的排序。

對三個關鍵字進行排序的判定樹深度是唯一的。即無論按什麼先後順序去進行比較，所得判定樹的深度都是3。

當關鍵字的個數超過3之後，不同的排序方法其判定樹的深度不同。例如，對4個關鍵字進行排序時，直接插入的判定樹的深度為6, 而折半插入的判定樹的深度為5。

可以證明，對4個關鍵字進行排序，至少需進行5次比較。因為，4個關鍵字排序的結果有4!=24種可能，即排序的判定樹上必須有24個葉子結點，其深度的最小值為6。

一般情況下，對n個關鍵字進行排序，可能得到的結果有n! 種，由於含n! 個葉子結點的二叉樹的深度不小於 , 則對n個關鍵字進行排序的比較次數至少是

。利用斯蒂林近似公式

所以，基於「比較關鍵字」進行排序的排序方法，可能達到的最快的時間復雜度為O(n logn )。

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一躺排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

假設要排序的數組是A[1]……A[N]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一躺快速排序。一躺快速排序的演算法是：

1）、設置兩個變數I、J，排序開始的時候I：=1，J：=N；

2）以第一個數組元素作為關鍵數據，賦值給X，即X：=A[1]；

3）、從J開始向前搜索，即由後開始向前搜索（J：=J-1），找到第一個小於X的值，兩者交換；

4）、從I開始向後搜索，即由前開始向後搜索（I：=I+1），找到第一個大於X的值，兩者交換；

5）、重復第3、4步，直到I=J；

例如：待排序的數組A的值分別是：（初始關鍵數據X：=49）

A[1] A[2] A[3] A[4] A[5] A[6] A[7]：

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,兩者交換，此時J：=4 )

此時再執行第三不的時候就發現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}

分別對前後兩部分進行快速排序 {13} 27 {38}

結束 結束 {49 65} 76 {97}

49 {65} 結束

結束

圖6 快速排序全過程

1）、設有N（假設N=10）個數，存放在S數組中；
2）、在S[1。。N]中任取一個元素作為比較基準，例如取T=S[1]，起目的就是在定出T應在排序結果中的位置K，這個K的位置在：S[1。。K-1]<=S[K]<=S[K+1..N]，即在S[K]以前的數都小於S[K]，在S[K]以後的數都大於S[K]；

3）、利用分治思想（即大化小的策略）可進一步對S[1。。K-1]和S[K+1。。N]兩組數據再進行快速排序直到分組對象只有一個數據為止。 1 2 3 4 5 6 7 8 9 10

如具體數據如下，那麼第一躺快速排序的過程是：

數組下標：

45 36 18 53 72 30 48 93 15 36

5） 36 36 18 15 30 45 48 93 72 534） 36 36 18 15 45 30 48 93 72 533） 36 36 18 15 72 30 48 93 45 532） 36 36 18 45 72 30 48 93 15 53

program kuaisu(input,output);
const n=10;
var
s:array[1..10] of integer;
k,l,m:integer;

procere qsort(lx,rx:integer);
var
I,j,t:integer;
Begin
I:lx;j:rx;t:s[I];
Repeat
While (s[j]>t) and (j>I) do
Begin
k:=k+1;
j:=j-1
end;
if I<j then
begin
s[I]:=s[j];I:=I+1;l:=l+1;
while (s[I]<t) and (I<j) do
begin
k:=k+1;
I:=I+1
End;
If I<j then
begin
S[j]:=s[I];j:=j-1;l:=l+1;
End;
End;
Until I=j;
S[I]:=t;I:=I+1;j:=j-1;l:=l+1;
If lx<j then qsort(lx,j);
If I<rx then qsort(I,rx)
End;{過程qsort結束}

Begin
Writeln('input 10 integer num:');
For m:=1 to n do read(s[m]);
K:=0;l:=0;
Qsort(l,n);
Writeln('排序後結果是：')；
For m:=1 to n do write(s[m]:4)
End.

通過一躺排序將45放到應該放的位置K，這里K=6，那麼再對S[1。。5]和S[6。。10]分別進行快速排序。程序代碼如下：<49,兩者交換，此時J:=6>

5. 求java快速排序的正確代碼

一趟快速怕序的具體做法是：附設兩個指針low和high,他們的初值分別為low和high,設樞軸記錄的關鍵字為privotkey,則首先從high所指位置向前搜索找到第一個關鍵字小於pivotkey的記錄和樞軸記錄互相交換,然後從low所指向的位置起向後搜索,找到第一個關鍵字大於privotkey的記錄和樞軸記錄互相交換，重復這兩步直至low==high位置.

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class 快速排序_1 {
public static void main(String[] args) throws InterruptedException {
int test[] = {15,23,56,7,13,52,20,7};
new 快速排序_1().qSort(test, 0, test.length-1);
for(int k:test) System.out.println(k);
}
public void qSort(int []array,int low,int high){
if(low
int privot=partition(array,low,high);
qSort(array,low,privot-1);
qSort(array,privot+1,high);
}
}
public int partition(int [] array,int low,int high){
/**
* 選擇 low位置 作為曲軸(支點)
*/
int pivot=array[low];
int temp=0;
/**
* 如果 low
*/
while(low
/**
* 先從 high端 開始判斷
*/
while(low=pivot) high--;
/**
* 進行 置換操作
*/
if(low
array[low]=array[high];
low++;
}
/**
* 從 low 端判斷
*/
while(low
/**
* 進行 置換操作
*/
if(low
array[high]=array[low];
high--;
}
}
array[low]=pivot;
return low;
}
}

6. Java的排序演算法有哪些

排序： 插入，冒泡，選擇，Shell,快速排序

7. java怎麼讓數組的數字從大到小排序

將數字從大到小排序的方法：

例如簡一點的冒泡排序，將第一個數字和後面的數字逐個比較大小，如果小於，則互換位置，大於則不動。此時，第一個數為數組中的最大數。然後再將第二個數與後面的數逐個比較，以次類推。

示例代碼如下：
publicclassTest{

publicstaticvoidmain(String[]args){
int[]array={12,3,1254,235,435,236,25,34,23};
inttemp;
for(inti=0;i<array.length;i++){
for(intj=i+1;j<array.length;j++){
if(array[i]<array[j]){
temp=array[i];
array[i]=array[j];
array[j]=temp; //兩個數交換位置
}
}
}
for(inti=0;i<array.length;i++){
System.out.print(array[i]+"");
}
}
}

數組對於每一門編程語言來說都是重要的數據結構之一，當然不同語言對數組的實現及處理也不盡相同。

Java 語言中提供的數組是用來存儲固定大小的同類型元素。

你可以聲明一個數組變數，如 numbers[100] 來代替直接聲明 100 個獨立變數 number0，number1，....，number99

(7)java快速排序演算法代碼擴展閱讀

Java中利用數組進行數字排序一般有4種方法：

1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。

2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。

3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。

4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。