八大排序算法圖解，Java八大排序

8種排序之間的關系:
  2 
  3 1， 直接插入排序
  4    （1）基本思想：在要排序的一組數中，假設前面(n-1)[n>=2] 個數已經是排
  5 好順序的，現在要把第n個數插到前面的有序數中，使得這n個數
  6 也是排好順序的。如此反復循環，直到全部排好順序。
  7  （2）實例
  8 
  9 （3）用java實現
 10 [java] view plaincopy
 11  package com.njue;  
 12    
 13 public class insertSort {  
 14 public insertSort(){  
 15     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};  
 16     int temp=0;  
 17     for(int i=1;i<a.length;i++){  
 18        int j=i-1;  
 19        temp=a[i];  
 20        for(;j>=0&&temp<a[j];j--){  
 21        a[j+1]=a[j];                       //將大于temp的值整體后移一個單位  
 22        }  
 23        a[j+1]=temp;  
 24     }  
 25     for(int i=0;i<a.length;i++)  
 26        System.out.println(a[i]);  
 27 }  
 28 }  
 29 
 30 2，           希爾排序（最小增量排序）
 31 （1）基本思想：算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然后再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。八大排序算法圖解、當增量減到1時，進行直接插入排序后，排序完成。
 32 （2）實例：
 33 
 34 
 35 （3）用java實現
 36 [java] view plaincopy
 37 public class shellSort {  
 38 public  shellSort(){  
 39     int a[]={1,54,6,3,78,34,12,45,56,100};  
 40     double d1=a.length;  
 41     int temp=0;  
 42     while(true){  
 43         d1= Math.ceil(d1/2);  
 44         int d=(int) d1;  
 45         for(int x=0;x<d;x++){  
 46             for(int i=x+d;i<a.length;i+=d){  
 47                 int j=i-d;  
 48                 temp=a[i];  
 49                 for(;j>=0&&temp<a[j];j-=d){  
 50                 a[j+d]=a[j];  
 51                 }  
 52                 a[j+d]=temp;  
 53             }  
 54         }  
 55         if(d==1)  
 56             break;  
 57     }  
 58     for(int i=0;i<a.length;i++)  
 59         System.out.println(a[i]);  
 60 }  
 61 }  
 62 
 63 3.簡單選擇排序
 64 （1）基本思想：在要排序的一組數中，選出最小的一個數與第一個位置的數交換；
 65 然后在剩下的數當中再找最小的與第二個位置的數交換，如此循環到倒數第二個數和最后一個數比較為止。
 66 （2）實例：
 67 
 68 
 69 （3）用java實現
 70 [java] view plaincopy
 71 public class selectSort {  
 72     public selectSort(){  
 73         int a[]={1,54,6,3,78,34,12,45};  
 74         int position=0;  
 75         for(int i=0;i<a.length;i++){  
 76               
 77             int j=i+1;  
 78             position=i;  
 79             int temp=a[i];  
 80             for(;j<a.length;j++){  
 81             if(a[j]<temp){  
 82                 temp=a[j];  
 83                 position=j;  
 84             }  
 85             }  
 86             a[position]=a[i];  
 87             a[i]=temp;  
 88         }  
 89         for(int i=0;i<a.length;i++)  
 90             System.out.println(a[i]);  
 91     }  
 92 }  
 93 
 94 4，      堆排序
 95 （1）基本思想：堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。八大排序移動次數比較。
 96 堆的定義如下：具有n個元素的序列（h1,h2,...,hn),當且僅當滿足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)時稱之為堆。在這里只討論滿足前者條件的堆。由堆的定義可以看出，堆頂元素（即第一個元素）必為最大項（大頂堆）。Java list排序。完全二叉樹可以很直觀地表示堆的結構。堆頂為根，其它為左子樹、右子樹。初始時把要排序的數的序列看作是一棵順序存儲的二叉樹，調整它們的存儲序，使之成為一個堆，這時堆的根節點的數最大。java排序方法有哪幾種。然后將根節點與堆的最后一個節點交換。然后對前面(n-1)個數重新調整使之成為堆。依此類推，直到只有兩個節點的堆，并對它們作交換，最后得到有n個節點的有序序列。java歸并排序、從算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最后一個元素交換位置。所以堆排序有兩個函數組成。一是建堆的滲透函數，二是反復調用滲透函數實現排序的函數。java直接排序。
 97 （2）實例：
 98 初始序列：46,79,56,38,40,84
 99 建堆：
100 
101 交換，從堆中踢出最大數
102 
103 
104 依次類推：最后堆中剩余的最后兩個結點交換，踢出一個，排序完成。
105 （3）用java實現
106 [java] view plaincopy
107 import java.util.Arrays;  
108   
109 public class HeapSort {  
110      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};  
111     public  HeapSort(){  
112         heapSort(a);  
113     }  
114     public  void heapSort(int[] a){  
115         System.out.println("開始排序");  
116         int arrayLength=a.length;  
117         //循環建堆  
118         for(int i=0;i<arrayLength-1;i++){  
119             //建堆  
120   
121       buildMaxHeap(a,arrayLength-1-i);  
122             //交換堆頂和最后一個元素  
123             swap(a,0,arrayLength-1-i);  
124             System.out.println(Arrays.toString(a));  
125         }  
126     }  
127   
128     private  void swap(int[] data, int i, int j) {  
129         // TODO Auto-generated method stub  
130         int tmp=data[i];  
131         data[i]=data[j];  
132         data[j]=tmp;  
133     }  
134     //對data數組從0到lastIndex建大頂堆  
135     private void buildMaxHeap(int[] data, int lastIndex) {  
136         // TODO Auto-generated method stub  
137         //從lastIndex處節點（最后一個節點）的父節點開始  
138         for(int i=(lastIndex-1)/2;i>=0;i--){  
139             //k保存正在判斷的節點  
140             int k=i;  
141             //如果當前k節點的子節點存在  
142             while(k*2+1<=lastIndex){  
143                 //k節點的左子節點的索引  
144                 int biggerIndex=2*k+1;  
145                 //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k節點的右子節點存在  
146                 if(biggerIndex<lastIndex){  
147                     //若果右子節點的值較大  
148                     if(data[biggerIndex]<data[biggerIndex+1]){  
149                         //biggerIndex總是記錄較大子節點的索引  
150                         biggerIndex++;  
151                     }  
152                 }  
153                 //如果k節點的值小于其較大的子節點的值  
154                 if(data[k]<data[biggerIndex]){  
155                     //交換他們  
156                     swap(data,k,biggerIndex);  
157                     //將biggerIndex賦予k，開始while循環的下一次循環，重新保證k節點的值大于其左右子節點的值  
158                     k=biggerIndex;  
159                 }else{  
160                     break;  
161                 }  
162             }<p align="left"> <span>   </span>}</p><p align="left">    }</p><p align="left"> <span style="background-color: white; ">}</span></p>  
163 
164 
165 5.冒泡排序
166 （1）基本思想：在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較后發現它們的排序與排序要求相反時，就將它們互換。
167 （2）實例：
168 
169 （3）用java實現
170 [java] view plaincopy
171 public class bubbleSort {  
172 public  bubbleSort(){  
173      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};  
174     int temp=0;  
175     for(int i=0;i<a.length-1;i++){  
176         for(int j=0;j<a.length-1-i;j++){  
177         if(a[j]>a[j+1]){  
178             temp=a[j];  
179             a[j]=a[j+1];  
180             a[j+1]=temp;  
181         }  
182         }  
183     }  
184     for(int i=0;i<a.length;i++)  
185     System.out.println(a[i]);     
186 }  
187 }  
188 
189 6.快速排序
190 （1）基本思想：選擇一個基準元素,通常選擇第一個元素或者最后一個元素,通過一趟掃描，將待排序列分成兩部分,一部分比基準元素小,一部分大于等于基準元素,此時基準元素在其排好序后的正確位置,然后再用同樣的方法遞歸地排序劃分的兩部分。
191 （2）實例：
192 
193 （3）用java實現
194 [java] view plaincopy
195 public class quickSort {  
196   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};  
197 public  quickSort(){  
198     quick(a);  
199     for(int i=0;i<a.length;i++)  
200         System.out.println(a[i]);  
201 }  
202 public int getMiddle(int[] list, int low, int high) {     
203             int tmp = list[low];    //數組的第一個作為中軸     
204             while (low < high) {     
205                 while (low < high && list[high] >= tmp) {     
206   
207       high--;     
208                 }     
209                 list[low] = list[high];   //比中軸小的記錄移到低端     
210                 while (low < high && list[low] <= tmp) {     
211                     low++;     
212                 }     
213                 list[high] = list[low];   //比中軸大的記錄移到高端     
214             }     
215            list[low] = tmp;              //中軸記錄到尾     
216             return low;                   //返回中軸的位置     
217         }    
218 public void _quickSort(int[] list, int low, int high) {     
219             if (low < high) {     
220                int middle = getMiddle(list, low, high);  //將list數組進行一分為二     
221                 _quickSort(list, low, middle - 1);        //對低字表進行遞歸排序     
222                _quickSort(list, middle + 1, high);       //對高字表進行遞歸排序     
223             }     
224         }   
225 public void quick(int[] a2) {     
226             if (a2.length > 0) {    //查看數組是否為空     
227                 _quickSort(a2, 0, a2.length - 1);     
228         }     
229        }   
230 }  
231 
232 
233 7、歸并排序
234 （1）基本排序：歸并（Merge）排序法是將兩個（或兩個以上）有序表合并成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然后再把有序子序列合并為整體有序序列。
235 （2）實例：
236 
237 （3）用java實現
238 
239 [java] view plaincopy
240 import java.util.Arrays;  
241   
242 public class mergingSort {  
243 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};  
244 public  mergingSort(){  
245     sort(a,0,a.length-1);  
246     for(int i=0;i<a.length;i++)  
247         System.out.println(a[i]);  
248 }  
249 public void sort(int[] data, int left, int right) {  
250     // TODO Auto-generated method stub  
251     if(left<right){  
252         //找出中間索引  
253         int center=(left+right)/2;  
254         //對左邊數組進行遞歸  
255         sort(data,left,center);  
256         //對右邊數組進行遞歸  
257         sort(data,center+1,right);  
258         //合并  
259         merge(data,left,center,right);  
260           
261     }  
262 }  
263 public void merge(int[] data, int left, int center, int right) {  
264     // TODO Auto-generated method stub  
265     int [] tmpArr=new int[data.length];  
266     int mid=center+1;  
267     //third記錄中間數組的索引  
268     int third=left;  
269     int tmp=left;  
270     while(left<=center&&mid<=right){  
271   
272    //從兩個數組中取出最小的放入中間數組  
273         if(data[left]<=data[mid]){  
274             tmpArr[third++]=data[left++];  
275         }else{  
276             tmpArr[third++]=data[mid++];  
277         }  
278     }  
279     //剩余部分依次放入中間數組  
280     while(mid<=right){  
281         tmpArr[third++]=data[mid++];  
282     }  
283     while(left<=center){  
284         tmpArr[third++]=data[left++];  
285     }  
286     //將中間數組中的內容復制回原數組  
287     while(tmp<=right){  
288         data[tmp]=tmpArr[tmp++];  
289     }  
290     System.out.println(Arrays.toString(data));  
291 }  
292   
293 }  
294 
295 8、基數排序
296 （1）基本思想：將所有待比較數值（正整數）統一為同樣的數位長度，數位較短的數前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后,數列就變成一個有序序列。
297 （2）實例：
298 
299 
300 （3）用java實現
301 [java] view plaincopy
302 import java.util.ArrayList;  
303 import java.util.List;  
304   
305 public class radixSort {  
306     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};  
307 public radixSort(){  
308     sort(a);  
309     for(int i=0;i<a.length;i++)  
310         System.out.println(a[i]);  
311 }  
312 public  void sort(int[] array){     
313                  
314             //首先確定排序的趟數;     
315         int max=array[0];     
316         for(int i=1;i<array.length;i++){     
317                if(array[i]>max){     
318                max=array[i];     
319                }     
320             }     
321   
322     int time=0;     
323            //判斷位數;     
324             while(max>0){     
325                max/=10;     
326                 time++;     
327             }     
328                  
329         //建立10個隊列;     
330             List<ArrayList> queue=new ArrayList<ArrayList>();     
331             for(int i=0;i<10;i++){     
332                 ArrayList<Integer> queue1=new ArrayList<Integer>();   
333                 queue.add(queue1);     
334         }     
335                 
336             //進行time次分配和收集;     
337             for(int i=0;i<time;i++){     
338                      
339                 //分配數組元素;     
340                for(int j=0;j<array.length;j++){     
341                     //得到數字的第time+1位數;   
342                    int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);  
343                    ArrayList<Integer> queue2=queue.get(x);  
344                    queue2.add(array[j]);  
345                    queue.set(x, queue2);  
346             }     
347                 int count=0;//元素計數器;     
348             //收集隊列元素;     
349                 for(int k=0;k<10;k++){   
350                 while(queue.get(k).size()>0){  
351                     ArrayList<Integer> queue3=queue.get(k);  
352                         array[count]=queue3.get(0);     
353                         queue3.remove(0);  
354                     count++;  
355               }     
356             }     
357     }               
358    }    
359   
360 }