1. public class MySort {
   
2. 
   
3.     /**
   
4.      * @param args
   
5.      */
   
6.     public static void main(String[] args) {
   
7.         int array[] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
   
8.         MySort mySort = new MySort();
   
9.         mySort.insertSort(array);
   
10.         System.out.print("插入排序结果 ：  ");
    
11.         mySort.printArray(array);
    
12.         System.out.println();
    
13.         mySort.bubbleSort(array);
    
14.         System.out.print("冒泡排序结果 ：  ");
    
15.         mySort.printArray(array);
    
16.         mySort.qsort(array);
    
17.         System.out.println();
    
18.         System.out.print("快速排序结果 ：  ");
    
19.         mySort.printArray(array);
    
20.         mySort.shellSort(array);
    
21.         System.out.println();
    
22.         System.out.print("希尔排序结果 ：  ");
    
23.         mySort.printArray(array);
    
24.         mySort.selectSort(array);
    
25.         System.out.println();
    
26.         System.out.print("选择排序结果 ：  ");
    
27.         mySort.printArray(array);
    
28.     }
    
29.      
    
30.     /**
    
31.      * 直接插入排序
    
32.      * 基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序
    
33.      */
    
34.     public void insertSort(int[] array){
    
35.         int temp=0;  
    
36.         for(int i=1;i<array.length;i++){  
    
37.            int j=i-1;  
    
38.            temp=array[i];  
    
39.            for(;j>=0&&temp<array[j];j--){  
    
40.                array[j+1]=array[j];                       //将大于temp的值整体后移一个单位  
    
41.            }  
    
42.            array[j+1]=temp;  
    
43.         }
    
44.     }
    
45.      
    
46.     /**
    
47.      * 冒泡排序
    
48.      * 基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
    
49.      */
    
50.     public void bubbleSort(int[] array) {
    
51.         int temp;
    
52.         for(int i=0;i<array.length;i++){//趟数
    
53.           for(int j=0;j<array.length-i-1;j++){//比较次数
    
54.             if(array[j]>array[j+1]){
    
55.               temp=array[j];
    
56.               array[j]=array[j+1];
    
57.               array[j+1]=temp;
    
58.             }
    
59.           }
    
60.         }
    
61.     }
    
62.      
    
63.     /**
    
64.      * 快速排序
    
65.      * 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
    
66.      * @param array
    
67.      */
    
68.     public void qsort(int array[]){
    
69.         if(array.length>1){
    
70.             _qsort(array,0,array.length-1);
    
71.         }
    
72.     }
    
73.     /**
    
74.      * 一趟快速排序
    
75.      * @param array
    
76.      */
    
77.     private void _qsort(int[] array,int low,int high){
    
78.         if(low < high){
    
79.             int middle = getMiddle(array, low, high);
    
80.             _qsort(array,low,middle-1);
    
81.             _qsort(array, middle+1, high);
    
82.         }
    
83.     }
    
84.     /**
    
85.      * 得到中间值
    
86.      */
    
87.     private int getMiddle(int[] array,int low,int high){
    
88.         int tmp = array[low];
    
89.         while(low < high){
    
90.             while(low < high && array[high] >= tmp)
    
91.                 high--;
    
92.             array[low] = array[high];
    
93.             while(low<high && array[low]<=tmp)
    
94.                 low++;
    
95.             array[high] = array[low];
    
96.         }
    
97.         array[low] = tmp;
    
98.         return low;
    
99.     }
    
100.      
     
101.     /**
     
102.      * 简单选择排序
     
103.      * 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
     
104.      * @param array
     
105.      */
     
106.     public void selectSort(int[] array){
     
107.         int position=0;  
     
108.         for(int i=0;i<array.length;i++){  
     
109.                
     
110.             int j=i+1;  
     
111.             position=i;  
     
112.             int temp=array[i];  
     
113.             for(;j<array.length;j++){  
     
114.             if(array[j]<temp){  
     
115.                 temp=array[j];  
     
116.                 position=j;  
     
117.             }  
     
118.             }  
     
119.             array[position]=array[i];  
     
120.             array[i]=temp;  
     
121.         }
     
122.     }
     
123.      
     
124.     /**
     
125.      * 希尔排序（最小增量排序）
     
126.      * 基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。
     
127.      * @param array
     
128.      */
     
129.     public  void shellSort(int[] array){  
     
130.         double d1=array.length;  
     
131.         int temp=0;  
     
132.         while(true){  
     
133.             d1= Math.ceil(d1/2);  
     
134.             int d=(int) d1;  
     
135.             for(int x=0;x<d;x++){  
     
136.                 for(int i=x+d;i<array.length;i+=d){  
     
137.                     int j=i-d;  
     
138.                     temp=array[i];  
     
139.                     for(;j>=0&&temp<array[j];j-=d){  
     
140.                         array[j+d]=array[j];  
     
141.                     }  
     
142.                     array[j+d]=temp;  
     
143.                 }  
     
144.             }  
     
145.             if(d==1)  
     
146.                 break;  
     
147.         }  
     
148.     }  
     
149.      
     
150.     /**
     
151.      * 打印数组中的所有元素
     
152.      */
     
153.      
     
154.     public void printArray(int[] array){
     
155.         for (int i = 0; i < array.length; i++) {
     
156.             System.out.print(array[i]+" ");
     
157.         }
     
158.     }
     
159. }

复制代码

1. public class MySort {
   
2. 
   
3.     /**
   
4.      * @param args
   
5.      */
   
6.     public static void main(String[] args) {
   
7.         int array[] = {45,32,54,12,43,65,11,3,43,6,33,90,44,1,178};
   
8.         MySort mySort = new MySort();
   
9.         mySort.insertSort(array);
   
10.         System.out.print("插入排序结果 ：  ");
    
11.         mySort.printArray(array);
    
12.         System.out.println();
    
13.         mySort.bubbleSort(array);
    
14.         System.out.print("冒泡排序结果 ：  ");
    
15.         mySort.printArray(array);
    
16.         mySort.qsort(array);
    
17.         System.out.println();
    
18.         System.out.print("快速排序结果 ：  ");
    
19.         mySort.printArray(array);
    
20.         mySort.shellSort(array);
    
21.         System.out.println();
    
22.         System.out.print("希尔排序结果 ：  ");
    
23.         mySort.printArray(array);
    
24.         mySort.selectSort(array);
    
25.         System.out.println();
    
26.         System.out.print("选择排序结果 ：  ");
    
27.         mySort.printArray(array);
    
28.     }
    
29.      
    
30.     /**
    
31.      * 直接插入排序
    
32.      * 基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序
    
33.      */
    
34.     public void insertSort(int[] array){
    
35.         int temp=0;  
    
36.         for(int i=1;i<array.length;i++){  
    
37.            int j=i-1;  
    
38.            temp=array[i];  
    
39.            for(;j>=0&&temp<array[j];j--){  
    
40.                array[j+1]=array[j];                       //将大于temp的值整体后移一个单位  
    
41.            }  
    
42.            array[j+1]=temp;  
    
43.         }
    
44.     }
    
45.      
    
46.     /**
    
47.      * 冒泡排序
    
48.      * 基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
    
49.      */
    
50.     public void bubbleSort(int[] array) {
    
51.         int temp;
    
52.         for(int i=0;i<array.length;i++){//趟数
    
53.           for(int j=0;j<array.length-i-1;j++){//比较次数
    
54.             if(array[j]>array[j+1]){
    
55.               temp=array[j];
    
56.               array[j]=array[j+1];
    
57.               array[j+1]=temp;
    
58.             }
    
59.           }
    
60.         }
    
61.     }
    
62.      
    
63.     /**
    
64.      * 快速排序
    
65.      * 基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
    
66.      * @param array
    
67.      */
    
68.     public void qsort(int array[]){
    
69.         if(array.length>1){
    
70.             _qsort(array,0,array.length-1);
    
71.         }
    
72.     }
    
73.     /**
    
74.      * 一趟快速排序
    
75.      * @param array
    
76.      */
    
77.     private void _qsort(int[] array,int low,int high){
    
78.         if(low < high){
    
79.             int middle = getMiddle(array, low, high);
    
80.             _qsort(array,low,middle-1);
    
81.             _qsort(array, middle+1, high);
    
82.         }
    
83.     }
    
84.     /**
    
85.      * 得到中间值
    
86.      */
    
87.     private int getMiddle(int[] array,int low,int high){
    
88.         int tmp = array[low];
    
89.         while(low < high){
    
90.             while(low < high && array[high] >= tmp)
    
91.                 high--;
    
92.             array[low] = array[high];
    
93.             while(low<high && array[low]<=tmp)
    
94.                 low++;
    
95.             array[high] = array[low];
    
96.         }
    
97.         array[low] = tmp;
    
98.         return low;
    
99.     }
    
100.      
     
101.     /**
     
102.      * 简单选择排序
     
103.      * 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
     
104.      * @param array
     
105.      */
     
106.     public void selectSort(int[] array){
     
107.         int position=0;  
     
108.         for(int i=0;i<array.length;i++){  
     
109.                
     
110.             int j=i+1;  
     
111.             position=i;  
     
112.             int temp=array[i];  
     
113.             for(;j<array.length;j++){  
     
114.             if(array[j]<temp){  
     
115.                 temp=array[j];  
     
116.                 position=j;  
     
117.             }  
     
118.             }  
     
119.             array[position]=array[i];  
     
120.             array[i]=temp;  
     
121.         }
     
122.     }
     
123.      
     
124.     /**
     
125.      * 希尔排序（最小增量排序）
     
126.      * 基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。
     
127.      * @param array
     
128.      */
     
129.     public  void shellSort(int[] array){  
     
130.         double d1=array.length;  
     
131.         int temp=0;  
     
132.         while(true){  
     
133.             d1= Math.ceil(d1/2);  
     
134.             int d=(int) d1;  
     
135.             for(int x=0;x<d;x++){  
     
136.                 for(int i=x+d;i<array.length;i+=d){  
     
137.                     int j=i-d;  
     
138.                     temp=array[i];  
     
139.                     for(;j>=0&&temp<array[j];j-=d){  
     
140.                         array[j+d]=array[j];  
     
141.                     }  
     
142.                     array[j+d]=temp;  
     
143.                 }  
     
144.             }  
     
145.             if(d==1)  
     
146.                 break;  
     
147.         }  
     
148.     }  
     
149.      
     
150.     /**
     
151.      * 打印数组中的所有元素
     
152.      */
     
153.      
     
154.     public void printArray(int[] array){
     
155.         for (int i = 0; i < array.length; i++) {
     
156.             System.out.print(array[i]+" ");
     
157.         }
     
158.     }
     
159. }

复制代码