1. /*
   
2. * 冒泡排序分析 :
   
3. * 算法思想:
   
4. *         每次相邻的两个进行比较,较大不断后移
   
5. *         最终每趟最大的沉底
   
6. *         示例 :索引 0 1 2 3 4
   
7. *                 i  5 8 9 1 2
   
8. *
   
9. *                    5 8 9 1 2  5<8  不动       
   
10. *         第0趟          5 8 9 1 2  8<9  不动
    
11. *         5 8 1 9 2  9>1 交换
    
12. *         5 8 1 2 9  9>2 交换  得出最大值为9  arr[4] = 9
    
13. *         共比较4次
    
14. *  
    
15. *  第1趟          5 8 1 2 9  5<8 不动
    
16. *         5 1 8 2 9  8>1 交换
    
17. *         5 1 2 8 9  8>2 交换  得出8为次大           arr[3] = 8
    
18. *         共比较3次
    
19. *         
    
20. *  第2趟         1 5 2 8 9  5>1 交换
    
21. *         1 2 5 8 9  5>2 交换  得出5位第三大         arr[2] = 5
    
22. *         共比较2次
    
23. *   
    
24. *  第3趟       1 2 5 8 9   1<2 不动  得出2是第四大         arr[1] = 2
    
25. *         共比较1次                                    剩余元素则为最小    arr[0] = 1
    
26. *         
    
27. *                                          
    
28. *  分析得 外圈总共4次,外圈第0次循环内圈是4次
    
29. *                             外圈第1次循环内圈是3次
    
30. *                             外圈第2次循环内圈是2次
    
31. *                             外圈第3次循环内圈是1次
    
32. *  定义外圈变量 x = 0 ;则内圈是从0 - 4 也就是小于5
    
33. *                  x = 1 , y 是 0 - 3  也就是小于4 5 - 1
    
34. *          x = 2 . y 是 0 - 2 也就是小于3 5 - 2
    
35. *          x = 3 . y 是 0 - 1 也就是小于2 5 - 3
    
36. *  
    
37. */
    
38. public class BubbleSort {
    
39. 
    
40.         /**
    
41.          * @param args
    
42.          */
    
43.         static int[] arr = {5,8,9,1,2};
    
44.         public static void main(String[] args) {
    
45. 
    
46.                 sortArr();
    
47.                 printArr();
    
48.         }
    
49. 
    
50.         public  static void printArr() {
    
51.                 System.out.print("[");
    
52.                 for (int i = 0; i < arr.length; i++) {
    
53.                         if(i!=arr.length-1){
    
54.                         System.out.print(arr[i]+" ,");
    
55.                         }else{
    
56.                                 System.out.println(arr[i]+"]");
    
57.                         }
    
58.                 }
    
59.         }
    
60. 
    
61.         public static void sortArr() {
    
62.                 for (int i = 0; i < arr.length-1; i++) {
    
63.                         for (int j = 0; j < arr.length-1-i; j++) {
    
64.                                 if(arr[j]>arr[j+1]){
    
65.                                         swap(arr,j,j+1);
    
66.                                 }
    
67.                         }
    
68.                 }
    
69.         }
    
70. 
    
71.         private static void swap(int[] arr, int i, int j) {
    
72.                
    
73.                 int temp = arr[i];
    
74.                 arr[i] = arr[j];
    
75.                 arr[j] = temp;
    
76.                
    
77.         }
    
78. 
    
79. }
    

复制代码

1. /*
   
2. * 冒泡排序分析 :
   
3. * 算法思想:
   
4. *         每次相邻的两个进行比较,较大不断后移
   
5. *         最终每趟最大的沉底
   
6. *         示例 :索引 0 1 2 3 4
   
7. *                i  5 8 9 1 2
   
8. *
   
9. *              5 8 9 1 2  5<8  不动       
   
10. *         第0趟   5 8 9 1 2  8<9  不动
    
11. *             5 8 1 9 2  9>1 交换
    
12. *             5 8 1 2 9  9>2 交换  得出最大值为9  arr[4] = 9
    
13. *              共比较4次
    
14. *  
    
15. *  第1趟           5 8 1 2 9  5<8 不动
    
16. *                     5 1 8 2 9  8>1 交换
    
17. *                     5 1 2 8 9  8>2 交换  得出8为次大           arr[3] = 8
    
18. *                     共比较3次
    
19. *         
    
20. *  第2趟          1 5 2 8 9  5>1 交换
    
21. *                    1 2 5 8 9  5>2 交换  得出5位第三大         arr[2] = 5
    
22. *                     共比较2次
    
23. *   
    
24. *  第3趟         1 2 5 8 9   1<2 不动  得出2是第四大         arr[1] = 2
    
25. *                    共比较1次                                    剩余元素则为最小    arr[0] = 1
    
26. *         
    
27. *                                          
    
28. *  分析得 外圈总共4次,外圈第0次循环内圈是4次
    
29. *                             外圈第1次循环内圈是3次
    
30. *                             外圈第2次循环内圈是2次
    
31. *                             外圈第3次循环内圈是1次
    
32. *  定义外圈变量 x = 0 ;则内圈是从0 - 4 也就是小于5
    
33. *                  x = 1 , y 是 0 - 3  也就是小于4 5 - 1
    
34. *          x = 2 . y 是 0 - 2 也就是小于3 5 - 2
    
35. *          x = 3 . y 是 0 - 1 也就是小于2 5 - 3
    
36. *  
    
37. */
    
38. public class BubbleSort {
    
39. 
    
40.         /**
    
41.          * @param args
    
42.          */
    
43.         static int[] arr = {5,8,9,1,2};
    
44.         public static void main(String[] args) {
    
45. 
    
46.                 sortArr();
    
47.                 printArr();
    
48.         }
    
49. 
    
50.         public  static void printArr() {
    
51.                 System.out.print("[");
    
52.                 for (int i = 0; i < arr.length; i++) {
    
53.                         if(i!=arr.length-1){
    
54.                         System.out.print(arr[i]+" ,");
    
55.                         }else{
    
56.                                 System.out.println(arr[i]+"]");
    
57.                         }
    
58.                 }
    
59.         }
    
60. 
    
61.         public static void sortArr() {
    
62.                 for (int i = 0; i < arr.length-1; i++) {
    
63.                         for (int j = 0; j < arr.length-1-i; j++) {
    
64.                                 if(arr[j]>arr[j+1]){
    
65.                                         swap(arr,j,j+1);
    
66.                                 }
    
67.                         }
    
68.                 }
    
69.         }
    
70. 
    
71.         private static void swap(int[] arr, int i, int j) {
    
72.                
    
73.                 int temp = arr[i];
    
74.                 arr[i] = arr[j];
    
75.                 arr[j] = temp;
    
76.                
    
77.         }
    
78. 
    
79. }

复制代码

以学会，不知道为什么现在的基础班不交冒泡排序了，以前都有，还有折半查找什么的都没有了

顶一下又不会怀孕!!!!!

顶一个！1！

已收 谢谢分享

看着感觉还是有点小复杂

真心觉得经典的冒泡排序，多可爱啊

大笑哈哈 发表于 2016-5-26 22:09
以学会，不知道为什么现在的基础班不交冒泡排序了，以前都有，还有折半查找什么的都没有了 ...

这是一种算法,现在我觉得黑马基础班讲算法很少,都是教你怎么写代码,不教底层了,为了速成,到最后还是需要自己去学习,排序算法,自己研究上一个月都不为过

.....................

可以假装看不见 发表于 2016-5-27 21:41
这是一种算法,现在我觉得黑马基础班讲算法很少,都是教你怎么写代码,不教底层了,为了速成,到最后还是需要 ...

具体到什么地方学习这些算法？还有底层这些，在哪里可以学到？

顶顶顶顶

大笑哈哈 发表于 2016-5-27 23:17
具体到什么地方学习这些算法？还有底层这些，在哪里可以学到？

这个就是for嵌套,可以看下打印倒三角,正三角,99乘法表 都是这个逻辑算法,底层就是循环遍历,for的底层就不知道了

zhenying.wang 发表于 2016-5-27 00:13
看着感觉还是有点小复杂

有点乱代码 不知道怎么回事,你可以自己粘贴出去 拍下版  我觉得这个还是比较清晰的思路

这些老师还讲过，我记得以前看视频还有折半查找什么的现在都没

果断顶啦！但是这个学过现在有点记得不起来，还是要知新 加 温故呀

表示今天研究这个研究了半天

不错，学习了