最近学习了几个基本的算法，特贴在这里一起分享哈

1. 
   
2. public class Sort {
   
3. 
   
4.         public static void main(String[] args) {
   
5.                 //调用自定制方法生成int[]
   
6.                 int[] src=getIntegerArray(20);
   
7.                 for(int i:src){
   
8.                         System.out.print(i+"        ");
   
9.                 }
   
10.                 System.out.println();
    
11.                
    
12.                 long startTime=System.nanoTime();
    
13.                 bubbleSort(src);
    
14.                 long endTime=System.nanoTime();
    
15.                 System.out.println("bubbleSort used time:"+(endTime-startTime));
    
16.                
    
17.                 long startTime1=System.nanoTime();
    
18.                 selectionSort(src);
    
19.                 long endTime1=System.nanoTime();
    
20.                 System.out.println("selectionsort used time:"+(endTime1-startTime1));
    
21.                
    
22.                
    
23.                 long startTime2=System.nanoTime();
    
24.                 insertionSort(src);
    
25.                 long endTime2=System.nanoTime();
    
26.                 System.out.println("insertionSort used time:"+(endTime2-startTime2));
    
27.                 //打印排序后数组
    
28.                 for(int i:src){
    
29.                         System.out.print(i+"        ");
    
30.                 }
    
31.                
    
32.         }
    
33.        
    
34.         public static int[] bubbleSort(int[] src){
    
35.                 if(src==null||src.length==0)
    
36.                         return null;
    
37.                 int out,in;
    
38.                 for(out=src.length-1;out>0;out--){
    
39.                         for(in=0;in<out;in++){
    
40.                                 if(src[in]>src[in+1]){
    
41.                                         int temp=src[in];
    
42.                                         src[in]=src[in+1];
    
43.                                         src[in+1]=temp;
    
44.                                 }
    
45.                         }
    
46.                 }
    
47.                 return src;
    
48.         }
    
49.        
    
50.         public static int[] selectionSort(int[] src){
    
51.                 if(src==null||src.length==0)
    
52.                         return null;
    
53.                 int out,in,min;
    
54.                 for(out=0;out<src.length-1;out++){
    
55.                         min=out;
    
56.                         for(in=out+1;in<src.length;in++){
    
57.                                 if(src[in]<src[min]){
    
58.                                         min=in;
    
59.                                 }
    
60.                                 int temp=src[out];
    
61.                                 src[out]=src[min];
    
62.                                 src[min]=temp;
    
63.                         }
    
64.                 }
    
65.                 return src;
    
66.         }
    
67.        
    
68.         public static int[] insertionSort(int[] src){//最快
    
69.                 if(src==null||src.length==0)
    
70.                         return null;
    
71.                 int out,in;
    
72.                 for(out=1;out<src.length;out++){
    
73.                         int temp=src[out];
    
74.                         in=out;
    
75.                         while(in>0&&src[in-1]>temp){
    
76.                                 src[in]=src[in-1];
    
77.                                 in--;
    
78.                         }
    
79.                 /*        for (; in > 0; in--) {    // 用时更少
    
80.                                 if (src[in - 1] > temp) {
    
81.                                         src[in] = src[in - 1];
    
82.                                 } else {
    
83.                                         break;
    
84.                                 }
    
85.                         }*/
    
86.                         src[in]=temp;
    
87.                 }
    
88.                 return src;
    
89.         }
    
90.        
    
91.         //生成随机int[]供测试用
    
92.         public static int[] getIntegerArray(int n){
    
93.                 if(n<=0)
    
94.                         return null;
    
95.                
    
96.                 int[] src=new int[n];
    
97.                 int index=0;
    
98.                 while(index<n){
    
99.                         src[index]=(int)(Math.random()*100);
    
100.                         index++;
     
101.                 }
     
102.                 return src;
     
103.         }
     
104. }
     

复制代码

希望楼主写一下思路和注释

说实话 楼主这代码风格不是很好- -
该留空格的地方不留空格
该有注释的地方没有注释提出一些改进意见
1.永远不要省略if for之类函数里的大括号
2.该留空格的地方要留空格 比如等于号两边
3.不相关的两段代码要用空行隔开 最好能分开两个函数

以及，其实我个人是从来不用IDE的自动代码整理的，时间长了自己就习惯了，自然而然的就写出来符合规范的代码格式了。
现在我写任何语言的代码，几乎都是照那一份格式来，这样的好处就是，我出门平板上只有个Sublime Text（一种记事本），照样可以写各种语言的代码，而不用一个语言一个IDE。

1. public class Sort {
   
2.     /**
   
3.      * main方法 程序从这里启动
   
4.      * @param args 从外部传入的参数列表
   
5.      */
   
6.     public static void main(String[] args) {
   
7.         //生成要排序的数组
   
8.         int[] src = getIntegerArray(20);
   
9. 
   
10.         //输出下要排序的数组
    
11.         for(int i : src){
    
12.             System.out.print(i + "\t");
    
13.         }
    
14.         System.out.println();
    
15. 
    
16.         //冒泡排序
    
17.         long startTime = System.nanoTime();
    
18.         bubbleSort(src);
    
19.         long endTime = System.nanoTime();
    
20.         System.out.println("bubbleSort used time:" + (endTime - startTime));
    
21.         
    
22.         //选择排序
    
23.         long startTime1 = System.nanoTime();
    
24.         selectionSort(src);
    
25.         long endTime1 = System.nanoTime();
    
26.         System.out.println("selectionsort used time:" + (endTime1 - startTime1));
    
27.         
    
28.         //插入排序
    
29.         long startTime2 = System.nanoTime();
    
30.         insertionSort(src);
    
31.         long endTime2 = System.nanoTime();
    
32.         System.out.println("insertionSort used time:" + (endTime2 - startTime2));
    
33.         
    
34.         //输出下排序后数组
    
35.         for(int i : src){
    
36.             System.out.print(i+"\t");
    
37.         }
    
38.     }
    
39. 
    
40.     /**
    
41.      * 冒泡排序
    
42.      * @param src 要被排序的数字数组
    
43.      * @return 排序后的数字数组
    
44.      */
    
45.     public static int[] bubbleSort(int[] src) {
    
46.         if(src == null || src.length == 0) {
    
47.             return null;
    
48.         }
    
49. 
    
50.         int out, in;
    
51.         for(out = src.length - 1; out > 0; out--) {
    
52.             for(in = 0; in < out; in++) {
    
53.                 if(src[in] > src[in + 1]) {
    
54.                     int temp = src[in];
    
55.                     src[in] = src[in + 1];
    
56.                     src[in + 1] = temp;
    
57.                 }
    
58.             }
    
59.         }
    
60. 
    
61.         return src;
    
62.     }
    
63. 
    
64.     /**
    
65.      * 选择排序
    
66.      * @param src 要被排序的数字数组
    
67.      * @return 排序后的数字数组
    
68.      */
    
69.     public static int[] selectionSort(int[] src) {
    
70.         if(src == null || src.length == 0) {
    
71.             return null;
    
72.         }
    
73. 
    
74.         int out, in, min;
    
75.         for(out = 0; out < src.length - 1; out++) {
    
76.             min = out;
    
77.             for(in = out + 1; in < src.length; in++) {
    
78.                 if(src[in] < src[min]) {
    
79.                     min = in;
    
80.                 }
    
81.                 int temp = src[out];
    
82.                 src[out] = src[min];
    
83.                 src[min] = temp;
    
84.             }
    
85.         }
    
86. 
    
87.         return src;
    
88.     }
    
89. 
    
90.     /**
    
91.      * 插入排序
    
92.      * @param src 要被排序的数字数组
    
93.      * @return 排序后的数字数组
    
94.      */
    
95.     public static int[] insertionSort(int[] src) { //最快
    
96.         if(src == null || src.length == 0) {
    
97.             return null;
    
98.         }
    
99. 
    
100.         int out,in;
     
101.         for(out = 1; out < src.length; out++) {
     
102.             int temp = src[out];
     
103.             in = out;
     
104.             while(in > 0 && src[in - 1] > temp) {
     
105.                 src[in] = src[in - 1];
     
106.                 in--;
     
107.             }
     
108. /*
     
109.             for (; in > 0; in--) {    // 用时更少
     
110.                 if (src[in - 1] > temp) {
     
111.                     src[in] = src[in - 1];
     
112.                 } else {
     
113.                     break;
     
114.                 }
     
115.             }
     
116. */
     
117.             src[in] = temp;
     
118.         }
     
119. 
     
120.         return src;
     
121.     }
     
122.    
     
123.     /**
     
124.      * 随机生成一些整数并以数组形式返回, 供测试排序函数用
     
125.      * @param n 要生成的整数数量
     
126.      * @return 一些随机大小的整数的数组
     
127.      */
     
128.     public static int[] getIntegerArray(int n) {
     
129.         if(n <= 0) {
     
130.             return null;
     
131.         }
     
132.         
     
133.         int[] src = new int[n];
     
134.         int index = 0;
     
135.         while(index < n){
     
136.             src[index] = (int)(Math.random() * 100);
     
137.             index++;
     
138.         }
     
139.         
     
140.         return src;
     
141.     }
     
142. }
     

复制代码

经过人工简单整理后的代码

cat73同学已然培养了良好的编程习惯

注释好少，不过大赞一下啊

3kx share  

写的很规范了，方便调用。

学习了~

有心人，nice，赞一个

路过一下..不过看懂了

加注释！！！！！！！！！！！！！！！！！

那个，代码是怎么贴的？？

非常不错！

建议做好注释