冒泡排序算法的优化(代码实现) [数据结构][Java]

冒泡排序算法的优化(代码实现)

这里我们将冒泡排序算法的优化封装成为一个方法(下面给出这个方法的代码)

public static void bubbleSortPlus(int [] arr){
    //定义一个临时变量用于交换两个位置的元素
    int temp = 0;

    //定义一个标识变量来判断我们的某一趟排序中是否一次交换位置的操作都没有发生
    boolean flag = false;

    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 -i; j++) {
            if(arr[j] > arr[j+1]){
                flag = true;
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        if(!flag){ // 表示flag的值为false,表示在一趟排序中一次元素的交换都没有发生过
            break;
        }else{
            flag = false; // 重置flag的值 ---> 这一点很重要
        }
    }
}

我们将这个优化后的冒泡排序算法封装到了我们的自定义工具类ArraySort类中,下面我们给出我们的ArraySort工具类的代码

package com.ffyc.util;

import java.util.Arrays;

/**
 * 数组排序的一个工具类(内部封装了很多排序的方法(八种内部排序都封装在里面))
 */
public class ArraySort {
    /**
     * 一步一步对冒泡排序的推演
     */
    public static void bubbleSort(){
        //定义了一个长度为5的数组
        //对于这个长度为5的数组我们进行冒泡排序要进行排序4趟
        int arr[] = {3,9,-1,10};

        /*
        第一趟排序,也就是将最大的数排到最后的位置
         */

        //定义一个临时变量,用于两个位置的数值进行交换时使用
        int temp = 0;

        /*
        在第一趟中我们要执行数组长度减-1次
         */
        for (int j = 0; j < arr.length - 1 - 0; j++) {
            //如果前面的数比后面的数大,则交换位置
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第一趟排序之后的结果
        System.out.println("第一趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第二趟排序,也即是将第二大的元素排到倒数第二个位置上
         */
        //这里就不用重复的定义一个临时变量了

        //注意: 由于我们第一趟中已经将我们的数组中的最后一个位置排好了,这个时候第二趟排序我们只需要排序除过最后一个元素的其他位置的元素就可以了
        for(int j =  0; j < arr.length - 1 - 1; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第二趟排序之后的结果
        System.out.println("第二趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第三趟排序: 将第三大的数排到数组中倒数第三个位置上
         */

        for(int j = 0; j < arr.length - 1 - 2; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第三趟的排序结果
        System.out.println("第三趟的排序结果: ");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 将冒泡排序归纳为一个双层for循环
     */
    public static void bubbleSort(int [] arr){
        //定义一个临时变量用于我们对两个位置上的元素的值进行交换
        int temp = 0;

        //定义外层for循环,控制冒泡排序执行的趟数
        for (int i = 0; i < arr.length - 1; i++) {
            //定义内存for循环,控制冒泡排序每趟执行的次数
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            //            System.out.println("第"+(i+1)+"趟冒泡排序的结果是");
            //            System.out.println(Arrays.toString(arr));
        }
    }

    /**
     * 冒泡排序算法的优化
     *    如果在某趟冒泡排序中没有执行一次元素交换,那么就提前退出冒泡排序
     *       因为说明在上一次就排好序了,那么这一次才能一次元素交换都不发生
     */
    public static void bubbleSortPlus(int [] arr){
        //定义一个临时变量用于交换两个位置的元素
        int temp = 0;

        //定义一个标识变量来判断我们的某一趟排序中是否一次交换位置的操作都没有发生
        boolean flag = false;

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if(arr[j] > arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
            if(!flag){ // 表示flag的值为false,表示在一趟排序中一次元素的交换都没有发生过
                break;
            }else{
                flag = false; // 重置flag的值 ---> 这一点很重要
            }
        }
    }
}

• ArraySort工具类中还封装了没有优化的冒泡排序算法

下面给出我们对优化后的冒泡排序算法的测试:

package com.ffyc.util.arraysorttest;

import com.ffyc.util.ArraySort;
import org.junit.Test;

import java.util.Arrays;

public class BubbleSortTest {
    //对我们的冒泡排序算法优化后的算法进行测试
    @Test
    public void test3(){
        int [] arr = {3,9,-1,10};
        System.out.println("排序前的数组为: ");
        System.out.println(Arrays.toString(arr));

        //调用我们的冒泡排序的优化版本
        ArraySort.bubbleSortPlus(arr);

        System.out.println("排序后的数组为: ");
        System.out.println(Arrays.toString(arr));
    }
}