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

合并排序

堆排序

插入排序

選擇排序

冒泡排序

讓我們?cè)敿?xì)了解這些 java 排序算法。

1.合并排序

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

該算法有兩個(gè)主要部分：

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

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

合并排序 Java 代碼：

類 排序 
{
    無(wú)效 合并( 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 ++)                                //復(fù)制元素到左子數(shù)組
        { 
            L [ i ]  = arr [ left + i ]; 
        } 
        for  ( j =  0 ; j < high ; j ++)                               //復(fù)制元素到右子數(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 )  {                              // 僅當(dāng)左側(cè)索引小于右側(cè)索引時(shí)才排序（表示已排序） 
            middle =  ( left + right )  /  2 ; 
            合并排序（ arr ，左，中）；                    //左子
            數(shù)組 mergeSort ( arr , middle +  1 , right );                //右子數(shù)組 
            合并（ arr ，左，中，右）；                //合并兩個(gè)子數(shù)組
        } 
    } 
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來(lái)。打印( 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中最重要的排序方法之一，需要學(xué)習(xí)才能進(jìn)入排序。它結(jié)合了樹(shù)和排序的概念，適當(dāng)?shù)丶訌?qiáng)了兩者概念的使用。堆是一個(gè)完整的二叉搜索樹(shù)，其中項(xiàng)目根據(jù)要求以特殊順序存儲(chǔ)。最小堆包含根處的最小元素，并且根的每個(gè)孩子都必須大于根本身。之后級(jí)別的孩子必須大于這些孩子，依此類推。類似地，最大堆包含根處的最大元素。對(duì)于排序過(guò)程，堆存儲(chǔ)為一個(gè)數(shù)組，其中對(duì)于索引 i 處的每個(gè)父節(jié)點(diǎn)，左子節(jié)點(diǎn)位于索引 2 * i + 1 處，右子節(jié)點(diǎn)位于索引 2 * i + 2 處。

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

該算法有兩個(gè)主要部分：

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

heapify() -此函數(shù)是堆排序算法的構(gòu)建塊。此函數(shù)確定正在檢查的元素作為根及其兩個(gè)子元素的最大值。如果最大值在根的孩子之間，則交換根和它的孩子。然后對(duì)新根重復(fù)此過(guò)程。當(dāng)找到數(shù)組中的最大元素(使其子元素小于它)時(shí)，函數(shù)停止。對(duì)于索引 i 處的節(jié)點(diǎn)，左孩子在索引 2 * i + 1 處，右孩子在索引 2 * i + 1 處。(數(shù)組中的索引從 0 開(kāi)始，因此根在 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 ]; //將當(dāng)前根移動(dòng)到末尾（因?yàn)樗亲畲蟮模?
            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個(gè)節(jié)點(diǎn)的左孩子的索引 = 2*i + 1 
        int right =  2  * i +  2 ;  //第i個(gè)節(jié)點(diǎn)的右孩子的索引= 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 )  
        {                                                //重復(fù)尋找堆中最大元素的過(guò)程
            temp = arr [ i ]; 
            arr [ i ]  = arr [最大值]；
            arr [最大值]  =溫度；
            堆化（ arr ， n ， MAX ）；
        } 
    }
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來(lái)。打印( 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)完成了更復(fù)雜的排序算法并希望繼續(xù)使用更簡(jiǎn)單的方法：插入排序是您的最佳選擇。雖然它不是對(duì)數(shù)組排序的優(yōu)化算法，但它是更容易理解的算法之一。實(shí)施也很容易。在插入排序中，人們選擇一個(gè)元素并將其視為關(guān)鍵。如果密鑰小于其前任，則將其移動(dòng)到數(shù)組中的正確位置。

算法：

開(kāi)始

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

將當(dāng)前索引 i 處的元素與其前身進(jìn)行比較。如果較小，請(qǐng)重復(fù)步驟 3。

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

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

結(jié)尾

插入排序 Java 代碼：

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

解釋它是如何工作的：

4.選擇排序

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

算法：

開(kāi)始

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

重復(fù)步驟直到找到最小元素。

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

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

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

結(jié)尾

選擇排序 Java 代碼：

類 排序 
{  
    void  selectionSort ( int arr [])  
    {  
        int pos ; 
        國(guó)際溫度; 
        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 [位置];             //用最小元素交換當(dāng)前元素
            arr [ pos ]  = arr [ i ];  
            arr [我]  =溫度;  
        }  
    }   
    void  display ( int arr [])                      //顯示數(shù)組
    {  
        for  ( int i = 0 ; i < arr .length ; i ++ ) { 
            System . 出來(lái)。打印( 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ù)初學(xué)者開(kāi)始其排序生涯的兩種算法是冒泡排序和選擇排序。這些排序算法效率不高，但它們提供了對(duì)什么是排序以及排序算法如何在幕后工作的關(guān)鍵見(jiàn)解。冒泡排序依賴于多次交換而不是單一的選擇排序。該算法繼續(xù)重復(fù)數(shù)組遍歷，交換不在正確位置的元素。

算法：

開(kāi)始

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

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

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

結(jié)尾

冒泡排序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 ])       //檢查元素是否有序
            {                            //如果沒(méi)有，交換它們
                int temp = arr [ i ]; 
                arr [ i ]  = arr [ i + 1 ];
                arr [ i + 1 ]  =溫度；
            } 
        }            
        冒泡排序( arr , n - 1 );            //一次完成，繼續(xù)下一個(gè)
    }
    void  display ( int arr [])                  //顯示數(shù)組
    {   
        for  ( int i = 0 ; i < arr .length ; ++ i ) { 
            System . 出來(lái)。打印( 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 ）；} }

解釋它是如何工作的：