java实现冒泡排序算法

目录

[1. 冒泡排序原理](#1. 冒泡排序原理)

[2. Java 代码实现](#2. Java 代码实现)

[3. 时间复杂度分析](#3. 时间复杂度分析)

[4. 空间复杂度分析](#4. 空间复杂度分析)

[5. 实际例子](#5. 实际例子)

[6. 冒泡排序的优势和劣势](#6. 冒泡排序的优势和劣势)

优势

劣势


1. 冒泡排序原理

冒泡排序的基本思想是通过多次遍历待排序的数组,每次比较相邻的两个元素,如果它们的顺序错误就交换它们的位置。这个过程会使得每一轮遍历后最大的元素"浮"到数组的末尾。具体步骤如下:

  1. 遍历数组:从第一个元素开始,比较相邻的两个元素。
  2. 比较和交换:如果前一个元素大于后一个元素,则交换它们的位置。
  3. 重复步骤:重复上述过程,直到数组完全排序。
2. Java 代码实现

下面是冒泡排序的 Java 实现:

java 复制代码
public class BubbleSort {

    // 冒泡排序方法
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;
        
        // 外层循环控制遍历次数
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            // 内层循环进行相邻元素的比较和交换
            for (int j = 0; j < n - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }
            // 如果在这一轮遍历中没有发生交换,说明数组已经有序,提前结束
            if (!swapped) {
                break;
            }
        }
    }

    // 主方法,用于测试
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        System.out.println("Original array:");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("Sorted array:");
        printArray(arr);
    }

    // 辅助方法,用于打印数组
    public static void printArray(int[] arr) {
        for (int num : arr) {
            System.out.print(num + " ");
        }
        System.out.println();
    }
}
3. 时间复杂度分析

冒泡排序的时间复杂度如下:

  • 最佳情况:如果数组已经是有序的,冒泡排序的时间复杂度为 O(n)O(n),因为只需要一次遍历就能确认数组已经排序。
  • 最坏情况:如果数组是逆序的,冒泡排序的时间复杂度为 O(n2)O(n2),因为需要进行 n×(n−1)n×(n−1) 次比较和交换。
  • 平均情况:冒泡排序的时间复杂度为 O(n2)O(n2)。
4. 空间复杂度分析

冒泡排序的空间复杂度为 O(1)O(1),因为它是一个原地排序算法,不需要额外的存储空间。

5. 实际例子

我们可以通过一个具体的例子来理解冒泡排序的过程:

假设有一个数组 [64, 34, 25, 12, 22, 11, 90],冒泡排序的过程如下:

  1. 第一轮遍历

    • 比较 64 和 34,交换位置:[34, 64, 25, 12, 22, 11, 90]
    • 比较 64 和 25,交换位置:[34, 25, 64, 12, 22, 11, 90]
    • 比较 64 和 12,交换位置:[34, 25, 12, 64, 22, 11, 90]
    • 比较 64 和 22,交换位置:[34, 25, 12, 22, 64, 11, 90]
    • 比较 64 和 11,交换位置:[34, 25, 12, 22, 11, 64, 90]
    • 比较 64 和 90,不交换位置:[34, 25, 12, 22, 11, 64, 90]
  2. 第二轮遍历

    • 比较 34 和 25,交换位置:[25, 34, 12, 22, 11, 64, 90]
    • 比较 34 和 12,交换位置:[25, 12, 34, 22, 11, 64, 90]
    • 比较 34 和 22,交换位置:[25, 12, 22, 34, 11, 64, 90]
    • 比较 34 和 11,交换位置:[25, 12, 22, 11, 34, 64, 90]
    • 比较 34 和 64,不交换位置:[25, 12, 22, 11, 34, 64, 90]
  3. 第三轮遍历

    • 比较 25 和 12,交换位置:[12, 25, 22, 11, 34, 64, 90]
    • 比较 25 和 22,交换位置:[12, 22, 25, 11, 34, 64, 90]
    • 比较 25 和 11,交换位置:[12, 22, 11, 25, 34, 64, 90]
    • 比较 25 和 34,不交换位置:[12, 22, 11, 25, 34, 64, 90]
  4. 第四轮遍历

    • 比较 12 和 22,不交换位置:[12, 22, 11, 25, 34, 64, 90]
    • 比较 22 和 11,交换位置:[12, 11, 22, 25, 34, 64, 90]
    • 比较 22 和 25,不交换位置:[12, 11, 22, 25, 34, 64, 90]
  5. 第五轮遍历

    • 比较 12 和 11,交换位置:[11, 12, 22, 25, 34, 64, 90]
    • 比较 12 和 22,不交换位置:[11, 12, 22, 25, 34, 64, 90]
  6. 第六轮遍历

    • 比较 11 和 12,不交换位置:[11, 12, 22, 25, 34, 64, 90]

最终,数组 [64, 34, 25, 12, 22, 11, 90] 被排序为 [11, 12, 22, 25, 34, 64, 90]

6. 冒泡排序的优势和劣势
优势
  • 简单易懂:冒泡排序的逻辑简单,容易理解和实现。
  • 适应性:对于部分有序的数组,冒泡排序可以提前结束,效率较高。
劣势
  • 时间复杂度高:在最坏情况下,时间复杂度为 O(n2),不适合处理大规模数据。
  • 效率较低:相比于其他排序算法(如快速排序、归并排序),冒泡排序的效率较低。
相关推荐
m0Java门徒几秒前
面向对象编程核心:封装、继承、多态与 static 关键字深度解析
java·运维·开发语言·intellij-idea·idea
无心水26 分钟前
【Java面试笔记:基础】8.对比Vector、ArrayList、LinkedList有何区别?
java·笔记·面试·vector·arraylist·linkedlist
创码小奇客1 小时前
MongoDB 时间序列:解锁数据时光机的终极指南
java·mongodb·trae
黯_森1 小时前
Java面向对象
java·后端
代码小侦探1 小时前
Java中以Maven方式引入Oracle JDBC Driver依赖的详解
java·oracle·maven
不畏惧的少年1 小时前
AQS的底层实现原理
java
洛小豆1 小时前
饭票、图书馆、GC:这样理解 Java 引用,谁还不会?
java·后端·面试
梁下轻语的秋缘1 小时前
每日c/c++题 备战蓝桥杯 ([洛谷 P1226] 快速幂求模题解)
c++·算法·蓝桥杯
CODE_RabbitV1 小时前
【深度强化学习 DRL 快速实践】逆向强化学习算法 (IRL)
算法
SimonLiu0091 小时前
清理HiNas(海纳斯) Docker日志并限制日志大小
java·docker·容器