算法可视化教学：冒泡排序的10种实现方式

最新推荐文章于 2026-06-27 19:41:07 发布

原创最新推荐文章于 2026-06-27 19:41:07 发布 · 842 阅读

19 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#算法

C 专栏收录该内容

287 篇文章

订阅专栏

🎓博主介绍：精通 C、Python、Java、JavaScript 等编程语言，具备全栈开发能力。日常专注于分享编程干货、算法解析、项目实战经验，以及前沿技术动态。让我们一起在技术的道路上不断探索，共同成长！

算法可视化教学：冒泡排序的10种实现方式

一、引言

冒泡排序作为一种基础且经典的排序算法，以其简单易懂的思想成为算法学习的入门之选。然而，看似简单的冒泡排序，实际上可以通过多种不同的实现方式来完成。深入了解这些不同的实现方式，不仅能加深我们对冒泡排序算法本身的理解，还能锻炼我们的编程思维和解决问题的能力。此外，结合算法可视化教学，能让我们更直观地看到排序过程，进一步提升学习效果。本文将详细介绍冒泡排序的10种实现方式，并对每种实现方式进行分析。

二、冒泡排序基础概念

（一）算法原理

冒泡排序的基本思想是重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

（二）示例过程

假设有一个数组 [5, 3, 8, 4, 2]，进行冒泡排序的过程如下：

第一轮：比较相邻元素，5 和 3 交换，得到 [3, 5, 8, 4, 2]；5 和 8 不交换；8 和 4 交换，得到 [3, 5, 4, 8, 2]；8 和 2 交换，得到 [3, 5, 4, 2, 8]，最大的数 8 已经“浮”到了最后。
第二轮：比较 3 和 5 不交换；5 和 4 交换，得到 [3, 4, 5, 2, 8]；5 和 2 交换，得到 [3, 4, 2, 5, 8]。
第三轮：比较 3 和 4 不交换；4 和 2 交换，得到 [3, 2, 4, 5, 8]。
第四轮：比较 3 和 2 交换，得到 [2, 3, 4, 5, 8]，排序完成。

三、冒泡排序的10种实现方式

（一）基本冒泡排序

def bubble_sort_basic(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]
    return arr

分析：这是最基本的冒泡排序实现方式，通过两层嵌套循环，外层循环控制排序的轮数，内层循环进行相邻元素的比较和交换。时间复杂度为 $O(n^2)$ ，空间复杂度为 $O (1)$ 。

（二）优化版冒泡排序（提前终止）

def bubble_sort_optimized(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
    return arr

分析：在基本冒泡排序的基础上，增加了一个标志变量 swapped。如果在某一轮排序中没有发生元素交换，说明数组已经有序，可以提前终止排序，减少不必要的比较。

（三）双向冒泡排序（鸡尾酒排序）

def cocktail_sort(arr):
    left = 0
    right = len(arr) - 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
    return arr

分析：双向冒泡排序在每一轮排序中，既从左到右比较和交换元素，也从右到左比较和交换元素，这样可以更快地将较大和较小的元素放到正确的位置，减少排序的轮数。

（四）递归冒泡排序

def recursive_bubble_sort(arr, n):
    if n == 1:
        return arr
    for i in range(n - 1):
        if arr[i] > arr[i + 1]:
            arr[i], arr[i + 1] = arr[i + 1], arr[i]
    return recursive_bubble_sort(arr, n - 1)

分析：递归冒泡排序通过递归的方式实现冒泡排序，每次递归将问题规模缩小，直到数组有序。递归的终止条件是数组长度为 1。

（五）带边界标记的冒泡排序

def bubble_sort_with_boundary(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
    return arr

分析：记录最后一次交换的位置，下次排序时只需要比较到该位置即可，避免了对已经有序部分的重复比较。

（六）奇偶冒泡排序

def odd_even_sort(arr):
    is_sorted = False
    while not is_sorted:
        is_sorted = True
        # 奇数位置比较
        for i in range(1, len(arr) - 1, 2):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                is_sorted = False
        # 偶数位置比较
        for i in range(0, len(arr) - 1, 2):
            if arr[i] > arr[i + 1]:
                arr[i], arr[i + 1] = arr[i + 1], arr[i]
                is_sorted = False
    return arr

分析：奇偶冒泡排序将排序过程分为奇数位置和偶数位置的比较，交替进行，直到数组有序。

（七）链表实现的冒泡排序

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

def bubble_sort_linked_list(head):
    if not head or not head.next:
        return head
    end = None
    while end != head.next:
        p = head
        while p.next != end:
            q = p.next
            if p.val > q.val:
                p.val, q.val = q.val, p.val
            p = p.next
        end = p
    return head

分析：对于链表结构的数组，通过链表节点的比较和值的交换来实现冒泡排序。

（八）逆序冒泡排序

def reverse_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]
    return arr

分析：与基本冒泡排序相反，逆序冒泡排序将较大的元素“沉”到数组的前端，实现降序排序。

（九）带比较函数的冒泡排序

def bubble_sort_with_comparator(arr, comparator):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if comparator(arr[j], arr[j + 1]):
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

# 示例比较函数（升序）
def ascending_comparator(a, b):
    return a > b

分析：通过传入比较函数，可以灵活地控制排序的规则，不仅可以实现升序和降序排序，还可以对自定义对象进行排序。

（十）并发冒泡排序（多线程实现）

import threading

def parallel_bubble_sort(arr, chunk_size):
    num_chunks = len(arr) // chunk_size
    threads = []

    def sort_chunk(start, end):
        for i in range(end - start):
            for j in range(start, end - i - 1):
                if arr[j] > arr[j + 1]:
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]

    # 创建并启动线程
    for i in range(num_chunks):
        start = i * chunk_size
        end = start + chunk_size
        thread = threading.Thread(target=sort_chunk, args=(start, end))
        threads.append(thread)
        thread.start()

    # 等待所有线程完成
    for thread in threads:
        thread.join()

    # 合并排序结果
    for i in range(1, num_chunks):
        start = i * chunk_size
        for j in range(start, min(start + chunk_size, len(arr))):
            for k in range(j, 0, -1):
                if arr[k] < arr[k - 1]:
                    arr[k], arr[k - 1] = arr[k - 1], arr[k]

    return arr