# 冒泡排序示例代碼
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("冒泡排序結(jié)果:", 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("插入排序結(jié)果:", 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("選擇排序結(jié)果:", 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("快速排序結(jié)果:", 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("歸并排序結(jié)果:", arr)

# `sorted()` 函數(shù)基本用法
arr = [64, 34, 25, 12, 22, 11, 90]
sorted_arr = sorted(arr)
print("基本排序結(jié)果:", sorted_arr)

# 穩(wěn)定性排序示例代碼
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("穩(wěn)定性排序結(jié)果:", sorted_employees)

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

# 對(duì)自定義對(duì)象排序示例代碼
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("自定義對(duì)象排序結(jié)果:", sorted_persons)

# 排序算法性能比較示例代碼
import time

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

start_time = time.time()
sorted_arr = sorted(arr)  # 使用內(nèi)置排序函數(shù)
end_time = time.time()
print(f"內(nèi)置排序函數(shù)運(yùn)行時(shí)間: {end_time - start_time}秒")

start_time = time.time()
bubble_sort(arr.copy())  # 使用冒泡排序
end_time = time.time()
print(f"冒泡排序運(yùn)行時(shí)間: {end_time - start_time}秒")

# 利用 key 參數(shù)對(duì)復(fù)雜數(shù)據(jù)結(jié)構(gòu)進(jìn)行排序示例
# 對(duì)字典的值進(jìn)行排序
dictionary = {'apple': 30, 'orange': 20, 'banana': 50, 'grapes': 10}
sorted_dict = sorted(dictionary, key=lambda x: dictionary[x])
print(sorted_dict)  # 輸出按值排序的鍵列表

# 避免修改原始數(shù)據(jù)示例
arr = [4, 3, 1, 2]
sorted_arr = sorted(arr)  # 創(chuàng)建一個(gè)新的已排序列表
print(sorted_arr)  # 輸出已排序列表
print(arr)  # 輸出原始列表，未被修改

# 選擇合適的排序算法示例
import random

# 對(duì)較小規(guī)模的數(shù)據(jù)使用選擇排序
small_data = random.sample(range(1, 50), 10)
print("Small data:", small_data)
sorted_small_data = sorted(small_data)  # 使用內(nèi)置排序
print("Sorted Small data:", sorted_small_data)

# 對(duì)較大規(guī)模的數(shù)據(jù)使用快速排序
large_data = random.sample(range(1, 100000), 10000)
print("Large data:", large_data[:10])  # 打印前10個(gè)數(shù)據(jù)，避免太多輸出
sorted_large_data = sorted(large_data)  # 使用內(nèi)置排序
print("Sorted Large data:", sorted_large_data[:10])  # 打印前10個(gè)排序后的數(shù)據(jù)，避免太多輸出