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),不适合处理大规模数据。
  • 效率较低:相比于其他排序算法(如快速排序、归并排序),冒泡排序的效率较低。
相关推荐
葵野寺10 分钟前
【多线程】线程池
java·开发语言·java-ee·web app
十六ᵛᵃᵉ10 分钟前
day6_FlinkSQL实战
java·redis·ajax
无难事者若执15 分钟前
新手村:逻辑回归-理解03:逻辑回归中的最大似然函数
算法·机器学习·逻辑回归
写代码写到手抽筋19 分钟前
C++多线程的性能优化
java·c++·性能优化
高林雨露22 分钟前
Java 与 Kotlin 对比学习指南(二)
java·开发语言·kotlin
IT从业者张某某32 分钟前
机器学习-04-分类算法-03KNN算法案例
算法·机器学习·分类
chen_song_35 分钟前
WebRTC的ICE之TURN协议的交互流程中继转发Relay媒体数据的turnserver的测试
算法·音视频·webrtc·交互·媒体
martian66544 分钟前
Maven核心配置文件深度解析:pom.xml完全指南
java·开发语言
蒙奇D索大1 小时前
【数据结构】图解图论:度、路径、连通性,五大概念一网打尽
数据结构·考研·算法·图论·改行学it
bing_1581 小时前
JVM 每个区域分别存储什么数据?
java·jvm