javasort底层算法

❶ 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();
	}
}