java实现冒泡排序算法

目录

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

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

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

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

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

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

优势

劣势

---

1. 冒泡排序原理

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

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

2. 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)，不适合处理大规模数据。
• 效率较低：相比于其他排序算法（如快速排序、归并排序），冒泡排序的效率较低。