java数据结构之排序

写在前面的话：本篇文章是我自己阅读程杰老师的大话数据结构之后自己所做的总结，网上有很多关于排序的详细介绍，我推荐伍迷家园所写的文章，介绍的非常详细。

排序是我们在程序中经常要用到的一种算法，好的排序可以极大的提高我们的工作效率，本篇主要介绍几种常见的排序算法；

（简单说明：下面的java程序是用来排序的，其中sum为排序数组，sum[0]不进行排序，只作为哨兵或者临时变量）

1、冒泡排序：冒泡排序是一种交换排序，其的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

 1 //冒泡排序2 最正宗的冒泡排序，i每循环一次，最小的数就像气泡一样慢慢浮到水面上
 2     public static void BubbleSort_2(int[] num){
 3         for(int i = 1; i < num.length; i++){
 4             for(int j = num.length-1; j > i; j--){
 5                 if(num[j-1] > num[j]){
 6                     Swap(num,j-1,j);    //交换函数  交换num[j-1]和num[j]的值
 7                 }
 8             }
 9         }
10     }

2、选择排序：简单选择排序法（Simple Selection Sort）就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i(1≤i≤n)个记录交换之。

 1 //选择排序
 2     public static void SelectSort(int[] num){
 3         int min;
 4         for(int i = 1; i < num.length; i++){
 5             min = i;
 6             for(int j = i + 1; j <num.length; j++){
 7                 if(num[min] > num[j]){
 8                     min = j;
 9                 }
10             }
11             if(i != min){
12                 Swap(num,i,min);        //交换函数  交换num[j-1]和num[j]的值
13             }
14         }
15     }

3、插入排序：直接插入排序（Straight Insertion Sort）的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。

 1  //插入排序
 2     public static void InsertSort(int[] num){
 3         int j;                             
 4         for(int i = 2; i < num.length; i++){
 5             if(num[i] < num[i-1]){
 6                 num[0] = num[i];
 7                 for( j = i-1; num[j] > num[0]; j--){
 8                     num[j+1] = num[j];          //记录右移
 9                 }
10                 num[j+1] = num[0]; //插入到正确位置
11                 num[0] = 0;         //把num[0] 置为0，还回到初始值
12             }
13         }
14     }

4、希尔排序：我们将原本有大量记录数的记录进行分组。分割成若干个子序列，此时每个子序列待排序的记录个数就比较少了，然后在这些子序列内分别进行直接插入排序，当整个序列都基本有序时，注意只是基本有序时，再对全体记录进行一次直接插入排序。

 1 //希尔排序
 2     public static void ShellSort(int[] num){
 3         int n = num.length; 
 4         int j;
 5         do{
 6             n = n/3 + 1;                    //增量序列
 7             for(int i = n; i < num.length; i++){
 8                 if(num[i] < num[i-n]){          //需要将num[i]插入到有序增量子表中
 9                     num[0] = num[i];
10                     for(j = i - n; j > 0 && num[0] < num[j];j -= n){
11                         num[j+n] = num[j];
12                     }
13                     num[j+n] = num[0];
14                 }
15             }
16         }while(n > 1);
17     }

5、堆排序：堆排序（Heap Sort）就是利用堆（假设利用大顶堆）进行排序的方法。它的基本思想是，将待排序的序列构造成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它与堆数组的末尾元素进行交换，此时末尾元素就是最大值，然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次小值。如此反复执行，便能得到一个有序序列了。（大顶堆：在完全二叉树中，每个结点的值都大于或等于其左右孩子结点的值）

 1  //堆排序算法   堆排序的时候一定要注意数组的下标，很容发生数组下标越界的情况
 2     public static void HeadSort(int[] num){
 3         for(int i = (num.length-1)/2; i>0; i--){        //将num构建成一个大顶堆
 4         HeapAdjust(num,i,num.length-1);
 5         }
 6         for(int i = num.length-1; i > 1; i--){     //排序num[3]~num[n]  其中数组开始两个元素num[1]和num[2]没有进行交换
 7             Swap(num,1,i);                            //交换函数  交换num[j-1]和num[j]的值
 8             HeapAdjust(num,1,i-1);
 9         }
10     }
11     /*本函数是为了将num调整为一个大顶堆，num除了num【1】以外，
12     其他节点都符合大顶堆的定义，这个函数是为堆排序算法服务的*/
13     public static void HeapAdjust(int[] num,int start,int stop){            
14         int i, num_x;
15         num_x = num[start];
16         for(i = 2*start; i <= stop; i*=2){       //沿关键字较大的纪录项下筛选
17             if(i+1 >= num.length){                //没有右孩子节点时，单独判断，否则num[i+1]会越界
18                 if(num[i/2] < num[i]){
19                     num[i/2] = num[i];
20                     start = i;
21                  break;
22               }else{
23                   break;
24               }
25             }
26             if(num[i] < num[i+1] && i < stop){
27                 ++i;                        //i为关键字较大的记录的下标 
28             }
29             if(num_x >= num[i]){                 //不在向下找了，num_x已经是最大的了
30                 break;
31             }
32             num[start] = num[i];
33             start = i;
34         }
35         num[start] = num_x;
36     }

6、归并排序：归并排序（Merging Sort）就是利用归并的思想实现的排序方法。它的原理是假设初始序列含有n个记录，则可以看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到⌈n/2⌉（⌈x⌉表示不小于x的最小整数）个长度为2的有序子序列；再两两归并，…… 如此重复，直至得到一个长度为n的有序序列为止，这种排序方法称为2路归并排序。

 1 //归并排序
 2     public static void MergeSort(int[] num){
 3         int[] temp =new int[num.length];
 4         MSort(num,temp ,1,num.length-1);
 5     }
 6     //Msort函数是将list数组进行分割，Merge函数是将分割后的list数组进行排序在组合
 7     public static void MSort(int[] list ,int[] temp,int left,int right){
 8         if(left  == right){
 9             return;   
10         }else{
11             int m = (left + right) / 2;
12             MSort(list,temp,left,m);
13             MSort(list,temp,m+1,right);
14             Merge(list,temp,left,m+1,right);
15         }
16     }
17     public static void Merge(int[] list,int[] temp,int left,int mid,int right){
18         int j = 0;
19         int left_x = left;
20         int mid_x = mid -1;
21         int n = right - left +1;                        //当前temp数组中数的个数
22         while(left <= mid_x &&  mid <= right){              //左右数组第一个数进行比较  把较小的数如到temp数组中
23             if(list[left] < list[mid]){
24                 temp[j++] = list[left++];
25             }else{
26                 temp[j++] = list[mid++];
27             }
28         }
29         while(left <= mid_x){                         //如果左边的数比右边的数多，就将剩下的入到temp数组中    j
30             temp[j++] = list[left++];
31         }
32 
33         while(mid <= right){                           //如果右边打数比左边的数多，就将右边剩下的数加入到temp数组当中去
34             temp[j++] = list[mid++];
35         }
36         
37         for(j = 0; j < n; j++){             //   将得到的temp数组加到list数组中    
38             list[left_x+j] = temp[j];
39         }         
40     }

7、快速排序：快速排序（Quick Sort）的基本思想是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

 1 //快速排序
 2     public static void QuickSort(int[] num){
 3         QSort(num,1,num.length-1);
 4     }
 5     public static void QSort(int[] num, int left, int right){
 6         int mid = Partition(num,left,right);
 7 
 8         QSort(num,left,mid-1);
 9         QSort(num,mid+1,right); 
10     }
11     //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
12     public static int   Partition(int[] num, int left, int right){
13         int result;
14         result = num[left];
15         while(left < right){
16             while( left < right && num[right] >= result){
17                 right++;
18             }
19             Swap(num,left,right);
20             while( left < right && num[left] <= result){
21                 left++;
22             }
23             Swap(num,left,right);
24         }
25         return left;
26     }

8、快速排序优化

 1  //快速排序优化
 2     public static void QuickSort_Op(int[] num){
 3         Qsort_Op(num,1,num.length-1);
 4     }
 5     public static void Qsort_Op(int[] num, int left, int right){
 6         final int N = 7;                //数组长度的阀值  当数组长度低于这个长度是就不在使用快速排序，而是使用插入排序
 7         if((right-left) > N){
 8             //尾递归优化
 9             while(left < right){
10                 int mid = Partition_Op(num,left,right);
11         
12                 Qsort_Op(num, left, mid-1);        //对底子表进行递归排序
13                 left = mid;            //尾递归
14             }
15          }else{              //当right-left小于7时，用直接插入排序
16                InsertSort(num);  
17          }
18    }
19   //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
20     public static int Partition_Op(int[] num, int left, int right){
21         int result;
22 
23         //优化选取轴承    三数取中（取左端、右端，中间三个），进行排序，取中间数作为轴承
24         int m = left + (right - left);
25         if(num[left] > num[right]){
26             Swap(num,left,right);
27         }
28         if(num[m] > num[right]){
29             Swap(num,m,right);
30         }
31         if(num[left] < num[m]){
32             Swap(num,left,m);
33         }
34         result  = num[left];         //y用子表的第一个记录作为轴承记录
35         num[0] = result;            //将轴承关键字备份到num[0]
36         while( left < right ){
37             while(left < right && num[right] > result){
38                 right--;
39             }
40             num[left] = num[right];  //选择替换而不是交换方式进行
41             while(left < right && num[left] < result){
42                 left++;
43             }
44             num[right] = num[left];         //选择替换而不是交换方式进行操作
45         }
46         num[left] = num[0];
47         return left;
48     }

下面代码包含了上述所有排序算法，是一段总结代码：

  1 /**
  2  * 2016/5/3
  3  * 排序算法大总结
  4  * 说明：本java程序是用来排序的，其中sum为排序数组，sum[0]不进行排序，只作为哨兵或者临时变量
  5  */
  6 package cn.Link;
  7 public class Sort{
  8     //测试主函数
  9     public static void main(String[] args){
 10         int n = 20;         //数组长度
 11         int[] num = new int[n];     //要排序的数组
 12         num[0] = 0;             //数组首位不进行排序操作，仅作为临时变量或者是哨兵
 13         for(int i = 1; i < n; i ++){
 14             num[i] = (int)(Math.random()*100);  //随机生成一个数作为数组元素
 15         }
 16 
 17         System.out.println("排序前的数组：");
 18         Print_num(num);
 19 
 20         //冒泡排序1
 21         int[] num_1 = (int[]) num.clone();        //将num数组全部复制给num_1数组
 22         BubbleSort_1(num_1);
 23         System.out.print("\n冒泡排序1排序后的结果");
 24         Print_num(num_1);
 25 
 26         //冒泡排序2
 27         int[] num_2 = (int[]) num.clone();        //将num数组全部复制给num_2数组
 28         BubbleSort_2(num_2);
 29         System.out.print("\n冒泡排序2排序后的结果：");
 30         Print_num(num_2);
 31 
 32         //冒泡排序3 对冒泡排序2的优化
 33         int[] num_3 = (int[]) num.clone();        //将num数组全部复制给num_3数组
 34         BubbleSort_3(num_3);
 35         System.out.print("\n冒泡排序3排序后的结果：");
 36         Print_num(num_3);
 37 
 38         //选择排序
 39         int[] num_4 = (int[]) num.clone();        //将num数组全部复制给num_4数组
 40         SelectSort(num_4);
 41         System.out.print("\n选择排序排序后的结果：");
 42         Print_num(num_4);
 43 
 44         //插入排序
 45         int[] num_5 = (int[])num.clone();        //将num数组全部复制给num_5数组
 46         InsertSort(num_5);
 47         System.out.print("\n插入排序排序后的结果");
 48         Print_num(num_5);
 49         
 50         //希尔排序
 51         int[] num_6 = (int[])num.clone();        //将num数组全部复制给num_6数组
 52         InsertSort(num_6);
 53         System.out.print("\n希尔排序排序后的结果");
 54         Print_num(num_6);
 55 
 56         //堆排序
 57         int[] num_7 = (int[])num.clone();        //将num数组全部复制给num_7数组
 58         HeadSort(num_7);
 59         System.out.print("\n堆排序排序后的结果");
 60         Print_num(num_7);
 61         
 62         //堆排序
 63         int[] num_8 = (int[])num.clone();        //将num数组全部复制给num_8数组
 64         MergeSort(num_8);
 65         System.out.print("\n归并排序排序后的结果");
 66         Print_num(num_8);
 67         
 68         //快速排序
 69         int[] num_9 = (int[])num.clone();        //将num数组全部复制给num_8数组
 70         MergeSort(num_9);
 71         System.out.print("\n快速排序排序后的结果");
 72         Print_num(num_9);
 73         
 74       //快速排序优化
 75         int[] num_10 = (int[])num.clone();        //将num数组全部复制给num_8数组
 76         MergeSort(num_10);
 77         System.out.print("\n快速排序优化后排序后结果");
 78         Print_num(num_10);
 79 
 80     }
 81 
 82     //交换数组中的两个数
 83     public static void Swap(int[]num,int i,int j){
 84         int num_x;
 85         num_x = num[i];
 86         num[i] = num[j];
 87         num[j] = num_x;
 88     }
 89 
 90     //遍历输出一个数组
 91     public static void Print_num(int[] num){
 92         System.out.println();
 93         for(int u:num){            //for-each 
 94             System.out.print(u+" ");
 95         }
 96     }
 97 
 98     //冒泡排序1  最简单的两两比较，反序则交换的排序
 99     public static void BubbleSort_1(int[]num){
100         for(int i = 1; i < num.length; i++){
101             for(int j = i+1; j < num.length; j++){
102                 if(num[i] > num[j]){
103                     Swap(num,i,j);
104                 }
105             }
106         }
107     }
108 
109     //冒泡排序2 最正宗的冒泡排序，i每循环一次，最小的数就像气泡一样慢慢浮到水面上
110     public static void BubbleSort_2(int[] num){
111         for(int i = 1; i < num.length; i++){
112             for(int j = num.length-1; j > i; j--){
113                 if(num[j-1] > num[j]){
114                     Swap(num,j-1,j);    //交换函数  交换num[j-1]和num[j]的值
115                 }
116             }
117         }
118     }
119 
120     //冒泡排序3  对冒泡排序的优化
121     public static void BubbleSort_3(int[] num){
122         boolean  flag = true;
123         for(int i = 1; i < num.length && flag; i++){
124             flag = false;                   //flag初始化为假
125             for(int j = num.length-1; j>i ; j--){
126                 if(num[j-1] > num[j]){
127                     Swap(num,j-1,j);        //交换函数  交换num[j-1]和num[j]的值
128                     flag = true;
129                 }
130             }
131         }
132     }
133 
134     //选择排序
135     public static void SelectSort(int[] num){
136         int min;
137         for(int i = 1; i < num.length; i++){
138             min = i;
139             for(int j = i + 1; j <num.length; j++){
140                 if(num[min] > num[j]){
141                     min = j;
142                 }
143             }
144             if(i != min){
145                 Swap(num,i,min);        //交换函数  交换num[j-1]和num[j]的值
146             }
147         }
148     }
149 
150     //插入排序
151     public static void InsertSort(int[] num){
152         int j;                             
153         for(int i = 2; i < num.length; i++){
154             if(num[i] < num[i-1]){
155                 num[0] = num[i];
156                 for( j = i-1; num[j] > num[0]; j--){
157                     num[j+1] = num[j];          //记录右移
158                 }
159                 num[j+1] = num[0]; //插入到正确位置
160                 num[0] = 0;         //把num[0] 置为0，还回到初始值
161             }
162         }
163     }
164     //希尔排序
165     public static void ShellSort(int[] num){
166         int n = num.length; 
167         int j;
168         do{
169             n = n/3 + 1;                    //增量序列
170             for(int i = n; i < num.length; i++){
171                 if(num[i] < num[i-n]){          //需要将num[i]插入到有序增量子表中
172                     num[0] = num[i];
173                     for(j = i - n; j > 0 && num[0] < num[j];j -= n){
174                         num[j+n] = num[j];
175                     }
176                     num[j+n] = num[0];
177                 }
178             }
179         }while(n > 1);
180     }
181 
182     //堆排序算法   堆排序的时候一定要注意数组的下标，很容发生数组下标越界的情况
183     public static void HeadSort(int[] num){
184         for(int i = (num.length-1)/2; i>0; i--){        //将num构建成一个大顶堆
185         HeapAdjust(num,i,num.length-1);
186         }
187         for(int i = num.length-1; i > 1; i--){     //排序num[3]~num[n]  其中数组开始两个元素num[1]和num[2]没有进行交换
188             Swap(num,1,i);                            //交换函数  交换num[j-1]和num[j]的值
189             HeapAdjust(num,1,i-1);
190         }
191     }
192     /*本函数是为了将num调整为一个大顶堆，num除了num【1】以外，
193     其他节点都符合大顶堆的定义，这个函数是为堆排序算法服务的*/
194     public static void HeapAdjust(int[] num,int start,int stop){            
195         int i, num_x;
196         num_x = num[start];
197         for(i = 2*start; i <= stop; i*=2){       //沿关键字较大的纪录项下筛选
198             if(i+1 >= num.length){                //没有右孩子节点时，单独判断，否则num[i+1]会越界
199                 if(num[i/2] < num[i]){
200                     num[i/2] = num[i];
201                     start = i;
202                  break;
203               }else{
204                   break;
205               }
206             }
207             if(num[i] < num[i+1] && i < stop){
208                 ++i;                        //i为关键字较大的记录的下标 
209             }
210             if(num_x >= num[i]){                 //不在向下找了，num_x已经是最大的了
211                 break;
212             }
213             num[start] = num[i];
214             start = i;
215         }
216         num[start] = num_x;
217     }
218 
219 
220     //归并排序
221     public static void MergeSort(int[] num){
222         int[] temp =new int[num.length];
223         MSort(num,temp ,1,num.length-1);
224     }
225     //Msort函数是将list数组进行分割，Merge函数是将分割后的list数组进行排序在组合
226     public static void MSort(int[] list ,int[] temp,int left,int right){
227         if(left  == right){
228             return;   
229         }else{
230             int m = (left + right) / 2;
231             MSort(list,temp,left,m);
232             MSort(list,temp,m+1,right);
233             Merge(list,temp,left,m+1,right);
234         }
235     }
236     public static void Merge(int[] list,int[] temp,int left,int mid,int right){
237         int j = 0;
238         int left_x = left;
239         int mid_x = mid -1;
240         int n = right - left +1;                        //当前temp数组中数的个数
241         while(left <= mid_x &&  mid <= right){              //左右数组第一个数进行比较  把较小的数如到temp数组中
242             if(list[left] < list[mid]){
243                 temp[j++] = list[left++];
244             }else{
245                 temp[j++] = list[mid++];
246             }
247         }
248         while(left <= mid_x){                         //如果左边的数比右边的数多，就将剩下的入到temp数组中    j
249             temp[j++] = list[left++];
250         }
251 
252         while(mid <= right){                           //如果右边打数比左边的数多，就将右边剩下的数加入到temp数组当中去
253             temp[j++] = list[mid++];
254         }
255         
256         for(j = 0; j < n; j++){             //   将得到的temp数组加到list数组中    
257             list[left_x+j] = temp[j];
258         }         
259     }
260 
261     //快速排序
262     public static void QuickSort(int[] num){
263         QSort(num,1,num.length-1);
264     }
265     public static void QSort(int[] num, int left, int right){
266         int mid = Partition(num,left,right);
267 
268         QSort(num,left,mid-1);
269         QSort(num,mid+1,right); 
270     }
271     //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
272     public static int   Partition(int[] num, int left, int right){
273         int result;
274         result = num[left];
275         while(left < right){
276             while( left < right && num[right] > result){
277                 right++;
278             }
279             Swap(num,left,right);
280             while( left < right && num[left] < result){
281                 left++;
282             }
283             Swap(num,left,right);
284         }
285         return left;
286     }
287 
288     //快速排序优化
289     public static void QuickSort_Op(int[] num){
290         Qsort_Op(num,1,num.length-1);
291     }
292     public static void Qsort_Op(int[] num, int left, int right){
293         final int N = 7;                //数组长度的阀值  当数组长度低于这个长度是就不在使用快速排序，而是使用插入排序
294         if((right-left) > N){
295             //尾递归优化
296             while(left < right){
297                 int mid = Partition_Op(num,left,right);
298         
299                 Qsort_Op(num, left, mid-1);        //对底子表进行递归排序
300                 left = mid;            //尾递归
301             }
302          }else{              //当right-left小于7时，用直接插入排序
303                InsertSort(num);  
304          }
305    }
306   //返回一个关键字，使得这个关键字左边的数都比它小，右边的数都比他大
307     public static int Partition_Op(int[] num, int left, int right){
308         int result;
309 
310         //优化选取轴承    三数取中（取左端、右端，中间三个），进行排序，取中间数作为轴承
311         int m = left + (right - left);
312         if(num[left] > num[right]){
313             Swap(num,left,right);
314         }
315         if(num[m] > num[right]){
316             Swap(num,m,right);
317         }
318         if(num[left] < num[m]){
319             Swap(num,left,m);
320         }
321         result  = num[left];         //y用子表的第一个记录作为轴承记录
322         num[0] = result;            //将轴承关键字备份到num[0]
323         while( left < right ){
324             while(left < right && num[right] > result){
325                 right--;
326             }
327             num[left] = num[right];  //选择替换而不是交换方式进行
328             while(left < right && num[left] < result){
329                 left++;
330             }
331             num[right] = num[left];         //选择替换而不是交换方式进行操作
332         }
333         num[left] = num[0];
334         return left;
335     }
336 
337 }

posted on 2016-05-03 00:38 snail-lb 阅读(818) 评论(0) 编辑收藏举报