Java经典数组冒泡排序（案例演示）

Java中的经典算法之冒泡排序（Bubble Sort）

---

前言

原理：比较两个相邻的元素，将值大的元素交换至右端。

思路：依次比较相邻的两个数，将小数放到前面，大数放到后面。

        即第一趟，首先比较第1个和第2个元素，将小数放到前面，大数放到后面。

        然后比较第2个和第3个元素，将小数放到前面，大数放到后面。

        如此继续，直到比较最后两个数，将小数放到前面，大数放到后面。

        重复第一趟步骤，直至全部排序完成。

例如：冒泡：从小到大，从左到右比较

数组：{6,3,8,2,9,1}

arr  0 1 2 3 4 5

    第一轮：
    第1次：arr[0]与arr[1]比较，6>3成立，就交换，{3,6,8,2,9,1}
    第2次：arr[1]与arr[2]比较，6>8不成立，不交换{3,6,8,2,9,1}
    第3次：arr[2]与arr[3]比较，8>2成立，就交换，{3,6,2,8,9,1}
    第4次：arr[3]与arr[4]比较，8>9不成立，不交换{3,6,2,8,9,1}
    第5次：arr[4]与arr[5]比较，9>1成立，就交换，{3,6,2,8,1,9}
    
    第一轮结果：{3,6,2,8,1,9}   9已经到达正确位置，下一轮不用在参与

    第二轮：
    第1次：arr[0]与arr[1]比较，3>6不成立，不交换{3,6,2,8,1,9}
    第2次：arr[1]与arr[2]比较，6>2成立，就交换，{3,2,6,8,1,9}
    第3次：arr[2]与arr[3]比较，6>8不成立，不交换{3,2,6,8,1,9}
    第4次：arr[3]与arr[4]比较，8>1成立，就交换，{3,2,6,1,8,9}
    
    第二轮结果：{3,2,6,1,8,9}   8已经到达正确位置，下一轮不用在参与
    
    第三轮：
    第1次：arr[0]与arr[1]比较，3>2成立，就交换，{2,3,6,1,8,9}
    第2次：arr[1]与arr[2]比较，3>6不成立，不交换{2,3,6,1,8,9}
    第3次：arr[2]与arr[3]比较，6>1成立，就交换，{2,3,1,6,8,9}
    
    第三轮结果：{2,3,1,6,8,9}   6已经到达正确位置，下一轮不用在参与
    
    第四轮：
    第1次：arr[0]与arr[1]比较，2>3不成立，不交换{2,3,1,6,8,9} 
    第2次：arr[1]与arr[2]比较，3>1成立，就交换，{2,1,3,6,8,9} 
    
    第四轮结果：{2,1,3,6,8,9}    3已经到达正确位置，下一轮不用在参与
    
    第五轮
    第1次：arr[0]与arr[1]比较，2>1成立，就交换，{1,2,3,6,8,9}
    
    第五轮结果：{1,2,3,6,8,9}   2已经到达正确位置，下一轮不用在参与
    
    剩下1，肯定是最小的了，不用比较了
    
    6个元素，比较了5轮， n个元素需要n-1轮
    每一轮比较很多次

实例代码：

public static void main(String[] args){
		int[] arr = {6,3,8,2,9,1};  //arr.length = 6
		
		//i=1,2,3,4,5  一共5轮
		for(int i=1; i<arr.length; i++){//轮数
			/*
			i=1，第1轮，j=0,1,2,3,4   arr[j]与arr[j+1]
			i=2，第2轮，j=0,1,2,3     arr[j]与arr[j+1]
			i=3，第3轮，j=0,1,2       arr[j]与arr[j+1]
			i=4，第4轮，j=0,1         arr[j]与arr[j+1]
			i=5，第5轮，j=0           arr[j]与arr[j+1]
			
			j=0, j<=arr.length-1-i
			*/
			for(int j=0; j<=arr.length-1-i; j++){
				if(arr[j] > arr[j+1]){
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		
		//结果
		for(int i=0; i<arr.length; i++){
			System.out.print(arr[i] + " ");
		}
	}

package com.zpark.test;

public class BubbleSort {
    public static void main(String[] args){
        char[] arr = {'h','e','l','l','o','j','a','v','a'};
        for(int i=1; i<arr.length; i++){//外循环的次数 = 轮数 = 数组的长度-1
    /*
    第1轮，i=1，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[1]与arr[0]
    第2轮，i=2，从右到左两两比较，arr[8]与arr[7]，arr[7]与arr[6]....arr[2]与arr[1]
    ...
    第8轮，i=8，从右到左两两比较，arr[8]与arr[7]
    		   arr[j]与arr[j-1]
    找两个关键点：（1）j的起始值：8（2）找j的终止值，依次是1,2,3,。。。8，得出j>=i
    */
            for(int j=8; j>=i; j--){
                //从大到小，后面的元素 > 前面的元素，就交换
                if(arr[j]>arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
    }
}

==代码描述==

从第一个位置开始遍历整个数组,使用嵌套循环

外层表示排序的次数,有n个数则只需要n-1次即可

内层循环则是把当前数值和后一位数值作比较,当前数值比后一位数值大(倒序),则进行交换位置

这样一来,内层循环走一遍,则是把当前比较的数组的最大值放到最后位置

外层循环走完则是排序完所有数字