javalist的排序演算法
下面給你介紹四種常用排序演算法：
1、冒泡排序
特點：效率低，實現簡單
思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。
㈡ Java List提供的默認排序方法sort()用的是什麼排序策略
你好，很高興回答你的問題。
List只是個介面，sort方法具體是怎麼排序的是在具體的實現類中的。
不同的實現類排序實現是不一樣的。有的同一個實現類在java的不同版本中排序的實現也可能是有差別的。
如果有幫助到你，請點擊採納。
㈢ 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; }
㈣ java List<T>排序
一、首先你的SpecialArticle類要實現 java.util.Comparator介面，在public int compare(Object o1, Object o2) 方法中對比兩個SpecialArticle的sort屬性的大小，第一個的大就返回1，第二個的大就返回-1，一樣大就返回0；二、然後使用java.util.Arrays的sort方法來替List集合排序：java.util.Arrays.sort(sa);。
㈤ 關於各種排列組合java演算法實現方法
一 利用二進制狀態法求排列組合 此種方法比較容易懂 但是運行喊隱頌效率不高 小數據排列組合可以使用
復制代碼 代碼如下: import java util Arrays;//利用二進制演算法進行全排列 //count : //count :
public class test { public static void main(String[] args) { long start=System currentTimeMillis(); count (); long end=System currentTimeMillis(); System out println(end start); } private static void count (){ int[] num=new int []{ }; for(int i= ;i<Math pow( );i++){ String str=Integer toString(i ); int sz=str length(); for(int j= ;j< sz;j++){ str=" "+str; } char[] temp=str toCharArray(); Arrays sort(temp); String gl=new String(temp); if(!gl equals(" ")){ continue; } String result=""; for(int m= ;m<str length();m++){ result+=num[Integer parseInt(str charAt(m)+"")]; } System out println(result); } } public static void count (){ int[] num=new int []{ }; int[] ss=new int []{ }; int[] temp=new int[ ]; while(temp[ ]< ){ temp[temp length ]++; for(int i=temp length ;i> ;i ){ if(temp[i]== ){ temp[i]= ; temp[i ]++; } } int []tt=temp clone(); Arrays sort(tt); if(!Arrays equals(tt ss)){ continue; } String result=""; for(int i= ;i<num length;i++){ result+=num[temp[i]]; } System out println(result); } } }
二 用遞歸的思想攜慧來求排列跟組合 代碼量比較大
復制代碼 代碼如下鄭鄭: package practice;import java util ArrayList; import java util List;
public class Test {
/** * @param args */ public static void main(String[] args) { // TODO Auto generated method stub Object[] tmp={ }; // ArrayList<Object[]> rs=RandomC(tmp); ArrayList<Object[]> rs=cmn(tmp ); for(int i= ;i<rs size();i++) { // System out print(i+"="); for(int j= ;j<rs get(i) length;j++) { System out print(rs get(i)[j]+" "); } System out println(); } }
// 求一個數組的任意組合 static ArrayList<Object[]> RandomC(Object[] source) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(source length== ) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=RandomC(psource); int len=result size();//fn組合的長度 result add((new Object[]{source[source length ]})); for(int i= ;i<len;i++) { Object[] tmp=new Object[result get(i) length+ ]; for(int j= ;j<tmp length ;j++) { tmp[j]=result get(i)[j]; } tmp[tmp length ]=source[source length ]; result add(tmp); } } return result; } static ArrayList<Object[]> cmn(Object[] source int n) { ArrayList<Object[]> result=new ArrayList<Object[]>(); if(n== ) { for(int i= ;i<source length;i++) { result add(new Object[]{source[i]}); } } else if(source length==n) { result add(source); } else { Object[] psource=new Object[source length ]; for(int i= ;i<psource length;i++) { psource[i]=source[i]; } result=cmn(psource n); ArrayList<Object[]> tmp=cmn(psource n ); for(int i= ;i<tmp size();i++) { Object[] rs=new Object[n]; for(int j= ;j<n ;j++) { rs[j]=tmp get(i)[j]; } rs[n ]=source[source length ]; result add(rs); } } return result; }
}
三 利用動態規劃的思想求排列和組合
復制代碼 代碼如下: package Acm; //強大的求組合數 public class MainApp { public static void main(String[] args) { int[] num=new int[]{ }; String str=""; //求 個數的組合個數 // count( str num ); // 求 n個數的組合個數 count ( str num); }private static void count (int i String str int[] num) { if(i==num length){ System out println(str); return; } count (i+ str num); count (i+ str+num[i]+" " num); }
private static void count(int i String str int[] num int n) { if(n== ){ System out println(str); return; } if(i==num length){ return; } count(i+ str+num[i]+" " num n ); count(i+ str num n); } }
下面是求排列
復制代碼 代碼如下: lishixin/Article/program/Java/JSP/201311/20148
㈥ java中快速排序的演算法舉個例子
package person.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* class name: RapidSort
* description: Java快速排序法：數組和集合
* @author Jr
*
*/
public class RapidSort {
private Random ran = new Random(); // 聲明一個全局變數ran，用來隨機生成整數
/**
* method name: sortArray
* description: 對數組的快速排序，只能用於int[]類型的數組
* @return
*/
private void sortArray() {
int[] array = new int[10]; // 聲明數組長度為10
for (int i = 0 ; i < array.length; i++) {
array[i] = ran.nextInt(10) + 1; // 數組賦值
}
Arrays.sort(array);
System.out.println(Arrays.toString(array));
}
/**
* method name: sortList
* description: 對集合的快速排序，可以用於List<Object>類型數組，
* 隱含意思就是對所有類型數組都適用
* @return
*/
private void sortList() {
List<Integer> list = new ArrayList<Integer>();
for (int i = 0 ; i < 10; i++) {
list.add(ran.nextInt(10) + 1); // 給集合賦10個值
}
Collections.sort(list);
System.out.println(list);
}
public static void main(String[] args) {
RapidSort rs = new RapidSort();
rs.sortArray();
rs.sortList();
}
}
㈦ Java的排序演算法有哪些
java的排序大的分類可以分為兩種：內排序和外排序。在排序過程中，全部記錄存放在內存，則稱為內排序，如果排序過程中需要使用外存，則稱為外排序。下面講的排序都是屬於內排序。
1.插入排序：直接插入排序、二分法插入排序、希爾排序。
2.選擇排序：簡單選擇排序、堆排序。
3.交換排序：冒泡排序、快速排序。
4.歸並排序
5.基數排序
㈧ java 實現ArrayList的sort
java中可以使用Sort方法，可以對集合中的元素進行排序。Sort有三種重載方法，聲明代碼如下所示。
public void Sort();
//使用集合元素的比較方式進行排序
public void Sort(IComparer comparer);
//使用自定義比較器進行排序
public void Sort(int index, int count, IComparer comparer)
//使用自定義比較器進行指定范圍的排序
注意：為使用Sort方法進行排序，集合中的所有元素必須實現IComparable介面，否則，將拋出異常。
這里介紹使用第一種方法進行簡單的排序實例
using System;
using System.Collections;
class Program{
static void Main(string[] args)
{
ArrayList al = new ArrayList();
al.AddRange(new string[8] { "Array1", "Array2", "Array3", "Array5", "Array4", "Array8", "Array7", "Array6" });
al.Sort();
foreach (string s in al)
{
Console.WriteLine(s);
}
Console.ReadLine();
}
}
㈨ 在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]