排序java

❶ java中有哪幾種常用的排序方法

1、冒泡排序
冒泡排序是一個比較簡單的排序方法。在待排序的數列基本有序的情況下排序速度較快。若要排序的數有n個，則需要n-1輪排序，第j輪排序中，從第一個數開始，相鄰兩數比較，若不符合所要求的順序，則交換兩者的位置；直到第n+1-j個數為止，第一個數與第二個數比較，第二個數與第三個數比較，......，第n-j個與第n+1-j個比較，共比較n-1次。此時第n+1-j個位置上的數已經按要求排好，所以不參加以後的比較和交換操作。例如：第一輪排序：第一個數與第二個數進行比較，若不符合要求的順序，則交換兩者的位置，否則繼續進行二個數與第三個數比較......。直到完成第n-1個數與第n個數的比較。此時第n個位置上的數已經按要求排好，它不參與以後的比較和交換操作；第二輪排序：第一個數與第二個數進行比較，......直到完成第n-2個數與第n-1個數的比較；......第n-1輪排序：第一個數與第二個數進行比較，若符合所要求的順序，則結束冒泡法排序；若不符合要求的順序，則交換兩者的位置，然後結束冒泡法排序。
共n-1輪排序處理，第j輪進行n-j次比較和至多n-j次交換。
從以上排序過程可以看出，較大的數像氣泡一樣向上冒，而較小的數往下沉，故稱冒泡法。

2、選擇排序
選擇法的原理是先將第一個數與後面的每一個數依次比較,不斷將將小的賦給第一個數,從而找出最小的,然後第二個數與後面的每一個數依次比較,從而找出第二小的,然後第三個數與後面的

3、插入排序
插入排序的原理是對數組中的第i個元素，認為它前面的i-1個已經排序好，然後將它插入到前面的i-1個元素中。插入排序對少量元素的排序較為有效.

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

❷ Java排序一共有幾種

日常操作中，常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸並排序等。

各類排序方法代碼如圖：

❸ java程序排序

java 程序排序可以使用默認的compartor類提供的排序方法，代碼如下：

Collections.sort(dataMap,newComparator<Map<String,Object>>(){

			@Override
			publicintcompare(Map<String,Object>lhs,Map<String,Object>rhs){
				switch(whichsort){
				caseSystem_OpenPosition_Sort_Currency:

					Stringd2=((String)rhs.get(Instrument));
					Stringd1=(String)lhs.get(Instrument);
					if(d2!=null&&d1!=null){

						intflag=d1.compareTo(d2);
						if(flag==0){
							Doubled3=((Double)rhs.get(OpenPrice));
							Doubled4=(Double)lhs.get(OpenPrice);
							if(d3!=null&&d4!=null){

								intflag2=d4.compareTo(d3);
								if(flag2==0){
									Stringd5=((String)rhs.get(BuySell));
									Stringd6=(String)lhs.get(BuySell);
									if(d5!=null&&d6!=null){

										returnd6.compareTo(d5);
									}
								}

								returnd4.compareTo(d3);
							}
						}else{
							returnflag;
						}
						//returnd1.compareTo(d2);
					}

❹ java排序

importjava.io.File;
importjava.util.Arrays;
importjava.util.Comparator;

publicclassTest{
publicstaticvoidmain(String...args){
File[]files=getFilesOrder(newFile("c:/"));

for(Filef:files){
System.out.println(f.getName());
}
}

privatestaticFile[]getFilesOrder(Filefile){
File[]files=null;
if(file.exists()){
files=file.listFiles();
Arrays.sort(files,getComparator());
}
returnfiles;
}

privatestaticComparator<?superFile>getComparator(){
returnnewComparator<File>(){
@Override
publicintcompare(Fileo1,Fileo2){
if(o1.isDirectory()&&o2.isFile())
return1;
elseif(o2.isDirectory()&&o1.isFile())
return-1;
else
returno1.getName().compareTo(o2.getName());
}
};
}
}

File 可以是 「文件」，也可以是 「目錄」，分開比較。

另外用 Comparator 比較方便。

❺ Java的幾種常見排序

快速排序法、冒泡法、選擇排序法、插入排序法
1.快速排序：

import java.util.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;
}

❻ 在java中如何給數據進行大小排序

privateList<Integer>mList=newArrayList<>();

mList.add(1);
mList.add(5);
mList.add(7);
mList.add(9);
mList.add(8);
mList.add(3);

//排序前
Log.d(TAG,"onCreate:"+mList.toString());

Collections.sort(mList);

//排序後
Log.d(TAG,"onCreate:"+mList.toString());

列印的Log：
[1,5,7,9,8,3]
[1,3,5,7,8,9]

❼ java中姓名排序~

不是特別理解你想問什麼，我暫且假設你想問的是如何排序然後輸出，若我理解有誤你可以再問。關於字元串的排序首先我們應該規定怎樣比較他們的大小，那麼我假定你想要的是字母靠前的更小，靠後的更大。那麼你可以使用String類的compare方法，然後使用STL的排序演算法排序就可以了。輸出循環輸出即可。

❽ java 排序

public class P
{
public static void main(String[] args)
{
String str="abc";
int loop=str.length()+1;

while(loop>0)
{
System.out.println(str);
str=str.charAt(str.length()-1)+str.substring(0,str.length()-1);
loop--;
}
}
}

❾ java升序排序

其實排序JAVA已經給我們做好了, 你只是需要自己去調用|: 聲明一個import java.util.Collections;再實現implements Comparator 通過Collections調用new 實現implements Comparator的類就行了 下面是代碼: package 別人的程序的分析設計; /** * @author greatwqs * */ import java.util.Collections; import java.util.*; public class myQuiz{ public static void main(String[] args) { Employee e1 = new Employee("Cay",4000); Employee e2 = new Employee("Bush",6000); Manager m1 = new Manager ("Alice",5000); //m1.setBonus(100000); List<Employee> list_1=new ArrayList<Employee>(); list_1.add(e1); list_1.add(e2); list_1.add(m1); System.out.println("以下按薪水排序後輸出[從高到低]"); Collections.sort(list_1,new Qing()); for(Employee e:list_1) System.out.println(e); List<Employee> list_2 = new ArrayList<Employee>(); list_2.add(e1); list_2.add(e2); list_2.add(m1); System.out.println("以下按照姓名字典順序輸出："); Collections.sort(list_2 , new Song()); for(Employee em :list_2){ System.out.println(em); } } } class Qing implements Comparator{ public int compare(Object obj0, Object obj1){ Employee c0 = (Employee)obj0; Employee c1 = (Employee)obj1; if(c0.getSalary() >= c1.getSalary()) return -1; else return 1; } } 下面還有代碼..

❿ Java實現幾種常見排序方法

最主要的是冒泡排序、選擇排序、插入排序以及快速排序

1、冒泡排序

冒泡排序是一個比較簡單的排序方法。在待排序的數列基本有序的情況下排序速度較快。若要排序的數有n個，則需要n-1輪排序，第j輪排序中，從第一個數開始，相鄰兩數比較，若不符合所要求的順序，則交換兩者的位置；直到第n+1-j個數為止，第一個數與第二個數比較，第二個數與第三個數比較，......，第n-j個與第n+1-j個比較，共比較n-1次。此時第n+1-j個位置上的數已經按要求排好，所以不參加以後的比較和交換操作。例如：第一輪排序：第一個數與第二個數進行比較，若不符合要求的順序，則交換兩者的位置，否則繼續進行二個數與第三個數比較......。直到完成第n-1個數與第n個數的比較。此時第n個位置上的數已經按要求排好，它不參與以後的比較和交換操作；第二輪排序：第一個數與第二個數進行比較，......直到完成第n-2個數與第n-1個數的比較；......第n-1輪排序：第一個數與第二個數進行比較，若符合所要求的順序，則結束冒泡法排序；若不符合要求的順序，則交換兩者的位置，然後結束冒泡法排序。
共n-1輪排序處理，第j輪進行n-j次比較和至多n-j次交換。
從以上排序過程可以看出，較大的數像氣泡一樣向上冒，而較小的數往下沉，故稱冒泡法。

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

2、選擇排序

選擇法的原理是先將第一個數與後面的每一個數依次比較,不斷將將小的賦給第一個數,從而找出最小的,然後第二個數與後面的每一個數依次比較,從而找出第二小的,然後第三個數與後面的每一個數依次比較,從而找出第三小的.....直到找到最後一個數。
public void sort(int x[])
{
int n=x.length;
int k,t;
for(int i=0;i<n-1;i++)
{
k=i;
for(int j=i+1;j=n;j++)
{
if(x[j]>x[k])k=j;
if(k!=i)
{
t=x[i];
x[i]=x[k];
x[k]=t;
}
}
}
}

3、插入排序

插入排序的原理是對數組中的第i個元素，認為它前面的i-1個已經排序好，然後將它插入到前面的i-1個元素中。插入排序對少量元素的排序較為有效.

public void sort(int obj[])
{
for(int j=1;j<obj.length;j++)
{
int key=obj[j];
int i=j-1;
while(i>=0&&obj[i]>key)
{
obj[i+1]=obj[i];
i--;
}
obj[i+1]=key;
}
}

4、快速排序

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

public void quickSort(int obj[],int low,int high)
{
int i=low;
int j=high;
int keyValue=obj[i];
while(i<j)
{
int temp=0;
while(i<j&&obj[j]>=keyValue)
{
j=j-1;
}
temp=obj[j];
obj[j]=obj[i];
obj[i]=temp;
while(i<j&&obj[i]<=keyValue)
{
i=i+1;
}
temp=obj[j];
obj[j]=ojb[i];
obj[i]=temp;
}
obj[i]=keyValue;
if(low<i-1)
{
quickSort(obj,low,i-1);
}
if(high>i+1)
{
quickSort(obj,i+1,high);
}
}