Java冒泡排序詳解

時間 2019-11-15

原文原文鏈接

Java冒泡排序

排序算法概述

所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操做。排序算法，就是如何使得記錄按照要求排列的方法。排序算法在不少領域獲得至關地重視，尤爲是在大量數據的處理方面。java

穩定性：一個排序算法是穩定的，就是當有兩個相等記錄的關鍵字R和S，且在本來的列表中R出如今S以前，在排序過的列表中R也將會是在S以前。算法

若是算法是穩定的有什麼好處呢？排序算法若是是穩定的，那麼從一個鍵上排序，而後再從另外一個鍵上排序，第一個鍵排序的結果能夠爲第二個鍵排序所用。基數排序就是這樣，先按低位排序，逐次按高位排序，低位相同的元素其順序再高位也相同時是不會改變的。數組

排序算法根據是否須要訪問外存分爲內部排序和外部排序。學習

內部排序是指待排序列徹底存放在內存中所進行的排序過程，適合不太大的元素序列。測試

外部排序指的是大文件的排序，即待排序的記錄存儲在外存儲器上，待排序的文件沒法一次裝入內存，須要在內存和外部存儲器之間進行屢次數據交換，以達到排序整個文件的目的。this

咱們如今要討論的排序都是內部排序。spa

冒泡排序指針

冒泡排序的效率很低，可是算法實現起來很簡單，所以很適合做爲研究排序的入門算法。code

基本思想cdn

對當前還未排好序的範圍內的所有數，自上而下對相鄰的倆個數依次進行比較和調整，讓較大的數下沉，較小的數往上冒。即：每當倆相鄰的數比較後發現他們的排序與排序的要求相反時，就將他們交換。每次遍歷均可肯定一個最大值放到待排數組的末尾，下次遍歷，對該最大值以及它以後的元素再也不排序（已經排好）。

java實現

public class Sort{  
   
  private int [] array;  
  public Sort(int [] array){  
     this.array = array;  
  }  
   
  //按順序打印數組中的元素  
  public void display(){  
     for(int i=0;i<array.length;i++){  
         System.out.print(array[i]+"\t");  
     }  
     System.out.println();  
  }  
   
  //冒泡排序  
  public void bubbleSort(){  
     int temp;  
     int len = array.length;  
     for(int i=0;i<len-1;i++){  //外層循環：每循環一次就肯定了一個相對最大元素  
         for(int j=1;j<len-i;j++){  //內層循環：有i個元素已經排好，根據i肯定本次的比較次數  
            if(array[j-1]>array[j]){  //若是前一位大於後一位，交換位置  
                temp = array[j-1];  
                array[j-1] = array[j];  
                array[j] = temp;  
            }  
         }  
         System.out.print("第"+(i+1)+"輪排序結果：");  
         display();  
     }  
  }         
}  複製代碼

測試：

public static void main(String[] args) {  
     int [] a = {1,5,4,11,2,20,18};  
     Sort sort = new Sort(a);  
     System.out.print("未排序時的結果：");  
     sort.display();  
     sort.bubbleSort();  
}  複製代碼

打印結果：

算法分析

上面的例子中，待排數組中一共有7個數，第一輪排序時進行了6次比較，第二輪排序時進行了5比較，依次類推，最後一輪進行了一次比較。加入元素總數爲N，則一共須要的比較次數爲：

(N-1)+ (N-2)+ (N-3)+ ...1=N*(N-1)/2複製代碼

這樣，算法約作了N2/2次比較。由於只有在前面的元素比後面的元素大時才交換數據，因此交換的次數少於比較的次數。若是數據是隨機的，大概有一半數據須要交換，則交換的次數爲N2/4（不過在最壞狀況下，即初始數據逆序時，每次比較都須要交換）。

交換和比較的操做次數都與N2成正比，因爲在大O表示法中，常數忽略不計，冒泡排序的時間複雜度爲O(N2)。O(N2)的時間複雜度是一個比較糟糕的結果，尤爲在數據量很大的狀況下。因此冒泡排序一般不會用於實際應用。

冒泡排序的改進

上面已經分析過，冒泡排序的效率比較低，因此咱們要經過各類方法改進。

最簡單的改進方法是加入一標誌性變量exchange，用於標誌某一趟排序過程當中是否有數據交換，若是進行某一趟排序時並無進行數據交換，則說明數據已經按要求排列好，可當即結束排序，避免沒必要要的比較過程.

在上例中，第四輪排序以後實際上整個數組已是有序的了，最後兩輪的比較不必進行。

改進後的代碼以下：

//冒泡排序改進1  
  public void bubbleSort_improvement_1(){  
     int temp;  
     int len = array.length;  
      
     for(int i=0;i<len-1;i++){   
         boolean exchange = false;  //設置交換變量  
         for(int j=1;j<len-i;j++){   
            if(array[j-1]>array[j]){  //若是前一位大於後一位，交換位置  
                temp = array[j-1];  
                array[j-1] = array[j];  
                array[j] = temp;  
                 
                if(!exchange) exchange =true;  //發生了交換操做  
            }  
         }  
         System.out.print("第"+(i+1)+"輪排序結果：");  
         display();  
         if(!exchange) break;  //若是上一輪沒有發生交換數據，證實已是有序的了，結束排序  
     }  
   }複製代碼

用一樣的初始數組測試，打印結果以下：

上面的改進方法，是根據上一輪排序有沒有發生數據交換做爲標識，進一步思考，若是上一輪排序中，只有後一段的幾個元素沒有發生數據交換，是否是能夠斷定這一段不用在進行比較了呢？答案是確定的。

例如上面的例子中，前四輪的排序結果爲：

未排序時的結果：1   5  4  11 2  20 18
第1輪排序結果：1  4  5  2  11 18 20
第2輪排序結果：1  4  2  5  11 18 20
第3輪排序結果：1  2  4  5  11 18 20
第4輪排序結果：1  2  4  5  11 18 20複製代碼

第1輪排序以後，十一、1八、20已是有序的了，後面的幾回排序後它們的位置都沒有變化，可是根據冒泡算法，18依然會在第2輪參與比較，11依然會在第2輪、第3輪參與比較，其實都是無用功。

咱們能夠對算法進一步改進：設置一個pos指針，pos後面的數據在上一輪排序中沒有發生交換，下一輪排序時，就對pos以後的數據再也不比較。

代碼改動以下：

//冒泡排序改進2  
public void bubbleSort_improvement_2(){  
   int temp;  
   int counter = 1;  
   int endPoint = array.length-1;  //endPoint表明最後一個須要比較的元素下標  
    
   while(endPoint>0){   
      intpos = 1;  
      for(int j=1;j<=endPoint;j++){    
          if(array[j-1]>array[j]){  //若是前一位大於後一位，交換位置  
             temp= array[j-1];  
             array[j-1]= array[j];  
             array[j]= temp;  
                  
             pos= j;  //下標爲j的元素與下標爲j-1的元素髮生了數據交換  
          }  
      }  
      //下一輪排序時只對下標小於pos的元素排序，下標大於等於pos的元素已經排好  
      endPoint= pos-1;  
       
      System.out.print("第"+counter+"輪排序結果：");  
      display();  
   }  
} 複製代碼

對的算法來講，沒有最好，只有更好。上面的兩種改進方法其實治標不治本，是一種「揚湯止沸」的改進，下面咱們來一次「釜底抽薪」的改進。

傳統的冒泡算法每次排序只肯定了最大值，咱們能夠在每次循環之中進行正反兩次冒泡，分別找到最大值和最小值，如此可以使排序的輪數減小一半。

改進代碼以下：

//冒泡排序改進3  
public void bubbleSort_improvement_3(){  
   int temp;  
   int low = 0;  
   int high = array.length-1;  
   int counter = 1;  
   while(low<high){   
       
      for(int i=low;i<high;++i){   //正向冒泡，肯定最大值  
          if(array[i]>array[i+1]){  //若是前一位大於後一位，交換位置  
             temp= array[i];  
             array[i]= array[i+1];  
             array[i+1]= temp;  
          }  
      }  
      --high;  
       
      for(int j=high;j>low;--j){   //反向冒泡，肯定最小值  
          if(array[j]<array[j-1]){  //若是前一位大於後一位，交換位置  
             temp= array[j];  
             array[j]= array[j-1];  
             array[j-1]= temp;  
          }  
      }  
      ++low;  
       
      System.out.print("第"+counter+"輪排序結果：");  
      display();  
      counter++;  
   }  
} 複製代碼