冒泡排序法（优化与实例演示）

IT小辉同学

于 2023-07-05 22:53:38 发布

阅读量1.1k

点赞数 2

文章标签：排序算法算法数据结构

本文链接：https://blog.csdn.net/weixin_53742691/article/details/131565339

版权

在这里插入图片描述

冒泡排序法

冒泡排序法基本介绍

冒泡排序是一种简单而经典的排序算法，它的原理是通过不断比较相邻元素的大小并交换位置，将较大（或较小）的元素逐渐“冒泡”到数组的末尾。这个过程持续进行多轮，直到整个数组按照顺序排列。

下面是冒泡排序的基本步骤：

从数组的第一个元素开始，依次比较相邻的两个元素。
如果前一个元素大于后一个元素，就交换它们的位置。
继续向后比较，直到最后一个元素。
一轮比较完成后，最大的元素将会“冒泡”到数组的最后位置。
重复上述步骤，但这次比较的次数少一次（因为最后一个元素已经排好序）。
重复进行多轮比较和交换，直到整个数组排序完成。

冒泡排序的时间复杂度为O(n^2)，其中n是待排序数组的长度。尽管冒泡排序的时间复杂度较高，但它的实现简单直观，特别适用于待排序数组元素个数较少的情况。

需要注意的是，冒泡排序是一种稳定排序算法，即相等元素的相对顺序在排序后保持不变。

冒泡排序法实际用例

这里我给你一个使用冒泡排序算法的实际用例，以对一个整数数组进行排序为例。假设我们有以下的整数数组：

[5, 2, 9, 1, 3]

使用冒泡排序算法，我们可以按照从小到大的顺序对该数组进行排序。下面是这个例子的排序过程：

第一轮：

比较 5 和 2，交换它们的位置，数组变为 [2, 5, 9, 1, 3]

比较 5 和 9，不需要交换位置

比较 9 和 1，交换它们的位置，数组变为 [2, 5, 1, 9, 3]

比较 9 和 3，交换它们的位置，数组变为 [2, 5, 1, 3, 9]

第一轮完成后，最大的元素 9 已经“冒泡”到数组的末尾。
第二轮：

比较 2 和 5，不需要交换位置

比较 5 和 1，交换它们的位置，数组变为 [2, 1, 5, 3, 9]

比较 5 和 3，交换它们的位置，数组变为 [2, 1, 3, 5, 9]

第二轮完成后，第二大的元素 5 也已经“冒泡”到了倒数第二个位置。
第三轮：

比较 2 和 1，交换它们的位置，数组变为 [1, 2, 3, 5, 9]

比较 2 和 3，不需要交换位置

第三轮完成后，第三大的元素 3 也已经“冒泡”到了倒数第三个位置。
第四轮：

比较 1 和 2，不需要交换位置

第四轮完成后，第四大的元素 2 也已经“冒泡”到了倒数第四个位置。

经过多轮的比较和交换，整个数组已经按照从小到大的顺序完成了排序。最终的排序结果为：[1, 2, 3, 5, 9]。

冒泡排序法代码演示

我将为你提供在Python、Java和JavaScript中演示冒泡排序算法的代码示例。

Python代码示例：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        # 进行一轮冒泡
        for j in range(0, n-i-1):
            # 比较相邻两个元素
            if arr[j] > arr[j+1]:
                # 交换位置
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 示例用法
arr = [5, 2, 9, 1, 3]
bubble_sort(arr)
print("排序结果：", arr)

Java代码示例：

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n; i++) {
            // 进行一轮冒泡
            for (int j = 0; j < n-i-1; j++) {
                // 比较相邻两个元素
                if (arr[j] > arr[j+1]) {
                    // 交换位置
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    // 示例用法
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 3};
        bubbleSort(arr);
        System.out.println("排序结果：");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

JavaScript代码示例：

function bubbleSort(arr) {
    var n = arr.length;
    for (var i = 0; i < n; i++) {
        // 进行一轮冒泡
        for (var j = 0; j < n-i-1; j++) {
            // 比较相邻两个元素
            if (arr[j] > arr[j+1]) {
                // 交换位置
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

// 示例用法
var arr = [5, 2, 9, 1, 3];
bubbleSort(arr);
console.log("排序结果：", arr);

这些代码示例演示了如何在Python、Java和JavaScript中实现冒泡排序算法。你可以根据需要选择相应的代码示例来运行和测试。

冒泡排序法优化

冒泡排序是一种简单但效率较低的排序算法。虽然它可以通过一些优化来提高性能，但在处理大规模数据集时，仍然不是最优的选择。下面是一些常见的优化技巧：

添加一个标志位：在每一轮冒泡开始之前，设置一个标志位来表示该轮是否有元素交换位置。如果这一轮没有发生任何交换，意味着数组已经有序，可以提前结束排序循环。
记录最后交换位置：记录每一轮最后一个发生交换的位置，该位置后面的元素已经有序。下一轮排序只需要比较到这个位置即可，减少不必要的比较次数。
优化边界：在每一轮冒泡过程中，通过减少比较的次数来优化边界。每一轮冒泡的交换操作会将当前最大（或最小）值冒泡到尾部，下一轮的边界可以缩小到上一轮最后发生交换的位置。
针对已经有序部分的优化：在每一轮冒泡中，可以记录当前轮是否有元素交换，如果没有发生交换，则说明已经有序部分的元素已经就位，不需要再次比较。
鸡尾酒排序：针对大部分元素已经有序的情况，可以使用鸡尾酒排序（双向冒泡排序）。该算法从左到右进行一轮冒泡，然后再从右到左进行一轮冒泡，交替进行，可以更快地将较大和较小的元素分别冒泡到数组的两端。

尽管以上优化可以提高冒泡排序的性能，但冒泡排序的时间复杂度仍然是O(n^2)，其中n是待排序数组的长度。如果需要处理大规模数据集，更高效的排序算法如快速排序、归并排序或堆排序可能更合适。

优化思路举例演示

我将为你提供使用Python代码演示冒泡排序算法的优化方法。

优化方法一：添加一个标志位

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        # 设置标志位
        swapped = False
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True
        # 判断是否发生交换，如果没有交换则数组已经有序，提前结束排序循环
        if not swapped:
            break

# 示例用法
arr = [5, 2, 9, 1, 3]
bubble_sort(arr)
print("排序结果：", arr)

优化方法二：记录最后交换位置

def bubble_sort(arr):
    n = len(arr)
    last_swap = n - 1  # 最后交换位置的初始值
    while last_swap > 0:
        new_last_swap = 0
        for i in range(last_swap):
            if arr[i] > arr[i+1]:
                arr[i], arr[i+1] = arr[i+1], arr[i]
                new_last_swap = i  # 更新最后交换位置
        last_swap = new_last_swap

# 示例用法
arr = [5, 2, 9, 1, 3]
bubble_sort(arr)
print("排序结果：", arr)

优化方法三：优化边界

def bubble_sort(arr):
    n = len(arr)
    left = 0
    right = n - 1
    while left < right:
        for i in range(left, right):
            if arr[i] > arr[i+1]:
                arr[i], arr[i+1] = arr[i+1], arr[i]
        right -= 1
        for i in range(right, left, -1):
            if arr[i] < arr[i-1]:
                arr[i], arr[i-1] = arr[i-1], arr[i]
        left += 1

# 示例用法
arr = [5, 2, 9, 1, 3]
bubble_sort(arr)
print("排序结果：", arr)

优化方法四：针对已经有序部分的优化

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
                swapped = True
        if not swapped:
            break

# 示例用法
arr = [5, 2, 9, 1, 3]
bubble_sort(arr)
print("排序结果：", arr)