排序:一. 冒泡排序 (前往后所有未排序的元素相邻比较)

系列文章共实现了六种排序算法:

  1. 冒泡排序
  2. 直接选择排序
  3. 插入排序
  4. 归并排序
  5. 快速排序
  6. 堆排序

定义了 Sortable 接口,每种排序方法实现该接口,在 sort 方法中实现排序。

public interface Sortable<T> {

    /**
     * 将数组进行排序
     *
     * @param sour       待排序的数组
     * @param comparator 排序规则
     * @return 数组中元素交换次数
     */
    int sort(T[] sour, Comparator<T> comparator);

}

测试示例如下:

public class Test {

    public static void main(String[] args) {

        Integer[] s = {1, 8, 9, 4, 3, 4, 3, 2, 1};
        Integer[] s1 = {1, 2, 4, 3, 5, 7};
        Integer[] s2 = {1, -2, 22223, 489, 335, 23437, 3, 4, 56, 76, 98, 12, 3421, 654};
        Integer[] s3 = P.getRandomArrays(1000, 10000);
        test2(s2);
    }

    // 测试堆排序
    private static void test2(Integer[] sour) {
        HeapSort heapSort = new HeapSort();
        P.out(sour);
        heapSort.sort(new MiniArrayHeap<>(), sour);
        P.out(sour);
    }

    private static void test1(Integer[] sour) {
        test(new SelectionSort<>(), sour); // 升序 交换 1 次
        test(new SelectionSort<>(), sour); // 升序 交换 5 次
    }

    private static <T extends Comparable> void test(Sortable<T> sortable, T... ts) {
        P.out(sortable.sort(ts, T::compareTo));
        P.out(Arrays.toString(ts));
    }

}
排序算法的稳定性

假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,ri=rj,且ri在rj之前,而在排序后的序列中,ri仍在rj之前,则称这种排序算法是稳定的;否则称为不稳定的。

稳定性的好处。排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。

正文

参考文章

时间复杂度O(n2),最好情况O(n),最坏情况O(n2),稳定。

适合数据规模很小的时候,而且它的效率也比较低。

通过重复地走访要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。

算法描述如下

1. 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤,除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

BubbleSort sort 方法实现如下:
image.png

代码已上传 GitHub ,可以在 这里 找到

展开阅读全文
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值