数据结构之排序

　　第一篇：数据结构之链表

　　第二篇：数据结构之栈和队列

　　第三篇：数据结构之二叉树

 

　　这篇文章主要讨论常见的排序算法。

　　排序算法分为内部排序和外部排序两种，内部排序是指只利用内存来完成的排序，外部排序是指借助外部存储设备完成的排序。外部排序主要针对记录比较多、内存无法一次全部加载的情况。我们这里主要关注内部排序。

　　内部排序大致分为四类：1）插入排序；2）交换排序；3）选择排序；4）归并排序；5）基数排序。我们下面会分别进行描述。

　　首先，我们来确定排序的对象，这里我们假设排序的对象是随机生成的非重复整数数组，有下面的辅助方法：

整型数组辅助方法（生成和打印） 
 1 public static int[] createArray(int count, int max)
 2 {
 3     if (count < 1) return null;
 4     int[] arrResult = new int[count];
 5     java.util.Random r = new java.util.Random();
 6     for(int i = 0; i < arrResult.length; i++)
 7     {
 8         int temp = 0;
 9         while(true)
10         {
11             temp = r.nextInt(max);
12             int j = 0;
13             for (j = 0; j < i; j++)
14             {
15                 if (arrResult[j] == temp) break;
16             }
17             if (j == i) break;
18         }
19         arrResult[i] = temp;
20     }
21     
22     return arrResult;
23 }
24 
25 private static void printArray(int[] array)
26 {
27     if (array == null)
28     {
29         return;
30     }
31     
32     StringBuffer sb = new StringBuffer();
33     for(int i = 0; i < array.length; i++)
34     {
35         sb.append(array[i]).append("->");
36     }
37     System.out.println(sb.substring(0, sb.length() - 2));
38 }

　　接下来，我们分别讨论上述几种排序算法。

　　1） 插入排序。它的基本思想是将一个元素插入到一个已排序的序列中，构成一个更大的序列。直接插入排序和希尔排序（shell）都属于插入排序。

直接插入排序 
 1 public static void insertSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     printArray(arrValue);
 5     for (int i = 1; i < arrValue.length; i++)
 6     {
 7         int temp = arrValue[i];
 8         int j = i;
 9         for (j = i; j > 0; j--)
10         {
11             if (arrValue[j - 1] > temp)
12             {
13                 arrValue[j] = arrValue[j - 1];
14             }
15             else
16             {
17                 break;
18             }
19         }
20         arrValue[j] = temp;
21         printArray(arrValue);    
22     }
23 }

 　　运行结果

22->32->2->46->9->29->20->45->3->26
22->32->2->46->9->29->20->45->3->26
2->22->32->46->9->29->20->45->3->26
2->22->32->46->9->29->20->45->3->26
2->9->22->32->46->29->20->45->3->26
2->9->22->29->32->46->20->45->3->26
2->9->20->22->29->32->46->45->3->26
2->9->20->22->29->32->45->46->3->26
2->3->9->20->22->29->32->45->46->26
2->3->9->20->22->26->29->32->45->46
希尔（Shell）排序 
 1 public static void shellSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     int length = arrValue.length/2;
 5     printArray(arrValue);
 6     while(length >= 1)
 7     {
 8         shell(arrValue, length);
 9         length = length/2;
10     }
11 }
12 
13 private static void shell(int[] arrValue, int d)
14 {
15     for(int i = d; i < arrValue.length; i++)
16     {
17         if (arrValue[i] < arrValue[i -d])
18         {
19             int temp = arrValue[i];
20             int j = i;
21             while(j >= d)
22             {
23                 if (arrValue[j-d] > temp) 
24                 {
25                     arrValue[j] = arrValue[j - d];
26                     j = j - d;
27                 }
28                 else
29                 {
30                     break;
31                 }                
32             }
33             arrValue[j] = temp;
34         }
35         printArray(arrValue);
36     }
37 }

　　运行结果

14->21->1->26->6->40->5->46->9->25
14->5->1->9->6->40->21->46->26->25
1->5->6->9->14->25->21->40->26->46
1->5->6->9->14->21->25->26->40->46

　　2） 交换排序。它的基本思想是遍历待排序序列，不停交换元素，最终得到一个排序的序列。冒泡排序和快速排序都属于交换排序。

冒泡排序 
 1 public static void bubbleSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     printArray(arrValue);
 5     for(int i = 0; i < arrValue.length; i++)
 6     {
 7         for(int j = i+ 1; j < arrValue.length; j++)
 8         {
 9             if (arrValue[i] > arrValue[j])
10             {
11                 int temp = arrValue[i];
12                 arrValue[i] = arrValue[j];
13                 arrValue[j] = temp;
14             }
15         }
16         printArray(arrValue);
17     }
18 }

 　　运行结果

35->2->19->37->43->47->39->34->21->0
0->35->19->37->43->47->39->34->21->2
0->2->35->37->43->47->39->34->21->19
0->2->19->37->43->47->39->35->34->21
0->2->19->21->43->47->39->37->35->34
0->2->19->21->34->47->43->39->37->35
0->2->19->21->34->35->47->43->39->37
0->2->19->21->34->35->37->47->43->39
0->2->19->21->34->35->37->39->47->43
0->2->19->21->34->35->37->39->43->47
0->2->19->21->34->35->37->39->43->47
快速排序 
 1 public static void quickSort(int[] arrValue, int left, int right)
 2 {
 3     if(left < right)
 4     {
 5         int i = division(arrValue, left, right);
 6         quickSort(arrValue, left, i - 1);
 7         quickSort(arrValue, i + 1, right);
 8     }
 9 }
10 
11 private static int division(int[] arrValue, int left, int right)
12 {
13     int baseValue = arrValue[left];
14     int midPos = left;
15     printArray(arrValue);
16     for (int i = left + 1; i <= right; i++)
17     {
18         if(arrValue[i] < baseValue) midPos++;
19     }
20     
21     if (midPos == left)
22     {
23         return midPos;
24     }
25     
26     arrValue[left] = arrValue[midPos]; 
27     arrValue[midPos] = baseValue;
28     
29     if (midPos == right)
30     {
31         return midPos;
32     }
33     for (int i = left; i < midPos; i++)
34     {
35         if (arrValue[i] > baseValue)
36         {
37             for (int j = right; j > midPos; j--)
38             {
39                 if (arrValue[j] < baseValue)
40                 {
41                     int temp = arrValue[i];
42                     arrValue[i] = arrValue[j];
43                     arrValue[j] = temp;
44                     right--;
45                     break;
46                 }
47             }
48         }
49     }
50             
51     return midPos;
52 }

　　运行结果

14->5->36->17->34->2->47->7->22->42
7->5->2->14->34->36->47->17->22->42
2->5->7->14->34->36->47->17->22->42
2->5->7->14->34->36->47->17->22->42
2->5->7->14->22->17->34->36->47->42
2->5->7->14->17->22->34->36->47->42
2->5->7->14->17->22->34->36->47->42

　　3）选择排序。它的基本思想是每次都从子序列中取得最小或者最大的元素。简单选择排序和堆排序都属于选择排序。

简单选择排序 
 1 public static void selectSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     printArray(arrValue);
 5     for (int i = 0; i < arrValue.length; i++)
 6     {
 7         int minValue = arrValue[i];
 8         int minIndex = i;
 9         for (int j = i; j < arrValue.length; j++)
10         {
11             if (arrValue[j] < minValue) 
12             {
13                 minIndex = j;
14                 minValue = arrValue[j]; 
15             }
16         }
17         if (i != minIndex)
18         {
19             int temp = arrValue[i];
20             arrValue[i] = arrValue[minIndex];
21             arrValue[minIndex] = temp;
22         }
23         printArray(arrValue);
24     }
25 }

 　　运行结果

43->28->29->31->37->32->27->36->12->3
3->28->29->31->37->32->27->36->12->43
3->12->29->31->37->32->27->36->28->43
3->12->27->31->37->32->29->36->28->43
3->12->27->28->37->32->29->36->31->43
3->12->27->28->29->32->37->36->31->43
3->12->27->28->29->31->37->36->32->43
3->12->27->28->29->31->32->36->37->43
3->12->27->28->29->31->32->36->37->43
3->12->27->28->29->31->32->36->37->43
3->12->27->28->29->31->32->36->37->43
堆排序 
 1 public static void heapSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     printArray(arrValue);
 5     for (int i = arrValue.length/2 - 1; i>=0; i--)
 6     {
 7         heapAdjust(arrValue, i, arrValue.length);
 8     }
 9     printArray(arrValue);
10     for (int i = arrValue.length - 1; i > 0; i--)
11     {
12         int temp = arrValue[0];
13         arrValue[0] = arrValue[i];
14         arrValue[i] = temp;
15                     
16         heapAdjust(arrValue, 0, i);
17         printArray(arrValue);
18     }
19     
20 }
21 
22 private static void heapAdjust(int[] arrValue, int parent, int length)
23 {
24     int child = 2* parent + 1;
25     int temp = arrValue[parent];
26     while(child < length)
27     {
28         if (child + 1 < length && arrValue[child] < arrValue[child + 1])
29         {
30             child = child + 1;
31         }
32         if (temp > arrValue[child])
33         {
34             break;
35         }
36         arrValue[parent] = arrValue[child];
37         
38         parent = child;
39         child = parent * 2 + 1;
40         
41     }
42     arrValue[parent] = temp;
43 }

　　运行结果

4->26->29->7->30->2->19->42->13->46
46->42->29->13->30->2->19->7->4->26
42->30->29->13->26->2->19->7->4->46
30->26->29->13->4->2->19->7->42->46
29->26->19->13->4->2->7->30->42->46
26->13->19->7->4->2->29->30->42->46
19->13->2->7->4->26->29->30->42->46
13->7->2->4->19->26->29->30->42->46
7->4->2->13->19->26->29->30->42->46
4->2->7->13->19->26->29->30->42->46
2->4->7->13->19->26->29->30->42->46

 　　4）归并排序。它的基本思想是递归和分治。

归并排序 
 1 public static void mergeSort(int[] arrValue, int start, int end)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     if (start + 1 < end)
 5     {
 6         int mid = (start + end)/2;
 7         mergeSort(arrValue, start, mid);
 8         mergeSort(arrValue, mid, end);
 9         merge(arrValue, start, mid, end);
10         printArray(arrValue);
11     }
12 
13 }
14 
15 private static void merge(int[] arrValue, int start, int mid, int end)
16 {
17     int[] temp = new int[end - start];
18     
19     int index1 = start;
20     int index2 = mid;
21     int index = 0;
22     while(index1 < mid && index2 < end)
23     {
24         if (arrValue[index1] < arrValue[index2])
25         {
26             temp[index] = arrValue[index1];
27             index1++;
28         }
29         else
30         {
31             temp[index] = arrValue[index2];
32             index2++;
33         }
34         index++;
35     }
36     
37     if (index1 < mid)
38     {
39         while(index1 < mid)
40         {
41             temp[index] = arrValue[index1];
42             index1++;
43             index++;
44         }
45     }
46     
47     if (index2 < end)
48     {
49         while(index2 < mid)
50         {
51             temp[index] = arrValue[index2];
52             index2++;
53             index++;
54         }
55     }
56     
57     for (int i = 0; i < index; i++)
58     {
59         arrValue[start + i] = temp[i];
60     }
61 }

　　运行结果

41->49->9->31->23->0->25->2->6->7
41->49->9->23->31->0->25->2->6->7
41->49->9->23->31->0->25->2->6->7
9->23->31->41->49->0->25->2->6->7
9->23->31->41->49->0->25->2->6->7
9->23->31->41->49->0->25->2->6->7
9->23->31->41->49->0->25->2->6->7
9->23->31->41->49->0->2->6->7->25
0->2->6->7->9->23->25->31->41->49

 　　5）基数排序。基数排序的思想和桶排序类似，它首先按照个位数值将序列放入到0-9共10个桶中，然后依次输出，接着，对新的序列按照十位数值再次放入桶中，然后再输出，以此类推，直到所有树的位数都遍历完毕，就可以得到排好序的序列。

基数排序 
 1 public static void radixSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     
 5     HashMap<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();
 6     int base = 10;
 7     printArray(arrValue);
 8     while(isNeedContinue(arrValue, base))
 9     {
10         map.clear();
11         for (int i = 0; i < arrValue.length; i++)
12         {
13             int key = arrValue[i]%base/(base/10);
14             if (!map.containsKey(key))
15             {
16                 map.put(key, new ArrayList<Integer>());
17             }
18             map.get(key).add(arrValue[i]);
19         }
20         for (int i = 0, j = 0; i < 10; i++)
21         {
22             if (map.containsKey(i))
23             {
24                 for(Integer value : map.get(i))
25                 {
26                     arrValue[j] = value;
27                     j++;
28                 }
29             }
30         }
31         base = base*10;
32         printArray(arrValue);
33     }
34 }
35 
36 private static boolean isNeedContinue(int[] arrValue, int base)
37 {
38     for(int i = 0; i < arrValue.length; i++)
39     {
40         if (base/10 <= arrValue[i]) return true;
41     }
42     return false;
43 }

　　运行结果

38->16->48->27->45->44->3->22->14->42
22->42->3->44->14->45->16->27->38->48
3->14->16->22->27->38->42->44->45->48

　　6）其他排序
　　也有一些其他排序算法比较巧妙，例如计数排序，它对于不重复序列排序来说，有时是一个很好的选择，它会首先计算序列的最小值和最大值，创建一个flag数组，数组长度为最大值和最小值之差，然后遍历序列，更新flag数组，最后遍历flag数组，输出排序结果。

计数排序 
 1 public static void smartSort(int[] arrValue)
 2 {
 3     if (arrValue == null || arrValue.length < 2) return;
 4     int min = arrValue[0];
 5     int max = arrValue[0];
 6     printArray(arrValue);
 7     for (int i = 1; i < arrValue.length; i++)
 8     {
 9         if (arrValue[i] < min) min = arrValue[i];
10         if (arrValue[i] > max) max = arrValue[i];
11     }
12     int[] arrFlag = new int[max - min + 1];
13     for (int i = 0; i < arrFlag.length; i++) arrFlag[i] = 0;
14     printArray(arrFlag);
15     for (int i = 0; i < arrValue.length; i++)
16     {
17         arrFlag[arrValue[i] - min] = 1;
18     }
19     printArray(arrFlag);
20     for(int i = 0, j = 0; i < arrFlag.length; i++)
21     {
22         if (arrFlag[i] == 1)
23         {
24             arrValue[j] = i + min;
25             j++;
26         }
27     }
28     printArray(arrValue);
29 }

 　　运行结果

2->32->35->0->38->26->21->10->22->5
0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0->0
1->0->1->0->0->1->0->0->0->0->1->0->0->0->0->0->0->0->0->0->0->1->1->0->0->0->1->0->0->0->0->0->1->0->0->1->0->0->1
0->2->5->10->21->22->26->32->35->38

　　下面我们来总结分析上述各排序算法

排序算法 平均时间复杂度 最优时间复杂度 最坏时间复杂度 空间复杂度 稳定性
直接插入排序 O(n*n) O(n) O(n*n) O(1) 稳定
希尔（shell）排序       O(1) 不稳定
冒泡排序 O(n*n) O(n) O(n*n) O(1) 稳定
快速排序 O(n*logn) O(n*logn) O(n*logn) O(n*logn) 不稳定
简单选择排序 O(n*n) O(n) O(n*n) O(1) 不稳定
堆排序 O(n*logn) O(n*logn) O(n*logn) O(1) 不稳定
归并排序 O(n*logn) O(n*logn) O(n*logn) O(n) 稳定
基数排序 O(d(n+radix)) O(d(n+radix)) O(d(n+radix)) O(radix) 稳定

 

 

 

 

 

 

 

 

posted @ 2013-04-14 15:23  李潘  阅读(1013)  评论(1)  编辑  收藏  举报