java 8大排序代码演示

1.   
2. /*  
3.  * 实现了八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序 以及快速排序、归并排序、堆排序和LST基数排序  
4.  */  
5. public class EightAlgorithms {   
6.       
7.   //插入排序：时间复杂度o(n^2)    
8.   public static void insertSort(int a[], int n) {   
9.     for (int i = 1; i < n; ++i) {   
10.       int temp = a[i];   
11.       int j = i - 1;   
12.       while (j >= 0 && a[j] > temp) {   
13.         a[j + 1] =a[j];   
14.         --j;   
15.       }   
16.       a[j + 1] = temp;   
17.     }   
18.   }   
19.       
20.   //冒泡排序：时间复杂度o(n^2)    
21.   public static void bubbleSort(int a[], int n) {   
22.     for (int i = n - 1; i > 0; --i) {   
23.       for (int j = 0; j < i; ++j) {   
24.         if (a[j] > a[j + 1]) {   
25.           int temp = a[j];   
26.           a[j] = a[j + 1];   
27.           a[j + 1] = temp;       
28.         }   
29.       }     
30.     }     
31.   }   
32.       
33.   //选择排序：时间复杂度o(n^2)    
34.   public static void selectSort(int a[], int n) {   
35.     for (int i = 0; i < n - 1; ++i) {   
36.       int min = a[i];   
37.       int index = i;   
38.       for (int j = i + 1; j < n; ++j) {   
39.         if (a[j] < min) {   
40.           min = a[j];   
41.           index = j;   
42.         }     
43.       }   
44.       a[index] = a[i];   
45.       a[i] = min;   
46.     }   
47.   }   
48.       
49.   //希尔排序：时间复杂度介于o(n^2)和o(nlgn)之间    
50.   public static void shellSort(int a[], int n) {   
51.     for (int gap = n / 2; gap >= 1; gap /= 2) {   
52.       for (int i = gap; i < n; ++i) {   
53.         int temp = a[i];   
54.         int j = i -gap;   
55.         while (j >= 0 && a[j] > temp) {   
56.           a[j + gap] = a[j];   
57.           j -= gap;   
58.         }   
59.         a[j + gap] = temp;   
60.       }   
61.     }     
62.   }   
63.       
64.   //快速排序：时间复杂度o(nlgn)    
65.   public static void quickSort(int a[], int n) {   
66.     _quickSort(a, 0, n-1);   
67.   }   
68.   public static void _quickSort(int a[], int left, int right) {   
69.     if (left < right) {   
70.       int q = _partition(a, left, right);   
71.       _quickSort(a, left, q - 1);   
72.       _quickSort(a, q + 1, right);   
73.     }   
74.   }   
75.   public static int _partition(int a[], int left, int right) {   
76.     int pivot = a[left];   
77.     while (left < right) {   
78.       while (left < right && a[right] >= pivot) {   
79.         --right;   
80.       }   
81.       a[left] = a[right];   
82.       while (left <right && a[left] <= pivot) {   
83.         ++left;   
84.       }   
85.       a[right] = a[left];   
86.     }   
87.     a[left] = pivot;   
88.     return left;   
89.   }   
90.       
91.   //归并排序：时间复杂度o(nlgn)    
92.   public static void mergeSort(int a[], int n) {   
93.     _mergeSort(a, 0 , n-1);   
94.   }   
95.   public static void _mergeSort(int a[], int left, int right) {   
96.     if (left <right) {   
97.       int mid = left + (right - left) / 2;   
98.       _mergeSort(a, left, mid);   
99.       _mergeSort(a, mid + 1, right);   
100.       _merge(a, left, mid, right);   
101.     }   
102.   }   
103.   public static void _merge(int a[], int left, int mid, int right) {   
104.     int length = right - left + 1;   
105.     int newA[] = new int[length];   
106.     for (int i = 0, j = left; i <= length - 1; ++i, ++j) {   
107.       newA[i] = a[j];   
108.     }   
109.     int i = 0;   
110.     int j = mid -left + 1;   
111.     int k = left;   
112.     for (; i <= mid - left && j <= length - 1; ++k) {   
113.       if (newA[i] < newA[j]) {   
114.         a[k] = newA[i++];   
115.       }   
116.       else {   
117.         a[k] = newA[j++];   
118.       }   
119.     }   
120.     while (i <= mid - left) {   
121.       a[k++] = newA[i++];   
122.     }   
123.     while (j <= right - left) {   
124.       a[k++] = newA[j++];   
125.     }   
126.   }   
127.       
128.   //堆排序：时间复杂度o(nlgn)    
129.   public static void heapSort(int a[], int n) {   
130.     builtMaxHeap(a, n);//建立初始大根堆   
131.     //交换首尾元素，并对交换后排除尾元素的数组进行一次上调整   
132.     for (int i = n - 1; i >= 1; --i) {   
133.       int temp = a[0];   
134.       a[0] = a[i];   
135.       a[i] = temp;   
136.       upAdjust(a, i);   
137.     }   
138.   }   
139.   //建立一个长度为n的大根堆   
140.   public static void builtMaxHeap(int a[], int n) {   
141.     upAdjust(a, n);   
142.   }   
143.   //对长度为n的数组进行一次上调整   
144.   public static void upAdjust(int a[], int n) {   
145.     //对每个带有子女节点的元素遍历处理，从后到根节点位置   
146.     for (int i = n / 2; i >= 1; --i) {   
147.       adjustNode(a, n, i);   
148.     }   
149.   }   
150.   //调整序号为i的节点的值   
151.   public static void adjustNode(int a[], int n, int i) {   
152.     //节点有左右孩子   
153.     if (2 * i + 1 <= n) {   
154.       //右孩子的值大于节点的值，交换它们   
155.       if (a[2 * i] > a[i - 1]) {   
156.         int temp = a[2 * i];   
157.         a[2 * i] = a[i - 1];   
158.         a[i - 1] = temp;   
159.       }   
160.       //左孩子的值大于节点的值，交换它们   
161.       if (a[2 * i -1] > a[i - 1]) {   
162.         int temp = a[2 * i - 1];   
163.         a[2 * i - 1] = a[i - 1];   
164.         a[i - 1] = temp;   
165.       }   
166.       //对节点的左右孩子的根节点进行调整   
167.       adjustNode(a, n, 2 * i);   
168.       adjustNode(a, n, 2 * i + 1);   
169.     }   
170.     //节点只有左孩子，为最后一个有左右孩子的节点   
171.     else if (2 * i == n) {   
172.       //左孩子的值大于节点的值，交换它们   
173.       if (a[2 * i -1] > a[i - 1]) {   
174.         int temp = a[2 * i - 1];   
175.         a[2 * i - 1] = a[i - 1];   
176.         a[i - 1] = temp;   
177.       }     
178.     }   
179.   }   
180.       
181.   //基数排序的时间复杂度为o(distance(n+radix)),distance为位数，n为数组个数，radix为基数   
182.   //本方法是用LST方法进行基数排序，MST方法不包含在内   
183.   //其中参数radix为基数，一般为10；distance表示待排序的数组的数字最长的位数；n为数组的长度   
184.   public static void lstRadixSort(int a[], int n, int radix, int distance) {   
185.     int[] newA = new int[n];//用于暂存数组   
186.     int[] count = new int[radix];//用于计数排序，保存的是当前位的值为0 到 radix-1的元素出现的的个数   
187.     int divide = 1;   
188.     //从倒数第一位处理到第一位   
189.     for (int i = 0; i < distance; ++i) {   
190.       System.arraycopy(a, 0, newA, 0, n);//待排数组拷贝到newA数组中   
191.       Arrays.fill(count, 0);//将计数数组置0   
192.       for (int j = 0; j < n; ++j) {   
193.         int radixKey = (newA[j] / divide) % radix; //得到数组元素的当前处理位的值   
194.         count[radixKey]++;   
195.       }   
196.       //此时count[]中每个元素保存的是radixKey位出现的次数   
197.       //计算每个radixKey在数组中的结束位置，位置序号范围为1-n   
198.       for (int j = 1; j < radix; ++j) {   
199.         count[j] = count[j] + count[j - 1];   
200.       }   
201.       //运用计数排序的原理实现一次排序，排序后的数组输出到a[]   
202.       for (int j = n - 1; j >= 0; --j) {   
203.         int radixKey = (newA[j] / divide) % radix;   
204.         a[count[radixKey] - 1] = newA[j];   
205.         --count[radixKey];   
206.       }   
207.       divide = divide * radix;   
208.     }   
209.   }   
210. }