Java实现排序算法(一)

1. /**
2.  * @(#)SortTest.java
3.  * 排序算法
4.  *
5.  * @author 
6.  * @version 1.00 2008/8/2
7.  */
8. public class SortTest {
10.     /**
11.      *选择排序
12.      *在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序
13.     */
14.    void selectSort(int[] sortIn){
15.         int i,j,temp,min=0;
16.         for(i=0;i<sortIn.length;i++){
17.             min=i;
18.             for(j=i;j<sortIn.length;j++){//每一趟都选择一个最小的
19.                 if(sortIn[j]<sortIn[min]) min=j;
20.             }
21.             //交换
22.             swap(sortIn,i,min);
23.         }
24.     }
25.     
26.     /**
27.      *冒泡排序
28.      *算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置
29.      */
30.     void bubbleSort(int[] sortIn){
31.         for(int i=0;i<sortIn.length;i++){
32.             for(int j=sortIn.length-1;j>i;j--){
33.                 if(sortIn[j]<sortIn[j-1])
34.                     swap(sortIn,j-1,j);         
35.             }
36.         }
37.     }
38.     
39.     /**
40.      *插入排序
41.      */
42.     void insertSort(int[] sortIn){
43.         for(int i=1;i<sortIn.length;i++){
44.             int temp=sortIn[i];
45.             int j=i-1;
46.             while(j>=0&&temp<sortIn[j]){
47.                 sortIn[j+1]=sortIn[j];//向后移动元素
48.                 j--;
49.             }
50.             sortIn[j+1]=temp;
51.         }
52.     }
53.     
54.     /**
55.      *希尔排序
56.      *Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块
57.      *排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，
58.      *知道最后成一个块，并使用插入排序。
59.      *这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,
60.      *从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。
61.      */
62.     void sheelSort(int[] sortIn){
63.         int d=sortIn.length;
64.         while(d>1){
65.             d=(d+1)/2;
66.             for(int i=0;i<sortIn.length-d;i++){
67.                 if(sortIn[i+d]<sortIn[i]){
68.                     swap(sortIn,i+d,i);
69.                 }
70.             }
71.         }
72.     }
73.     /**
74.      *快速排序
75.      *(1)分解(2)求解(3)组合
76.      */
77.     void quickSort(int[] sortIn,int low,int high){
78.         int pivotpos;//划分后的基准记录的位置
79.         if(low<high){//仅当区间长度大于1时才需排序
80.             pivotpos=partition(sortIn,low,high);//做划分
81.             quickSort(sortIn,low,pivotpos-1);//对左区间进行递归排序
82.             quickSort(sortIn,pivotpos+1,high);//对右区间进行递归排序
83.         }
84.     }
85.     
86.     private int partition(int[] sortIn,int i,int j){
87.         int pivot=sortIn[i];
88.         while(i<j){
89.             //从右向左扫描，查找第一个关键字小于pivot的记录
90.             while(i<j&&sortIn[j]>=pivot) j--;
91.             if(i<j){
92.                 swap(sortIn,i,j);//交换sortIn[i]和sortIn[j]
93.                 i++;
94.             }
95.             
96.             //从左向右扫描，查找第一个关键字大于pivot的记录
97.             while(i<j&&sortIn[i]<=pivot) i++;
98.             if(i<j){
99.                 swap(sortIn,i,j);
100.                 j--;
101.             }
102.         }
103.         sortIn[i]=pivot;//基准位置已被最终定位
104.         return i;
105.     } 
106.         
107.     /**
108.      *交换位置
109.      */
110.     private void swap(int a[],int i,int j){
111.         int temp=a[i];
112.         a[i]=a[j];
113.         a[j]=temp;
114.     }
115.     
116.     public static void main(String[] args){
117.         int[] sortIn={49,38,56,97,76,13,27,99,55,3};
118.         SortTest ss=new SortTest();
119.         
120.         //ss.selectSort(sortIn);
121.         //ss.bubbleSort(sortIn);
122.         //ss.insertSort(sortIn);
123.         //ss.sheelSort(sortIn);
124.         ss.quickSort(sortIn,0,sortIn.length-1);
125.         for(int num:sortIn){
126.             System.out.print(" "+num);
127.         }
128.     }
129. }