1. public class ArreyDome {
   
2.         /*
   
3.          * 首先我们来看看,常规的方式实现冒泡排序,
   
4.          * 冒泡排序的思想主要是两两比较,直到数组的结束,而每次比较出来的结果,
   
5.          * 后面的值一定是最大(升序)或最小(降序)的那么,我们开始遍历数组,  
   
6.          * 每次遍历后,后面的值一定是最大或最小的那么我们每次遍历完后,后面的值就可以不要再考虑了
   
7.          * 直到程序到数组不在可以比较的时候.
   
8.          * */
   
9.         public void bubblie(int[] arr) {
   
10.                 for (int i = 0; i < arr.length-1; i++) {
    
11.                         for (int j = 0; j < arr.length-1-i; j++) {
    
12.                                 if (arr[j] > arr[j + 1]) {
    
13.                                         int tmp = arr[j];
    
14.                                         arr[j] = arr[j + 1];
    
15.                                         arr[j + 1] = tmp;
    
16.                                 }
    
17.                         }
    
18.                 }
    
19.         }
    
20.         /*
    
21.          * 前面的方法是,从后面向前面递减,那么我们为什么不吧比较的次数从后往前递增呢?
    
22.          * 每次遍历都保证数组的前面的数据都是有序的呢?
    
23.          *
    
24.          * */
    
25.         public void bubblie1(int[] arr) {
    
26.                 for (int i = 0; i < arr.length - 1; i++) {
    
27.                         for (int j = 0; j < i; j++) {
    
28.                                 if (arr[j] > arr[j + 1]) {
    
29.                                         int tmp = arr[j];
    
30.                                         arr[j] = arr[j + 1];
    
31.                                         arr[j + 1] = tmp;
    
32.                                 }
    
33.                         }
    
34.                 }
    
35.         }
    
36.         /*
    
37.          * 上面的程序都是两层循环嵌套,但每次无非比较的还是数组.
    
38.          * 那么将数组在传给自己就好了,何必这么麻烦,但是需要考虑的是程序
    
39.          * 在调用自己的话对无限制的运行下去,那么我需要考虑一个边界,
    
40.          * 来看看前两个程序,无论是第一种还是第二种他都是将程序外层循环的边界设定为arr.length()
    
41.          * 这样我们就定义一个标记,当这个标记等于arr.length()就返回即可
    
42.          *
    
43.          * */
    
44.         public void bubblie2(int[] arr,int i) {
    
45.                 if(arr.length==i){
    
46.                         return;
    
47.                 }        
    
48.                 for (int j = 0; j < arr.length - 1; j++) {
    
49.                                 if (arr[j] > arr[j + 1]) {
    
50.                                         int tmp = arr[j];
    
51.                                         arr[j] = arr[j + 1];
    
52.                                         arr[j + 1] = tmp;
    
53.                         }
    
54.                 }
    
55.                 i++;
    
56.                 bubblie2(arr, i);
    
57.         }

复制代码

//请经量避免使用递归,因它很耗内存的

学习了…………