java快排

⑴ 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

⑵ java實現幾種常見排序演算法

下面給你介紹四種常用排序演算法：

1、冒泡排序

特點：效率低，實現簡單

思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。

⑶ 最快的排序演算法是什麼

最快的排序演算法是什麼，很多人的第一反應是快排，感覺QuickSort 當然應該最快了，其實並非如此，坦歲快排是不穩定的，最壞情況下，快排序並不是最優，Java7 中引入的 TimSort 就是一個結合了插入排序和歸並排序的高效演算法.

Timsort最早是 Tim Peters 於2001年為 python 寫的排序演算法。自從發明該演算法以來，它已被用作Python，Java，Android平台和GNU Octave中的默認排序演算法。

關於此演算法的詳細描述參見 http://svn.python.org/projects/python/trunk/Objects/listsort.txt

看看它與另外兩個高效排序演算法的比較

相比之下， TimSort 的最佳，平均和最壞情況綜合起來最佳。在數據量比較少（<=64）的情況下，它直接用 Insert Sort，否則使用 MergeSort + BinarySearch 來提高排序效率

下面寫一個給撲克牌排序的例子，比較一下冒泡，插入，快排，歸並排序，TimSort的性能:

然後分別用以上5種排序方法來做下性能比較

將1000 副牌打亂順序的撲克牌排序下來，結果如下

但是 TimSort 也有讓做睜一個問題， 在 JDK7 的描述中提到它有如下兼容性問題

所以在JDK7以後，實現Comparable介面的比較器需要滿足以下三個約束條件：
1） 自反性：x，y 的比較結果和 y，x 的比較結果胡團相反。
2） 傳遞性：x>y, y>z,則 x>z。
3） 對稱性：x=y,則 x,z 比較結果和 y，z 比較結果相同。

如果你的比較方法違反了以上的約束，要麼你不使用這個新的演算法，還是回到傳統的歸並排序

要麼修改你的比較器以符合上述的約束條件。

舉兩個例子如下

⑷ java基礎 insert方法問題

20大進階架構專題每日送達

1.直接插入排序

經常碰到這樣一類排序問題：把新的數據插入到已經排好的數據列中。

• 將第一個數和第二個數排序，然後構成一個有序序列

• 將第三個數插入進去，構成一個新的有序序列。

• 對第四個數、第五個數……直到最後一個數，重復第二步。

如何寫成代碼：


• 首先設定插入次數，即循環次數，for(int i=1;i

• 設嫌蘆信定插入數和得到已經排好序列的最後一個數的位數。insertNum和j=i-1。

• 從最後一個數開始向前循環，如果插入數小於當前數，就將當前數向後移動一位。

• 將當前數放置到空著的位置，即j+1。

代碼芹輪實現如下：

public void insertSort(int[] a){
int length=a.length;//數組長度，將這個提取出來是為了提高速度。
int insertNum;//要插入的數
for(int i=1;i//插入的次數
insertNum=a[i];//要插入的數
int j=i-1;//已經排序好的序列元素個數
while(j>=0&&a[j]>insertNum){//序列從後到前循環，將大於insertNum的數向後移動一格
a[j+1]=a[j];//元素移動一格
j--;
}
a[j+1]=insertNum;//將需要插入的數放在要插入的位置。
}
}


2.希爾排序

• 對於直接插入排序問題，數據量巨大時。

• 將數的個數設為n，取奇數k=n/2，將下標差值為k的數分為一組，構成有序序列。

• 再取k=k/2 ，將下標差值為k的書分為一組，構成有序序列。

• 重復第二步，直到k=1執行簡單插入排序。

如何寫成代碼：

• 首先確定分的組數。

• 然後對組中元素進行插入排序。

• 然後將length/2，重復1,2步，直到length=0為止。

代碼實現如下：

public void sheelSort(int[] a){
int d = a.length;
while (d!=0) {
d=d/2;
for (int x = 0; x < d; x++) {//分的組數
for (int i = x + d; i < a.length; i += d) {//組中的元素，從第二個數開始
int j = i - d;//j為有序序列最後一位的位數
int temp = a[i];//要插入的元素
for (; j >= 0 && temp < a[j]; j -= d) {//從後往前遍歷。
a[j + d] = a[j];//向後移動d位
}
a[j + d] = temp;
}
}
}
}


3.簡單選擇排序

• 常用於取序列中最大最小的幾個數時。

(如果每次比較都交換，那麼就是交換排序；如果每次比較完一個循環再交換，就是簡單選擇排序。)

• 遍歷整個序列，將最小的數放在最前面。

• 遍歷剩下的序列，將最小的數放在最前面。

• 重復第二步，直到只剩下一個數。

如何寫成代碼：


• 首先確定循環次數，並且記住當前數字和當前位置。

• 將當前位置後面所有的數與當前數字進行對比，小數賦值給key，並記住小數的位置。

• 比對完成後，將最小的值與第一個數的值交換。

• 重復2、3步嘩亮。

代碼實現如下：

public void selectSort(int[] a) {
int length = a.length;
for (int i = 0; i < length; i++) {//循環次數
int key = a[i];
int position=i;
for (int j = i + 1; j < length; j++) {//選出最小的值和位置
if (a[j] < key) {
key = a[j];
position = j;
}
}
a[position]=a[i];//交換位置
a[i]=key;
}
}


4.堆排序

• 對簡單選擇排序的優化。

• 將序列構建成大頂堆。

• 將根節點與最後一個節點交換，然後斷開最後一個節點。

• 重復第一、二步，直到所有節點斷開。

代碼實現如下：


public void heapSort(int[] a){
System.out.println("開始排序");
int arrayLength=a.length;
//循環建堆
for(int i=0;i-1;i++){
//建堆

buildMaxHeap(a,arrayLength-1-i);
//交換堆頂和最後一個元素
swap(a,0,arrayLength-1-i);
System.out.println(Arrays.toString(a));
}
}
private void swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//對data數組從0到lastIndex建大頂堆
private void buildMaxHeap(int[] data, int lastIndex) {
// TODO Auto-generated method stub
//從lastIndex處節點（最後一個節點）的父節點開始
for(int i=(lastIndex-1)/2;i>=0;i--){
//k保存正在判斷的節點
int k=i;
//如果當前k節點的子節點存在
while(k*2+1<=lastIndex){
//k節點的左子節點的索引
int biggerIndex=2*k+1;
//如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在
if(biggerIndex //若果右子節點的值較大
if(data[biggerIndex]1]){
//biggerIndex總是記錄較大子節點的索引
biggerIndex++;
}
}
//如果k節點的值小於其較大的子節點的值
if(data[k] //交換他們
swap(data,k,biggerIndex);
//將biggerIndex賦予k，開始while循環的下一次循環，重新保證k節點的值大於其左右子節點的值
k=biggerIndex;
}else{
break;
}
}
}
}


5.冒泡排序

• 一般不用。

• 將序列中所有元素兩兩比較，將最大的放在最後面。

• 將剩餘序列中所有元素兩兩比較，將最大的放在最後面。

• 重復第二步，直到只剩下一個數。

如何寫成代碼：


• 設置循環次數。

• 設置開始比較的位數，和結束的位數。

• 兩兩比較，將最小的放到前面去。

• 重復2、3步，直到循環次數完畢。

代碼實現如下：

public void bubbleSort(int[] a){
int length=a.length;
int temp;
for(int i=0;i for(int j=0;j-1;j++){
if(a[j]>a[j+1]){
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}


6.快速排序

• 要求時間最快時。

• 選擇第一個數為p，小於p的數放在左邊，大於p的數放在右邊。

• 遞歸的將p左邊和右邊的數都按照第一步進行，直到不能遞歸。

代碼實現如下：


public static void quickSort(int[] numbers, int start, int end) {
if (start < end) {
int base = numbers[start]; // 選定的基準值（第一個數值作為基準值）
int temp; // 記錄臨時中間值
int i = start, j = end;
do {
while ((numbers[i] < base) && (i < end))
i++;
while ((numbers[j] > base) && (j > start))
j--;
if (i <= j) {
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
i++;
j--;
}
} while (i <= j);
if (start < j)
quickSort(numbers, start, j);
if (end > i)
quickSort(numbers, i, end);
}
}


7.歸並排序

• 速度僅次於快排，內存少的時候使用，可以進行並行計算的時候使用。

• 選擇相鄰兩個數組成一個有序序列。

• 選擇相鄰的兩個有序序列組成一個有序序列。

• 重復第二步，直到全部組成一個有序序列。

代碼實現如下：


public static void mergeSort(int[] numbers, int left, int right) {
int t = 1;// 每組元素個數
int size = right - left + 1;
while (t < size) {
int s = t;// 本次循環每組元素個數
t = 2 * s;
int i = left;
while (i + (t - 1) < size) {
merge(numbers, i, i + (s - 1), i + (t - 1));
i += t;
}
if (i + (s - 1) < right)
merge(numbers, i, i + (s - 1), right);
}
}
private static void merge(int[] data, int p, int q, int r) {
int[] B = new int[data.length];
int s = p;
int t = q + 1;
int k = p;
while (s <= q && t <= r) {
if (data[s] <= data[t]) {
B[k] = data[s];
s++;
} else {
B[k] = data[t];
t++;
}
k++;
}
if (s == q + 1)
B[k++] = data[t++];
else
B[k++] = data[s++];
for (int i = p; i <= r; i++)
data[i] = B[i];
}


8.基數排序

• 用於大量數，很長的數進行排序時。

• 將所有的數的個位數取出，按照個位數進行排序，構成一個序列。

• 將新構成的所有的數的十位數取出，按照十位數進行排序，構成一個序列。

代碼實現如下：


public void sort(int[] array) {
//首先確定排序的趟數;
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
int time = 0;
//判斷位數;
while (max > 0) {
max /= 10;
time++;
}
//建立10個隊列;
List queue = new ArrayList ();
for ( int i = 0; i < 10; i++) {
ArrayList queue1 = new ArrayList ();
queue.add(queue1);
}
//進行time次分配和收集;
for ( int i = 0; i < time; i++) {
//分配數組元素;
for ( int j = 0; j < array.length; j++) {
//得到數字的第time+1位數;
int x = array[j] % ( int) Math. pow( 10, i + 1) / ( int) Math. pow( 10, i);
ArrayList queue2 = queue.get(x);
queue2.add( array[j]);
queue. set(x, queue2);
}
int count = 0; //元素計數器;
//收集隊列元素;
for ( int k = 0; k < 10; k++) {
while ( queue.get(k).size() > 0) {
ArrayList queue3 = queue.get(k);
array[count] = queue3.get( 0);
queue3.remove( 0);
count++;
}
}
}
}

來源：KaelQ

地址：www.jianshu.com/p/5e171281a387

獲取方式：點「在看」，V信關注師長的小號：編程最前線並回復面試領取，更多精彩陸續奉上。

⑸ 快速排序演算法原理與實現

快速排序的原理：通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小。

然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

假設要排序的數組是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。

(5)java快排擴展閱讀：

設要排序的數組是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指針位置不變。

⑹ 快速排序的演算法復雜度分析

原文地址：
快速排序的演算法復雜度分析
以下是快排的java演算法：

大家都知道快排的時間復雜度是O(n*ln[n])，那麼這個復雜度是如何計算出來的呢？

最好的情況下，每次劃分對一個記錄定位後，要記錄的左側子序列與右側子序列的長度相同。在具有n個記錄的序列中，一次劃分需要對整個待劃分序列掃描一遍，所需的時間為O(n)。

設 是對n個記錄的序列進行排序的時間，每次劃分後，正好把劃分區域分為長度相等的連個子序列，顯然T(0)=T(1) =1,則有：

最壞的情況下，待排序的記錄序列正序或逆序，每次劃分只能得到一個比上一次劃分少一個記錄的子序列，（另一個子序列為空）。此時，必須經過n-1次遞歸調用才能把所有記錄定位，而且第i趟劃分需要經過n-i次比較才能找個才能找到第i個記錄的位置，因此時間復雜度為

平均情況下，設軸值記錄的關鍵碼第k小（1≤k≤n）,則有：

由上式可推出如下兩式：

兩式相減,然後兩邊同除以n(n+1)得

又因為f(n)單調遞減，單調有界數列極限定理，所以f(n)有界

此數稱為歐拉常數，

約為 0.57721566490153286060651209

所以

所以

**如果有何處不當，請不吝賜教，一定多加完善。謝謝 **

參考資料：

【1】《演算法設計與分析》第二版 王紅梅

⑺ Java冒泡排序的原理

冒泡排序是所欲排序演算法里最好理解的了。
1、排序演算法：
A)比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
B)對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
C)針對所有的元素重復以上的步驟，除了最後一個。
D)持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
2、給你一個java的實現代碼：
public class BubbleSort{
     public static void main(String[] args){
         int score[] = {67, 69, 75, 87, 89, 90, 99, 100};
         for (int i = 0; i < score.length -1; i++){ //最多做n-1趟排序
             for(int j = 0 ;j < score.length - i - 1; j++){ //對當前無序區間score[0......length-i-1]進行排序(j的范圍很關鍵，這個范圍是在逐步縮小的)
                 if(score[j] < score[j + 1]){ //把小的值交換到後面
                     int temp = score[j];
                     score[j] = score[j + 1];
                     score[j + 1] = temp;
                 }
             }
             System.out.print("第" + (i + 1) + "次排序結果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "\t");
             }
             System.out.println("");
         }
             System.out.print("最終排序結果：");
             for(int a = 0; a < score.length; a++){
                 System.out.print(score[a] + "\t");
        }
     }
 }