java實現排序

① java怎麼實現Windows文件夾里的排序

import java.io.File;
import java.util.Arrays;
import java.util.Comparator;
public class FileSort {
public static void main(String[] args) {
File file = new File("F:/MerDescription/imp-19038075415690540");
if (file.isDirectory()) { // 判斷file是否為目錄
String[] fileNames = file.list();
Arrays.sort(fileNames, new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
if(returnDouble(s1)<returnDouble(s2))
return -1;
else if(returnDouble(s1)>returnDouble(s2))
return 1;
else
return 0;
}
public double returnDouble(String str){
StringBuffer sb = new StringBuffer();
for(int i=0;i<str.length();i++){
if(Character.isDigit(str.charAt(i)))
sb.append(str.charAt(i));
else if(str.charAt(i)=='.'&&i<str.length()-1&&Character.isDigit(str.charAt(i+1)))
sb.append(str.charAt(i));
else break;
}
if(sb.toString().isEmpty())
return 0;
else
return Double.parseDouble(sb.toString());
}
});
for (int i = 0; i < fileNames.length; i++) {
System.out.println(fileNames[i]);
}
}
}
}

② 如何用JAVA實現快速排序演算法

本人特地給你編的代碼x0dx0a親測{(inta[],intp,intr){x0dx0aintx=a[r-1];x0dx0ainti=p-1;x0dx0ainttemp;x0dx0afor(intj=p;j<=r-1;j++){x0dx0aif(a[j-1]<=x){x0dx0a//swap(a[j-1],a[i-1]);x0dx0ai++;x0dx0atemp=a[j-1];x0dx0aa[j-1]=a[i-1];x0dx0aa[i-1]=temp;x0dx0ax0dx0a}x0dx0a}x0dx0a//swap(a[r-1,a[i+1-1]);x0dx0atemp=a[r-1];x0dx0aa[r-1]=a[i+1-1];x0dx0aa[i+1-1]=temp;x0dx0ax0dx0areturni+1;x0dx0ax0dx0a}x0dx0ax0dx0apublicstaticvoidQuickSort(inta[],intp,intr){x0dx0ax0dx0aif(p

③ Java中如何對集合排序

Java內建的排序（冒泡）：Java集合有兩個實現的工具類，Collections和Arrays。Collections針對集合類型。Arrays針對數組。只需要一個為你排序需判叢要的定製的Comparator或Comparable的實現，將其作為參數傳給Collections或Arrays的sort方法就行。
可以自己用畢沖野程序去實現這個排序。用for從原List裡面一個一個手喊拿出來比較然後一個新建的List裡面去。
樓主看一下參考資料。

④ 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

(4)java實現排序擴展閱讀

Java中利用數組進行數字排序一般有4種方法：

1、選擇排序是先將數組中的第一個數作為最大或最小數，然後通過循環比較交換最大數或最小數與一輪比較中第一個數位置進行排序。

2、冒泡排序也是先將數組中的第一個數作為最大或最小數，循環比較相鄰兩個數的大小，滿足條件就互換位置，將最大數或最小數沉底。

3、快速排序法主要是運用Arrays類中的Arrays.sort方法（）實現。

4、插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。

⑤ 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])+",");}}}

運行結果如下：

⑥ 請給出java幾種排序方法

java常見的排序分為：
1 插入類排序
主要就是對於一個已經有序的序列中，插入一個新的記錄。它包括：直接插入排序，折半插入排序和希爾排序
2 交換類排序
這類排序的核心就是每次比較都要「交換」，在每一趟排序都會兩兩發生一系列的「交換」排序，但是每一趟排序都會讓一個記錄排序到它的最終位置上。它包括：起泡排序，快速排序
3 選擇類排序
每一趟排序都從一系列數據中選擇一個最大或最小的記錄，將它放置到第一個或最後一個為位置交換，只有在選擇後才交換，比起交換類排序，減少了交換記錄的時間。屬於它的排序：簡單選擇排序，堆排序
4 歸並類排序
將兩個或兩個以上的有序序列合並成一個新的序列
5 基數排序
主要基於多個關鍵字排序的。
下面針對上面所述的演算法，講解一些常用的java代碼寫的演算法
二 插入類排序之直接插入排序
直接插入排序,一般對於已經有序的隊列排序效果好。
基本思想：每趟將一個待排序的關鍵字按照大小插入到已經排序好的位置上。
演算法思路，從後往前先找到要插入的位置，如果小於則就交換，將元素向後移動，將要插入數據插入該位置即可。時間復雜度為O(n2),空間復雜度為O(1)
package sort.algorithm;
public class DirectInsertSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
int temp, j;
for (int i = 1; i < data.length; i++) {
temp = data[i];
j = i - 1;
// 每次比較都是對於已經有序的
while (j >= 0 && data[j] > temp) {
data[j + 1] = data[j];
j--;
}
data[j + 1] = temp;
}
// 輸出排序好的數據
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}
三 插入類排序之折半插入排序(二分法排序)
條件：在一個已經有序的隊列中，插入一個新的元素
折半插入排序記錄的比較次數與初始序列無關
思想：折半插入就是首先將隊列中取最小位置low和最大位置high，然後算出中間位置mid
將中間位置mid與待插入的數據data進行比較，
如果mid大於data，則就表示插入的數據在mid的左邊，high=mid-1;
如果mid小於data，則就表示插入的數據在mid的右邊,low=mid+1
最後整體進行右移操作。
時間復雜度O(n2),空間復雜度O(1)

package sort.algorithm;
//折半插入排序
public class HalfInsertSort {
public static void main(String[] args) {
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };
// 存放臨時要插入的元素數據
int temp;
int low, mid, high;
for (int i = 1; i < data.length; i++) {
temp = data[i];
// 在待插入排序的序號之前進行折半插入
low = 0;
high = i - 1;
while (low <= high) {
mid = (low + high) / 2;
if (temp < data[mid])
high = mid - 1;
else
// low=high的時候也就是找到了要插入的位置，
// 此時進入循環中，將low加1，則就是要插入的位置了
low = mid + 1;
}
// 找到了要插入的位置，從該位置一直到插入數據的位置之間數據向後移動
for (int j = i; j >= low + 1; j--)
data[j] = data[j - 1];
// low已經代表了要插入的位置了
data[low] = temp;
}
for (int k = 0; k < data.length; k++) {
System.out.print(data[k] + " ");
}
}
}

四 插入類排序之希爾排序
希爾排序，也叫縮小增量排序，目的就是盡可能的減少交換次數，每一個組內最後都是有序的。
將待續按照某一種規則分為幾個子序列，不斷縮小規則，最後用一個直接插入排序合成
空間復雜度為O(1)，時間復雜度為O(nlog2n)
演算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。

package sort.algorithm;
public class ShellSort {
public static void main(String[] args) {
int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };
double d1 = a.length;
int temp = 0;
while (true)
{
//利用這個在將組內倍數減小
//這里依次為5,3,2,1
d1 = Math.ceil(d1 / 2);
//d為增量每個分組之間索引的增量
int d = (int) d1;
//每個分組內部排序
for (int x = 0; x < d; x++)
{
//組內利用直接插入排序
for (int i = x + d; i < a.length; i += d) {
int j = i - d;
temp = a[i];
for (; j >= 0 && temp < a[j]; j -= d) {
a[j + d] = a[j];
}
a[j + d] = temp;
}
}

if (d == 1)
break;
}
for (int i = 0; i < a.length; i++)
System.out.print(a[i]+" ");
}
}

五 交換類排序之冒泡排序
交換類排序核心就是每次比較都要進行交換
冒泡排序：是一種交換排序
每一趟比較相鄰的元素，較若大小不同則就會發生交換，每一趟排序都能將一個元素放到它最終的位置！每一趟就進行比較。
時間復雜度O(n2)，空間復雜度O(1)

package sort.algorithm;
//冒泡排序：是一種交換排序
public class BubbleSort {
// 按照遞增順序排序
public static void main(String[] args) {
// TODO Auto-generated method stub
int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };
int temp = 0;
// 排序的比較趟數,每一趟都會將剩餘最大數放在最後面
for (int i = 0; i < data.length - 1; i++) {
// 每一趟從開始進行比較，將該元素與其餘的元素進行比較
for (int j = 0; j < data.length - 1; j++) {
if (data[j] > data[j + 1]) {
temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
}
for (int i = 0; i < data.length; i++)
System.out.print(data[i] + " ");
}
}

⑦ java實現幾種常見排序演算法

下面給你介紹四種常用排序演算法：

1、冒泡排序

特點：效率低，實現簡單

思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。

⑧ JAVA編程：編程實現將數組int a[]={78 23 56 34 12 45 67 89 90 1}按從小到大順序進行排序

數字自帶有個方法

Arrays.sort(a);

int arry[]={2,1,4,3,7,9,6};

Arrays.sort(arry);

for(Integer a : arry) {

System.out.println(a);

}

例如：

import java.util.Arrays;

public class Test

{

public static void main(String[] args)

{

int a[] = new int[]{8,5,4,2,0,9};

Arrays.sort(a);

System.out.println("排序結果是：");

for(int i=0;i<a.length;i++)

{

System.out.print(a[i]+" ");

}

(8)java實現排序擴展閱讀：

當編輯並運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟體（例如記事本、寫字板、UltraEdit等）或集成開發環境（Eclipse、叢中叢MyEclipse等）在Java源文件中定義不同的類，通過調用類（這些類實現了Java API）中的方法來訪問資源系統，把源文件編譯生成一種二進制中間碼，存儲在class文件中，然後再通過運行與操作系統平滲櫻台環境相對應的Java虛擬機來運行class文件，執行編譯產生的位元組碼，調用class文件中實現的方法來滿足程序的Java API調培仔用。

⑨ 用JAVA排序介面實現

日行一善當學習拉。好久局升沒幫人並或做作業了
首先是介面 compareForNumber.java

public interface compareForNumber {
public int compareTwoNumber(Object obj_1,Object obj_2);
public Object sortTowNumber(Object obj[]);
}

下面是實現介面的具體實現類Test_1.java

public class Test_1 implements compareForNumber{

@Override
public int compareTwoNumber(Object obj_1, Object obj_2) {
int value_1;
int value_2;
try {
value_1 = ((Integer) obj_1).intValue();
value_2 = ((Integer) obj_2).intValue();
if(value_1 > value_2)
{
return value_1;
}else if(value_1 < value_2)
{
return value_2;
}else if(value_1 == value_2){
return 0;
}
} catch (Exception e) {
System.out.println("你輸入不是int類型");
e.printStackTrace();
}
return 0;
}

@Override
public Object sortTowNumber(Object[] obj) {
int maxLength = 0;
String maxValues = "";
int maxLocal = 0;
for(int i =0;i<obj.length;i++)
{
try {
String values = String.valueOf(obj[i]);
if(values.length() > maxLength)
{
maxLength = values.length();
maxValues = values;
maxLocal = i +1;
}
if(i == obj.length-1)
{
System.out.println("該字元串數組最長是" + maxValues + "長度是" + maxLength + "是數組的第" + maxLocal + "個");
}
} catch (Exception e) {
System.out.println("轉型失敗你輸入可能不是字元串數組");
e.printStackTrace();
}
}
return "該字元串數組最長是" + maxValues + "長桐蔽老度是" + maxLength + "是數組的第" + maxLocal + "個";
}

public static void main(String[] args) {
System.out.println(new Test_1().compareTwoNumber(3, 2));//傳入兩個數字比較大小

String a[] = {"ni","nihao","woshizuichangde","nihaoa"};//傳入字元串數組返回結果
new Test_1().sortTowNumber(a);
}
}