Java 本身就是一門靈活的語言，支持多種排序算法的操作。這些算法中的大多數(shù)本身都非常靈活，可以使用遞歸和迭代方法來實現(xiàn)。以下是動力節(jié)點為大家介紹java中最流行的5種排序算法：

合并排序

堆排序

插入排序

選擇排序

冒泡排序

讓我們詳細了解這些 java 排序算法。

1.合并排序

合并排序是人類已知的 java 中最靈活的排序算法之一(是的，不是開玩笑)。它使用分而治之的策略對數(shù)組中的元素進行排序。它也是一種穩(wěn)定的排序，這意味著它不會改變數(shù)組中彼此相關的原始元素的順序。底層策略將數(shù)組分解為多個較小的段，直到獲得只有兩個元素(或一個元素)的段?，F(xiàn)在，對這些段中的元素進行排序，并合并這些段以形成更大的段。這個過程一直持續(xù)到整個數(shù)組被排序。

該算法有兩個主要部分：

mergeSort() -此函數(shù)計算子數(shù)組的中間索引，然后將子數(shù)組分成兩半。前半部分從索引左到中，后半部分從索引中間+1 到右。分區(qū)完成后，該函數(shù)會自動調(diào)用 merge() 函數(shù)對由 mergeSort() 調(diào)用處理的子數(shù)組進行排序。

merge() -此函數(shù)為排序過程執(zhí)行實際繁重的工作。它需要輸入四個參數(shù)——數(shù)組、起始索引(左)、中間索引(中間)和結束索引(右)。收到后，merge() 會將子數(shù)組拆分為兩個子數(shù)組——一個左子數(shù)組和一個右子數(shù)組。左子數(shù)組從索引左到中運行，而右子數(shù)組從索引middle+1 運行到右。該函數(shù)然后合并兩個子數(shù)組以獲得排序的子數(shù)組。

合并排序 Java 代碼：

類 排序 
{
    無效 合并( int arr [],  int left ,  int middle ,  int right ) 
    { 
        int low = middle - left +  1 ;                     //左子數(shù)組的大小
        int high = right - middle ;                       //右子數(shù)組的大小 
        詮釋L []  = 新 詮釋[低];                              //創(chuàng)建左右子數(shù)組
        int R []  =  new  int [ high ];
        整數(shù)i =  0 , j =  0 ; 
        for  ( i =  0 ; i < low ; i ++)                                //復制元素到左子數(shù)組
        { 
            L [ i ]  = arr [ left + i ]; 
        } 
        for  ( j =  0 ; j < high ; j ++)                               //復制元素到右子數(shù)組
        { 
            R [ j ]  = arr [ middle +  1  +? ]; 
        }         
        詮釋k =左;                                            //獲取排序的起始索引
        i =  0 ;                                              //在執(zhí)行合并之前重置循環(huán)變量
        j =  0 ;
        while  ( i < low && j < high )                      //合并左右子數(shù)組
        { 
            if  ( L [ i ]  <= R [ j ])  
            { 
                arr [ k ]  = L [ i ]; 
                我++; 
            }
            其他 
            { 
                arr [ k ]  = R [ j ]; 
                ? ++; 
            }
            ? ++; 
        } 
        while  ( i < low )                              //合并左子數(shù)組的剩余元素
        { 
            arr [ k ]  = L [ i ]; 
            我++; 
            ? ++; 
        } 
        while  ( j < high )                            //合并右子數(shù)組的剩余元素
        { 
            arr [ k ]  = R [ j ]; 
            ? ++; 
            ? ++; 
        } 
    }
    void  mergeSort ( int arr [],  int left ,  int right )        //為排序創(chuàng)建子案例的輔助函數(shù)
    { 
        int middle ; 
        if  ( left < right )  {                              // 僅當左側索引小于右側索引時才排序（表示已排序） 
            middle =  ( left + right )  /  2 ; 
            合并排序（ arr ，左，中）；                    //左子
            數(shù)組 mergeSort ( arr , middle +  1 , right );                //右子數(shù)組 
            合并（ arr ，左，中，右）；                //合并兩個子數(shù)組
        } 
    } 
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來。打印( arr [ i ]+ " " ); } }      
    public  static  void  main ( String args []) 
    { 
        int arr []  =  {  9 ,  3 ,  1 ,  5 ,  13 ,  12  }; 
        排序 ob =  new Sort (); 
        ob _ 合并排序( arr ,  0 , arr .length - 1 ) ; 
        ob _ 顯示（ arr ）；} }     

解釋它是如何工作的

2.堆排序

堆排序是java中最重要的排序方法之一，需要學習才能進入排序。它結合了樹和排序的概念，適當?shù)丶訌娏藘烧吒拍畹氖褂?。堆是一個完整的二叉搜索樹，其中項目根據(jù)要求以特殊順序存儲。最小堆包含根處的最小元素，并且根的每個孩子都必須大于根本身。之后級別的孩子必須大于這些孩子，依此類推。類似地，最大堆包含根處的最大元素。對于排序過程，堆存儲為一個數(shù)組，其中對于索引 i 處的每個父節(jié)點，左子節(jié)點位于索引 2 * i + 1 處，右子節(jié)點位于索引 2 * i + 2 處。

用未排序數(shù)組的元素構建一個最大堆 ，然后從數(shù)組的根中提取最大元素，然后與數(shù)組的最后一個元素進行交換。完成后，將重建最大堆以獲取下一個最大元素。這個過程一直持續(xù)到堆中只有一個節(jié)點。

該算法有兩個主要部分：

heapSort() -此函數(shù)有助于構建最初使用的最大堆。完成后，將提取每個根元素并將其發(fā)送到數(shù)組的末尾。完成后，將從根中重建最大堆。再次提取根并將其發(fā)送到數(shù)組的末尾，因此該過程繼續(xù)進行。

heapify() -此函數(shù)是堆排序算法的構建塊。此函數(shù)確定正在檢查的元素作為根及其兩個子元素的最大值。如果最大值在根的孩子之間，則交換根和它的孩子。然后對新根重復此過程。當找到數(shù)組中的最大元素(使其子元素小于它)時，函數(shù)停止。對于索引 i 處的節(jié)點，左孩子在索引 2 * i + 1 處，右孩子在索引 2 * i + 1 處。(數(shù)組中的索引從 0 開始，因此根在 0)。

堆排序 Java 代碼：

類 排序 { 
    public  void  heapSort ( int arr []) 
    { 
        int temp ; 
        for  ( int i = arr .length / 2 - 1 ; i >= 0 ; i --) //建立堆{ 
            heapify ( arr , arr .length , i ) ; }                      
        for  ( int i = arr .length - 1 ; i > 0 ; i -- ) //從堆中提取元素{ 
            temp = arr [ 0 ]; //將當前根移動到末尾（因為它是最大的） 
            arr [ 0 ] = arr [ i ]; 
            arr [我] =溫度; 
            heapify ( arr ,我,                                                                                            0 );                                              //recall heapify 為剩余的元素重建堆
        } 
    } 
    void  heapify ( int arr [],  int n ,  int i ) 
    { 
        int MAX = i ;  // 將最大初始化為根
        int left =  2  * i +  1 ;  //第i個節(jié)點的左孩子的索引 = 2*i + 1 
        int right =  2  * i +  2 ;  //第i個節(jié)點的右孩子的索引= 2 * i + 2 
        int temp ;
        if  ( left < n && arr [ left ]  > arr [ MAX ])             //檢查根的左孩子是否大于根
        { 
            MAX = left ; 
        } 
        if  ( right < n && arr [ right ]  > arr [ MAX ])             //檢查根的右孩子是否大于根
        { 
            MAX = right ; 
        } 
        if  ( MAX != i )  
        {                                                //重復尋找堆中最大元素的過程
            temp = arr [ i ]; 
            arr [ i ]  = arr [最大值]；
            arr [最大值]  =溫度；
            堆化（ arr ， n ， MAX ）；
        } 
    }
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來。打印( arr [ i ]+ " " ); } }   
    public  static  void  main ( String args []) 
    { 
        int arr []  =  {  1 ,  12 ,  9  ,  3 ,  10 ,  15  }; 
        排序 ob =  new Sort (); 
        ob _ 堆排序（ arr ）；
        ob _ 顯示（ arr ）；
    } 
}

解釋它是如何工作的：

3.插入排序

如果您已經(jīng)完成了更復雜的排序算法并希望繼續(xù)使用更簡單的方法：插入排序是您的最佳選擇。雖然它不是對數(shù)組排序的優(yōu)化算法，但它是更容易理解的算法之一。實施也很容易。在插入排序中，人們選擇一個元素并將其視為關鍵。如果密鑰小于其前任，則將其移動到數(shù)組中的正確位置。

算法：

開始

重復步驟 2 到 4，直到到達數(shù)組末端。

將當前索引 i 處的元素與其前身進行比較。如果較小，請重復步驟 3。

繼續(xù)從數(shù)組的“排序”部分移動元素，直到找到鍵的正確位置。

遞增循環(huán)變量。

結尾

插入排序 Java 代碼：

class  Sort   
{  
    static  void  insertSort ( int arr [],  int n )  
    {  
        if  ( n <=  1 )                              //passes are done 
        { 
            return ;  
        }
        插入排序( arr , n - 1  );         //一個元素排序，剩下的數(shù)組排序       
        int last = arr [ n - 1 ];                         //數(shù)組的最后一個元素
        int j = n - 2 ;                                 //正確的數(shù)組最后一個元素的索引       
        while  ( j >=  0  && arr [ j ]  > last )                  //找到最后一個元素的正確索引
        {  
            arr [ j + 1 ]  = arr [ j ];                           //如果沒有找到正確的索引，則將已排序元素的部分向上移動一個元素
            j --;  
        }  
        arr [ j + 1 ]  =最后;                             //將最后一個元素設置在正確的索引處
    } 
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來。打印( arr [ i ]+ " " ); } }                
    公共 靜態(tài) 無效 主要（字符串[] args ） 
    {  
        int arr []  =  { 22 ,  21 ,  11 ,  15 ,  16 };        
        插入排序（ arr ， arr.length ）； 
        排序 ob = new Sort (); 
        ob _ 顯示（ arr ）；} }  

解釋它是如何工作的：

4.選擇排序

二次排序算法是一些比較流行的排序算法，易于理解和實現(xiàn)。這些并沒有為數(shù)組排序提供獨特或優(yōu)化的方法——相反，它們應該為剛接觸它的人提供排序概念的構建塊。在選擇排序中，使用了兩個循環(huán)。內(nèi)部循環(huán)從數(shù)組中挑選最小元素并將其移動到外部循環(huán)指示的正確索引處。在外循環(huán)的每次運行中，一個元素都會移動到數(shù)組中的正確位置。它也是python中非常流行的排序算法。

算法：

開始

運行兩個循環(huán)：一個內(nèi)循環(huán)和一個外循環(huán)。

重復步驟直到找到最小元素。

將外部循環(huán)變量標記的元素標記為最小值。

如果內(nèi)部循環(huán)中的當前元素小于標記的最小元素，則將最小元素的值更改為當前元素。

將最小元素的值與外部循環(huán)變量標記的元素交換。

結尾

選擇排序 Java 代碼：

類 排序 
{  
    void  selectionSort ( int arr [])  
    {  
        int pos ; 
        國際溫度; 
        for  ( int i =  0 ; i < arr .length ; i ++ ) {  
            pos = i ; for ( int j = i + 1 ; j < arr .length ; j ++ ) {           
                if  ( arr [ j ]  < arr [ pos ])                   //找到最小元素的索引
                { 
                    pos = j ; 
                } 
            }
            溫度= arr [位置];             //用最小元素交換當前元素
            arr [ pos ]  = arr [ i ];  
            arr [我]  =溫度;  
        }  
    }   
    void  display ( int arr [])                      //顯示數(shù)組
    {  
        for  ( int i = 0 ; i < arr .length ; i ++ ) { 
            System . 出來。打印( arr [ i ]+ " " ); } } 
    public  static  void  main ( String args [])  
    {  
        Sort ob =  new Sort ();  
        int arr []  =  { 64 , 25 , 12 , 22 , 11 };  
        ob _ 選擇排序( arr );  
        ob _ 顯示（ arr ）； 
    }  
} 

解釋它是如何工作的：

5.冒泡排序

大多數(shù)初學者開始其排序生涯的兩種算法是冒泡排序和選擇排序。這些排序算法效率不高，但它們提供了對什么是排序以及排序算法如何在幕后工作的關鍵見解。冒泡排序依賴于多次交換而不是單一的選擇排序。該算法繼續(xù)重復數(shù)組遍歷，交換不在正確位置的元素。

算法：

開始

運行兩個循環(huán)——一個內(nèi)循環(huán)和一個外循環(huán)。

重復步驟，直到外循環(huán)用盡。

如果內(nèi)部循環(huán)中的當前元素小于其下一個元素，則交換兩個元素的值。

結尾

冒泡排序Java代碼：

class  Sort  
{ 
    static  void  bubbleSort ( int arr [],  int n ) 
    {                                        
        if  ( n ==  1 )                      //passes are done 
        { 
            return ; 
        }
        for  ( int i = 0 ; i < n - 1 ; i ++)        //遍歷未排序的元素
        { 
            if  ( arr [ i ]  > arr [ i + 1 ])       //檢查元素是否有序
            {                            //如果沒有，交換它們
                int temp = arr [ i ]; 
                arr [ i ]  = arr [ i + 1 ];
                arr [ i + 1 ]  =溫度；
            } 
        }            
        冒泡排序( arr , n - 1 );            //一次完成，繼續(xù)下一個
    }
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來。打印( arr [ i ]+ " " ); } }     
    public  static  void  main ( String [] args ) 
    { 
        Sort ob =  new Sort (); 
        int arr []  =  { 6 ,  4 ,  5 ,  12 ,  2 ,  11 ,  9 };     
        冒泡排序（ arr ， arr .length ）；
        ob _ 顯示（ arr ）；} }

解釋它是如何工作的：