本文目錄一覽：
請給出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培訓學校告訴你JS排序之冒泡排序以及寫法？
時間複雜度指的是一個演算法執行所耗費的時間
空間複雜度指運行完一個程序所需內存的大小
穩定指，如果a=b,a在b的前面，排序後a仍然在b的前面
不穩定指，如果a=b，a在b的前面，排序後可能會交換位置
原理
依次比較相鄰的兩個值，如果後面的比前面的小，則將小的元素排到前面。依照這個規則進行多次並且遞減的迭代，直到順序正確。
時間複雜度，空間複雜度，穩定性
1.平均時間複雜度O(n*n)
2.最好情況O(n)
3.最差情況O(n*n)
4.空間複雜度O(1)
5.穩定性：穩定
冒泡排序的寫法
兩個循環
當i=0的時候，裡面的循環完整執行，從j=0執行到j=6,這也就是第一遍排序，結果是將最大的數排到了最後，這一遍循環結束後的結果應該是[8,15,88,55,76,21,39,94]
當i=1的時候，裡面的循環再次完整執行，由於最大的數已經在最後了，沒有必要去比較數組的最後兩項，這也是jarr.length-1-i的巧妙之處，結果是[8,15,55,76,21,39,88,94]
說到這裡，規律就清楚了，玉溪北大青鳥建議每次將剩下數組裡面最大的一個數排到最後面，當第一個循環執行到最後的時候，也就是i=6,此時，j=0,只需要比較數組的第一和第二項，比較完畢，返回。
java編程的冒泡等排序示例
Java排序演算法
1）分類：
1）插入排序（直接插入排序、希爾排序）
2）交換排序（冒泡排序、快速排序）
3）選擇排序（直接選擇排序、堆排序）
4）歸併排序
5）分配排序（箱排序、基數排序）
所需輔助空間最多：歸併排序
所需輔助空間最少：堆排序
平均速度最快：快速排序
不穩定：快速排序，希爾排序，堆排序。
1）選擇排序演算法的時候
1.數據的規模 ； 2.數據的類型 ； 3.數據已有的順序
一般來說，當數據規模較小時，應選擇直接插入排序或冒泡排序。任何排序演算法在數據量小時基本體現不出來差距。 考慮數據的類型，比如如果全部是正整數，那麼考慮使用桶排序為最優。 考慮數據已有順序，快排是一種不穩定的排序（當然可以改進），對於大部分排好的數據，快排會浪費大量不必要的步驟。數據量極小，而起已經基本排好序，冒泡是最佳選擇。我們說快排好，是指大量隨機數據下，快排效果最理想。而不是所有情況。
3）總結：
——按平均的時間性能來分：
1）時間複雜度為O(nlogn)的方法有：快速排序、堆排序和歸併排序，其中以快速排序為最好；
2）時間複雜度為O(n2)的有：直接插入排序、起泡排序和簡單選擇排序，其中以直接插入為最好，特 別是對那些對關鍵字近似有序的記錄序列尤為如此；
3）時間複雜度為O(n)的排序方法只有，基數排序。
當待排記錄序列按關鍵字順序有序時，直接插入排序和起泡排序能達到O(n)的時間複雜度;而對於快速排序而言，這是最不好的情況，此時的時間性能蛻化為O(n2)，因此是應該盡量避免的情況。簡單選擇排序、堆排序和歸併排序的時間性能不隨記錄序列中關鍵字的分布而改變。
——按平均的空間性能來分（指的是排序過程中所需的輔助空間大小）：
1） 所有的簡單排序方法(包括：直接插入、起泡和簡單選擇)和堆排序的空間複雜度為O(1)；
2） 快速排序為O(logn )，為棧所需的輔助空間;
3） 歸併排序所需輔助空間最多，其空間複雜度為O(n );
4）鏈式基數排序需附設隊列首尾指針，則空間複雜度為O(rd )。
——排序方法的穩定性能：
1） 穩定的排序方法指的是，對於兩個關鍵字相等的記錄，它們在序列中的相對位置，在排序之前和 經過排序之後，沒有改變。
2） 當對多關鍵字的記錄序列進行LSD方法排序時，必須採用穩定的排序方法。
3） 對於不穩定的排序方法，只要能舉出一個實例說明即可。
4） 快速排序，希爾排序和堆排序是不穩定的排序方法。
4）插入排序：
包括直接插入排序，希爾插入排序。
直接插入排序： 將一個記錄插入到已經排序好的有序表中。
1, sorted數組的第0個位置沒有放數據。
2，從sorted第二個數據開始處理：
如果該數據比它前面的數據要小，說明該數據要往前面移動。
首先將該數據備份放到 sorted的第0位置當哨兵。
然後將該數據前面那個數據後移。
然後往前搜索，找插入位置。
找到插入位置之後講 第0位置的那個數據插入對應位置。
O(n*n), 當待排記錄序列為正序時，時間複雜度提高至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];
//數據結構課本上這個地方沒有給出判讀，出錯：
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）交換排序：
包括冒泡排序，快速排序。
冒泡排序法：該演算法是專門針對已部分排序的數據進行排序的一種排序演算法。如果在你的數據清單中只有一兩個數據是亂序的話，用這種演算法就是最快的排序演算法。如果你的數據清單中的數據是隨機排列的，那麼這種方法就成了最慢的演算法了。因此在使用這種演算法之前一定要慎重。這種演算法的核心思想是掃描數據清單，尋找出現亂序的兩個相鄰的項目。當找到這兩個項目後，交換項目的位置然後繼續掃描。重複上面的操作直到所有的項目都按順序排好。
快速排序：通過一趟排序，將待排序記錄分割成獨立的兩個部分，其中一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。具體做法是：使用兩個指針low,high, 初值分別設置為序列的頭，和序列的尾，設置pivotkey為第一個記錄，首先從high開始向前搜索第一個小於pivotkey的記錄和pivotkey所在位置進行交換，然後從low開始向後搜索第一個大於pivotkey的記錄和此時pivotkey所在位置進行交換，重複知道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位置。
堆排序：首先，數組裡面用層次遍歷的順序放一棵完全二叉樹。從最後一個非終端結點往前面調整，直到到達根結點，這個時候除根節點以外的所有非終端節點都已經滿足堆得條件了，於是需要調整根節點使得整個樹滿足堆得條件，於是從根節點開始，沿著它的兒子們往下面走（最大堆沿著最大的兒子走，最小堆沿著最小的兒子走）。 主程序裡面，首先從最後一個非終端節點開始調整到根也調整完，形成一個heap， 然後將heap的根放到後面去（即：每次的樹大小會變化，但是 root都是在1的位置，以方便計算兒子們的index，所以如果需要升序排列，則要逐步大頂堆。因為根節點被一個個放在後面去了。 降序排列則要建立小頂堆）
代碼中的問題： 有時候第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;
// 這個地方jend與課本不同，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）歸併排序：
將兩個或兩個以上的有序表組合成一個新的有序表。歸併排序要使用一個輔助數組，大小跟原數組相同，遞歸做法。每次將目標序列分解成兩個序列，分別排序兩個子序列之後，再將兩個排序好的子序列merge到一起。
歸併排序Java代碼：
public class MergeSort {
private double[] bridge;//輔助數組
public void sort(double[] obj){
if (obj == null){
throw new NullPointerException(“
The param can not be null!”);
}
bridge = new double[obj.length]; // 初始化中間數組
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){
// 從兩個數組中取出小的放入中間數組
if (obj[left]-obj[mid]=10e-6){
bridge[third++] = obj[left++];
} else{
bridge[third++] = obj[mid++];
}
}
// 剩餘部分依次置入中間數組
while (mid = right){
bridge[third++] = obj[mid++];
}
while (left = center){
bridge[third++] = obj[left++];
}
// 將中間數組的內容拷貝回原數組
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）基數排序：
使用10個輔助隊列，假設最大數的數字位數為 x， 則一共做 x次，從個位數開始往前，以第i位數字的大小為依據，將數據放進輔助隊列，搞定之後回收。下次再以高一位開始的數字位為依據。
以Vector作輔助隊列，基數排序的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培訓：JS排序之冒泡排序以及寫法？
時間複雜度指的是一個演算法執行所耗費的時間空間複雜度指運行完一個程序所需內存的大小穩定指，如果a=b,a在b的前面，排序後a仍然在b的前面不穩定指，如果a=b，a在b的前面，排序後可能會交換位置原理依次比較相鄰的兩個值，如果後面的比前面的小，則將小的元素排到前面。
依照這個規則進行多次並且遞減的迭代，直到順序正確。
時間複雜度，空間複雜度，穩定性1.平均時間複雜度O(n*n)2.最好情況O(n)3.最差情況O(n*n)4.空間複雜度O(1)5.穩定性：穩定冒泡排序的寫法兩個循環當i=0的時候，裡面的循環完整執行，從j=0執行到j=6,這也就是第一遍排序，結果是將最大的數排到了最後，這一遍循環結束後的結果應該是[8,15,88,55,76,21,39,94]當i=1的時候，裡面的循環再次完整執行，由於最大的數已經在最後了，沒有必要去比較數組的最後兩項，這也是jarr.length-1-i的巧妙之處，結果是[8,15,55,76,21,39,88,94]說到這裡，規律就清楚了，遼寧北大青鳥建議每次將剩下數組裡面最大的一個數排到最後面，當第一個循環執行到最後的時候，也就是i=6,此時，j=0,只需要比較數組的第一和第二項，比較完畢，返回。
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/243892.html
微信掃一掃 
支付寶掃一掃 