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

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

甘泉網(wǎng)站制作公司哪家好，找創(chuàng)新互聯(lián)！從網(wǎng)頁設(shè)計、網(wǎng)站建設(shè)、微信開發(fā)、APP開發(fā)、成都響應(yīng)式網(wǎng)站建設(shè)公司等網(wǎng)站項目制作，到程序開發(fā)，運營維護。創(chuàng)新互聯(lián)2013年至今到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗和運維經(jīng)驗，來保證我們的工作的順利進行。專注于網(wǎng)站建設(shè)就選創(chuàng)新互聯(liá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ù)雜度可以達到O(n)，主要有：計數(shù)排序，基數(shù)排序，桶排序等。

java快速排序簡單代碼

.example-btn{color:#fff;background-color:#5cb85c;border-color:#4cae4c}.example-btn:hover{color:#fff;background-color:#47a447;border-color:#398439}.example-btn:active{background-image:none}div.example{width:98%;color:#000;background-color:#f6f4f0;background-color:#d0e69c;background-color:#dcecb5;background-color:#e5eecc;margin:0 0 5px 0;padding:5px;border:1px solid #d4d4d4;background-image:-webkit-linear-gradient(#fff,#e5eecc 100px);background-image:linear-gradient(#fff,#e5eecc 100px)}div.example_code{line-height:1.4em;width:98%;background-color:#fff;padding:5px;border:1px solid #d4d4d4;font-size:110%;font-family:Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;word-break:break-all;word-wrap:break-word}div.example_result{background-color:#fff;padding:4px;border:1px solid #d4d4d4;width:98%}div.code{width:98%;border:1px solid #d4d4d4;background-color:#f6f4f0;color:#444;padding:5px;margin:0}div.code div{font-size:110%}div.code div,div.code p,div.example_code p{font-family:"courier new"}pre{margin:15px auto;font:12px/20px Menlo,Monaco,Consolas,"Andale Mono","lucida console","Courier New",monospace;white-space:pre-wrap;word-break:break-all;word-wrap:break-word;border:1px solid #ddd;border-left-width:4px;padding:10px 15px} 排序算法是《數(shù)據(jù)結(jié)構(gòu)與算法》中最基本的算法之一。排序算法可以分為內(nèi)部排序和外部排序，內(nèi)部排序是數(shù)據(jù)記錄在內(nèi)存中進行排序，而外部排序是因排序的數(shù)據(jù)很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。常見的內(nèi)部排序算法有：插入排序、希爾排序、選擇排序、冒泡排序、歸并排序、快速排序、堆排序、基數(shù)排序等。以下是快速排序算法：

快速排序是由東尼·霍爾所發(fā)展的一種排序算法。在平均狀況下，排序 n 個項目要 Ο(nlogn) 次比較。在最壞狀況下則需要 Ο(n2) 次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他 Ο(nlogn) 算法更快，因為它的內(nèi)部循環(huán)（inner loop）可以在大部分的架構(gòu)上很有效率地被實現(xiàn)出來。

快速排序使用分治法（Divide and conquer）策略來把一個串行（list）分為兩個子串行（sub-lists）。

快速排序又是一種分而治之思想在排序算法上的典型應(yīng)用。本質(zhì)上來看，快速排序應(yīng)該算是在冒泡排序基礎(chǔ)上的遞歸分治法。

快速排序的名字起的是簡單粗暴，因為一聽到這個名字你就知道它存在的意義，就是快，而且效率高！它是處理大數(shù)據(jù)最快的排序算法之一了。雖然 Worst Case 的時間復(fù)雜度達到了 O(n?)，但是人家就是優(yōu)秀，在大多數(shù)情況下都比平均時間復(fù)雜度為 O(n logn) 的排序算法表現(xiàn)要更好，可是這是為什么呢，我也不知道。好在我的強迫癥又犯了，查了 N 多資料終于在《算法藝術(shù)與信息學競賽》上找到了滿意的答案：

快速排序的最壞運行情況是 O(n?)，比如說順序數(shù)列的快排。但它的平攤期望時間是 O(nlogn)，且 O(nlogn) 記號中隱含的常數(shù)因子很小，比復(fù)雜度穩(wěn)定等于 O(nlogn) 的歸并排序要小很多。所以，對絕大多數(shù)順序性較弱的隨機數(shù)列而言，快速排序總是優(yōu)于歸并排序。

1. 算法步驟

從數(shù)列中挑出一個元素，稱為 "基準"（pivot）;

重新排序數(shù)列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數(shù)可以到任一邊）。在這個分區(qū)退出之后，該基準就處于數(shù)列的中間位置。這個稱為分區(qū)（partition）操作；

遞歸地（recursive）把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序；

2. 動圖演示

代碼實現(xiàn) JavaScript 實例 function quickSort ( arr , left , right ) {

var len = arr. length ,

? ? partitionIndex ,

? ? left = typeof left != 'number' ? 0 : left ,

? ? right = typeof right != 'number' ? len - 1 : right ;

if ( left

java編程的冒泡等排序示例

Java排序算法

1）分類：

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

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

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

4）歸并排序

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

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

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

平均速度最快：快速排序

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

1）選擇排序算法的時候

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

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

3）總結(jié)：

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

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

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

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

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

——按平均的空間性能來分（指的是排序過程中所需的輔助空間大?。?/p>

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

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

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

4）鏈式基數(shù)排序需附設(shè)隊列首尾指針，則空間復(fù)雜度為O(rd )。

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

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

2） 當對多關(guā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位置當哨兵。

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

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

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

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

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

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

插入排序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ù)進行排序的一種排序算法。如果在你的數(shù)據(jù)清單中只有一兩個數(shù)據(jù)是亂序的話，用這種算法就是最快的排序算法。如果你的數(shù)據(jù)清單中的數(shù)據(jù)是隨機排列的，那么這種方法就成了最慢的算法了。因此在使用這種算法之前一定要慎重。這種算法的核心思想是掃描數(shù)據(jù)清單，尋找出現(xiàn)亂序的兩個相鄰的項目。當找到這兩個項目后，交換項目的位置然后繼續(xù)掃描。重復(fù)上面的操作直到所有的項目都按順序排好。

快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關(guān)鍵字均比另一部分記錄的關(guān)鍵字小，則可分別對這兩部分記錄繼續(xù)進行排序，以達到整個序列有序。具體做法是：使用兩個指針low,high, 初值分別設(shè)置為序列的頭，和序列的尾，設(shè)置pivotkey為第一個記錄，首先從high開始向前搜索第一個小于pivotkey的記錄和pivotkey所在位置進行交換，然后從low開始向后搜索第一個大于pivotkey的記錄和此時pivotkey所在位置進行交換，重復(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)整，直到到達根結(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ù)組相同，遞歸做法。每次將目標序列分解成兩個序列，分別排序兩個子序列之后，再將兩個排序好的子序列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ù)放進輔助隊列，搞定之后回收。下次再以高一位開始的數(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堆排序代碼

//從a[index]到a[len]除了a[index]外其它元素滿足一個堆，把a[index]調(diào)整到合適位置

//這個堆滿足父節(jié)點孩子結(jié)點，且要保證2*index能取到index的左孩子，

public static void adjustHeap(int[] a,int index,int len){

int scn=a[index];

for(int i=2*index;i=m;i*=2){

if(ima[i]a[i+1])i+=1;

if(!a[i]scn)break;

a[index]=a[i];index=i;

}

a[index]=scn;

}

//數(shù)組a從a[1]開始存放元素，如果想從a[0]開始則要調(diào)整adjustHeap代碼，以便滿足完全二叉樹

//性質(zhì)，代碼未經(jīng)測試

public static void heapSort(int[] a){

for(int i=(a.length-1)/2;i0;i--)

adjustHeap(a,i,a.length-1);

int tmp;

for(int i=a.length-1;i1;i--){

tmp=a[i];

a[i]=a[1];

a[1]=tmp;

adjustHeap(a,1,i-1);

}

}

網(wǎng)站題目：堆排序java代碼 堆排序的算法及代碼實現(xiàn)
地址分享：http://sd-ha.com/article48/doijpep.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)站導(dǎo)航、軟件開發(fā)、關(guān)鍵詞優(yōu)化、企業(yè)網(wǎng)站制作、小程序開發(fā)、網(wǎng)頁設(shè)計公司

廣告

聲明：本網(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)