讲解在java程序中各种排序算法相关知识
Java代码
1.插入排序:
2.
3.1.package org.rut.util.algorithm.support;
4.2.import org.rut.util.algorithm.SortUtil;
5.3.4.public class InsertSort implements SortUtil.Sort{
6.5. /* (non-Javadoc)
7.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
8.7. */
9.8. public void sort(int[] data) {
10.9. int temp;
11.10. for(int i=1;i<data.length;i++){
12.11. for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
13.12. SortUtil.swap(data,j,j-1);
14.13. }
15.14. }
16.15. }
17.16.}
18.17.冒泡排序:
19.
20.1.package org.rut.util.algorithm.support;
21.2.import org.rut.util.algorithm.SortUtil;
22.3.4.public class BubbleSort implements SortUtil.Sort{
23.5. /* (non-Javadoc)
24.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
25.7. */
26.8. public void sort(int[] data) {
27.9. int temp;
28.10. for(int i=0;i<data.length;i++){
29.11. for(int j=data.length-1;j>i;j--){
30.12. if(data[j]<data[j-1]){
31.13. SortUtil.swap(data,j,j-1);
32.14. }
33.15. }
34.16. }
35.17. }
36.18.}
37.19.选择排序:
38.1.package org.rut.util.algorithm.support;
39.2.import org.rut.util.algorithm.SortUtil;
40.3.4.public class SelectionSort implements SortUtil.Sort {
41.5. /*
42.6. * (non-Javadoc)
43.7. *
44.8. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
45.9. */
46.10. public void sort(int[] data) {
47.11. int temp;
48.12. for (int i = 0; i < data.length; i++) {
49.13. int lowIndex = i;
50.14. for (int j = data.length - 1; j > i; j--) {
51.15. if (data[j] < data[lowIndex]) {
52.16. lowIndex = j;
53.17. }
54.18. }
55.19. SortUtil.swap(data,i,lowIndex);
56.20. }
57.21. }
58.22.}
59.23.Shell排序:
60.1.package org.rut.util.algorithm.support;
61.2.import org.rut.util.algorithm.SortUtil;
62.3.4.public class ShellSort implements SortUtil.Sort{
63.5. /* (non-Javadoc)
64.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
65.7. */
66.8. public void sort(int[] data) {
67.9. for(int i=data.length/2;i>2;i/=2){
68.10. for(int j=0;j<i;j++){
69.11. insertSort(data,j,i);
70.12. }
71.13. }
72.14. insertSort(data,0,1);
73.15. }
74.16. /**
75.17. * @param data
76.18. * @param j
77.19. * @param i
78.20. */
79.21. private void insertSort(int[] data, int start, int inc) {
80.22. int temp;
81.23. for(int i=start+inc;i<data.length;i+=inc){
82.24. for(int j=i;(j>=inc)&&(data[j]<data[j-inc]);j-=inc){
83.25. SortUtil.swap(data,j,j-inc);
84.26. }
85.27. }
86.28. }
87.29.}
88.30.快速排序:
89.1.package org.rut.util.algorithm.support;
90.2.import org.rut.util.algorithm.SortUtil;
91.3.4.public class QuickSort implements SortUtil.Sort{
92.5. /* (non-Javadoc)
93.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
94.7. */
95.8. public void sort(int[] data) {
96.9. quickSort(data,0,data.length-1);
97.10. }
98.11. private void quickSort(int[] data,int i,int j){
99.12. int pivotIndex=(i+j)/2;
100.13. //swap 14. SortUtil.swap(data,pivotIndex,j);
101.15.
102.16. int k=partition(data,i-1,j,data[j]);
103.17. SortUtil.swap(data,k,j);
104.18. if((k-i)>1) quickSort(data,i,k-1);
105.19. if((j-k)>1) quickSort(data,k+1,j);
106.20.
107.21. }
108.22. /**
109.23. * @param data
110.24. * @param i
111.25. * @param j
112.26. * @return
113.27. */
114.28. private int partition(int[] data, int l, int r,int pivot) {
115.29. do{
116.30. while(data[++l]<pivot);
117.31. while((r!=0)&&data[--r]>pivot);
118.32. SortUtil.swap(data,l,r);
119.33. }
120.34. while(l<r);
121.35. SortUtil.swap(data,l,r);
122.36. return l;
123.37. }
124.38.}
125.39.改进后的快速排序:
126.1.package org.rut.util.algorithm.support;
127.2.import org.rut.util.algorithm.SortUtil;
128.3.4.public class ImprovedQuickSort implements SortUtil.Sort {
129.5. private static int MAX_STACK_SIZE=4096;
130.6. private static int THRESHOLD=10;
131.7. /* (non-Javadoc)
132.8. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
133.9. */
134.10. public void sort(int[] data) {
135.11. int[] stack=new int[MAX_STACK_SIZE];
136.12.
137.13. int top=-1;
138.14. int pivot;
139.15. int pivotIndex,l,r;
140.16.
141.17. stack[++top]=0;
142.18. stack[++top]=data.length-1;
143.19.
144.20. while(top>0){
145.21. int j=stack[top--];
146.22. int i=stack[top--];
147.23.
148.24. pivotIndex=(i+j)/2;
149.25. pivot=data[pivotIndex];
150.26.
151.27. SortUtil.swap(data,pivotIndex,j);
152.28.
153.29. //partition 30. l=i-1;
154.31. r=j;
155.32. do{
156.33. while(data[++l]<pivot);
157.34. while((r!=0)&&(data[--r]>pivot));
158.35. SortUtil.swap(data,l,r);
159.36. }
160.37. while(l<r);
161.38. SortUtil.swap(data,l,r);
162.39. SortUtil.swap(data,l,j);
163.40.
164.41. if((l-i)>THRESHOLD){
165.42. stack[++top]=i;
166.43. stack[++top]=l-1;
167.44. }
168.45. if((j-l)>THRESHOLD){
169.46. stack[++top]=l+1;
170.47. stack[++top]=j;
171.48. }
172.49.
173.50. }
174.51. //new InsertSort().sort(data); 52. insertSort(data);
175.53. }
176.54. /**
177.55. * @param data
178.56. */
179.57. private void insertSort(int[] data) {
180.58. int temp;
181.59. for(int i=1;i<data.length;i++){
182.60. for(int j=i;(j>0)&&(data[j]<data[j-1]);j--){
183.61. SortUtil.swap(data,j,j-1);
184.62. }
185.63. }
186.64. }
187.65.}
188.66.归并排序:
189.1.package org.rut.util.algorithm.support;
190.2.import org.rut.util.algorithm.SortUtil;
191.3.4.public class MergeSort implements SortUtil.Sort{
192.5. /* (non-Javadoc)
193.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
194.7. */
195.8. public void sort(int[] data) {
196.9. int[] temp=new int[data.length];
197.10. mergeSort(data,temp,0,data.length-1);
198.11. }
199.12.
200.13. private void mergeSort(int[] data,int[] temp,int l,int r){
201.14. int mid=(l+r)/2;
202.15. if(l==r) return ;
203.16. mergeSort(data,temp,l,mid);
204.17. mergeSort(data,temp,mid+1,r);
205.18. for(int i=l;i<=r;i++){
206.19. temp[i]=data[i];
207.20. }
208.21. int i1=l;
209.22. int i2=mid+1;
210.23. for(int cur=l;cur<=r;cur++){
211.24. if(i1==mid+1)
212.25. data[cur]=temp[i2++];
213.26. else if(i2>r)
214.27. data[cur]=temp[i1++];
215.28. else if(temp[i1]<temp[i2])
216.29. data[cur]=temp[i1++];
217.30. else
218.31. data[cur]=temp[i2++];
219.32. }
220.33. }
221.34.}
222.35.改进后的归并排序:
223.
224.1.package org.rut.util.algorithm.support;
225.2.import org.rut.util.algorithm.SortUtil;
226.3.4.public class ImprovedMergeSort implements SortUtil.Sort {
227.5. private static final int THRESHOLD = 10;
228.6. /*
229.7. * (non-Javadoc)
230.8. *
231.9. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
232.10. */
233.11. public void sort(int[] data) {
234.12. int[] temp=new int[data.length];
235.13. mergeSort(data,temp,0,data.length-1);
236.14. }
237.15. private void mergeSort(int[] data, int[] temp, int l, int r) {
238.16. int i, j, k;
239.17. int mid = (l + r) / 2;
240.18. if (l == r)
241.19. return;
242.20. if ((mid - l) >= THRESHOLD)
243.21. mergeSort(data, temp, l, mid);
244.22. else
245.23. insertSort(data, l, mid - l + 1);
246.24. if ((r - mid) > THRESHOLD)
247.25. mergeSort(data, temp, mid + 1, r);
248.26. else
249.27. insertSort(data, mid + 1, r - mid);
250.28. for (i = l; i <= mid; i++) {
251.29. temp[i] = data[i];
252.30. }
253.31. for (j = 1; j <= r - mid; j++) {
254.32. temp[r - j + 1] = data[j + mid];
255.33. }
256.34. int a = temp[l];
257.35. int b = temp[r];
258.36. for (i = l, j = r, k = l; k <= r; k++) {
259.37. if (a < b) {
260.38. data[k] = temp[i++];
261.39. a = temp[i];
262.40. } else {
263.41. data[k] = temp[j--];
264.42. b = temp[j];
265.43. }
266.44. }
267.45. }
268.46. /**
269.47. * @param data
270.48. * @param l
271.49. * @param i
272.50. */
273.51. private void insertSort(int[] data, int start, int len) {
274.52. for(int i=start+1;i<start+len;i++){
275.53. for(int j=i;(j>start) && data[j]<data[j-1];j--){
276.54. SortUtil.swap(data,j,j-1);
277.55. }
278.56. }
279.57. }
280.58.}
281.59.堆排序:
282.1.package org.rut.util.algorithm.support;
283.2.import org.rut.util.algorithm.SortUtil;
284.3.4.public class HeapSort implements SortUtil.Sort{
285.5. /* (non-Javadoc)
286.6. * @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])
287.7. */
288.8. public void sort(int[] data) {
289.9. MaxHeap h=new MaxHeap();
290.10. h.init(data);
291.11. for(int i=0;i<data.length;i++)
292.12. h.remove();
293.13. System.arraycopy(h.queue,1,data,0,data.length);
294.14. }
295.15.16. private static class MaxHeap{
296.17.
297.18.
298.19. void init(int[] data){
299.20. this.queue=new int[data.length+1];
300.21. for(int i=0;i<data.length;i++){
301.22. queue[++size]=data[i];
302.23. fixUp(size);
303.24. }
304.25. }
305.26.
306.27. private int size=0;
307.28. private int[] queue;
308.29.
309.30. public int get() {
310.31. return queue[1];
311.32. }
312.33. public void remove() {
313.34. SortUtil.swap(queue,1,size--);
314.35. fixDown(1);
315.36. }
316.37. //fixdown 38. private void fixDown(int k) {
317.39. int j;
318.40. while ((j = k << 1) <= size) {
319.41. if (j < size && queue[j]<queue[j+1])
320.42. j++;
321.43. if (queue[k]>queue[j]) //不用交换 44. break;
322.45. SortUtil.swap(queue,j,k);
323.46. k = j;
324.47. }
325.48. }
326.49. private void fixUp(int k) {
327.50. while (k > 1) {
328.51. int j = k >> 1;
329.52. if (queue[j]>queue[k])
330.53. break;
331.54. SortUtil.swap(queue,j,k);
332.55. k = j;
333.56. }
334.57. }
335.58. }
336.59.}
337.60.SortUtil:
338.1.package org.rut.util.algorithm;
339.2.import org.rut.util.algorithm.support.BubbleSort;
340.3.import org.rut.util.algorithm.support.HeapSort;
341.4.import org.rut.util.algorithm.support.ImprovedMergeSort;
342.5.import org.rut.util.algorithm.support.ImprovedQuickSort;
343.6.import org.rut.util.algorithm.support.InsertSort;
344.7.import org.rut.util.algorithm.support.MergeSort;
345.8.import org.rut.util.algorithm.support.QuickSort;
346.9.import org.rut.util.algorithm.support.SelectionSort;
347.10.import org.rut.util.algorithm.support.ShellSort;
348.11.12.public class SortUtil {
349.13. public final static int INSERT = 1;
350.14. public final static int BUBBLE = 2;
351.15. public final static int SELECTION = 3;
352.16. public final static int SHELL = 4;
353.17. public final static int QUICK = 5;
354.18. public final static int IMPROVED_QUICK = 6;
355.19. public final static int MERGE = 7;
356.20. public final static int IMPROVED_MERGE = 8;
357.21. public final static int HEAP = 9;
358.22. public static void sort(int[] data) {
359.23. sort(data, IMPROVED_QUICK);
360.24. }
361.25. private static String[] name={
362.26. “insert”,“bubble”,“selection”,“shell”,“quick”,“improved_quick”,“merge”,“improved_merge”,“heap”
363.27. };
364.28.
365.29. private static Sort[] impl=new Sort[]{
366.30. new InsertSort(),
367.31. new BubbleSort(),
368.32. new SelectionSort(),
369.33. new ShellSort(),
370.34. new QuickSort(),
371.35. new ImprovedQuickSort(),
372.36. new MergeSort(),
373.37. new ImprovedMergeSort(),
374.38. new HeapSort()
375.39. };
376.40. public static String toString(int algorithm){
377.41. return name[algorithm-1];
378.42. }
379.43.
380.44. public static void sort(int[] data, int algorithm) {
381.45. impl[algorithm-1].sort(data);
382.46. }
383.47. public static interface Sort {
384.48. public void sort(int[] data);
385.49. }
386.50. public static void swap(int[] data, int i, int j) {
387.51. int temp = data[i];
388.52. data[i] = data[j];
389.53. data[j] = temp;
390.54. }
391.55.}