程序員必知的8大排序(java實現)

8種排序之間的關係:java

 一、 直接插入排序

  (1)基本思想:算法

  在要排序的一組數中,假設前面(n-1)[n>=2] 個數已是排好順序的,如今要把第n個數插到前面的有序數中,使得這n個數也是排好順序的。如此反覆循環,直到所有排好順序。shell

  (2)實例數組

  (3)用java實現函數


package com.njue;
public class insertSort {
public insertSort(){
     inta[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
     int temp= 0 ;
     for ( int i= 1 ;i<a.length;i++){
        int j=i- 1 ;
        temp=a[i];
        for (;j>= 0 &&temp<a[j];j--){
        a[j+ 1 ]=a[j];                       //將大於temp的值總體後移一個單位
        }
        a[j+ 1 ]=temp;
     }
     for ( int i= 0 ;i<a.length;i++)
        System.out.println(a[i]);
}
}

 二、希爾排序(最小增量排序)

  (1)基本思想:ui

  算法先將要排序的一組數按某個增量d(n/2,n爲要排序數的個數)分紅若干組,每組中記錄的下標相差d.對每組中所有元素進行直接插入排序,而後再 用一個較小的增量(d/2)對它進行分組,在每組中再進行直接插入排序。當增量減到1時,進行直接插入排序後,排序完成。spa

  (2)實例:code

  (3)用java實現排序


public class shellSort {
public  shellSort(){
     int a[]={ 1 , 54 , 6 , 3 , 78 , 34 , 12 , 45 , 56 , 100 };
     double d1=a.length;
     int temp= 0 ;
     while ( true ){
         d1= Math.ceil(d1/ 2 );
         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.println(a[i]);
}
}

 三、簡單選擇排序

  (1)基本思想:遞歸

  在要排序的一組數中,選出最小的一個數與第一個位置的數交換;而後在剩下的數當中再找最小的與第二個位置的數交換,如此循環到倒數第二個數和最後一個數比較爲止。

  (2)實例:

  (3)用java實現


public class selectSort {
     public selectSort(){
         int a[]={ 1 , 54 , 6 , 3 , 78 , 34 , 12 , 45 };
         int position= 0 ;
         for ( int i= 0 ;i<a.length;i++){
             
             int j=i+ 1 ;
             position=i;
             int temp=a[i];
             for (;j<a.length;j++){
             if (a[j]<temp){
                 temp=a[j];
                 position=j;
             }
             }
             a[position]=a[i];
             a[i]=temp;
         }
         for ( int i= 0 ;i<a.length;i++)
             System.out.println(a[i]);
     }
}

 四、堆排序

  (1)基本思想:

  堆排序是一種樹形選擇排序,是對直接選擇排序的有效改進。

  堆的定義以下:具備n個元素的序列(h1,h2,...,hn),當且僅當知足(hi>=h2i,hi>=2i+1)或(hi& lt;=h2i,hi<=2i+1)(i=1,2,...,n/2)時稱之爲堆。在這裏只討論知足前者條件的堆。由堆的定義能夠看出,堆頂元素(即 第一個元素)必爲最大項(大頂堆)。徹底二叉樹能夠很直觀地表示堆的結構。堆頂爲根,其它爲左子樹、右子樹。初始時把要排序的數的序列看做是一棵順序存儲 的二叉樹,調整它們的存儲序,使之成爲一個堆,這時堆的根節點的數最大。而後將根節點與堆的最後一個節點交換。而後對前面(n-1)個數從新調整使之成爲 堆。依此類推,直到只有兩個節點的堆,並對它們做交換,最後獲得有n個節點的有序序列。從算法描述來看,堆排序須要兩個過程,一是創建堆,二是堆頂與堆的 最後一個元素交換位置。因此堆排序有兩個函數組成。一是建堆的滲透函數,二是反覆調用滲透函數實現排序的函數。

  (2)實例:

  初始序列:46,79,56,38,40,84

  建堆:

  交換,從堆中踢出最大數

  剩餘結點再建堆,再交換踢出最大數

  依次類推:最後堆中剩餘的最後兩個結點交換,踢出一個,排序完成。

  (3)用java實現


import java.util.Arrays;
public class HeapSort {
      int a[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
     public  HeapSort(){
         heapSort(a);
     }
     public  void heapSort( int [] a){
         System.out.println( "開始排序" );
         int arrayLength=a.length;
         //循環建堆
         for ( int i= 0 ;i<arrayLength- 1 ;i++){
             //建堆
             buildMaxHeap(a,arrayLength- 1 -i);
             //交換堆頂和最後一個元素
             swap(a, 0 ,arrayLength- 1 -i);
             System.out.println(Arrays.toString(a));
         }
     }
 
     private  void swap( int [] data, int i, int j) {
         // TODO Auto-generated method stub
         int tmp=data[i];
         data[i]=data[j];
         data[j]=tmp;
     }
     //對data數組從0到lastIndex建大頂堆
     private void buildMaxHeap( int [] data, int lastIndex) {
         // TODO Auto-generated method stub
         //從lastIndex處節點(最後一個節點)的父節點開始
         for ( int i=(lastIndex- 1 )/ 2 ;i>= 0 ;i--){
             //k保存正在判斷的節點
             int k=i;
             //若是當前k節點的子節點存在
             while (k* 2 + 1 <=lastIndex){
                 //k節點的左子節點的索引
                 int biggerIndex= 2 *k+ 1 ;
                 //若是biggerIndex小於lastIndex,即biggerIndex+1表明的k節點的右子節點存在
                 if (biggerIndex<lastIndex){
                     //若果右子節點的值較大
                     if (data[biggerIndex]<data[biggerIndex+ 1 ]){
                         //biggerIndex老是記錄較大子節點的索引
                         biggerIndex++;
                     }
                 }
                 //若是k節點的值小於其較大的子節點的值
                 if (data[k]<data[biggerIndex]){
                     //交換他們
                     swap(data,k,biggerIndex);
                     //將biggerIndex賦予k,開始while循環的下一次循環,從新保證k節點的值大於其左右子節點的值
                     k=biggerIndex;
                 } else {
                     break ;
                 }
             }
         }
     }
}

 五、冒泡排序

  (1)基本思想:

  在要排序的一組數中,對當前還未排好序的範圍內的所有數,自上而下對相鄰的兩個數依次進行比較和調整,讓較大的數往下沉,較小的往上冒。即:每當兩相鄰的數比較後發現它們的排序與排序要求相反時,就將它們互換。

  (2)實例:

  (3)用java實現


public class bubbleSort {
public  bubbleSort(){
      int a[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
     int temp= 0 ;
     for ( int i= 0 ;i<a.length- 1 ;i++){
         for ( int j= 0 ;j<a.length- 1 -i;j++){
         if (a[j]>a[j+ 1 ]){
             temp=a[j];
             a[j]=a[j+ 1 ];
             a[j+ 1 ]=temp;
         }
         }
     }
     for ( int i= 0 ;i<a.length;i++)
     System.out.println(a[i]);  
   }
}

 六、快速排序

  (1)基本思想:

  選擇一個基準元素,一般選擇第一個元素或者最後一個元素,經過一趟掃描,將待排序列分紅兩部分,一部分比基準元素小,一部分大於等於基準元素,此時基準元素在其排好序後的正確位置,而後再用一樣的方法遞歸地排序劃分的兩部分。

  (2)實例:

  (3)用java實現


public class quickSort {
   int a[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
public  quickSort(){
     quick(a);
     for ( int i= 0 ;i<a.length;i++)
         System.out.println(a[i]);
}
public int getMiddle( int [] list, int low, int high) {  
             int tmp = list[low];    //數組的第一個做爲中軸  
             while (low < high) {  
                 while (low < high && list[high] >= tmp) {  
  
       high--;  
                 }  
                 list[low] = list[high];   //比中軸小的記錄移到低端  
                 while (low < high && list[low] <= tmp) {  
                     low++;  
                 }  
                 list[high] = list[low];   //比中軸大的記錄移到高端  
             }  
            list[low] = tmp;              //中軸記錄到尾  
             return low;                   //返回中軸的位置  
        
public void _quickSort( int [] list, int low, int high) {  
             if (low < high) {  
                int middle = getMiddle(list, low, high);  //將list數組進行一分爲二  
                 _quickSort(list, low, middle - 1 );        //對低字表進行遞歸排序  
                _quickSort(list, middle + 1 , high);       //對高字表進行遞歸排序  
             }  
         }
public void quick( int [] a2) {  
             if (a2.length > 0 ) {    //查看數組是否爲空  
                 _quickSort(a2, 0 , a2.length - 1 );  
         }  
      }
}

 七、歸併排序

  (1)基本排序:

  歸併(Merge)排序法是將兩個(或兩個以上)有序表合併成一個新的有序表,即把待排序序列分爲若干個子序列,每一個子序列是有序的。而後再把有序子序列合併爲總體有序序列。

  (2)實例:

  (3)用java實現


import java.util.Arrays;
public class mergingSort {
int a[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
public  mergingSort(){
     sort(a, 0 ,a.length- 1 );
     for ( int i= 0 ;i<a.length;i++)
         System.out.println(a[i]);
}
public void sort( int [] data, int left, int right) {
     // TODO Auto-generated method stub
     if (left<right){
         //找出中間索引
         int center=(left+right)/ 2 ;
         //對左邊數組進行遞歸
         sort(data,left,center);
         //對右邊數組進行遞歸
         sort(data,center+ 1 ,right);
         //合併
         merge(data,left,center,right);
         
     }
}
public void merge( int [] data, int left, int center, int right) {
     // TODO Auto-generated method stub
     int [] tmpArr= new int [data.length];
     int mid=center+ 1 ;
     //third記錄中間數組的索引
     int third=left;
     int tmp=left;
     while (left<=center&&mid<=right){
  
    //從兩個數組中取出最小的放入中間數組
         if (data[left]<=data[mid]){
             tmpArr[third++]=data[left++];
         } else {
             tmpArr[third++]=data[mid++];
         }
     }
     //剩餘部分依次放入中間數組
     while (mid<=right){
         tmpArr[third++]=data[mid++];
     }
     while (left<=center){
         tmpArr[third++]=data[left++];
     }
     //將中間數組中的內容複製回原數組
     while (tmp<=right){
         data[tmp]=tmpArr[tmp++];
     }
     System.out.println(Arrays.toString(data));
}
  
}

 八、基數排序

  (1)基本思想:

  將全部待比較數值(正整數)統一爲一樣的數位長度,數位較短的數前面補零。而後,從最低位開始,依次進行一次排序。這樣從最低位排序一直到最高位排序完成之後,數列就變成一個有序序列。

  (2)實例:

  (3)用java實現


import java.util.ArrayList;
import java.util.List;
public class radixSort {
     int a[]={ 49 , 38 , 65 , 97 , 76 , 13 , 27 , 49 , 78 , 34 , 12 , 64 , 5 , 4 , 62 , 99 , 98 , 54 , 101 , 56 , 17 , 18 , 23 , 34 , 15 , 35 , 25 , 53 , 51 };
public radixSort(){
     sort(a);
     for ( int i= 0 ;i<a.length;i++)
         System.out.println(a[i]);
}
public  void sort( int [] array){  
                
             //首先肯定排序的趟數;  
         int max=array[ 0 ];  
         for ( int i= 1 ;i<array.length;i++){  
                if (array[i]>max){  
                max=array[i];  
                }  
             }  
  
     int time= 0 ;  
            //判斷位數;  
             while (max> 0 ){  
                max/= 10 ;  
                 time++;  
             }  
                
         //創建10個隊列;  
             List<ArrayList> queue= new ArrayList<ArrayList>();  
             for ( int i= 0 ;i< 10 ;i++){  
                 ArrayList<Integer> queue1= new ArrayList<Integer>();
                 queue.add(queue1);  
         }  
               
             //進行time次分配和收集;  
             for ( int i= 0 ;i<time;i++){  
                    
                 //分配數組元素;  
                for ( int j= 0 ;j<array.length;j++){  
                     //獲得數字的第time+1位數;
                    int x=array[j]%( int )Math.pow( 10 , i+ 1 )/( int )Math.pow( 10 , i);
                    ArrayList<Integer> queue2=queue.get(x);
                    queue2.add(array[j]);
                    queue.set(x, queue2);
             }  
                 int count= 0 ; //元素計數器;  
             //收集隊列元素;  
                 for ( int k= 0 ;k< 10 ;k++){
                 while (queue.get(k).size()> 0 ){
                     ArrayList<Integer> queue3=queue.get(k);
                         array[count]=queue3.get( 0 );  
                         queue3.remove( 0 );
                     count++;
               }  
             }  
     }            
   
}
相關文章
相關標籤/搜索