排序算法之冒泡排序，选择排序以及堆排序

江海i

已于 2022-05-06 15:27:06 修改

阅读量215

点赞数

分类专栏： 2022 # 算法文章标签：算法排序算法 java

于 2022-05-02 14:54:03 首次发布

本文链接：https://blog.csdn.net/weixin_44289860/article/details/124526687

版权

2022 同时被 2 个专栏收录

67 篇文章 2 订阅

订阅专栏

算法

12 篇文章 0 订阅

订阅专栏

以下的排序算法都是以升序为准。

1. 排序（Sorting）

即将一个组无序的数据，排序成为升序或者降序。

1.1 排序算法分类

在这里插入图片描述

1.2 排序算法的稳定性（Stability）

如果相等的2个元素，在排序前后的相对位置保存不变，那么这是稳定的排序算法。

例如：

排序前：5 1 3a 4 7 3b;
稳定的排序：1 3a 3b 4 5 7;
不稳定的排序：1 3b 3a 4 5 7;

1.3 原地算法（In-place Algorithm）

不依赖额外的资源或者依赖少数的额外资源，仅依靠输出来覆盖输入。空间复杂度为**O(1)**的可以认为是原地算法。

2. 公共父类

为了便于比较多种不同的排序方法的效率，抽取一个公共的父类。后面的排序算法，直接继承父类然后实现自己的sort方法即可。

/**
 * @Description 排序算法公共父类
 * @date 2022/5/2 9:17
 */
public abstract class Sort<T extends Comparable<T>> implements Comparable<Sort<T>>{

    // 数组
    protected T[] arr;
    // 比较次数
    private int cmpCount;
    // 交换次数
    private int swapCount;
    // 执行时间
    private long time;
    // 小数点格式化
    private DecimalFormat fmt = new DecimalFormat("#.00");

    // 父类构造函数，调用sort方法，由子类去实现
    public void sort(T[] arr){
        if (arr == null || arr.length < 2) return;
        this.arr = arr;
        long begin = System.currentTimeMillis();
        sort();
        time  = System.currentTimeMillis() - begin;
    }

    /**
     * 比较方法，按照时间 - 比较次数 - 交换次数。
     * @param o
     * @return
     */
    @Override
    public int compareTo(Sort<T> o) {
        int result = (int) (time - o.time);
        if (result != 0) return  result;

        result = cmpCount - o.cmpCount;
        if (result != 0) return result;

        result = swapCount - o.swapCount;
        return result;
    }

    /**
     * 子类实现方法
     */
    protected abstract void sort();

    /**
     * 比较索引位置的大小
     * @param i1 索引1
     * @param i2 索引2
     * @return 等于0 : i1 == i2 ; 小于0 i1 < i2 ; 大于0 i1 > i2
     */
    protected int cmp(int i1, int i2){
        cmpCount++;
        return arr[i1].compareTo(arr[i2]);
    }

    /**
     * 比较元素的大小
     * @param v1 值1
     * @param v2 值2
     * @return 等于0 : i1 == i2 ; 小于0 i1 < i2 ; 大于0 i1 > i2
     */
    protected int cmp(T v1, T v2){
        cmpCount++;
        return v1.compareTo(v2);
    }

    /**
     * 交换索引位置的元素
     * @param i1 索引1
     * @param i2 索引2
     */
    protected void swap(int i1, int i2){
        swapCount++;
        T tmp = arr[i1];
        arr[i1] = arr[i2];
        arr[i2] = tmp;
    }

    /**
     * 将传入较长的数转为位数
     * @param number
     * @return
     */
    private String numberString(int number) {
        if (number < 10000) return "" + number;

        if (number < 100000000) return fmt.format(number / 10000.0) + "万";
        return fmt.format(number / 100000000.0) + "亿";
    }

    /**
     * 判断稳定性
     * @return
     */
    private boolean isStable(){
        // 根据student类型测试，如果年龄相同的分数呈递增状态则是稳定性排序。
        Student[] students = new Student[20];
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student(i * 10, 10);
        }
        sort((T[]) students);
        for (int i = 1; i < students.length; i++) {
            int score = students[i].score;
            int prevScore = students[i - 1].score;
            if (score != prevScore + 10) return false;
        }
        return true;
    }

    @Override
    public String toString() {
        String timeStr = "耗时：" + (time / 1000.0) + "s(" + time + "ms)";
        String compareCountStr = "比较：" + numberString(cmpCount);
        String swapCountStr = "交换：" + numberString(swapCount);
        String stableStr = "稳定性：" + isStable() + " ";
        return "【" + getClass().getSimpleName() + "】\n"
                + stableStr + " \t"
                + timeStr + " \t"
                + compareCountStr + "\t "
                + swapCountStr + "\n"
                + "------------------------------------------------------------------";
    }
}

Student

/**
 * @Description
 * @date 2022/5/2 14:43
 */
public class Student implements Comparable<Student> {
    public int score;
    public int age;

    public Student(int score, int age) {
        this.score = score;
        this.age = age;
    }

    @Override
    public int compareTo(Student o) {
        return age - o.age;
    }
}

3. 冒泡排序（Bubble Sort）

最坏合平均的时间复杂度为O( n² )；空间复杂度为O(1)。

从头开始比较相邻的元素，如果第二个比第一个大，交换他们的位置；
第一轮结束后，最大的元素位于末尾；
循环 1 步骤。

/**
 * @Description 冒泡排序
 * @date 2022/5/1 14:35
 */
public class BubbleSort<T extends Comparable<T>> extends Sort<T> {
    @Override
    protected void sort() {
        for (int end = arr.length - 1; end > 0; end--) {
            for (int begin = 1; begin <= end; begin++) {
                if (cmp(begin,begin - 1) < 0){
                    swap(begin,begin - 1);
                }
            }
        }
    }
}

3.1 优化冒泡排序

3.1.2 提前有序退出

如果数据已经完全有序，可以提前终止。

/**
 * @Description 冒泡排序有序退出
 * @date 2022/5/2 9:30
 */
public class BubbleSortStop<T extends Comparable<T>> extends Sort<T>{
    @Override
    protected void sort() {
        for (int end = arr.length - 1; end > 0; end--) {
            boolean sorted = true;
            for (int begin = 1; begin <= end; begin++) {
                if (cmp(begin, begin - 1) < 0){
                    swap(begin, begin-1);
                    sorted = false;
                }
            }
            if (sorted){
                break;
            }
        }
    }
}

3.1.2 尾部局部有序

如果尾部已经局部有序，记录最后一次交换的位置，减少比较次数。

在这里插入图片描述
如图中，尾部的部分数据已经是有序的，不需要再进行排序。

/**
 * @Description 冒泡优化，如果尾部局部有序，不需要进行比较
 * @date 2022/5/2 9:31
 */
public class BubbleSortNotLast<T extends Comparable<T>> extends Sort<T>{
    @Override
    protected void sort() {
        for (int end = arr.length - 1; end > 0; end--) {
            // 默认为完全有序的情况，如果符合一轮扫描就会退出循环，取值只要 end-- 之后不符合循环条件即可
            int sortIndex = 1;
            for (int begin = 1; begin <= end; begin++) {
                if (cmp(begin, begin - 1) < 0){
                    swap(begin, begin - 1);
                    // 记录最后一次交换的位置
                    sortIndex = begin;
                }
            }
            // 保存到扫描最后的位置
            end = sortIndex;
        }
    }
}

最好的情况下时间复杂度达到O ( n )。

4. 选择排序（Selection Sort）

从序列中找到最大的元素，与最末尾的元素交换位置；第二轮忽略掉第一轮中的最大元素，再找出剩余的最大元素；重复执行。

交换次数少于冒泡，平均性能优于冒泡排序。
最好、最坏和平均时间复杂度为O( n² )；空间复杂度为O( 1 )。

/**
 * @Description 选择排序
 * @date 2022/5/1 16:05
 */
public class SelectionSort<E extends Comparable<E>> extends Sort<E> {
    @Override
    protected void sort() {
        for (int end = arr.length - 1; end > 0; end--) {
            int maxIndex = 0;
            for (int start = 1; start <= end; start++) {
                if (cmp(maxIndex,start) <= 0){ // 如果有索引，大于最大值的索引，重新赋值
                    maxIndex = start;
                }
            }
            swap(maxIndex,end);
        }
    }
}

5. 堆排序（Heap Sort）

选择排序的一种优化。

执行流程：

对序列进行原地建堆；
重复执行：①交换堆顶和尾元素；②堆元素数量减一；③对0位置进行一次下滤操作。

图示：
给定数组：

原地键堆（大顶堆）：

堆对应数组索引：

交换 0 位置和尾元素，堆size - 1，并对新的 0 位置元素进行下滤：

再次进行交换时就可以忽略掉已经排好序的最后一个元素，与倒数第二个进行交换，循环进行，直到堆中元素为1时：

排序完成。

平均时间复杂度为：O(nlogn)，不是一个稳定的排序。

/**
 * @Description 堆排序实现
 * @date 2022/5/2 9:36
 */
public class HeapSort<T extends Comparable<T>> extends Sort<T> {

    // 记录堆元素数量
    private int heapSize;

    @Override
    protected void sort() {
        // 原地建堆
        heapSize = arr.length;
        for (int i = (heapSize >> 1) - 1 ; i >= 0; i--) {
            siftDown(i);
        }

        while (heapSize > 1){
            // 交换堆顶元素和尾部元素，并减一
            swap(0, --heapSize);
            // 0 位置元素下滤
            siftDown(0);
        }
    }

    /**
     * 下滤
     * @param index 下滤索引
     */
    private void siftDown(int index) {
        T element = arr[index];
        int half = heapSize >> 1;
        while (index < half) { // index必须是非叶子节点
            // 默认是左边跟父节点比
            int childIndex = (index << 1) + 1;
            T child = arr[childIndex];
            int rightIndex = childIndex + 1;
            // 右子节点比左子节点大
            if (rightIndex < heapSize &&
                    cmp(arr[rightIndex], child) > 0) {
                child = arr[childIndex = rightIndex];
            }
            // 大于等于子节点
            if (cmp(element, child) >= 0) break;
            arr[index] = child;
            index = childIndex;
        }
        arr[index] = element;
    }
}

6. 测试比较

分别实例化不同的排序类，比较他们的效率。

/**
 * @Description 排序测试
 * @date 2022/5/2 9:20
 */
@SuppressWarnings({"rawtypes","unchecked"})
public class SortMain {
    public static void main(String[] args) {
        Integer[] arr = Integers.random(10000, 1, 2000);
        testSort(new Sort[]{
                new HeapSort(),
                new SelectionSort(),
                new BubbleSort(),
                new BubbleSortStop(),
                new BubbleSortNotLast()
        },arr);
    }

    static void testSort(Sort[] sorts,Integer[] arr){
        for (Sort sort : sorts) {
            Integer[] newArr = Integers.copy(arr);
            sort.sort(newArr);
            System.out.println(sort);
            Asserts.test(Integers.isAscOrder(newArr));
        }
    }
}

比较结果：

7. 工具类使用

https://download.csdn.net/download/weixin_44289860/85262837

江海i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序算法之冒泡排序，选择排序以及堆排序

以下的排序算法都是以升序为准。1. 排序（Sorting）即将一个组无序的数据，排序成为升序或者降序。1.1 排序算法分类1.2 排序算法的稳定性（Stability）如果相等的2个元素，在排序前后的相对位置保存不变，那么这是稳定的排序算法。例如：排序前：5 1 3a 4 7 3b;稳定的排序：1 3a 3b 4 5 7;不稳定的排序：1 3b 3a 4 5 7;1.3 原地算法（In-place Algorithm）不依赖额外的资源或者依赖少数的额外资源，仅依靠输.
复制链接

扫一扫