冒泡排序

冒泡排序及优化：

核心：就是比较两个数的大小，左边和右边的大小不同则交换位置。

代码：

//第一轮的排序详解：
public class bubbleSort(){
    public static void main(String[] args){
        System.out.println("冒泡排序：");
        //需要排序的数组
        int[] arr = {54,53,3,3,32,23};
        
        //进行第一轮的比较
        for(int i = 1; i <= arr.length; i++){
            //arr[i]是右边的数，arr[i-1]是左边的数
           if(arr[i] < arr[i-1]){ //如果左边的大于左边的则交换
                //用零时变量,交换两个变量的值
            	int tmp = arr[i];  
            	arr[i] = arr[i-1];
            	arr[i-1] = tmp;
           }
        }
        //循环遍历打印排序后的数组
        System.out.println("[");
        for(int i = 0; i <= arr.length; i++){
            if(i  == arr.length){
                System.out.println(arr[i]);
            }else {
                System.out.println(arr[i]+"]");
            }
        }  
        //得到的结果是：[53,3,3,32,23,54]
    }
}

//根据上面第一轮的思路，写出完整的冒泡排序算法
	public static void main(String[] args) {
		System.out.println("冒泡排序：");
		// 需要排序的数组
		int[] arr = { 54, 57, 3, 3, 32, 23 };
		// 外层循环控制总的比较轮数
		for (int j = arr.length - 1; j > 0; j--) {
            //里面的进行每次轮数的比较
			for (int i = 1; i <= j; i++) {
				if (arr[i] < arr[i - 1]) {
					// 用零时变量,交换两个变量的值
					int tmp = arr[i];
					arr[i] = arr[i - 1];
					arr[i - 1] = tmp;
				}
			}
		}

		// 循环遍历打印排序后的数组
		System.out.print("[");
		for (int i = 0; i <= arr.length - 1; i++) {
			if (i == arr.length - 1) {
				System.out.print(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
        //排序结果：[3,3,23,32,54,57]
	}

冒泡排序的优化：

为什么需要优化：

在实际应用中，数据可能会有成千上百个，数据越多，原始排序方法浪费的时间越多，为了提升开发效率，我们需要对其进行一定的优化。

优化一：

一个未知数组，在进行冒泡时，如果其序列已经有一定的顺序，那么用原来的方法，不管有没有顺序，都会进行比较，从而浪费时间。即可以提前让其结束冒泡。

//优化一：
public static void main(String[] args) {
		System.out.println("冒泡排序：");
		// 需要排序的数组
		int[] arr = { 54, 57, 3, 3, 32, 23 };
		// 外层循环控制总的比较轮数
		for (int j = arr.length - 1; j > 0; j--) {
            //里面的进行每次轮数的比较
            //需要在控制轮数的里面进行优化
            boolean bubbleSort = true;//定义一布尔值用来判断，
			for (int i = 1; i <= j; i++) {
              // 这个条件是用来判断左右的大小，如果此条件成立，则进行以下代码，即交换，也就是说是无序的。优化思路是：如果条件不成立则说明数组有序
				if (arr[i] < arr[i - 1]) { 
					// 用零时变量,交换两个变量的值
					int tmp = arr[i];
					arr[i] = arr[i - 1];
					arr[i - 1] = tmp;
                    bubbleSort = false; //如果布尔值是false，则说明数组是无序的。如果返回True,则说明数组是由序的则跳出本次的轮数。
				}
                if(bubbleSort) break;
			}
		}

		// 循环遍历打印排序后的数组
		System.out.print("[");
		for (int i = 0; i <= arr.length - 1; i++) {
			if (i == arr.length - 1) {
				System.out.print(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
        //排序结果：[3,3,23,32,54,57]
	}

优化二：

 * 优化思路：
	 * 数组在进行比较后，最后面的数据已经排好序了，用原来的方法会依然把最后面的数据进行比较。从而降低效率
	 * 所以记录最后一次的交换位置。

//优化一：
public static void main(String[] args) {
		System.out.println("冒泡排序：");
		// 需要排序的数组
		int[] arr = { 54, 57, 3, 3, 32, 23 };
		// 外层循环控制总的比较轮数
		for (int j = arr.length - 1; j > 0; j--) {
            //里面的进行每次轮数的比较
            //需要在控制轮数的里面进行优化
           int sortIndex = -1;
			for (int i = 1; i <= j; i++) {
				if (arr[i] < arr[i - 1]) { 
					// 用零时变量,交换两个变量的值
					int tmp = arr[i];
					arr[i] = arr[i - 1];
					arr[i - 1] = tmp;
                sortIndex = i; //获取每一轮最好的一个数据，赋值给sortIndex
                }
			}
            j = sortIndex; //把值赋值给j,因为J控制的是最外层的轮数
		}

		// 循环遍历打印排序后的数组
		System.out.print("[");
		for (int i = 0; i <= arr.length - 1; i++) {
			if (i == arr.length - 1) {
				System.out.print(arr[i] + "]");
			} else {
				System.out.print(arr[i] + ",");
			}
		}
        //排序结果：[3,3,23,32,54,57]
	}