Python中sorted()函数的强大排序技术实例探索

# 冒泡排序示例代码
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

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = bubble_sort(arr)
print("冒泡排序结果:", sorted_arr)

# 插入排序示例代码
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = insertion_sort(arr)
print("插入排序结果:", sorted_arr)

# 选择排序示例代码
def selection_sort(arr):
    for i in range(len(arr)):
        min_idx = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = selection_sort(arr)
print("选择排序结果:", sorted_arr)

# 快速排序示例代码
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        less_than_pivot = [x for x in arr[1:] if x <= pivot]
        greater_than_pivot = [x for x in arr[1:] if x > pivot]
        return quick_sort(less_than_pivot) + [pivot] + quick_sort(greater_than_pivot)

# 使用示例
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = quick_sort(arr)
print("快速排序结果:", sorted_arr)

# 归并排序示例代码
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

# 使用示例
arr = [64, 34, 25, 12, 22, 11, 90]
merge_sort(arr)
print("归并排序结果:", arr)

# `sorted()` 函数基本用法
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = sorted(arr)
print("基本排序结果:", sorted_arr)

# 稳定性排序示例代码
employees = [
    {'name': 'Alice', 'age': 25},
    {'name': 'Bob', 'age': 30},
    {'name': 'Alice', 'age': 20},
    {'name': 'Charlie', 'age': 25}
]

sorted_employees = sorted(employees, key=lambda x: x['name'])
print("稳定性排序结果:", sorted_employees)

# 逆序排序示例代码
arr = [64, 34, 25, 12, 22, 11, 90]
reverse_sorted_arr = sorted(arr, reverse=True)
print("逆序排序结果:", reverse_sorted_arr)

# 对自定义对象排序示例代码
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

persons = [Person('Alice', 25), Person('Bob', 20), Person('Charlie', 30)]
sorted_persons = sorted(persons, key=lambda x: x.age)
print("自定义对象排序结果:", sorted_persons)

# 排序算法性能比较示例代码
import time

arr = list(range(10000, 0, -1))

start_time = time.time()
sorted_arr = sorted(arr)  # 使用内置排序函数
end_time = time.time()
print(f"内置排序函数运行时间: {end_time - start_time}秒")

start_time = time.time()
bubble_sort(arr.copy())  # 使用冒泡排序
end_time = time.time()
print(f"冒泡排序运行时间: {end_time - start_time}秒")

# 利用 key 参数对复杂数据结构进行排序示例
# 对字典的值进行排序
dictionary = {'apple': 30, 'orange': 20, 'banana': 50, 'grapes': 10}
sorted_dict = sorted(dictionary, key=lambda x: dictionary[x])
print(sorted_dict)  # 输出按值排序的键列表

# 避免修改原始数据示例
arr = [4, 3, 1, 2]
sorted_arr = sorted(arr)  # 创建一个新的已排序列表
print(sorted_arr)  # 输出已排序列表
print(arr)  # 输出原始列表，未被修改

# 选择合适的排序算法示例
import random

# 对较小规模的数据使用选择排序
small_data = random.sample(range(1, 50), 10)
print("Small data:", small_data)
sorted_small_data = sorted(small_data)  # 使用内置排序
print("Sorted Small data:", sorted_small_data)

# 对较大规模的数据使用快速排序
large_data = random.sample(range(1, 100000), 10000)
print("Large data:", large_data[:10])  # 打印前10个数据，避免太多输出
sorted_large_data = sorted(large_data)  # 使用内置排序
print("Sorted Large data:", sorted_large_data[:10])  # 打印前10个排序后的数据，避免太多输出