冒泡排序

有数组 {4,5,6,3,2,1}
如果当前元素比下一元素大就进行替换

冒泡次数	冒泡结果
第一次冒泡	{4,5,3,2,1,6}
第二次冒泡	{4,3,2,1,5,6}
第三次冒泡	{3,2,1,4,5,6}
第四次冒泡	{2,1,3,4,5,6}
第五次冒泡	{1,2,3,4,5,6}
第六次冒泡	{1,2,3,4,5,6}

代码实现

import java.util.Arrays;

/**
 * 冒泡排序编写
 */
public class Bubble {

    /**
     * 对于数组元素排序
     */
    public static void sort(Comparable[] arr) {
//        for (int i = arr.length - 1; i > 0; i--) {
//            for (int j = 0; j < i; j++) {
//                // 如果下一个元素比我大就进行替换
//                if (greater(arr[j], arr[j + 1])) {
//                    swap(arr, j, j + 1);
//                }
//            }
//        }
        for (int i = 0; i < arr.length - 1; i++) {//外层循环控制排序趟数
            for (int j = 0; j < arr.length - 1 - i; j++) {//内层循环控制每一趟排序多少次
            	 // 如果下一个元素比我大就进行替换
                if (greater(arr[j], arr[j + 1])) {
                    swap(arr, j, j + 1);
                }
            }
        }
    }

    /**
     * @param c1 cur元素
     * @param c2 next元素
     * @return next大于cur吗  true 大于  false 小于等于
     *
     *
     */
    private static boolean greater(Comparable c1, Comparable c2) {
        return c1.compareTo(c2) > 0;
    }

    /**
     * 交换位置
     *
     * @param a 整体数组
     * @param i cur元素
     * @param j next元素
     */
    private static void swap(Comparable[] a, int i, int j) {
        // 创建临时变量 用于交换元素位置
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }


}

class Test2{
    public static void main(String[] args) {
        // 使用Integer，实现了Comparable接口
        Integer [] array ={4,5,6,3,2,1};
        Bubble.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

口诀 外层循环n-1 内层循环n-1-i 里面来个值互换

时间复杂度

1. 空间复杂度就是在交换元素时那个临时变量所占的内存空间；
2. 最优的空间复杂度就是开始元素顺序已经排好了，则空间复杂度为：0；
3. 最差的空间复杂度就是开始元素逆序排序了，则空间复杂度为：O(n)；
4. 平均的空间复杂度为：O(1)；
5. 最优时间复杂度 n

最差的时间情况 复杂度为：O( n^2 )