快速排序java
1. 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
(1)快速排序java擴展閱讀
Java中利用數組進行數字排序一般有4種方法：
1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。
2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。
3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。
4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。
2. java 怎麼將List裡面數據排序
不好意思，上午只是粗略地看了一下，沒有細致看，現在詳細回答你的提問。
ArrayList底層是用一個長度為10的Object數組實現，不管添加進去什麼類型的數據，都會轉換成Object對象，除非你用很早以前的JDK版本。這樣就好理解了，像你寫的程序arrayList1中add了String和Integer兩種類型的數據，這兩類對象沒有什麼可比性，就像拿打火機和U盤比一個性質。所以，是沒有辦法進行直接排序的。
你要求的是要按ArrayList裡面的第1、2、4數據進行排序，這個可以。
先來arrayList1
四個數據分別是2、"daas"、6、"1"，第1、2、4數據即2、「daas」、「1」，我選擇按照String類型進行排序，所以第1個數據2轉換成String類型即可。因為第3個數據6不進行排序，remove就好。這是個題還是個什麼，其實還是留了點活路的，因為後面的（你arrayList234下面）代碼都是往arrayList1中添加的，而且還都是String類型。這也是我選擇String類型進行排序的原因。代碼如下：
List arrayList1 = new ArrayList();
arrayList1.add(2); //0
arrayList1.add("daas"); //1
arrayList1.add(6); //2
arrayList1.add("1"); //3
list.add(arrayList1);
//my code
String convert = String.valueOf(arrayList1.get(0));
arrayList1.remove(2);
arrayList1.remove(0);
arrayList1.add(convert);
/此處為你的arrayList234代碼
Collections.sort(arrayList1);
for(int i = 0; i < arrayList1.size(); i++) {
System.out.println(arrayList1.get(i));
}
結果為：
1
2
3
5
8
daas
因為怕你深挖，強調兩點：
第一點，由結果看出Collections.sort(arrayList1)，是以String的ASCII碼進行排序的，為了證明這一點，就要看原代碼，這時你就會發現JDK中String的compareTo方法是個空實現，底層並不是用java寫的，這點沒事，我們可以用一定的方法讓它把特徵暴露出來，然後就可以理解思想。你看我下面寫的小測試程序就會明白。
String a = new String("Z");
String b = new String("A");
System.out.println(a.compareTo(b));
String c = new String("A");
String d = new String("B");
System.out.println(c.compareTo(d));
//看結果，證明String的自然順序比較即比較ASCII值，只是第一步。
//看結果，證明compareTo返回值是後面的ASCII碼減支前面的ASCII碼，第二步。
String e = new String("g");
String f = new String("e");
String h = new String("h");
List<String> list = new ArrayList<String>();
list.add(e);
list.add(f);
list.add(h);
Collections.sort(list);
for(String i : list) {
System.out.println(i);
}
結果為：
25
-1
e
g
h
//證明String的自然排序即ASCII碼從小到大排序，最後一步。
第二點，你的要求是「要按ArrayList裡面的第1、2.4數據進行排序，分別怎麼做啊」，這個問題的描述有問題，或者不詳細，arryList2、arrayList3、arrayList4任何一個裡面一共就add了3個數據，哪來第4個。如果是分別對arrayList234裡面的數據進行排序，兩個選擇，（1）把所有Integer轉換成String類型，再排序，參考arrayList2。（2）運用Integer.valueOf()方法，將內容為數字的String數據轉換成Integer，把原來的remove掉，把內容非數字的String數據remove掉，再排序，桶排序、冒泡排序、快速排序等你隨便選。
講解到這，不管想對哪個list進行排序，你應該都會寫了。
總結：
除非比較ASCII碼，Integer類型和內容為非數字的String類型數據是沒有辦法進行比較的，不管是直接比較，還是間接比較。還是上面那句話，像打火機和U盤沒有可比性一樣，理解這點很重要。
即使用Integer.valueOf()方法對內容為非數字的String類型數據進行轉換沒有用，會報NumberFormatException。說這點意思是如果你想按Integer類型排序，得把所有內容為非數字的String類型數據remove掉。
題外話：這種類型的題我記得上大學的時候有，不知道你是不是學生，今天想來，其實用處真不大，都用泛型，現在寫代碼不用泛型的程序員幾乎是完全不存在了。
祝心情愉快~~
親手打，如果滿意，把分給我吧~~哈哈。。
3. 在java編程中如何對數組進行排序，並輸出排序後的數組及原數組下標值
java變成對數組進行排序可以使用ArraySort方法，保存源數組下標值可以存入map中，如下代碼：
importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.HashMap;
importjava.util.List;
publicclassceshi{
publicstaticvoidmain(String[]args){
intn=5;
int[]a={8,5,4,6,2,1,7,9,3};
HashMapmap=newHashMap();
for(inti=0;i<a.length;i++){
map.put(a[i],i);//將值和下標存入Map
}
//排列
Listlist=newArrayList();
Arrays.sort(a);//升序排列
for(inti=0;i<a.length;i++){
list.add(a[i]);
}
for(Objectobject:list){
System.out.print(object+",");
}
System.out.println();
//查找原始下標
for(inti=0;i<n;i++){
System.out.print(map.get(a[i])+",");
}
}
}
運行結果如下：
4. Java通過幾種經典的演算法來實現數組排序
JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。
快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。
冒泡法是運用遍歷數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。
選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。
插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。
<1>利用Arrays帶有的排序方法快速排序
public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //進行排序 for(int i: a){ System.out.print(i); } } }
<2>冒泡排序演算法
public static int[] bubbleSort(int[] args){//冒泡排序演算法 for(int i=0;i<args.length-1;i++){ for(int j=i+1;j<args.length;j++){ if (args[i]>args[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; }
<3>選擇排序演算法
public static int[] selectSort(int[] args){//選擇排序演算法 for (int i=0;i<args.length-1 ;i++ ){ int min=i; for (int j=i+1;j<args.length ;j++ ){ if (args[min]>args[j]){ min=j; } } if (min!=i){ int temp=args[i]; args[i]=args[min]; args[min]=temp; } } return args; }
<4>插入排序演算法
public static int[] insertSort(int[] args){//插入排序演算法 for(int i=1;i<args.length;i++){ for(int j=i;j>0;j--){ if (args[j]<args[j-1]){ int temp=args[j-1]; args[j-1]=args[j]; args[j]=temp; }else break; } } return args; }
5. java中應該怎樣對字元串數組進行排序
可以使用冒泡排序，選擇排序等多種方式就行排序，兩個for循環嵌套就可以或者使用sort()方法進行快速排序
6. java十大演算法
演算法一：快速排序演算法
快速排序是由東尼·霍爾所發展的一種排序演算法。在平均狀況下，排序 n 個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況並不常見。事實上，快速排序通常明顯比其他Ο(n log n) 演算法更快，因為它的內部循環（inner loop）可以在大部分的架構上很有效率地被實現出來。
快速排序使用分治法（Divide and conquer）策略來把一個串列（list）分為兩個子串列（sub-lists）。
演算法步驟：
1 從數列中挑出一個元素，稱為 "基準"（pivot），
2 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱為分區（partition）操作。
3 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個演算法總會退出，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。
演算法二：堆排序演算法
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。
堆排序的平均時間復雜度為Ο(nlogn) 。
演算法步驟：
創建一個堆H[0..n-1]
把堆首（最大值）和堆尾互換
3. 把堆的尺寸縮小1，並調用shift_down(0),目的是把新的數組頂端數據調整到相應位置
4. 重復步驟2，直到堆的尺寸為1
演算法三：歸並排序
歸並排序（Merge sort，台灣譯作：合並排序）是建立在歸並操作上的一種有效的排序演算法。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。
演算法步驟：
1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合並後的序列
2. 設定兩個指針，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指針所指向的元素，選擇相對小的元素放入到合並空間，並移動指針到下一位置
4. 重復步驟3直到某一指針達到序列尾
5. 將另一序列剩下的所有元素
7. java實現幾種常見排序演算法
下面給你介紹四種常用排序演算法：
1、冒泡排序
特點：效率低，實現簡單
思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。
8. 快速排序的演算法復雜度分析
原文地址：
快速排序的演算法復雜度分析
以下是快排的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】《演算法設計與分析》第二版 王紅梅