java編程的冒泡等排序示例

Java排序算法

目前創(chuàng)新互聯(lián)公司已為1000多家的企業(yè)提供了網(wǎng)站建設(shè)、域名、虛擬空間、綿陽服務(wù)器托管、企業(yè)網(wǎng)站設(shè)計、井研網(wǎng)站維護(hù)等服務(wù)，公司將堅持客戶導(dǎo)向、應(yīng)用為本的策略，正道將秉承"和諧、參與、激情"的文化，與客戶和合作伙伴齊心協(xié)力一起成長，共同發(fā)展。

1）分類：

1）插入排序（直接插入排序、希爾排序）

2）交換排序（冒泡排序、快速排序）

3）選擇排序（直接選擇排序、堆排序）

4）歸并排序

5）分配排序（箱排序、基數(shù)排序）

所需輔助空間最多：歸并排序

所需輔助空間最少：堆排序

平均速度最快：快速排序

不穩(wěn)定：快速排序，希爾排序，堆排序。

1）選擇排序算法的時候

1.數(shù)據(jù)的規(guī)模 ； 2.數(shù)據(jù)的類型 ； 3.數(shù)據(jù)已有的順序

一般來說，當(dāng)數(shù)據(jù)規(guī)模較小時，應(yīng)選擇直接插入排序或冒泡排序。任何排序算法在數(shù)據(jù)量小時基本體現(xiàn)不出來差距。 考慮數(shù)據(jù)的類型，比如如果全部是正整數(shù)，那么考慮使用桶排序為最優(yōu)。 考慮數(shù)據(jù)已有順序，快排是一種不穩(wěn)定的排序（當(dāng)然可以改進(jìn)），對于大部分排好的數(shù)據(jù)，快排會浪費大量不必要的步驟。數(shù)據(jù)量極小，而起已經(jīng)基本排好序，冒泡是最佳選擇。我們說快排好，是指大量隨機(jī)數(shù)據(jù)下，快排效果最理想。而不是所有情況。

3）總結(jié)：

——按平均的時間性能來分：

1）時間復(fù)雜度為O(nlogn)的方法有：快速排序、堆排序和歸并排序，其中以快速排序為最好；

2）時間復(fù)雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特 別是對那些對關(guān)鍵字近似有序的記錄序列尤為如此；

3）時間復(fù)雜度為O(n)的排序方法只有，基數(shù)排序。

當(dāng)待排記錄序列按關(guān)鍵字順序有序時，直接插入排序和起泡排序能達(dá)到O(n)的時間復(fù)雜度;而對于快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應(yīng)該盡量避免的情況。簡單選擇排序、堆排序和歸并排序的時間性能不隨記錄序列中關(guān)鍵字的分布而改變。

——按平均的空間性能來分（指的是排序過程中所需的輔助空間大小）：

1） 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間復(fù)雜度為O(1)；

2） 快速排序為O(logn )，為棧所需的輔助空間;

3） 歸并排序所需輔助空間最多，其空間復(fù)雜度為O(n );

4）鏈?zhǔn)交鶖?shù)排序需附設(shè)隊列首尾指針，則空間復(fù)雜度為O(rd )。

——排序方法的穩(wěn)定性能：

1） 穩(wěn)定的排序方法指的是，對于兩個關(guān)鍵字相等的記錄，它們在序列中的相對位置，在排序之前和 經(jīng)過排序之后，沒有改變。

2） 當(dāng)對多關(guān)鍵字的記錄序列進(jìn)行LSD方法排序時，必須采用穩(wěn)定的排序方法。

3） 對于不穩(wěn)定的排序方法，只要能舉出一個實例說明即可。

4） 快速排序，希爾排序和堆排序是不穩(wěn)定的排序方法。

4）插入排序：

包括直接插入排序，希爾插入排序。

直接插入排序： 將一個記錄插入到已經(jīng)排序好的有序表中。

1, sorted數(shù)組的第0個位置沒有放數(shù)據(jù)。

2，從sorted第二個數(shù)據(jù)開始處理：

如果該數(shù)據(jù)比它前面的數(shù)據(jù)要小，說明該數(shù)據(jù)要往前面移動。

首先將該數(shù)據(jù)備份放到 sorted的第0位置當(dāng)哨兵。

然后將該數(shù)據(jù)前面那個數(shù)據(jù)后移。

然后往前搜索，找插入位置。

找到插入位置之后講 第0位置的那個數(shù)據(jù)插入對應(yīng)位置。

O(n*n), 當(dāng)待排記錄序列為正序時，時間復(fù)雜度提高至O(n)。

希爾排序（縮小增量排序 diminishing increment sort）：先將整個待排記錄序列分割成若干個子序列分別進(jìn)行直接插入排序，待整個序列中的記錄基本有序時，再對全體記錄進(jìn)行一次直接插入排序。

面試穿什么，這里找答案！

插入排序Java代碼：

public class InsertionSort {

// 插入排序：直接插入排序 ，希爾排序

public void straightInsertionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=2;jsortedLen;j++){

if(sorted[j]sorted[j-1]){

sorted[0]= sorted[j];//先保存一下后面的那個

sorted[j]=sorted[j-1];// 前面的那個后移。

int insertPos=0;

for(int k=j-2;k=0;k--){

if(sorted[k]sorted[0]){

sorted[k+1]=sorted[k];

}else{

insertPos=k+1;

break;

}

}

sorted[insertPos]=sorted[0];

}

}

}

public void shellInertionSort(double [] sorted, int inc){

int sortedLen= sorted.length;

for(int j=inc+1;jsortedLen;j++ ){

if(sorted[j]sorted[j-inc]){

sorted[0]= sorted[j];//先保存一下后面的那個

int insertPos=j;

for(int k=j-inc;k=0;k-=inc){

if(sorted[k]sorted[0]){

sorted[k+inc]=sorted[k];

//數(shù)據(jù)結(jié)構(gòu)課本上這個地方?jīng)]有給出判讀，出錯：

if(k-inc=0){

insertPos = k;

}

}else{

insertPos=k+inc;

break;

}

}

sorted[insertPos]=sorted[0];

}

}

}

public void shellInsertionSort(double [] sorted){

int[] incs={7,5,3,1};

int num= incs.length;

int inc=0;

for(int j=0;jnum;j++){

inc= incs[j];

shellInertionSort(sorted,inc);

}

}

public static void main(String[] args) {

Random random= new Random(6);

int arraysize= 21;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

InsertionSort sorter=new InsertionSort();

// sorter.straightInsertionSort(sorted);

sorter.shellInsertionSort(sorted);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面試穿什么，這里找答案！

5）交換排序：

包括冒泡排序，快速排序。

冒泡排序法：該算法是專門針對已部分排序的數(shù)據(jù)進(jìn)行排序的一種排序算法。如果在你的數(shù)據(jù)清單中只有一兩個數(shù)據(jù)是亂序的話，用這種算法就是最快的排序算法。如果你的數(shù)據(jù)清單中的數(shù)據(jù)是隨機(jī)排列的，那么這種方法就成了最慢的算法了。因此在使用這種算法之前一定要慎重。這種算法的核心思想是掃描數(shù)據(jù)清單，尋找出現(xiàn)亂序的兩個相鄰的項目。當(dāng)找到這兩個項目后，交換項目的位置然后繼續(xù)掃描。重復(fù)上面的操作直到所有的項目都按順序排好。

快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關(guān)鍵字均比另一部分記錄的關(guān)鍵字小，則可分別對這兩部分記錄繼續(xù)進(jìn)行排序，以達(dá)到整個序列有序。具體做法是：使用兩個指針low,high, 初值分別設(shè)置為序列的頭，和序列的尾，設(shè)置pivotkey為第一個記錄，首先從high開始向前搜索第一個小于pivotkey的記錄和pivotkey所在位置進(jìn)行交換，然后從low開始向后搜索第一個大于pivotkey的記錄和此時pivotkey所在位置進(jìn)行交換，重復(fù)知道low=high了為止。

交換排序Java代碼：

public class ExchangeSort {

public void BubbleExchangeSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=sortedLen;j0;j--){

int end= j;

for(int k=1;kend-1;k++){

double tempB= sorted[k];

sorted[k]= sorted[k]sorted[k+1]?

sorted[k]:sorted[k+1];

if(Math.abs(sorted[k]-tempB)10e-6){

sorted[k+1]=tempB;

}

}

}

}

public void QuickExchangeSortBackTrack(double [] sorted,

int low,int high){

if(lowhigh){

int pivot= findPivot(sorted,low,high);

QuickExchangeSortBackTrack(sorted,low,pivot-1);

QuickExchangeSortBackTrack(sorted,pivot+1,high);

}

}

public int findPivot(double [] sorted, int low, int high){

sorted[0]= sorted[low];

while(lowhigh){

while(lowhigh sorted[high]= sorted[0])--high;

sorted[low]= sorted[high];

while(lowhigh sorted[low]=sorted[0])++low;

sorted[high]= sorted[low];

}

sorted[low]=sorted[0];

return low;

}

public static void main(String[] args) {

Random random= new Random(6);

int arraysize= 21;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

ExchangeSort sorter=new ExchangeSort();

// sorter.BubbleExchangeSort(sorted);

sorter.QuickExchangeSortBackTrack(sorted, 1, arraysize-1);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

6）選擇排序：

分為直接選擇排序， 堆排序

直接選擇排序：第i次選取 i到array.Length-1中間最小的值放在i位置。

堆排序：首先，數(shù)組里面用層次遍歷的順序放一棵完全二叉樹。從最后一個非終端結(jié)點往前面調(diào)整，直到到達(dá)根結(jié)點，這個時候除根節(jié)點以外的所有非終端節(jié)點都已經(jīng)滿足堆得條件了，于是需要調(diào)整根節(jié)點使得整個樹滿足堆得條件，于是從根節(jié)點開始，沿著它的兒子們往下面走（最大堆沿著最大的兒子走，最小堆沿著最小的兒子走）。 主程序里面，首先從最后一個非終端節(jié)點開始調(diào)整到根也調(diào)整完，形成一個heap， 然后將heap的根放到后面去（即：每次的樹大小會變化，但是 root都是在1的位置，以方便計算兒子們的index，所以如果需要升序排列，則要逐步大頂堆。因為根節(jié)點被一個個放在后面去了。 降序排列則要建立小頂堆）

代碼中的問題： 有時候第2個和第3個順序不對（原因還沒搞明白到底代碼哪里有錯）

選擇排序Java代碼：

public class SelectionSort {

public void straitSelectionSort(double [] sorted){

int sortedLen= sorted.length;

for(int j=1;jsortedLen;j++){

int jMin= getMinIndex(sorted,j);

exchange(sorted,j,jMin);

}

}

public void exchange(double [] sorted,int i,int j){

int sortedLen= sorted.length;

if(isortedLen jsortedLen ij i=0 j=0){

double temp= sorted[i];

sorted[i]=sorted[j];

sorted[j]=temp;

}

}

public int getMinIndex(double [] sorted, int i){

int sortedLen= sorted.length;

int minJ=1;

double min= Double.MAX_VALUE;

for(int j=i;jsortedLen;j++){

if(sorted[j]min){

min= sorted[j];

minJ= j;

}

}

return minJ;

}

public void heapAdjust(double [] sorted,int start,int end){

if(startend){

double temp= sorted;

// 這個地方j(luò)end與課本不同，j=end會報錯：

for(int j=2*start;jend;j *=2){

if(j+1end sorted[j]-sorted[j+1]10e-6){

++j;

}

if(temp=sorted[j]){

break;

}

sorted=sorted[j];

start=j;

}

sorted=temp;

}

}

public void heapSelectionSort(double [] sorted){

int sortedLen = sorted.length;

for(int i=sortedLen/2;i0;i--){

heapAdjust(sorted,i,sortedLen);

}

for(int i=sortedLen;i1;--i){

exchange(sorted,1,i);

heapAdjust(sorted,1,i-1);

}

}

public static void main(String [] args){

Random random= new Random(6);

int arraysize=9;

double [] sorted=new double[arraysize];

System.out.print("Before Sort:");

for(int j=1;jarraysize;j++){

sorted[j]= (int)(random.nextDouble()* 100);

System.out.print((int)sorted[j]+" ");

}

System.out.println();

SelectionSort sorter=new SelectionSort();

// sorter.straitSelectionSort(sorted);

sorter.heapSelectionSort(sorted);

System.out.print("After Sort:");

for(int j=1;jsorted.length;j++){

System.out.print((int)sorted[j]+" ");

}

System.out.println();

}

}

面試穿什么，這里找答案！

7）歸并排序：

將兩個或兩個以上的有序表組合成一個新的有序表。歸并排序要使用一個輔助數(shù)組，大小跟原數(shù)組相同，遞歸做法。每次將目標(biāo)序列分解成兩個序列，分別排序兩個子序列之后，再將兩個排序好的子序列merge到一起。

歸并排序Java代碼：

public class MergeSort {

private double[] bridge;//輔助數(shù)組

public void sort(double[] obj){

if (obj == null){

throw new NullPointerException("

The param can not be null!");

}

bridge = new double[obj.length]; // 初始化中間數(shù)組

mergeSort(obj, 0, obj.length - 1); // 歸并排序

bridge = null;

}

private void mergeSort(double[] obj, int left, int right){

if (left right){

int center = (left + right) / 2;

mergeSort(obj, left, center);

mergeSort(obj, center + 1, right);

merge(obj, left, center, right);

}

}

private void merge(double[] obj, int left,

int center, int right){

int mid = center + 1;

int third = left;

int tmp = left;

while (left = center mid = right){

// 從兩個數(shù)組中取出小的放入中間數(shù)組

if (obj[left]-obj[mid]=10e-6){

bridge[third++] = obj[left++];

} else{

bridge[third++] = obj[mid++];

}

}

// 剩余部分依次置入中間數(shù)組

while (mid = right){

bridge[third++] = obj[mid++];

}

while (left = center){

bridge[third++] = obj[left++];

}

// 將中間數(shù)組的內(nèi)容拷貝回原數(shù)組

copy(obj, tmp, right);

}

private void copy(double[] obj, int left, int right)

{

while (left = right){

obj[left] = bridge[left];

left++;

}

}

public static void main(String[] args) {

Random random = new Random(6);

int arraysize = 10;

double[] sorted = new double[arraysize];

System.out.print("Before Sort:");

for (int j = 0; j arraysize; j++) {

sorted[j] = (int) (random.nextDouble() * 100);

System.out.print((int) sorted[j] + " ");

}

System.out.println();

MergeSort sorter = new MergeSort();

sorter.sort(sorted);

System.out.print("After Sort:");

for (int j = 0; j sorted.length; j++) {

System.out.print((int) sorted[j] + " ");

}

System.out.println();

}

}

面試穿什么，這里找答案！

8）基數(shù)排序：

使用10個輔助隊列，假設(shè)最大數(shù)的數(shù)字位數(shù)為 x， 則一共做 x次，從個位數(shù)開始往前，以第i位數(shù)字的大小為依據(jù)，將數(shù)據(jù)放進(jìn)輔助隊列，搞定之后回收。下次再以高一位開始的數(shù)字位為依據(jù)。

以Vector作輔助隊列，基數(shù)排序的Java代碼：

public class RadixSort {

private int keyNum=-1;

private VectorVectorDouble util;

public void distribute(double [] sorted, int nth){

if(nth=keyNum nth0){

util=new VectorVectorDouble();

for(int j=0;j10;j++){

Vector Double temp= new Vector Double();

util.add(temp);

}

for(int j=0;jsorted.length;j++){

int index= getNthDigit(sorted[j],nth);

util.get(index).add(sorted[j]);

}

}

}

public int getNthDigit(double num,int nth){

String nn= Integer.toString((int)num);

int len= nn.length();

if(len=nth){

return Character.getNumericValue(nn.charAt(len-nth));

}else{

return 0;

}

}

public void collect(double [] sorted){

int k=0;

for(int j=0;j10;j++){

int len= util.get(j).size();

if(len0){

for(int i=0;ilen;i++){

sorted[k++]= util.get(j).get(i);

}

}

}

util=null;

}

public int getKeyNum(double [] sorted){

double max= Double.MIN_VALUE;

for(int j=0;jsorted.length;j++){

if(sorted[j]max){

max= sorted[j];

}

}

return Integer.toString((int)max).length();

}

public void radixSort(double [] sorted){

if(keyNum==-1){

keyNum= getKeyNum(sorted);

}

for(int i=1;i=keyNum;i++){

distribute(sorted,i);

collect(sorted);

}

}

public static void main(String[] args) {

Random random = new Random(6);

int arraysize = 21;

double[] sorted = new double[arraysize];

System.out.print("Before Sort:");

for (int j = 0; j arraysize; j++) {

sorted[j] = (int) (random.nextDouble() * 100);

System.out.print((int) sorted[j] + " ");

}

System.out.println();

RadixSort sorter = new RadixSort();

sorter.radixSort(sorted);

System.out.print("After Sort:");

for (int j = 0; j sorted.length; j++) {

System.out.print((int) sorted[j] + " ");

}

System.out.println();

}

}

//copy而來

java 桶排序 輸入n個0~1000之間的整數(shù)，將它們從大到小排序。謝謝啦

import?java.util.Scanner;

public?class?Help?{

public?static?void?main(String[]?args)?{

Scanner?sc=new?Scanner(System.in);

int?size=sc.nextInt();//記錄次數(shù)n

int[]?s=new?int[size];//儲存數(shù)字的數(shù)組

for(int?i=0;isize;i++){

int?p=sc.nextInt();

if(0pp1000){//進(jìn)行判斷

s[i]=p;

}

else{

System.out.println("您輸入的數(shù)字非法！");}

}

Arrays.sort(s);//從小到大排序

for(int?i=0;i=(int)size/2;i++){//再將順序倒過來

int?l=s.length;

int?ss=s[i];

s[i]=s[l-1-i];

s[l-1-i]=ss;

}

for(int?i=0;isize;i++)?{

System.out.println(s[i]);

}

}

}

不懂再問哦~~~

java排序算法有多少種

算法和語言無關(guān)吧，語言只是把具體的算法實現(xiàn)出來而已。據(jù)我了解的排序算法11-13種。排序算法嘛 主要就是個思想而已。不同的算法時間復(fù)雜度不一樣，空間復(fù)雜度也不一樣，當(dāng)然執(zhí)行的效率也不一樣。當(dāng)然采用哪種算法還取決于你要實現(xiàn)什么樣的功能。就好比說：要同時盡快的找出最大最小，或者盡快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)

雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)

插入排序 （insertion sort）— O(n2)

桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體

計數(shù)排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體

歸并排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體

原地歸并排序 — O(n2)

二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體

鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體

基數(shù)排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體

Gnome sort — O(n2)

Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體不穩(wěn)定

選擇排序 （selection sort）— O(n2)

希爾排序 （shell sort）— O(n log n) 如果使用最佳的現(xiàn)在版本

Comb sort — O(n log n)

堆排序 （heapsort）— O(n log n)

Smoothsort — O(n log n)

快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數(shù)串列一般相信是最快的已知排序

等。

java 怎么將List里面數(shù)據(jù)排序

學(xué)生實體類，包含姓名和年齡屬性，

比較時先按姓名升序排序，如果姓名相同則按年齡升序排序。

第一種：實體類自己實現(xiàn)比較

（實現(xiàn)comparable接口：public interface ComparableT ，里面就一個方法聲明：public int compareTo(T o); ）

然后利用List類的sort(Comparator? super E c)方法或java.util.Collections工具類的sort(ListT list) （其實里面就一句：list.sort(null); ）進(jìn)行排序：

結(jié)果：

第二種：借助比較器進(jìn)行排序。

示例代碼：

比較器java.util.Comparator類是一個接口（public interface ComparatorT )，包含int compare(T o1, T o2);等方法：

我們的比較器要實現(xiàn)該接口并實現(xiàn)compare方法：

比較的時候可以利用List的sort(Comparator? super E c)方法（或者java.util.Collections工具類的sort(ListT list, Comparator? super T c)方法）進(jìn)行排序。

結(jié)果跟第一種方法一樣：

java怎么實現(xiàn)排序

Java實現(xiàn)幾種常見排序方法

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

以下常見算法的定義

1. 插入排序：插入排序基本操作就是將一個數(shù)據(jù)插入到已經(jīng)排好序的有序數(shù)據(jù)中，從而得到一個新的、個數(shù)加一的有序數(shù)據(jù)，算法適用于少量數(shù)據(jù)的排序，時間復(fù)雜度為O(n^2)。是穩(wěn)定的排序方法。插入排序的基本思想是：每步將一個待排序的紀(jì)錄，按其關(guān)鍵碼值的大小插入前面已經(jīng)排序的文件中適當(dāng)位置上，直到全部插入完為止。

2. 選擇排序：選擇排序（Selection sort）是一種簡單直觀的排序算法。它的工作原理是每一次從待排序的數(shù)據(jù)元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數(shù)據(jù)元素排完。 選擇排序是不穩(wěn)定的排序方法。

3. 冒泡排序：冒泡排序（Bubble Sort），是一種計算機(jī)科學(xué)領(lǐng)域的較簡單的排序算法。它重復(fù)地走訪過要排序的數(shù)列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個算法的名字由來是因為越大的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端。

4. 快速排序：快速排序（Quicksort）是對冒泡排序的一種改進(jìn)。它的基本思想是：通過一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排序，整個排序過程可以遞歸進(jìn)行，以此達(dá)到整個數(shù)據(jù)變成有序序列。

5. 歸并排序：歸并排序是建立在歸并操作上的一種有效的排序算法,該算法是采用分治法（Divide and Conquer）的一個非常典型的應(yīng)用。將已有序的子序列合并，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合并成一個有序表，稱為二路歸并。

6. 希爾排序：希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進(jìn)版本。希爾排序是非穩(wěn)定排序算法。希爾排序是把記錄按下標(biāo)的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關(guān)鍵詞越來越多，當(dāng)增量減至1時，整個文件恰被分成一組，算法便終止。

java 編寫一個程序,輸入3個整數(shù),然后程序?qū)@三個整數(shù)按照從大到小進(jìn)行排列

可以實現(xiàn)比較器Comparator來定制排序方案，同時使用Colletions.sort的方式進(jìn)行排序，代碼如下：

public void sortDesc(ListLong s){

Collections.sort(s, new ComparatorLong() {

public int compare(Long o1, Long o2) {

Long result = o2 - o1;

return result.intValue();

}

});

s.forEach(item-{

System.out.print(item +" ");

});

}

同時常用的比較排序算法主要有：冒泡排序，選擇排序，插入排序，歸并排序，堆排序，快速排序等。

java的冒泡排序?qū)崿F(xiàn)如下：

public?static?void?bubbleSort(int?[]arr)?{????????for(int?i?=0;iarr.length-1;i++)?{????????????for(int?j=0;jarr.length-i-1;j++)?{//-1為了防止溢出????????????????if(arr[j]arr[j+1])?{????????????????????int?temp?=?arr[j];?????????????????????????????????????????arr[j]=arr[j+1];?????????????????????????????????????????arr[j+1]=temp;????????????}????????????}????????????}????}

還有非比較排序，時間復(fù)雜度可以達(dá)到O(n)，主要有：計數(shù)排序，基數(shù)排序，桶排序等。

新聞標(biāo)題：用java代碼寫桶排序法,編程桶排序
標(biāo)題鏈接：http://chinadenli.net/article43/dsgpshs.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供服務(wù)器托管、網(wǎng)站策劃、ChatGPT、網(wǎng)站導(dǎo)航、手機(jī)網(wǎng)站建設(shè)、外貿(mào)建站

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)