各种排序算法java实现

1. package org.rut.util.algorithm.support;
2. import org.rut.util.algorithm.SortUtil;
3.  
4. public class InsertSort implements SortUtil.Sort{
5.     /* (non-Javadoc)
6.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
7.      */
8.     public void sort(int[] data) {
9.         int temp;
10.         for(int i=1;i<data.length;i++){
11.             for(int j=i;(j>0)&amp;&amp;(data[j]<data[j-1]);j–){
12.                 SortUtil.swap(data,j,j-1);
13.             }
14.         }        
15.     }
16. }
17. <span id="more-798"></span>

冒泡排序:
 

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.  
5. public class BubbleSort implements SortUtil.Sort{
6.     /* (non-Javadoc)
7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
8.      */
9.     public void sort(int[] data) {
10.         int temp;
11.         for(int i=0;i<data.length;i++){
12.             for(int j=data.length-1;j>i;j–){
13.                 if(data[j]<data[j-1]){
14.                     SortUtil.swap(data,j,j-1);
15.                 }
16.             }
17.         }
18.     }
19. }
20.  

选择排序:

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.  
5. public class SelectionSort implements SortUtil.Sort {
6.     /*
7.      * (non-Javadoc)
8.      * 
9.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
10.      */
11.     public void sort(int[] data) {
12.         int temp;
13.         for (int i = 0; i < data.length; i++) {
14.             int lowIndex = i;
15.             for (int j = data.length – 1; j > i; j–) {
16.                 if (data[j] < data[lowIndex]) {
17.                     lowIndex = j;
18.                 }
19.             }
20.             SortUtil.swap(data,i,lowIndex);
21.         }
22.     }
23. }
24.  

Shell排序:

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.  
5. public class ShellSort implements SortUtil.Sort{
6.     /* (non-Javadoc)
7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
8.      */
9.     public void sort(int[] data) {
10.         for(int i=data.length/2;i>2;i/=2){
11.             for(int j=0;j<i;j++){
12.                 insertSort(data,j,i);
13.             }
14.         }
15.         insertSort(data,0,1);
16.     }
17.     /**
18.      * @param data
19.      * @param j
20.      * @param i
21.      */
22.     private void insertSort(int[] data, int start, int inc) {
23.         int temp;
24.         for(int i=start+inc;i<data.length;i+=inc){
25.             for(int j=i;(j>=inc)&amp;&amp;(data[j]<data[j-inc]);j-=inc){
26.                 SortUtil.swap(data,j,j-inc);
27.             }
28.         }
29.     }
30. }

快速排序:

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.  
5. public class QuickSort implements SortUtil.Sort{
6.     /* (non-Javadoc)
7.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
8.      */
9.     public void sort(int[] data) {
10.         quickSort(data,0,data.length-1);        
11.     }
12.     private void quickSort(int[] data,int i,int j){
13.         int pivotIndex=(i+j)/2;
14.         //swap
15.         SortUtil.swap(data,pivotIndex,j);
16.         
17.         int k=partition(data,i-1,j,data[j]);
18.         SortUtil.swap(data,k,j);
19.         if((k-i)>1) quickSort(data,i,k-1);
20.         if((j-k)>1) quickSort(data,k+1,j);
21.         
22.     }
23.     /**
24.      * @param data
25.      * @param i
26.      * @param j
27.      * @return
28.      */
29.     private int partition(int[] data, int l, int r,int pivot) {
30.         do{
31.            while(data[++l]<pivot);
32.            while((r!=0)&amp;&amp;data[–r]>pivot);
33.            SortUtil.swap(data,l,r);
34.         }
35.         while(l<r);
36.         SortUtil.swap(data,l,r);        
37.         return l;
38.     }
39. }

改进后的快速排序:

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.  
5. public class ImprovedQuickSort implements SortUtil.Sort {
6.     private static int MAX_STACK_SIZE=4096;
7.     private static int THRESHOLD=10;
8.     /* (non-Javadoc)
9.      * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
10.      */
11.     public void sort(int[] data) {
12.         int[] stack=new int[MAX_STACK_SIZE];
13.         
14.         int top=-1;
15.         int pivot;
16.         int pivotIndex,l,r;
17.         
18.         stack[++top]=0;
19.         stack[++top]=data.length-1;
20.         
21.         while(top>0){
22.             int j=stack[top–];
23.             int i=stack[top–];
24.             
25.             pivotIndex=(i+j)/2;
26.             pivot=data[pivotIndex];
27.             
28.             SortUtil.swap(data,pivotIndex,j);
29.             
30.             //partition
31.             l=i-1;
32.             r=j;
33.             do{
34.                 while(data[++l]<pivot);
35.                 while((r!=0)&amp;&amp;(data[–r]>pivot));
36.                 SortUtil.swap(data,l,r);
37.             }
38.             while(l<r);
39.             SortUtil.swap(data,l,r);
40.             SortUtil.swap(data,l,j);
41.             
42.             if((l-i)>THRESHOLD){
43.                 stack[++top]=i;
44.                 stack[++top]=l-1;
45.             }
46.             if((j-l)>THRESHOLD){
47.                 stack[++top]=l+1;
48.                 stack[++top]=j;
49.             }
50.             
51.         }
52.         //new InsertSort().sort(data);
53.         insertSort(data);
54.     }
55.     /**
56.      * @param data
57.      */
58.     private void insertSort(int[] data) {
59.         int temp;
60.         for(int i=1;i<data.length;i++){
61.             for(int j=i;(j>0)&amp;&amp;(data[j]<data[j-1]);j–){
62.                 SortUtil.swap(data,j,j-1);
63.             }
64.         }       
65.     }
66. }

归并排序:

1.  
2. package org.rut.util.algorithm.support;
3. import org.rut.util.algorithm.SortUtil;
4.