Python 冒泡排序详解

        冒泡排序是一种简单的排序算法，它重复地遍历要排序的列表，比较相邻元素并交换它们的位置，直到整个列表排序完成。

基本冒泡排序

def bubble_sort_basic(arr):
    """
    基本冒泡排序实现
    """
    n = len(arr)
    
    # 遍历所有数组元素
    for i in range(n):
        # 最后 i 个元素已经排好序
        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

# 测试
numbers = [64, 34, 25, 12, 22, 11, 90]
print("排序前:", numbers)
sorted_numbers = bubble_sort_basic(numbers.copy())
print("排序后:", sorted_numbers)

优化版本

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

# 测试
test_array = [5, 1, 4, 2, 8]
print("优化前排序过程:")
bubble_sort_basic(test_array.copy())
print("\n优化后排序过程:")
bubble_sort_optimized(test_array.copy())

2. 记录最后交换位置优化

def bubble_sort_advanced(arr):
    """
    高级优化版冒泡排序 - 记录最后交换位置
    """
    n = len(arr)
    last_swap = n - 1
    
    while last_swap > 0:
        current_swap = -1
        
        for j in range(0, last_swap):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                current_swap = j  # 记录最后交换的位置
        
        # 如果没有发生交换，提前结束
        if current_swap == -1:
            break
        
        last_swap = current_swap
    
    return arr

完整示例与测试

import random
import time
from typing import List, Callable

def test_bubble_sort():
    """测试不同的冒泡排序实现"""
    
    # 测试数据
    test_cases = [
        [64, 34, 25, 12, 22, 11, 90],
        [5, 2, 8, 1, 9],
        [1],
        [],
        [3, 3, 3, 3],
        [9, 8, 7, 6, 5, 4, 3, 2, 1]  # 逆序
    ]
    
    algorithms = {
        "基本冒泡排序": bubble_sort_basic,
        "优化冒泡排序": bubble_sort_optimized,
        "高级冒泡排序": bubble_sort_advanced
    }
    
    for name, algorithm in algorithms.items():
        print(f"\n{name}:")
        for i, test_case in enumerate(test_cases):
            test_copy = test_case.copy()
            result = algorithm(test_copy)
            print(f"  测试 {i+1}: {test_case} -> {result}")

def performance_comparison():
    """性能比较"""
    print("\n性能比较:")
    
    # 生成测试数据
    sizes = [100, 500, 1000]
    algorithms = {
        "基本冒泡排序": bubble_sort_basic,
        "优化冒泡排序": bubble_sort_optimized
    }
    
    for size in sizes:
        test_data = [random.randint(1, 1000) for _ in range(size)]
        print(f"\n数据量: {size}")
        
        for name, algorithm in algorithms.items():
            data_copy = test_data.copy()
            start_time = time.time()
            algorithm(data_copy)
            end_time = time.time()
            
            print(f"  {name}: {end_time - start_time:.4f} 秒")

# 运行测试
if __name__ == "__main__":
    test_bubble_sort()
    performance_comparison()

可视化冒泡排序过程

def bubble_sort_visual(arr):
    """
    带可视化过程的冒泡排序
    """
    n = len(arr)
    print(f"初始数组: {arr}")
    
    for i in range(n):
        swapped = False
        print(f"\n第 {i+1} 轮遍历:")
        
        for j in range(0, n - i - 1):
            print(f"  比较 {arr[j]} 和 {arr[j+1]}", end="")
            
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
                print(" -> 交换")
            else:
                print(" -> 不交换")
        
        print(f"本轮结果: {arr}")
        
        if not swapped:
            print("已排序完成，提前终止！")
            break
    
    return arr

# 可视化演示
demo_array = [6, 3, 8, 1, 5]
print("冒泡排序可视化过程:")
bubble_sort_visual(demo_array.copy())

冒泡排序类实现

class BubbleSorter:
    """
    冒泡排序器类
    """
    
    def __init__(self):
        self.comparison_count = 0
        self.swap_count = 0
    
    def sort(self, arr: List) -> List:
        """排序方法"""
        self.comparison_count = 0
        self.swap_count = 0
        
        n = len(arr)
        
        for i in range(n):
            swapped = False
            
            for j in range(0, n - i - 1):
                self.comparison_count += 1
                
                if arr[j] > arr[j + 1]:
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]
                    self.swap_count += 1
                    swapped = True
            
            if not swapped:
                break
        
        return arr
    
    def get_stats(self) -> dict:
        """获取排序统计信息"""
        return {
            "comparisons": self.comparison_count,
            "swaps": self.swap_count
        }

# 使用类版本
sorter = BubbleSorter()
test_data = [64, 34, 25, 12, 22, 11, 90]

print("原始数据:", test_data)
sorted_data = sorter.sort(test_data.copy())
print("排序后:", sorted_data)
print("统计信息:", sorter.get_stats())

算法分析

时间复杂度

• 最坏情况: O(n²) - 数组完全逆序

• 最好情况: O(n) - 数组已经排序（优化版本）

• 平均情况: O(n²)

空间复杂度

• O(1) - 原地排序，只需要常数级别的额外空间

稳定性

• 稳定排序算法 - 相等元素的相对顺序保持不变

实际应用场景

虽然冒泡排序在实际应用中很少使用（因为效率较低），但它适用于：

1. 教学目的 - 理解排序算法的基础

2. 小规模数据 - 数据量很小时代码简单

3. 几乎已排序的数据 - 优化版本在这种情况下表现较好

# 实用示例：对学生成绩排序
def sort_student_grades():
    """使用冒泡排序对学生成绩排序"""
    
    students = [
        {"name": "Alice", "grade": 85},
        {"name": "Bob", "grade": 92},
        {"name": "Charlie", "grade": 78},
        {"name": "Diana", "grade": 95},
        {"name": "Eve", "grade": 88}
    ]
    
    # 按成绩排序
    n = len(students)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if students[j]["grade"] > students[j + 1]["grade"]:
                students[j], students[j + 1] = students[j + 1], students[j]
                swapped = True
        if not swapped:
            break
    
    print("按成绩排序的学生:")
    for student in students:
        print(f"  {student['name']}: {student['grade']}")

# 运行示例
sort_student_grades()

        冒泡排序是理解排序算法思想的良好起点，但在实际项目中，通常会选择更高效的算法如快速排序、归并排序或内置的 sorted() 函数。