算法-冒泡排序

算法描述

1. 依次比较数组中相邻两个元素大小，若 a[j] > a[j+1]，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后
2. 重复以上步骤，直到整个数组有序

优化方式:

• 每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，表示整个数组有s,直接退出外层循环即可
• 总结：1.是否发生交换、2.记录最后发生交换的索引

package com.unit.sort;
import java.util.Arrays;
/**
 * ClassName:BubbleSort
 * Package:com.unit.sort
 * Description:冒泡排序(小到大排序) 从简单到优化   时间复杂度O(n^2)
 * @author 
 * @create -08-06 15:39
 */
public class BubbleSort {
    public static void main(String[] args) {
        int[] array = {5, 2, 7, 4, 1, 3, 8, 9};
        //int[] a = {1, 2, 3, 4, 5, 7, 8, 9};
        bubble1(array);
        bubble2(array);
        bubble3(array);
        bubble4(array);
    }
    //方式一：双层for（普通）
    public static void bubble1(int[] arr) {
        for (int j = 0; j < arr.length - 1; j++) {//比较轮数
            //一轮冒泡
            for (int i = 0; i < arr.length - 1; i++) {//比较次数，   arr.length - 1因为i从0开始    
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                }
            }
            System.out.println("第" + j + "轮冒泡" + Arrays.toString(arr));
        }
    }
    
    //方式二：双层for (后一轮可以比前一轮少比较一次，比如  7  8(此时顺序已经排好了))
    public static void bubble2(int[] arr) {
        for (int j = 0; j < arr.length - 1; j++) {//比较轮数
            //一轮冒泡
            for (int i = 0; i < arr.length - 1 - j; i++) {//比较次数，   rr.length - 1因为i从0开始    
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                }
            }
            System.out.println("第" + j + "轮冒泡" + Arrays.toString(arr));
        }
    }
    
    //方式三：如果没有发生一次交换，说明已经有序了
    public static void bubble3(int[] arr) {
        for (int j = 0; j < arr.length-1; j++) {//比较轮数
            //一轮冒泡
            boolean swapped = false; //是否发生交换，如果发生，则改为true
            for (int i = 0; i < arr.length - 1 - j; i++) {//比较次数，   rr.length - 1因为i从0开始    
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                    swapped = true;
                }
            }
            System.out.println("第" + j + "轮冒泡" + Arrays.toString(arr));
            if (!swapped) {
                break;
            }
        }
    }
    
    //方式4：有一些已经有序了，并比较过
    //记录最后一次交换位置的索引
    public static void bubble4(int[] arr) {
        int n = arr.length - 1;
        while (true) {
            //一轮冒泡
            int last = 0;
            for (int i = 0; i < n; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                    last = i;//将最后一次交换的索引赋值给last
                }
            }
            n = last;//将最后一次交换的索引last复制给下轮
            System.out.println("第轮冒泡" + Arrays.toString(arr));
            if (n == 0) {
                break;
            }
        }
    }
    //数组交换位置
    public static void swap(int[] a, int i, int j) {
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
}