0.0如果一个贴子提问已经有人回答，然后我再把自己写的代码打上去，会不会有技术分
下面是算法分享……
↓   ↓   ↓   ↓   ↓   ↓   ↓

1. public class SortAll {
   
2.          public static void main(String[] args){
   
3.                 int[] i = { 1, 5, 6, 12, 4, 9, 3, 23, 39, 403, 596, 87 };
   
4.                 System.out.println("----冒泡排序的结果：");  
   
5.                 maoPao(i);
   
6.                 System.out.println();
   
7.                 System.out.println("----选择排序的结果：");   
   
8.                 xuanZe(i);   
   
9.                 System.out.println();     
   
10.                 System.out.println("----插入排序的结果：");   
    
11.                 chaRu(i);   
    
12.                 System.out.println();
    
13.                 System.out.println("----希尔（Shell）排序的结果：");   
    
14.                 shell(i);   
    
15.        
    
16.         }  
    
17.        
    
18.         // 冒泡排序
    
19.         public static void maoPao(int[] x) {   
    
20.                 for (int i = 0; i < x.length; i++) {  
    
21.                         for (int j = i + 1; j < x.length; j++) {   
    
22.                                 if (x[i] > x[j]) {
    
23.                                         int temp = x[i];     
    
24.                                         x[i] = x[j];   
    
25.                                         x[j] = temp;     
    
26.                                         }     
    
27.                                 }   
    
28.                         }   
    
29.                 for (int i : x) {   
    
30.                         System.out.print(i + " ");   
    
31.                 }  
    
32.         }        
    
33.         // 选择排序   
    
34.         public static void xuanZe(int[] x) {  
    
35.                 for (int i = 0; i < x.length; i++) {
    
36.                         int lowerIndex = i;     
    
37.                         // 找出最小的一个索引     
    
38.                         for (int j = i + 1; j < x.length; j++) {   
    
39.                                 if (x[j] < x[lowerIndex]) {   
    
40.                                         lowerIndex = j;      
    
41.                                 }     
    
42.                         }   
    
43.                         // 交换      
    
44.                         int temp = x[i];  
    
45.                         x[i] = x[lowerIndex];   
    
46.                         x[lowerIndex] = temp;   
    
47.                 }     
    
48.                 for (int i : x) {  
    
49.                         System.out.print(i + " ");  
    
50.                 }  
    
51.         }      
    
52.        
    
53.         // 插入排序      
    
54.         public static void chaRu(int[] x) {   
    
55.                 for (int i = 1; i < x.length; i++) {
    
56.                         // i从一开始，因为第一个数已经是排好序的啦  
    
57.                         for (int j = i; j > 0; j--) {
    
58.                                 if (x[j] < x[j - 1]) {     
    
59.                                         int temp = x[j];   
    
60.                                         x[j] = x[j - 1];   
    
61.                                         x[j - 1] = temp;   
    
62.                                 }   
    
63.                         }   
    
64.                 }      
    
65.                 for (int i : x) {
    
66.                         System.out.print(i + " ");   
    
67.                 }  
    
68.         }     
    
69.        
    
70.         // 希尔排序   
    
71.         public static void shell(int[] x) {   
    
72.                 // 分组  
    
73.                 for (int increment = x.length / 2; increment > 0; increment /= 2) {
    
74.                         // 每个组内排序  
    
75.                         for (int i = increment; i < x.length; i++) {   
    
76.                                 int temp = x[i];   
    
77.                                 int j = 0;        
    
78.                                 for (j = i; j >= increment; j -= increment) {      
    
79.                                         if (temp < x[j - increment]) {        
    
80.                                                 x[j] = x[j - increment];     
    
81.                                         } else {         
    
82.                                                 break;   
    
83.                                         }      
    
84.                                 }        
    
85.                                 x[j] = temp;     
    
86.                         }     
    
87.                 }         
    
88.                 for (int i : x) {
    
89.                         System.out.print(i + " ");   
    
90.                 }   
    
91.         }
    
92.        
    
93. 
    
94.        
    
95. }

复制代码

我就懂一个算法，把元素存储进Set集合，对集合进行排序，把集合当成数组返回。