import heapq
# 初始化列表
data = [3, 1, 4, 1, 5, 9, 2, 6]
# 將列表轉(zhuǎn)換為堆（原地操作）
heapq.heapify(data)
print(f"堆化后的列表: {data}")  # 輸出: [1, 1, 2, 3, 5, 9, 4, 6]
# 向堆中插入元素
heapq.heappush(data, 0)
print(f"插入0后的堆: {data}")  # 輸出: [0, 1, 2, 1, 5, 9, 4, 6, 3]
# 彈出最小元素
min_element = heapq.heappop(data)
print(f"彈出的最小元素: {min_element}")  # 輸出: 0
print(f"彈出后的堆: {data}")  # 輸出: [1, 1, 2, 3, 5, 9, 4, 6]

import heapq
import random

# 生成測試數(shù)據(jù)
numbers = [random.randint(1, 1000) for _ in range(100)]

# 獲取最大的5個元素
largest_5 = heapq.nlargest(5, numbers)
print(f"最大的5個元素: {largest_5}")

# 獲取最小的5個元素
smallest_5 = heapq.nsmallest(5, numbers)
print(f"最小的5個元素: {smallest_5}")

# 使用key參數(shù)進行自定義比較
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
longest_3 = heapq.nlargest(3, words, key=len)
print(f"最長的3個單詞: {longest_3}")  # 輸出: ['elderberry', 'banana', 'cherry']

import heapq

# 合并多個有序序列
list1 = [1, 3, 5, 7]
list2 = [2, 4, 6, 8]
list3 = [0, 9, 10]

merged = list(heapq.merge(list1, list2, list3))
print(f"合并后的有序列表: {merged}")  # 輸出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

import heapq

class PriorityQueue:
    def __init__(self):
        self._heap = []
        self._index = 0  # 用于處理優(yōu)先級相同的情況
    
    def push(self, item, priority):
        """添加元素到優(yōu)先級隊列"""
        heapq.heappush(self._heap, (priority, self._index, item))
        self._index += 1
    
    def pop(self):
        """彈出優(yōu)先級最高的元素"""
        if self._heap:
            return heapq.heappop(self._heap)[-1]
        raise IndexError("優(yōu)先級隊列為空")
    
    def is_empty(self):
        return len(self._heap) == 0

# 使用示例
pq = PriorityQueue()
pq.push("任務(wù)A", 3)
pq.push("任務(wù)B", 1)  # 最高優(yōu)先級
pq.push("任務(wù)C", 2)

while not pq.is_empty():
    print(f"執(zhí)行: {pq.pop()}")
# 輸出: 執(zhí)行: 任務(wù)B → 執(zhí)行: 任務(wù)C → 執(zhí)行: 任務(wù)A

import heapq

class MedianFinder:
    def __init__(self):
        # 最大堆（使用負數(shù)模擬）和最小堆
        self.max_heap = []  # 存儲較小的一半
        self.min_heap = []  # 存儲較大的一半
    
    def add_num(self, num):
        if not self.max_heap or num <= -self.max_heap[0]:
            heapq.heappush(self.max_heap, -num)
        else:
            heapq.heappush(self.min_heap, num)
        
        # 平衡兩個堆
        if len(self.max_heap) > len(self.min_heap) + 1:
            heapq.heappush(self.min_heap, -heapq.heappop(self.max_heap))
        elif len(self.min_heap) > len(self.max_heap):
            heapq.heappush(self.max_heap, -heapq.heappop(self.min_heap))
    
    def find_median(self):
        if len(self.max_heap) == len(self.min_heap):
            return (-self.max_heap[0] + self.min_heap[0]) / 2
        else:
            return -self.max_heap[0]

# 使用示例
finder = MedianFinder()
for num in [1, 3, 2, 6, 4, 5]:
    finder.add_num(num)
    print(f"當前中位數(shù): {finder.find_median()}")

import heapq

def heap_sort(iterable):
    """使用堆排序算法對可迭代對象進行排序"""
    heap = list(iterable)
    heapq.heapify(heap)  # 構(gòu)建最小堆
    return [heapq.heappop(heap) for _ in range(len(heap))]

# 排序示例
unsorted_data = [9, 2, 7, 5, 1, 8, 3, 6, 4]
sorted_data = heap_sort(unsorted_data)
print(f"堆排序結(jié)果: {sorted_data}")  # 輸出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

import heapq

class MaxHeap:
    def __init__(self):
        self._heap = []
    
    def push(self, item):
        heapq.heappush(self._heap, -item)
    
    def pop(self):
        return -heapq.heappop(self._heap)
    
    def peek(self):
        return -self._heap[0] if self._heap else None

# 最大堆使用示例
max_heap = MaxHeap()
for num in [3, 1, 4, 1, 5]:
    max_heap.push(num)

print("最大堆元素彈出順序:")
while max_heap._heap:
    print(max_heap.pop())
# 輸出: 5, 4, 3, 1, 1

import heapq

class Task:
    def __init__(self, name, priority, duration):
        self.name = name
        self.priority = priority
        self.duration = duration
    
    def __lt__(self, other):
        # 定義比較規(guī)則：優(yōu)先級高的在前，相同優(yōu)先級時持續(xù)時間短的在前
        if self.priority == other.priority:
            return self.duration < other.duration
        return self.priority > other.priority
    
    def __repr__(self):
        return f"Task({self.name}, priority:{self.priority}, duration:{self.duration})"

# 自定義對象堆操作
tasks = [
    Task("緊急任務(wù)", 3, 2),
    Task("普通任務(wù)", 1, 5),
    Task("重要任務(wù)", 2, 3)
]

heap = []
for task in tasks:
    heapq.heappush(heap, task)

print("任務(wù)執(zhí)行順序:")
while heap:
    print(heapq.heappop(heap))

import heapq

# 流式處理大數(shù)據(jù)集
def process_large_dataset(data_stream, top_n=10):
    """使用堆處理大數(shù)據(jù)流，只維護Top-N元素"""
    heap = []
    
    for item in data_stream:
        if len(heap) < top_n:
            heapq.heappush(heap, item)
        elif item > heap[0]:  # 對于最大Top-N，使用最小堆
            heapq.heapreplace(heap, item)
    
    return sorted(heap, reverse=True)

# 模擬大數(shù)據(jù)流處理
import random
data_stream = (random.randint(1, 10000) for _ in range(100000))
top_10 = process_large_dataset(data_stream, 10)
print(f"大數(shù)據(jù)流中的Top-10: {top_10}")