java基础算法系列(二)冒泡排序的优化讲解(鸡尾酒算法)

简介: java基础算法系列(二)冒泡排序的优化讲解(鸡尾酒算法)

上一篇文章我们讲解了冒泡排序的简单优化,但是这个优化我们还是能发现问题,那就是我们只注意了到了从前往后进行冒泡排序,而从后往前排序也是可以的,那么我们可以来了解一下鸡尾酒排序。

鸡尾酒排序:

鸡尾酒排序又称双向冒泡排序、鸡尾酒搅拌排序、搅拌排序、涟漪排序、来回排序或快乐小时排序,鸡尾酒排序是冒泡排序的一种变形。该算法与一般的冒泡排序的不同处在于排序时是以双向在序列中进行排序。

其每一趟排序都可以将当前的最大值和最小值放置到正确的位置.传统的鸡尾酒排序 算法即使引入了标志是否交换的变量来记录前一趟数据是否发生交换从而确定排序是否结束,也无法处理前一趟排序有数据交换但是某些连续的数据存储子区间无交 换的情况.为了有效降低不必要的比较,引入了一种鸡尾酒排序算法的改进算法.

public static void main(String[] args) {
        int[] arr = { 1, 3, 4, 2, 6, 7, 8, 0, 5 };
        // 将最小值排到队尾
        long startTime = System.nanoTime(); // 获取开始时间
        for (int i = 0; i < arr.length / 2; i++) {
            for (int j = i; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 将最大值排到队头
            for (int j = arr.length - 1 - (i + 1); j > i; j--) {
                if (arr[j] < arr[j - 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        long endTime = System.nanoTime(); // 获取结束时间
        System.out.println("排序結果:" + Arrays.toString(arr));
        System.out.println("程序运行时间: " + (endTime - startTime) + "ns");
    }

打印结果

排序結果:[0, 1, 2, 3, 4, 5, 6, 7, 8]
程序运行时间:3600ns

那么我们上述鸡尾酒算法是否也能优化一下呢?我们来可以试试在左右起始位置定义一个索引,然后定义循环的方向,在每一个大循环中依次进行小循环,由于while循环比较好写,这里用了while循环。

改造后代码如下:

public static void main(String[] args) {
        int[] arr = { 1, 2, 4, 3, 6, 7, 8, 0, 5, 9 };
        int left = 0; // 左向循环起始位置
        int right = arr.length - 1; // 右向循环起始位置
        boolean leftToRight = true; // 循环方向
        long startTime = System.nanoTime(); // 获取开始时间
        while (left < right) {
            if (leftToRight) {
                // 从左到右,依次比较大小,排序完得到该趟排序右边最大值
                for (int i = left; i < right; i++) {
                    if (arr[i] > arr[i + 1]) {
                        arr[i] = arr[i] ^ arr[i + 1];
                        arr[i + 1] = arr[i] ^ arr[i + 1];
                        arr[i] = arr[i] ^ arr[i + 1];
                    }
                }
                right--;
                leftToRight = false;
            } else {
                // 从右到左,依次比较大小,排序完得到该趟排序左边最小值
                for (int j = right; j > left; j--) {
                    if (arr[j - 1] > arr[j]) {
                        arr[j - 1] = arr[j - 1] ^ arr[j];
                        arr[j] = arr[j - 1] ^ arr[j];
                        arr[j - 1] = arr[j - 1] ^ arr[j];
                    }
                }
                left++;
                leftToRight = true;
            }
        }
        long endTime = System.nanoTime(); // 获取结束时间
        System.out.println("排序結果:" + Arrays.toString(arr));
        System.out.println("程序运行时间: " + (endTime - startTime) + "ns");
    }

打印结果如下:

排序結果:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
程序运行时间:2300ns

有人会说,上面的代码优化了吗,第一个鸡尾酒算法经过计算一共进入了12次循环,第二个则进入了11次,根据数据的不同而异。效率有些许的提升。

本章节是来自整理的java基础算法的第二节。你看完本系列文章,是不是感觉面试offer又能多2K!!


相关文章
|
4天前
|
缓存 Java
深入理解Java并发编程:线程池的应用与优化
【5月更文挑战第30天】本文将深入探讨Java并发编程中的一个重要主题——线程池。我们将详细解析线程池的概念、应用及其优化方法,帮助读者更好地理解和使用线程池,提高程序的性能和效率。
|
2天前
|
搜索推荐 算法 Java
JAVA中的交换类排序算法详解
JAVA中的交换类排序算法详解
7 1
|
2天前
|
搜索推荐 算法 Java
JAVA中的排序算法详解与实战
JAVA中的排序算法详解与实战
6 1
|
2天前
|
算法 Java
JAVA中实现最短距离算法——Dijkstra算法详解
JAVA中实现最短距离算法——Dijkstra算法详解
4 1
|
2天前
|
算法 Java
JAVA中的递推算法及其应用
JAVA中的递推算法及其应用
5 1
|
3天前
|
安全 Java 编译器
Java并发编程中的锁优化策略
【5月更文挑战第30天】 在多线程环境下,确保数据的一致性和程序的正确性是至关重要的。Java提供了多种锁机制来管理并发,但不当使用可能导致性能瓶颈或死锁。本文将深入探讨Java中锁的优化策略,包括锁粗化、锁消除、锁降级以及读写锁的使用,以提升并发程序的性能和响应能力。通过实例分析,我们将了解如何在不同场景下选择和应用这些策略,从而在保证线程安全的同时,最小化锁带来的开销。
|
3天前
|
安全 Java 开发者
Java中的并发编程优化技巧
在当今软件开发领域,多核处理器和分布式系统的普及使得并发编程成为了必不可少的技能。本文将介绍一些Java中的并发编程优化技巧,涵盖了线程管理、锁机制、并发集合等方面的内容,帮助开发者更好地应对并发编程中的挑战。
|
4天前
|
安全 Java 开发者
Java并发编程中的锁优化策略
【5月更文挑战第30天】 在Java并发编程领域,锁机制是实现线程同步的关键手段之一。随着JDK版本的发展,Java虚拟机(JVM)为提高性能和降低延迟,引入了多种锁优化技术。本文将深入探讨Java锁的优化策略,包括偏向锁、轻量级锁以及自旋锁等,旨在帮助开发者更好地理解和应用这些高级特性以提升应用程序的性能。
|
4天前
|
监控 算法 Java
深入理解Java并发编程:线程池的应用与优化
【5月更文挑战第30天】 在Java开发中,线程是实现并发处理的基础。然而,随着系统复杂性的增加和资源管理的需要,合理利用线程池已成为提升性能、保证系统稳定性的关键策略。本文将探讨线程池的核心原理,分析其应用场景,并提出优化线程池性能的实践建议,旨在帮助开发者更高效地使用Java进行并发编程。
|
4天前
|
Java 编译器
Java并发编程中的锁优化策略
【5月更文挑战第30天】在Java并发编程中,锁是一种重要的同步机制,用于保护共享资源。然而,不当的使用可能导致性能下降,甚至死锁。本文将探讨Java并发编程中的锁优化策略,包括锁粗化、锁消除、锁降级等方法,以提高程序的性能。