java中数组冒泡排序的实现

冒泡排序

时间复杂度为O(n^2)
思路：
1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换位置
2.每一次比较,都会产生出一个最大或最小的数值
3.下一轮则可以少一轮排序
4.依次循环，直到结束

---

最终代码

import java.util.Arrays;

public class Demo1 {
    public static void main(String[] args) {
        // 测试使用
        // 定义一个数组nums用来排序
        int[] nums = {888,111,45,7,89,453,1,45};
        // 将定义的nums数组作为参数传入sort方法
        // 声明一个数组sort进行接收
        int[] sort = sort(nums);
        // 使用Arrays工具类打印sort
        System.out.println(Arrays.toString(sort));
    }

    // 自定义一个排序方法sort()
    // 参数为一个int数组
    public static int[] sort(int[] array){
        // 定义一个临时变量
        int temp = 0;

        // 外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {

            // 优化：
            // 在外层嵌套中定义一个布尔值用于判断是否排序完成
            boolean flag = false;

            // 内层循环，判断两个数大小
            // 如果第一个数比第二个数大，就交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                // 如果后面的数比前面的大就交换他(由大到小)
                // 将>换成<则由小到大
                // 此时需要一个临时变量
                if (array[j+1]>array[j]){
                    // 将当前值拿出放入临时值中
                    temp = array[j];
                    // 将大值赋给当前值
                    array[j] = array[j+1];
                    // 将拿出来的当前值赋给大值
                    array[j+1] = temp;
                    // 每一次排序完成都将flag设为true
                    flag = true;
                }
            }
            // 如果开始没有进行内部循环了(也就是排序结束了)
            if (flag == false) {
                // 就跳出循环,结束排序
                break;
            }
        }

        // 经过反复循环后,将排序后的数组返回
        return array;
    }
}

步骤：

1.建一个方法(方法名为sort,参数为一个int型的数组,返回值为一个 int型的数组)

public static int[] sort(int[] array){
    return array;
}

---

2.写一层外层循环，判断要排序循环多少次

public static int[] sort(int[] array){
    	// 外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {
        }
        // 经过反复循环后,将排序后的数组返回
        return array;
    }

---

3.写内层循环，让每一次外层循环进行一次遍历

public static int[] sort(int[] array){
    // 外层循环，判断要走多少次
    for (int i = 0; i < array.length-1; i++) {
        // 内层循环
        for (int j = 0; j < array.length-1-i; j++) {
        }
    }
    // 经过反复循环后,将排序后的数组返回
    return array;
}

---

4.定义一个临时变量temp用于拿出遍历时的当前数值,用于当前数值后面的数比他大就交换他

   public static int[] sort(int[] array){
        // 定义一个临时变量
        int temp = 0;

        // 外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {

            // 内层循环，判断两个数大小
            // 如果第一个数比第二个数大，就交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                // 如果后面的数比前面的大就交换他(由大到小)
                // 将>换成<则由小到大
                // 此时需要一个临时变量
                if (array[j+1]>array[j]){
                    // 将当前值拿出放入临时值中
                    temp = array[j];
                    // 将大值赋给当前值
                    array[j] = array[j+1];
                    // 将拿出来的当前值赋给大值
                    array[j+1] = temp;
                }
            }
        }

        // 经过反复循环后,将排序后的数组返回
        return array;
    }

完成

---

---

优化:

在外层循环中定义一个布尔值，用于判断排序是否提前完成，如果完成则提前结束排序

public static int[] sort(int[] array){
        // 定义一个临时变量
        int temp = 0;

        // 外层循环，判断要走多少次
        for (int i = 0; i < array.length-1; i++) {

            // 优化：
            // 在外层嵌套中定义一个布尔值用于判断是否排序完成
            boolean flag = false;

            // 内层循环，判断两个数大小
            // 如果第一个数比第二个数大，就交换位置
            for (int j = 0; j < array.length-1-i; j++) {
                // 如果后面的数比前面的大就交换他(由大到小)
                // 将>换成<则由小到大
                // 此时需要一个临时变量
                if (array[j+1]>array[j]){
                    // 将当前值拿出放入临时值中
                    temp = array[j];
                    // 将大值赋给当前值
                    array[j] = array[j+1];
                    // 将拿出来的当前值赋给大值
                    array[j+1] = temp;
                    // 每一次排序完成都将flag设为true
                    flag = true;
                }
            }
            // 如果开始没有进行内部循环了(也就是排序结束了)
            if (flag == false) {
                // 就跳出循环,结束排序
                break;
            }
        }

        // 经过反复循环后,将排序后的数组返回
        return array;
    }