Python排序工具案例如何封装排序算法

本文目录导读：

1. 基础封装类
2. 策略模式封装
3. 装饰器封装
4. 链式调用封装
5. 使用示例

我来给你介绍几种封装排序算法的Python实现方式：

基础封装类

class Sorter:
    """基础排序器类"""
    def __init__(self, algorithm='quick'):
        self.algorithm = algorithm
        self.comparisons = 0  # 统计比较次数
        self.swaps = 0       # 统计交换次数
    def sort(self, arr):
        """执行排序"""
        self.comparisons = 0
        self.swaps = 0
        if self.algorithm == 'bubble':
            return self._bubble_sort(arr.copy())
        elif self.algorithm == 'quick':
            return self._quick_sort(arr.copy())
        elif self.algorithm == 'merge':
            return self._merge_sort(arr.copy())
        else:
            raise ValueError(f"不支持的排序算法: {self.algorithm}")
    def _bubble_sort(self, arr):
        """冒泡排序"""
        n = len(arr)
        for i in range(n):
            swapped = False
            for j in range(0, n-i-1):
                self.comparisons += 1
                if arr[j] > arr[j+1]:
                    arr[j], arr[j+1] = arr[j+1], arr[j]
                    self.swaps += 1
                    swapped = True
            if not swapped:
                break
        return arr
    def _quick_sort(self, arr):
        """快速排序"""
        if len(arr) <= 1:
            return arr
        pivot = arr[0]
        left = []
        right = []
        for num in arr[1:]:
            self.comparisons += 1
            if num < pivot:
                left.append(num)
            else:
                right.append(num)
        self.swaps += len(left) + len(right)
        return self._quick_sort(left) + [pivot] + self._quick_sort(right)
    def _merge_sort(self, arr):
        """归并排序"""
        if len(arr) <= 1:
            return arr
        mid = len(arr) // 2
        left = self._merge_sort(arr[:mid])
        right = self._merge_sort(arr[mid:])
        return self._merge(left, right)
    def _merge(self, left, right):
        """合并两个有序数组"""
        result = []
        i = j = 0
        while i < len(left) and j < len(right):
            self.comparisons += 1
            if left[i] <= right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
            self.swaps += 1
        result.extend(left[i:])
        result.extend(right[j:])
        return result
    def get_stats(self):
        """获取排序统计信息"""
        return {
            'algorithm': self.algorithm,
            'comparisons': self.comparisons,
            'swaps': self.swaps
        }

策略模式封装

from abc import ABC, abstractmethod
from typing import List
class SortStrategy(ABC):
    """排序策略基类"""
    @abstractmethod
    def sort(self, arr: List) -> List:
        pass
    @property
    @abstractmethod
    def name(self) -> str:
        pass
class BubbleSort(SortStrategy):
    """冒泡排序策略"""
    @property
    def name(self):
        return "冒泡排序"
    def sort(self, arr):
        arr = arr.copy()
        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
class QuickSort(SortStrategy):
    """快速排序策略"""
    @property
    def name(self):
        return "快速排序"
    def sort(self, arr):
        arr = arr.copy()
        self._quick_sort(arr, 0, len(arr)-1)
        return arr
    def _quick_sort(self, arr, low, high):
        if low < high:
            pi = self._partition(arr, low, high)
            self._quick_sort(arr, low, pi-1)
            self._quick_sort(arr, pi+1, high)
    def _partition(self, arr, low, high):
        pivot = arr[high]
        i = low - 1
        for j in range(low, high):
            if arr[j] <= pivot:
                i += 1
                arr[i], arr[j] = arr[j], arr[i]
        arr[i+1], arr[high] = arr[high], arr[i+1]
        return i + 1
class SortContext:
    """排序上下文类"""
    def __init__(self, strategy: SortStrategy = None):
        self._strategy = strategy
    def set_strategy(self, strategy: SortStrategy):
        self._strategy = strategy
    def execute_sort(self, arr):
        if not self._strategy:
            raise ValueError("请先设置排序策略")
        print(f"使用 {self._strategy.name} 进行排序...")
        start_time = __import__('time').time()
        result = self._strategy.sort(arr)
        elapsed_time = __import__('time').time() - start_time
        print(f"排序完成，耗时: {elapsed_time:.4f} 秒")
        return result

装饰器封装

import time
from functools import wraps
def sort_timer(func):
    """排序计时装饰器"""
    @wraps(func)
    def wrapper(arr, *args, **kwargs):
        start_time = time.time()
        result = func(arr, *args, **kwargs)
        elapsed_time = time.time() - start_time
        print(f"{func.__name__}: {elapsed_time:.4f} 秒")
        return result
    return wrapper
def sort_validator(func):
    """排序验证装饰器"""
    @wraps(func)
    def wrapper(arr, *args, **kwargs):
        # 验证输入
        if not isinstance(arr, (list, tuple)):
            raise TypeError("输入必须是列表或元组")
        result = func(list(arr), *args, **kwargs)
        # 验证输出
        if not all(result[i] <= result[i+1] for i in range(len(result)-1)):
            raise ValueError("排序结果错误")
        return result
    return wrapper
class SortDecorator:
    """装饰器封装的排序类"""
    @staticmethod
    @sort_timer
    @sort_validator
    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]
        return arr
    @staticmethod
    @sort_timer
    @sort_validator
    def selection_sort(arr):
        """选择排序"""
        n = len(arr)
        for i in range(n):
            min_idx = i
            for j in range(i+1, n):
                if arr[j] < arr[min_idx]:
                    min_idx = j
            arr[i], arr[min_idx] = arr[min_idx], arr[i]
        return arr
    @staticmethod
    @sort_timer
    @sort_validator
    def insertion_sort(arr):
        """插入排序"""
        for i in range(1, len(arr)):
            key = arr[i]
            j = i - 1
            while j >= 0 and arr[j] > key:
                arr[j+1] = arr[j]
                j -= 1
            arr[j+1] = key
        return arr

链式调用封装

class ChainSorter:
    """链式调用的排序工具"""
    def __init__(self, data):
        self.data = list(data)
        self._reset()
    def _reset(self):
        self.steps = []
        self.comparisons = 0
        return self
    def bubble(self):
        """冒泡排序"""
        arr = self.data.copy()
        n = len(arr)
        for i in range(n):
            for j in range(0, n-i-1):
                self.comparisons += 1
                if arr[j] > arr[j+1]:
                    arr[j], arr[j+1] = arr[j+1], arr[j]
        self.data = arr
        self.steps.append("bubble")
        return self
    def quick(self):
        """快速排序"""
        self.data = self._quick_sort(self.data.copy())
        self.steps.append("quick")
        return self
    def _quick_sort(self, arr):
        if len(arr) <= 1:
            return arr
        pivot = arr[len(arr) // 2]
        left = [x for x in arr if x < pivot]
        middle = [x for x in arr if x == pivot]
        right = [x for x in arr if x > pivot]
        return self._quick_sort(left) + middle + self._quick_sort(right)
    def sort(self, method='auto'):
        """自动或指定排序"""
        if method == 'auto':
            if len(self.data) < 1000:
                return self.bubble()
            else:
                return self.quick()
        elif method == 'bubble':
            return self.bubble()
        elif method == 'quick':
            return self.quick()
    def get_result(self):
        """获取排序结果"""
        return {
            'data': self.data,
            'steps': self.steps,
            'comparisons': self.comparisons
        }
    def print_result(self):
        """打印结果"""
        result = self.get_result()
        print(f"排序方法: {result['steps']}")
        print(f"比较次数: {result['comparisons']}")
        print(f"结果: {result['data'][:10]}...")

使用示例

if __name__ == "__main__":
    # 测试数据
    test_data = [64, 34, 25, 12, 22, 11, 90, 88, 76, 45]
    # 1. 基础封装类
    print("=== 基础封装类 ===")
    sorter = Sorter(algorithm='quick')
    sorted_data = sorter.sort(test_data)
    print(f"排序结果: {sorted_data}")
    print(f"统计信息: {sorter.get_stats()}")
    # 2. 策略模式封装
    print("\n=== 策略模式封装 ===")
    context = SortContext(QuickSort())
    result = context.execute_sort(test_data)
    print(f"结果: {result}")
    # 3. 装饰器封装
    print("\n=== 装饰器封装 ===")
    result = SortDecorator.bubble_sort(test_data)
    print(f"结果: {result}")
    # 4. 链式调用封装
    print("\n=== 链式调用封装 ===")
    result = ChainSorter(test_data)\
        .sort('quick')\
        .get_result()
    print(f"排序数据: {result['data']}")

这些封装方式各有特点：

• 基础封装类：功能完整，包含统计信息
• 策略模式：易于扩展，符合开闭原则
• 装饰器封装：代码简洁，功能组合灵活
• 链式调用：语法优雅，可读性好

你可以根据实际需求选择合适的封装方式。