冒泡算法--通俗易通

 冒泡算法相对来说算是比较简单的了，希望看官在看的时候，千万不要急，我已经把每一轮的分解过程写出来了，然后再写一个总的排序，希望对你有所帮助。

一.冒泡算法介绍

　　定义：

　　　　通过对无序数组列表的下标开始依次对相邻元素的值进行比较，若发现逆序则交换，使较大的元素逐渐从前向移，就像水底的气泡一样逐渐向上冒泡。

　　排序思想：

　　　　冒泡是通过2个循环来进行排序的，内循环每1轮排出的元素是在当前数组中相对较大的元素，外循环则是对元素的个数进行循环。
　　冒泡算法分为2种：
　　　　1.一种是利用内、外循环的脚标来确定二个数，进行比较。
　　　　2.另一种是利用内存循环的脚标、内循环脚标+1来确定2个数，来进行比较

　

二.代码实现

　　1.分步实现

　　2.整体实现

　　3.优化步骤

三.时间复杂度

　　冒泡算法是通过内外循环而来的，那么它的规模则是O(n^2),即内外循环循环的次数相乘，就是这个算法执行的规模，想想是不是很大。

　　分步实现过程

package com.zpb.bubbling;

import java.util.Arrays;

/**
 * @des                                  
 * @author  zhao
 * @date    2019年10月28日下午11:02:06
 * 
 */
public class BubblingSort {
    
    public static void main(String[] args) {
        int arr[] ={101,34,119,1};
        bubblingSort(arr);
    }
    
    public static void bubblingSort(int arr[]) {
        //对于一个数组排序，我们先将排序分成多轮进行，
        
        //第1轮排序：========================================================= 101 和 34 进行排序
        int temp = 0;
        for (int j = 0; j < arr.length -1- 0; j++) {    //-1是因为最后一个数是不需要排序的，-0是从arr[0]的位置开始
            if(arr[j] > arr[j+1]) {                    //如果前1个数大于后一个数，那么就将其进行交换位置
                temp = arr[j];                        //我们先将前1个数存放到临时变量中
                arr[j] = arr[j+1];                    //将后1个变量赋值给前1个变量
                arr[j+1] = temp;                    //再将刚才的临时变量存储的值，赋值给后1个变量
                //这个过程就好比，你端了一杯红酒，我端了一杯啤酒，你想喝我的啤酒，所以我们就找了一个临时的空杯子，我将啤酒倒在空杯子中，你将红酒倒
                //在了我的杯子中，然后又将临时空杯子中的啤酒倒进了你的杯子中
            }
        }
        System.out.println("第1轮排序完成后："+Arrays.toString(arr));    //[34, 101, 1, 119]
        
        //第2轮排序：=========================================================  101 和 1 进行排序
        //请注意：在第2次排序的时候数组的位置已经变化了，关键点在于,在第1次排序之前，第1个元素和第2个元素已经交换过位置，所以在第2次排序的时候，其实
        //是从第2个位置开始进行排序的，这个点很关键，请一定要记住！！！
        for (int j = 0; j < arr.length -1 -1; j++) { //-1是因为最后一个数是不需要排序的，-1是从arr[1]的位置开始
            if(arr[j] > arr[j+1]) {                     //如果前1个数大于后一个数，那么就将其进行交换位置
                temp = arr[j];                         //我们先将前1个数存放到临时变量中
                arr[j] = arr[j+1];                     //将后1个变量赋值给前1个变量
                arr[j+1] = temp;                     //再将刚才的临时变量存储的值，赋值给后1个变量
                //这个过程就好比，你端了一杯红酒，我端了一杯啤酒，你想喝我的啤酒，所以我们就找了一个临时的空杯子，我将啤酒倒在空杯子中，你将红酒倒
                //在了我的杯子中，然后又将临时空杯子中的啤酒倒进了你的杯子中
            }
        }
        System.out.println("第2轮排序完成后："+Arrays.toString(arr));    //[34, 1, 101, 119]
        
        //第3轮排序：=========================================================  101  和119 进行排序
        for (int j = 0; j < arr.length -1 -2; j++) {    //-1是因为最后一个数是不需要排序的，-2是从arr[2]的位置开始
            if(arr[j] > arr[j+1]) {                    //如果前1个数大于后一个数，那么就将其进行交换位置
                temp = arr[j];                        //我们先将前1个数存放到临时变量中
                arr[j] = arr[j+1];                    //将后1个变量赋值给前1个变量
                arr[j+1] = temp;                    //再将刚才的临时变量存储的值，赋值给后1个变量
                //这个过程就好比，你端了一杯红酒，我端了一杯啤酒，你想喝我的啤酒，所以我们就找了一个临时的空杯子，我将啤酒倒在空杯子中，你将红酒倒
                //在了我的杯子中，然后又将临时空杯子中的啤酒倒进了你的杯子中
            }
        }
        System.out.println("第3轮排序完成后："+Arrays.toString(arr));    //[1, 34, 101, 119]
        
        //第4轮排序：=========================================================  101 和119 进行排序
        for (int j = 0; j < arr.length -1 -3; j++) {    //-1是因为最后一个数是不需要排序的，-3是从arr[3]的位置开始
            if(arr[j] > arr[j+1]) {                    //如果前1个数大于后一个数，那么就将其进行交换位置
                temp = arr[j];                        //我们先将前1个数存放到临时变量中
                arr[j] = arr[j+1];                    //将后1个变量赋值给前1个变量
                arr[j+1] = temp;                    //再将刚才的临时变量存储的值，赋值给后1个变量
            }
        }
        System.out.println("第4轮排序完成后："+Arrays.toString(arr));    //[1, 34, 101, 119]
        
    }
}

　整体实现

package com.zpb.bubbling;

import java.util.Arrays;

/**
 * @des                                  
 * @author  zhao
 * @date    2019年11月2日下午10:20:15
 * 
 */
public class BubblingSort2 {
    
    public static void main(String[] args) {
        int arr[] = {3,-1,4,2,5};
        bubblingSort(arr);
    }
    
    public static void bubblingSort(int arr[]) {
        
        int temp = 0;
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = 0; j < arr.length -1 - i; j++) {
                if(arr[j] > arr[j+1]) {
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            System.out.println("第"+i+"次排序结果是："+Arrays.toString(arr));
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    
}

　优化步骤

package com.zpb.bubbling;

import java.util.Arrays;

/**
 * @des                                  
 * @author  zhao
 * @date    2019年11月2日下午11:53:52
 * 
 */
public class BubblingSort3 {
    public static void main(String[] args) {
        int arr[] = {101,34,119,1};
        bubblingSort(arr);
    }
    
    public static void bubblingSort(int arr[]) {
        
        int temp = 0;
        boolean flag = false;
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = 0; j < arr.length -1 - i; j++) {
                if(arr[j] > arr[j+1]) {
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            System.out.println("第"+i+"次排序结果是："+Arrays.toString(arr));
            }
            if(!flag) {      //在一趟排序中，一次交换都没有发生过
                break;
            }else {
                flag = false;
            }
        }
    }
}

 八大算法持续更新中，希望对你有所帮助，敬请关注！！！