使用JAVA语言编写冒泡排序

在CSDN潜水这么久也不知道写什么好，突发奇想来写个冒泡排序记录一下，以作为我的起始点。

   冒泡排序应该是算法/排序里最简单的了，这个作为初学者（我也是）请务必要掌握~

而且学校那边的测试也一般会考的。

   例子：给定一个数组arr{66, 32, 24, 15, 53}，按从小到大的形式排序输出该数组。

        我的个人思路是：冒泡排序实则就是动态性地从前往后对比一组组相邻的元素，把大的数依次往数组后面放置，第一次放置最大数，第二次放置次大数......第n-1次放置次小数，第n次放置最小数，这样小的数就放在了数组前边，大的数就放在了数组后边，从而完成从小到大的排序。

        下面来看看代码，多打代码就能熟悉的了。

public class Main {
    public static void main(String[] args) {
        int[] arr = {66, 32, 24, 15, 53};
        //arr是array“数组”的缩写
        int temp = 0;
        //temp是temporary“临时变量”的缩写
        //涉及到交换变量a,b需要用到一个中间变量c,以充当媒介进行交换
        //就像交换a杯和b杯中的水，需要一个空杯c来进行交换
        for (int i = 0; i < 4; i++) {
            if (arr[i] > arr[i + 1]) {
                //以下两个元素的交换其实是有规律的
                //以左斜角度来看=号两边，刚好右边对应着左边的元素名，这就是个模板
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }
        
        System.out.println("arr数组第一次排序后为");
        //for循环输出打印数组
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i] + " ");
            //prtintln少个ln就没有换行，为了观感最好加个空格字符进行间隔
        }
    }
}

第一次排序后可以得知，该数组的最大值66通过交换放在了数组的末位,那么接着来看第二次排序。

public class Main {
    public static void main(String[] args) {
        int[] arr = {66, 32, 24, 15, 53};

        int temp = 0;
        for (int i = 0; i < 4; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        for (int i = 0; i < 3; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        System.out.println("arr数组第二次排序后为");
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

第二次排序后，次大值53由于第一次就已经恰好排在了倒数第二位，所以结果上看最后两位依然是

53，66，同时我们可以发现，第二个for循环i<4变成了i<3，这可以理解为“每次排序后都能对比出一个较大值放在数组后面，所以下一轮对比的次数就减少1次”。

那么最终是轮回了多少次for循环呢？答案是4次，因为最终递减直到i<1，就已经排序完成了，期间总共轮回了4次for循环，并且每次for循环中进行相邻元素比较的次数都会-1

下面我们来看最终的代码：

public class Main {
    public static void main(String[] args) {
        int[] arr = {66, 32, 24, 15, 53};

        int temp = 0;
        for (int i = 0; i < 4; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        for (int i = 0; i < 3; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        for (int i = 0; i < 2; i++) {
            if (arr[i] > arr[i + 1]) {
                temp = arr[i];
                arr[i] = arr[i + 1];
                arr[i + 1] = temp;
            }
        }

        for (int i = 0; i < 1; i++) {
            if(arr[i] > arr[i+1]){
                temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }

        System.out.println("arr数组排序后为");
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

显然，我们的这个数组arr已经实现了从小到大进行排序输出了，可能会有人疑问为什么第一个for不是从i<5开始呢？因为这会导致for里头的arr[i+1]越界了，并且从代码理解上看，也并不是从i<5开始的。

i < 数字，这个“数字”可理解为“从数组首端开始，由前往后动态性相邻元素的对比次数”

相邻元素的交换，也就是arr[0]和arr[1]对比，如果arr[0]>arr[1]，则交换，否则不交换；然后再arr[1]和arr[2]进行对比，如果arr[1]>arr[2]，则交换，否则不交换；后面重复如此。

但是这段“最终版”代码这么冗长，显然我们是可以改进的，以下我们就来看最终完善版的冒泡排序。

public class Main {
    public static void main(String[] args) {
        int[] arr = {66, 32, 24, 15, 53};
        int temp = 0;
        //完善版我们可以用for的嵌套循环来实现冒泡排序
        for (int i = 0; i < arr.length - 1 ; i++) {
            //首先从最终版我们可以看出，for总共使用了4次
            //所以那4个for的连用我们可以归为外循环
            //arr.length - 1 也就是5 - 1 = 4次
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //其次内循环就是同最终版的for循环体里的代码差不多
                //但是最终版的i<n的数字我们知道是递减1的规律
                //所以内循环j我们可以用-i来实现动态性地递减1
                //因为作为外循环次数的i是动态性递增的(i++)
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        
        System.out.println("arr数组排序后为");
        for (int i = 0; i <arr.length ; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

完善版和最终版的运行结果一致，所以不再放结果图了，我们可以很明了地看出，完善版的代码是要比最终版的代码要精简不少，而且完善版的规律也很显而易见，可以说这就是冒泡排序的模板，遇到从小到大排序可以直接套来用的。

我不建议死记硬背地去记住它，应该是去理解代码，理清其中的逻辑，如果不是了解过冒泡排序的人去打代码，一般都get不到for的嵌套循环是从内层往外的这个逻辑顺序进行编写的，而不是从外层再到内层。

还好我学过c语言的基础，在学习JAVA的时候知道怎么打

感谢观看！一定要多打代码。