java 实现 冒泡排序、选择排序、插入排序。

[java] view plaincopyprint?

1. <span style="font-size:18px;"><strong>package com.j2se;  
2.   
3. public class TestSort {  
4.     public static void main(String args[]) {  
5.         int[] a = { 1, 7, 3, 9, 2, 5, 8, 4, 6 };  
6.         // bubbleSort(a); // 冒泡(Bubble Sort)排序  
7.         // selectionSort(a); // 选择排序  
8.         insertSort(a); // 插入排序  
9.         for (int i = 0; i < a.length; i++) {  
10.             System.out.print(a[i] + " ");  
11.         }  
12.     }  
13.     /**************************************************************** 
14.      *  
15.      *  
16.       
17.      冒泡排序的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。 
18.         即首先比较第1个和第2个数，将小数放前，大数放后。 
19.         然后比较第2个数和第3个数，将小数放前，大数放后. 
20.         如此继续，直至比较最后两个数，将小数放前，大数放后。 
21.             重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数）. 
22.         将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最小数。 
23.         如此下去，直至最终完成排序。 
24.          
25.         由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。 
26.         用二重循环实现，外循环变量设为i，内循环变量设为j。 
27.             外循环重复9次，内循环依次重复9，8，...，1次。 
28.             每次进行比较的两个元素都是与内循环j有关的, 
29.                 它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。 
30.                  
31.                 public class BubbleSort {   
32.                         public static void sort(int[] data) {   
33.                             int temp;   
34.                             for (int i = 0; i < data.length; i++) {   
35.                                 for (int j = data.length - 1; j > i; j--) {   
36.                                     if (data[i] > data[j]) {   
37.                                         temp = data[i];   
38.                                         data[i] = data[j];   
39.                                         data[j] = temp;   
40.                                     }   
41.                                 }   
42.                             }   
43.                         }   
44.                        
45.                         public static void main(String[] args) {   
46.                             int[] a = { 4, 2, 3, 1, 5 };   
47.                             sort(a);   
48.                             for (int i = 0; i < a.length; i++)   
49.                                 System.out.print(a[i] + " ");   
50.                         }   
51.                 }   
52.         ================================================================================= 
53.          
54.                 public class Test { 
55.                   public static void main(String[] args) { 
56.                     int[] a = { 10, 32, 1, 9, 5, 7, 12, 0, 4, 3 }; 
57.  
58.                     System.out.print("排序前: "); 
59.                  
60.                     for (int i = 0; i < a.length; i++) 
61.                       System.out.printf("%3s", a[i]); 
62.                  
63.                     System.out.println(); 
64.                  
65.                     Test test = new Test(); 
66.                     test.bubbleSort(a); 
67.                  
68.                     System.out.print("排序后: "); 
69.                  
70.                     for (int i = 0; i < a.length; i++) 
71.                       System.out.printf("%3s", a[i]); 
72.                  
73.                     System.out.println(); 
74.                   } 
75.                  
76.                   public void bubbleSort(int[] a) { 
77.                     int len = a.length; 
78.                  
79.                     System.out.println("数组大小是:" + len); 
80.                  
81.                     boolean change = false; 
82.                     int temp; 
83.                     int count = 0; 
84.                  
85.                     for (int i = len; i > 1; i--) { 
86.                       for (int j = 0; j < i - 1; j++) { 
87.                         if (a[j + 1] < a[j]) { 
88.                           temp = a[j + 1]; 
89.                           a[j + 1] = a[j]; 
90.                           a[j] = temp; 
91.                           change = true; 
92.                           count++; 
93.                         } 
94.                  
95.                       } 
96.                       if (change) { 
97.                         System.out.print("第" + count + "趟交换: "); 
98.                         for (int k = 0; k < len; k++) 
99.                           System.out.print(a[k] + " "); 
100.                  
101.                         System.out.println(); 
102.                       } 
103.                     } 
104.                   } 
105.                 } 
106.          
107.          
108.      *  
109.      * @param a 
110.      * @return 
111.      */  
112.     public static int[] bubbleSort(int[] a) {  
113.         int len = a.length;  
114.         for (int i = len - 1; i >= 1; i--) {  
115.             for (int j = 0; j <= i - 1; j++) {  
116.                 if (a[j] > a[j + 1]) {  
117.                     int temp = a[j];  
118.                     a[j] = a[j + 1];  
119.                     a[j + 1] = temp;  
120.                 }  
121.             }  
122.         }  
123.         return a;  
124.     }  
125.     /**************************************************** 
126.      *  
127.      *  
128.       
129.      选择排序的基本思想是：对待排序的记录序列进行n-1遍的处理. 
130.          第1遍处理是将L[1..n]中最小者与L[1]交换位置, 
131.          第2遍处理是将L[2..n]中最小者与L[2]交换位置，......， 
132.          第i遍处理是将L[i..n]中最小者与L[i]交换位置。 
133.     这样，经过i遍处理之后，前i个记录的位置就已经按从小到大的顺序排列好了。  
134. 　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。  
135.      *  
136.      * @param a 
137.      * @return 
138.      */  
139.     public static int[] selectionSort(int[] a) {  
140.         for (int i = 0; i < a.length; i++) {  
141.             for (int j = i + 1; j < a.length; j++) {  
142.                 if (a[i] > a[j]) {  
143.                     int temp = a[i];  
144.                     a[i] = a[j];  
145.                     a[j] = temp;  
146.                 }  
147.             }  
148.         }  
149.         return a;  
150.     }  
151.   
152.     public static int[] insertSort(int[] a) {  
153.         for (int i = 1; i < a.length; i++) {  
154.             for (int j = i; j > 0; j--) {  
155.                 if (a[j] < a[j - 1]) {  
156.                     int temp = a[j];  
157.                     a[j] = a[j - 1];  
158.                     a[j - 1] = temp;  
159.                 } else {  
160.                     break;  
161.                 }  
162.             }  
163.         }  
164.         return a;  
165.     }  
166.   
167. }  
168. </strong></span>  

更多算法参考： http://blog.csdn.net/feixiaoxing/article/details/6993718