排序算法之冒泡排序

Posted 2020-09-18 稻草人

冒泡算法是最常见的排序算法之一，算法的思路也比较简单，也比较容易实现。对于一组n个数据的记录，最坏的情况需要n-1趟比较。

第一趟：依次比较索引为0和1、1和2、2和3...n-2和n-1的元素，如果前者大于后者则交换这两个数据，所以经过第一趟，最大的元素排到了最后；而第二趟就不用管最后一个数据了，只需要再遍历前面的n-1个数据，以此类推。

例如,19,45,16,21*，23，21,30

第一趟的结果：19,16,21*，23,21,30,45

冒泡算法是稳定的。以下是具体的实现：

package test.java.sort.Util;

/**
 * 定义一个数据包装类
 * @author tom
 */
public class DataWrap implements Comparable<DataWrap> {
    int data;
    String flag;

    public DataWrap(int data, String flag) {
        this.data = data;
        this.flag = flag;
    }

    @Override
    public String toString() {
        return data + flag;
    }

    // 如果当前data大于dw,返回1；小于和等于返回数值不是1
    @Override
    public int compareTo(DataWrap dw) {
        return this.data > dw.data ? 1 : (this.data == dw.data ? 0 : -1);
    }
}

 

package test.java.sort.bubble;

import test.java.sort.Util.DataWrap;

/**
 *  Java实现冒泡算法
 * @author tom
 */
public class BubbleDemo {

    public static void bubbleSort(DataWrap[] data) {
        System.out.println("开始排序");
        int arrayLength = data.length;
        for (int i = 0; i < arrayLength; i++) {
            for (int j = 0; j < arrayLength - i - 1; j++) {
                if (data[j].compareTo(data[j + 1]) > 0) {
                    DataWrap temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;
                }
            }
            System.out.println(java.util.Arrays.toString(data));
        }
    }

    public static void main(String[] args) {
        DataWrap[] data = { 
                new DataWrap(19, ""), 
                new DataWrap(45, ""), 
                new DataWrap(16, ""), 
                new DataWrap(21, "*"),
                new DataWrap(23, ""), 
                new DataWrap(21, ""),
                new DataWrap(30, ""),};
        System.out.println("排序之前");
        System.out.println(java.util.Arrays.toString(data));
        bubbleSort(data);
        System.out.println("排序完成");
        System.out.println(java.util.Arrays.toString(data));
    }
}

 

程序输出结果：

排序之前
[19, 45, 16, 21*, 23, 21, 30]
开始排序
[19, 16, 21*, 23, 21, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
[16, 19, 21*, 21, 23, 30, 45]
排序完成
[16, 19, 21*, 21, 23, 30, 45]