javasort底層演算法_Java的排序演算法有哪些

❶ java中的SORT怎麼用

Java中的Sort（排序）通常指的是Collections.sort() 對 List 的排序，該排序方式有兩種不同改的使用方法：
第一種是list中的對象實現Comparable介面，如下
public class User implements Comparable<User>{
private String name;
private Integer order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getOrder() {
return order;
}
public void setOrder(Integer order) {
this.order = order;
}
public int compareTo(User arg0) {
return this.getOrder().compareTo(arg0.getOrder());
}
}
此時可以直接排序
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
//此處add user2再add user1
list.add(user2);
list.add(user1);
Collections.sort(list);
for(User u : list){
System.out.println(u.getName());
}
}
第二種方法是根據Collections.sort重載方法來實現，例如：
public static void main(String[] args) {
User user1 = new User();
user1.setName("a");
user1.setOrder(1);
User user2 = new User();
user2.setName("b");
user2.setOrder(2);
List<User> list = new ArrayList<User>();
list.add(user2);
list.add(user1);

Collections.sort(list,new Comparator<User>(){
public int compare(User arg0, User arg1) {
return arg0.getOrder().compareTo(arg1.getOrder());
}
});
for(User u : list){
System.out.println(u.getName());
}
}

❷ java 數列sort方法

Arrays.sort(odd);是對odd直接進行排序，不需要返回值，排序結果還是在原來的數組里
應該是你的輸出邏輯不對
index=0下面的語句都不執行
for(int n=0;n<index;n++)
{System.out.print(odd[n]+" ");}

❸ JAVA中有哪幾種常用的排序方法每個排序方法的實現思路是如何的每個方法的思想是什麼

一、冒泡排序

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先比較 a[1]與a[2]的值，若a[1]大於a[2]則交換兩者的值，否則不變。再比較a[2]與a[3]的值，若a[2]大於a[3]則交換兩者的值，否則不變。再比較a[3]與a[4]，以此類推，最後比較a[n-1]與a[n]的值。這樣處理一輪後，a[n]的值一定是這組數據中最大的。再對 a[1]~a[n-1]以相同方法處理一輪，則a[n-1]的值一定是a[1]~a[n-1]中最大的。再對a[1]~a[n-2]以相同方法處理一輪，以此類推。共處理n-1輪後a[1]、a[2]、……a[n]就以升序排列了。

優點：穩定；

缺點：慢，每次只能移動相鄰兩個數據。

二、選擇排序

冒泡排序的改進版。

每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。

選擇排序是不穩定的排序方法。

n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：

①初始狀態：無序區為R[1..n]，有序區為空。

②第1趟排序

在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

……

③第i趟排序

第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n- 1)。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。

優點：移動數據的次數已知（n-1次）；

缺點：比較次數多。

三、插入排序

已知一組升序排列數據a[1]、a[2]、……a[n]，一組無序數據b[1]、 b[2]、……b[m]，需將二者合並成一個升序數列。首先比較b[1]與a[1]的值，若b[1]大於a[1]，則跳過，比較b[1]與a[2]的值，若b[1]仍然大於a[2]，則繼續跳過，直到b[1]小於a數組中某一數據a[x]，則將a[x]~a[n]分別向後移動一位，將b[1]插入到原來 a[x]的位置這就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若無數組a，可將b[1]當作n=1的數組a）

優點：穩定，快；

缺點：比較次數不一定，比較次數越少，插入點後的數據移動越多，特別是當數據總量龐大的時候，但用鏈表可以解決這個問題。

三、縮小增量排序

由希爾在1959年提出，又稱希爾排序(shell排序)。

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。發現當n不大時，插入排序的效果很好。首先取一增量d(d<n)，將a[1]、a[1+d]、a[1+2d]……列為第一組，a[2]、a[2+d]、 a[2+2d]……列為第二組……，a[d]、a[2d]、a[3d]……列為最後一組以次類推，在各組內用插入排序，然後取d'<d，重復上述操作，直到d=1。

優點：快，數據移動少；

缺點：不穩定，d的取值是多少，應取多少個不同的值，都無法確切知道，只能憑經驗來取。

四、快速排序

快速排序是目前已知的最快的排序方法。

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先任取數據 a[x]作為基準。比較a[x]與其它數據並排序，使a[x]排在數據的第k位，並且使a[1]~a[k-1]中的每一個數據<a[x]，a[k+1]~a[n]中的每一個數據>a[x]，然後採用分治的策略分別對a[1]~a[k-1]和a[k+1]~a[n] 兩組數據進行快速排序。

優點：極快，數據移動少；

缺點：不穩定。

五、箱排序

已知一組無序正整數數據a[1]、a[2]、……a[n]，需將其按升序排列。首先定義一個數組x[m],且m>=a[1]、a[2]、……a[n]，接著循環n次，每次x[a]++.

優點：快，效率達到O(1)

缺點：數據范圍必須為正整數並且比較小

六、歸並排序

歸並排序是多次將兩個或兩個以上的有序表合並成一個新的有序表。最簡單的歸並是直接將兩個有序的子表合並成一個有序的表。

歸並排序是穩定的排序.即相等的元素的順序不會改變.如輸入記錄 1(1) 3(2) 2(3) 2(4) 5(5) (括弧中是記錄的關鍵字)時輸出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按輸入的順序.這對要排序數據包含多個信息而要按其中的某一個信息排序,要求其它信息盡量按輸入的順序排列時很重要.這也是它比快速排序優勢的地方.

❹ Java的排序演算法有哪些

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

❺ 關於Java中Array.sort()排序原理，越詳細越好！

是Arrays.sort(a);吧

給你看源碼

=============

/**/publicstaticvoidsort(int[]paramArrayOfInt)
/**/{
/*96*/sort1(paramArrayOfInt,0,paramArrayOfInt.length);
/**/}

//

/**/privatestaticvoidsort1(int[]paramArrayOfInt,intparamInt1,intparamInt2)
/**/{
/*558*/if(paramInt2<7){
/*559*/for(i=paramInt1;i<paramInt2+paramInt1;i++)
/*560*/for(j=i;(j>paramInt1)&&(paramArrayOfInt[(j-1)]>paramArrayOfInt[j]);j--)
/*561*/swap(paramArrayOfInt,j,j-1);
/*562*/return;
/**/}
/**/
/**/
/*566*/inti=paramInt1+(paramInt2>>1);
/*567*/if(paramInt2>7){
/*568*/j=paramInt1;
/*569*/k=paramInt1+paramInt2-1;
/*570*/if(paramInt2>40){
/*571*/m=paramInt2/8;
/*572*/j=med3(paramArrayOfInt,j,j+m,j+2*m);
/*573*/i=med3(paramArrayOfInt,i-m,i,i+m);
/*574*/k=med3(paramArrayOfInt,k-2*m,k-m,k);
/**/}
/*576*/i=med3(paramArrayOfInt,j,i,k);
/**/}
/*578*/intj=paramArrayOfInt[i];
/**/
/**/
/*581*/intk=paramInt1;intm=k;intn=paramInt1+paramInt2-1;inti1=n;
/**/for(;;){
/*583*/if((m<=n)&&(paramArrayOfInt[m]<=j)){
/*584*/if(paramArrayOfInt[m]==j)
/*585*/swap(paramArrayOfInt,k++,m);
/*586*/m++;
/**/}else{
/*588*/while((n>=m)&&(paramArrayOfInt[n]>=j)){
/*589*/if(paramArrayOfInt[n]==j)
/*590*/swap(paramArrayOfInt,n,i1--);
/*591*/n--;
/**/}
/*593*/if(m>n)
/**/break;
/*595*/swap(paramArrayOfInt,m++,n--);
/**/}
/**/}
/**/
/*599*/inti3=paramInt1+paramInt2;
/*600*/inti2=Math.min(k-paramInt1,m-k);vecswap(paramArrayOfInt,paramInt1,m-i2,i2);
/*601*/i2=Math.min(i1-n,i3-i1-1);vecswap(paramArrayOfInt,m,i3-i2,i2);
/**/
/**/
/*604*/if((i2=m-k)>1)
/*605*/sort1(paramArrayOfInt,paramInt1,i2);
/*606*/if((i2=i1-n)>1){
/*607*/sort1(paramArrayOfInt,i3-i2,i2);
/**/}
/**/}
/**/
/**/
/**/privatestaticvoidswap(int[]paramArrayOfInt,intparamInt1,intparamInt2)
/**/{
/*614*/inti=paramArrayOfInt[paramInt1];
/*615*/paramArrayOfInt[paramInt1]=paramArrayOfInt[paramInt2];
/*616*/paramArrayOfInt[paramInt2]=i;
/**/}

❻ java中Arrays.sort使用的是什麼演算法

Arrays.sort()
先來看看Arrays.sort();，一點進這個方法會看到是這樣子的
publicstaticvoidsort(int[]a){
DualPivotQuicksort.sort(a,0,a.length-1,null,0,0);
}123
果然沒這么簡單，DualPivotQuicksort翻譯過來就是雙軸快速排序，關於雙軸排序可以去這里http://www.cnblogs.com/nullzx/p/5880191.html看看。那再次點進去，可以發現有這么一段代碼
if(right-left<QUICKSORT_THRESHOLD){
sort(a,left,right,true);
return;
}1234
可以發現如果數組的長度小於QUICKSORT_THRESHOLD的話就會使用這個雙軸快速排序，而這個值是286。
那如果大於286呢，它就會堅持數組的連續升序和連續降序性好不好，如果好的話就用歸並排序，不好的話就用快速排序，看下面這段注釋就可以看出
*Thearrayisnothighlystructured,
*.
123
那現在再回到上面的決定用雙軸快速排序的方法上，再點進去，發現又會多一條判斷
//Useinsertionsortontinyarrays
if(length<INSERTION_SORT_THRESHOLD)
123
即如果數組長度小於INSERTION_SORT_THRESHOLD(值為47)的話，那麼就會用插入排序了，不然再用雙軸快速排序。
所以總結一下Arrays.sort()方法，如果數組長度大於等於286且連續性好的話，就用歸並排序，如果大於等於286且連續性不好的話就用雙軸快速排序。如果長度小於286且大於等於47的話就用雙軸快速排序，如果長度小於47的話就用插入排序。真是有夠繞的~

❼ 有朋友能詳細介紹一下java中sort的用法嗎

1.java.util.Collections.sort(List list)與Comparable,Comparator 介面
2.java.util.Arrays.sort(T[])與Comparable,Comparator 介面
3.JFace中 TableView ，TreeView， ListView的排序，實現ViewerSorter
兩者的實現類似，不同的是針對的對象不一樣。Collections.sort（）針對的是List，Arrays.sort（）針對的是數組。如果List中或者數組中存的都是基本數據類型(byte、short、int、long、float、double、char、boolean) 和 String，那麼我們直接使用即可。如果其中存的數據是對象，那麼有兩種方法，一是每個對象實現Comparable介面，二是使用Collections.sort(List list，Comparator c)或者Arrays.sort(T[]，Comparator c)，臨時實現一個Comparator 來實現排序。

最後是一個以TableView 為例。
TableViewer tableViewer = new TableViewer(detailGroup, SWT.BORDER | SWT.V_SCROLL
| SWT.H_SCROLL | SWT.FULL_SELECTION);
tableViewer.setSorter(new FolderSorter());
public class FolderSorter extends ViewerSorter {
。。。。。。
}

❽ JAVA中Arrays.sort()排序的原理是什麼

有的時候需要對數組里的element進行排序。當然可以自己編寫合適的排序方法，但既然java包里有自帶的Arrays.sort排序方法，在數組元素比較少的時候為何不用？

Sorting an Array 1. 數字排序 int[] intArray = new int[] { 4, 1, 3, -23 };

Arrays.sort(intArray);

輸出： [-23, 1, 3, 4]

2. 字元串排序，先大寫後小寫 String[] strArray = new String[] { "z", "a", "C" };

Arrays.sort(strArray);

輸出： [C, a, z]

3. 嚴格按字母表順序排序，也就是忽略大小寫排序 Case-insensitive sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

輸出： [a, C, z]

4. 反向排序， Reverse-order sort

Arrays.sort(strArray, Collections.reverseOrder());

輸出：[z, a, C]

5. 忽略大小寫反向排序 Case-insensitive reverse-order sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

Collections.reverse(Arrays.asList(strArray));

輸出： [z, C, a]

java初學者最常見的錯誤思想，就是試圖去寫一些方法來完成數組的排序功能，其實，數組排序功能，在java的api裡面早已實現，我們沒有必要去重復製造輪子。

Arrays類有一個靜態方法sort,利用這個方法我們可以傳入我們要排序的數組進去排序，因為我們傳入的是一個數組的引用，所以排序完成的結果也通過這個引用的來更改數組.對於整數、字元串排序，jdk提供了默認的實現，如果要對一個對象數組排序，則要自己實現 java.util.Comparator介面。

packagecom.gjh.gee.arrays;
importjava.util.Arrays;
publicclassArraySortDemo{
	publicvoidsortIntArray(){
		int[]arrayToSort=newint[]{48,5,89,80,81,23,45,16,2};
		System.out.println("排序前");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
		//調用數組的靜態排序方法sort
		Arrays.sort(arrayToSort);
		System.out.println("排序後");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
	}
	publicvoidsortStringArray(){
		String[]arrayToSort=newString[]{"Oscar","Charlie","Ryan",
		"Adam","David"};
		System.out.println("排序前");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
		System.out.println("排序後");
		//調用數組的靜態排序方法sort
		Arrays.sort(arrayToSort);
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
	}
	publicvoidsortObjectArray(){
		Dogo1=newDog("dog1",1);
		Dogo2=newDog("dog2",4);
		Dogo3=newDog("dog3",5);
		Dogo4=newDog("dog4",2);
		Dogo5=newDog("dog5",3);
		Dog[]dogs=newDog[]{o1,o2,o3,o4,o5};
		System.out.println("排序前");
		for(inti=0;i<dogs.length;i++){
			Dogdog=dogs[i];
			System.out.println(dog.getName());
		}
		Arrays.sort(dogs,newByWeightComparator());
		System.out.println("排序後：");
		for(inti=0;i<dogs.length;i++){
			Dogdog=dogs[i];
			System.out.println(dog.getName());
		}
	}
	publicstaticvoidmain(String[]args){
		ArraySortDemot=newArraySortDemo();
		t.sortIntArray();
		t.sortStringArray();
		t.sortObjectArray();
	}
}

導航:首頁 > 源碼編譯 > javasort底層演算法

javasort底層演算法

與javasort底層演算法相關的資料