Python合并有序序列的多种方法完全指南

import heapq

# 基础合并
seq1 = [1, 3, 5, 7]
seq2 = [2, 4, 6, 8]
seq3 = [0, 9, 10]

merged = heapq.merge(seq1, seq2, seq3)
print("heapq合并结果:", list(merged))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def large_sequence_merge(sequences):
    """大型序列合并生成器"""
    return heapq.merge(*sequences)

# 使用示例
# 生成大型有序序列
seq1 = (i for i in range(0, 1000000, 2))  # 偶数序列
seq2 = (i for i in range(1, 1000000, 2))  # 奇数序列

print("大型序列合并:")
merged = large_sequence_merge([seq1, seq2])
# 验证前10个
first_10 = [next(merged) for _ in range(10)]
print("前10个元素:", first_10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

def custom_merge(sequences, key=None, reverse=False):
    """自定义排序合并"""
    return heapq.merge(*sequences, key=key, reverse=reverse)

# 使用示例
students1 = [
    {'name': 'Alice', 'score': 90},
    {'name': 'Bob', 'score': 85}
]

students2 = [
    {'name': 'Charlie', 'score': 92},
    {'name': 'David', 'score': 88}
]

# 按分数降序合并
merged = custom_merge([students1, students2], 
                      key=lambda x: x['score'], reverse=True)
print("自定义排序合并:")
for student in merged:
    print(f"{student['name']}: {student['score']}")
# Charlie:92, Alice:90, David:88, Bob:85

def k_way_merge(sequences):
    """多路归并排序实现"""
    heap = []
    # 初始化堆
    for i, seq in enumerate(sequences):
        iterator = iter(seq)
        try:
            first_item = next(iterator)
            heapq.heappush(heap, (first_item, i, iterator))
        except StopIteration:
            pass
    
    while heap:
        value, index, iterator = heapq.heappop(heap)
        yield value
        try:
            next_value = next(iterator)
            heapq.heappush(heap, (next_value, index, iterator))
        except StopIteration:
            pass

# 使用示例
seq1 = [1, 4, 7]
seq2 = [2, 5, 8]
seq3 = [3, 6, 9]
print("多路归并结果:", list(k_way_merge([seq1, seq2, seq3])))  # [1,2,3,4,5,6,7,8,9]

def infinite_stream_merge(streams):
    """无限流合并"""
    heap = []
    # 初始化
    for i, stream in enumerate(streams):
        heapq.heappush(heap, (next(stream), i, stream))
    
    while heap:
        value, index, stream = heapq.heappop(heap)
        yield value
        try:
            next_value = next(stream)
            heapq.heappush(heap, (next_value, index, stream))
        except StopIteration:
            pass

# 使用示例
def fibonacci():
    """斐波那契序列生成器"""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

def primes():
    """质数序列生成器"""
    yield 2
    primes_list = [2]
    candidate = 3
    while True:
        if all(candidate % p != 0 for p in primes_list if p * p <= candidate):
            primes_list.append(candidate)
            yield candidate
        candidate += 2

print("无限流合并:")
streams = [fibonacci(), primes()]
merged = infinite_stream_merge(streams)
for _ in range(15):  # 取前15个
    print(next(merged), end=' ')
# 0 1 2 2 3 3 5 5 8 13 17 21 34 55 89

def time_series_merge(series, time_key='timestamp'):
    """时间序列合并"""
    heap = []
    # 初始化
    for i, seq in enumerate(series):
        iterator = iter(seq)
        try:
            item = next(iterator)
            heapq.heappush(heap, (item[time_key], i, iterator, item))
        except StopIteration:
            pass
    
    while heap:
        timestamp, index, iterator, item = heapq.heappop(heap)
        yield item
        try:
            next_item = next(iterator)
            heapq.heappush(heap, (next_item[time_key], index, iterator, next_item))
        except StopIteration:
            pass

# 使用示例
logs1 = [
    {'timestamp': '2023-01-01 10:00', 'event': 'login'},
    {'timestamp': '2023-01-01 10:05', 'event': 'action1'},
    {'timestamp': '2023-01-01 10:10', 'event': 'logout'}
]

logs2 = [
    {'timestamp': '2023-01-01 10:03', 'event': 'action2'},
    {'timestamp': '2023-01-01 10:07', 'event': 'action3'}
]

print("\n时间序列合并:")
for event in time_series_merge([logs1, logs2]):
    print(f"{event['timestamp']}: {event['event']}")
# 按时间顺序输出所有事件

def distributed_merge_sort(data, chunk_size=1000):
    """分布式归并排序"""
    import multiprocessing
    from concurrent.futures import ProcessPoolExecutor
    
    # 分割数据
    chunks = [data[i:i+chunk_size] for i in range(0, len(data), chunk_size)]
    
    # 并行排序
    with ProcessPoolExecutor() as executor:
        sorted_chunks = list(executor.map(sorted, chunks))
    
    # 多路归并
    return k_way_merge(sorted_chunks)

# 使用示例
import random
large_data = [random.randint(0, 1000000) for _ in range(1000000)]
sorted_data = distributed_merge_sort(large_data)

# 验证排序
print("分布式排序验证:", sorted_data[:10])  # 最小的10个数字

class DistributedLogMerger:
    """分布式日志合并系统"""
    def __init__(self, nodes):
        self.nodes = nodes  # 节点地址列表
        self.buffer_size = 1000
        self.buffers = {node: [] for node in nodes}
    
    def fetch_logs(self, node):
        """从节点获取日志（模拟）"""
        # 实际应用中会从分布式存储获取
        return [
            {'timestamp': f'2023-01-01 10:{i:02d}', 'node': node, 'event': f'event{i}'}
            for i in range(60)
        ]
    
    def merge_logs(self):
        """合并日志"""
        # 初始化堆
        heap = []
        for node in self.nodes:
            logs = self.fetch_logs(node)
            if logs:
                heapq.heappush(heap, (logs[0]['timestamp'], node, 0, logs))
        
        # 归并
        while heap:
            timestamp, node, index, logs = heapq.heappop(heap)
            yield logs[index]
            
            # 推进该序列
            next_index = index + 1
            if next_index < len(logs):
                heapq.heappush(heap, (logs[next_index]['timestamp'], node, next_index, logs))
            else:
                # 加载下一批日志
                new_logs = self.fetch_logs(node)
                if new_logs:
                    heapq.heappush(heap, (new_logs[0]['timestamp'], node, 0, new_logs))

# 使用示例
nodes = ['node1', 'node2', 'node3']
merger = DistributedLogMerger(nodes)
print("分布式日志合并:")
for i, log in enumerate(merger.merge_logs()):
    print(f"{log['timestamp']} [{log['node']}]: {log['event']}")
    if i >= 5:  # 只显示前5条
        break

def merge_sorted_queries(queries, key='id'):
    """合并多个有序查询结果"""
    heap = []
    # 初始化游标
    for i, query in enumerate(queries):
        cursor = query.execute().fetchone()
        if cursor:
            heapq.heappush(heap, (getattr(cursor, key), i, cursor, query))
    
    # 归并
    while heap:
        _, index, cursor, query = heapq.heappop(heap)
        yield cursor
        next_cursor = query.execute().fetchone()
        if next_cursor:
            heapq.heappush(heap, (getattr(next_cursor, key), index, next_cursor, query))

# 使用示例（模拟）
class Query:
    """模拟数据库查询"""
    def __init__(self, data):
        self.data = sorted(data, key=lambda x: x['id'])
        self.index = 0
    
    def execute(self):
        return self
    
    def fetchone(self):
        if self.index < len(self.data):
            item = self.data[self.index]
            self.index += 1
            return type('Row', (object,), item)()  # 模拟行对象
        return None

# 创建查询
query1 = Query([{'id': 1, 'name': 'Alice'}, {'id': 4, 'name': 'David'}])
query2 = Query([{'id': 2, 'name': 'Bob'}, {'id': 5, 'name': 'Eve'}])
query3 = Query([{'id': 3, 'name': 'Charlie'}, {'id': 6, 'name': 'Frank'}])

print("多查询结果合并:")
for row in merge_sorted_queries([query1, query2, query3], key='id'):
    print(f"ID: {row.id}, Name: {row.name}")

def merge_paginated_results(fetch_page_func, key='id', page_size=100):
    """合并分页结果"""
    heap = []
    page_cache = {}
    
    # 获取第一页
    for page_num in range(1, 100):  # 假设最多100页
        page = fetch_page_func(page_num, page_size)
        if not page:
            break
        page_cache[page_num] = page
        if page:
            heapq.heappush(heap, (getattr(page[0], key), page_num, 0, page))
    
    # 归并
    while heap:
        _, page_num, index, page = heapq.heappop(heap)
        yield page[index]
        
        # 推进该页
        next_index = index + 1
        if next_index < len(page):
            heapq.heappush(heap, (getattr(page[next_index], key), page_num, next_index, page))
        else:
            # 加载下一页
            next_page_num = page_num + 1
            if next_page_num in page_cache:
                next_page = page_cache[next_page_num]
                if next_page:
                    heapq.heappush(heap, (getattr(next_page[0], key), next_page_num, 0, next_page))
            else:
                next_page = fetch_page_func(next_page_num, page_size)
                page_cache[next_page_num] = next_page
                if next_page:
                    heapq.heappush(heap, (getattr(next_page[0], key), next_page_num, 0, next_page))

# 使用示例（模拟）
class PaginatedAPI:
    """模拟分页API"""
    def __init__(self, data):
        self.data = sorted(data, key=lambda x: x['id'])
    
    def fetch_page(self, page, size):
        start = (page - 1) * size
        end = start + size
        return self.data[start:end]

# 创建测试数据
all_data = [{'id': i, 'value': i*10} for i in range(1, 1001)]
api = PaginatedAPI(all_data)

print("分页结果合并:")
merged = merge_paginated_results(api.fetch_page, key='id')
for i, item in enumerate(merged):
    if i >= 5:  # 只显示前5个
        break
    print(f"ID: {item['id']}, Value: {item['value']}")

def merge_order_books(bids, asks):
    """合并买卖订单簿"""
    from collections import defaultdict
    
    # 合并买单
    bid_book = defaultdict(float)
    for bid in bids:
        bid_book[bid['price']] += bid['quantity']
    
    # 合并卖单
    ask_book = defaultdict(float)
    for ask in asks:
        ask_book[ask['price']] += ask['quantity']
    
    # 生成合并订单簿
    merged_bids = sorted([{'price': p, 'quantity': q} for p, q in bid_book.items()], 
                        key=lambda x: x['price'], reverse=True)
    merged_asks = sorted([{'price': p, 'quantity': q} for p, q in ask_book.items()], 
                        key=lambda x: x['price'])
    
    return merged_bids, merged_asks

# 使用示例
bids = [
    {'price': 99.5, 'quantity': 100},
    {'price': 99.5, 'quantity': 50},
    {'price': 99.0, 'quantity': 200}
]

asks = [
    {'price': 100.5, 'quantity': 150},
    {'price': 101.0, 'quantity': 100},
    {'price': 100.5, 'quantity': 75}
]

merged_bids, merged_asks = merge_order_books(bids, asks)
print("合并买单簿:")
for bid in merged_bids:
    print(f"价格: {bid['price']}, 数量: {bid['quantity']}")
print("合并卖单簿:")
for ask in merged_asks:
    print(f"价格: {ask['price']}, 数量: {ask['quantity']}")

def merge_market_data(sources, key='timestamp'):
    """合并多交易所市场数据"""
    heap = []
    # 初始化
    for i, source in enumerate(sources):
        iterator = iter(source)
        try:
            data = next(iterator)
            heapq.heappush(heap, (data[key], i, iterator, data))
        except StopIteration:
            pass
    
    # 归并
    while heap:
        timestamp, index, iterator, data = heapq.heappop(heap)
        yield data
        try:
            next_data = next(iterator)
            heapq.heappush(heap, (next_data[key], index, iterator, next_data))
        except StopIteration:
            pass

# 使用示例（模拟）
def exchange_data(exchange_name, interval=0.1):
    """模拟交易所数据流"""
    import time
    price = 100.0
    for _ in range(5):
        time.sleep(interval)
        price += random.uniform(-1, 1)
        yield {
            'timestamp': time.time(),
            'exchange': exchange_name,
            'price': round(price, 2)
        }

# 创建数据源
import time, random
source1 = exchange_data('ExchangeA', 0.1)
source2 = exchange_data('ExchangeB', 0.15)
source3 = exchange_data('ExchangeC', 0.2)

print("多交易所数据合并:")
for i, data in enumerate(merge_market_data([source1, source2, source3])):
    print(f"{data['timestamp']:.4f} [{data['exchange']}]: {data['price']}")
    if i >= 10:  # 只显示前10条
        break

def memory_efficient_merge(sequences):
    """内存高效合并"""
    return heapq.merge(*sequences)

# 使用生成器避免内存问题
large_seq1 = (i for i in range(0, 10000000, 2))
large_seq2 = (i for i in range(1, 10000000, 2))

print("内存高效合并:")
merged = memory_efficient_merge([large_seq1, large_seq2])
# 检查内存使用
import sys
print("内存占用:", sys.getsizeof(merged))  # 很小，因为生成器

def prefetch_merge(sequences, prefetch_size=1000):
    """预取优化合并"""
    # 预取数据
    prefetched = []
    for seq in sequences:
        buffer = []
        for _ in range(prefetch_size):
            try:
                buffer.append(next(seq))
            except StopIteration:
                break
        prefetched.append(buffer)
    
    # 合并预取数据
    for item in heapq.merge(*prefetched):
        yield item
    
    # 继续合并剩余数据
    active_sequences = []
    for seq, buffer in zip(sequences, prefetched):
        if buffer:
            active_sequences.append(iter(buffer))
        try:
            next(seq)  # 检查是否还有数据
            active_sequences.append(seq)
        except StopIteration:
            pass
    
    if active_sequences:
        yield from heapq.merge(*active_sequences)

# 使用示例
seq1 = (i for i in range(0, 100, 2))
seq2 = (i for i in range(1, 100, 2))
merged = prefetch_merge([seq1, seq2], prefetch_size=10)
print("预取优化合并:", list(merged))

# 小数据直接合并
merged = heapq.merge(seq1, seq2)

# 大数据使用生成器
merged = heapq.merge(large_seq1, large_seq2)

# 分布式系统使用分布式归并

def safe_merge(sequences):
    """安全合并（处理空序列）"""
    non_empty = [seq for seq in sequences if any(True for _ in seq)]
    return heapq.merge(*non_empty) if non_empty else []

def robust_merge(sequences):
    """健壮的合并函数"""
    try:
        return heapq.merge(*sequences)
    except TypeError as e:
        print(f"合并错误: {e}")
        # 尝试转换
        try:
            return heapq.merge(*[iter(seq) for seq in sequences])
        except:
            return []

import time

def timed_merge(sequences):
    """带时间监控的合并"""
    start = time.time()
    result = list(heapq.merge(*sequences))
    duration = time.time() - start
    print(f"合并耗时: {duration:.4f}秒, 元素数量: {len(result)}")
    return result

def file_based_merge(file_paths):
    """基于文件的合并"""
    files = [open(path) for path in file_paths]
    try:
        merged = heapq.merge(*files)
        yield from merged
    finally:
        for f in files:
            f.close()

def merge_sorted_sequences(sequences, key=None, reverse=False):
    """
    合并多个有序序列

    参数:
        sequences: 有序序列列表
        key: 排序键函数
        reverse: 是否降序

    返回:
        合并后的有序序列生成器

    注意:
        所有输入序列必须有序
        使用堆实现高效合并
    """
    return heapq.merge(*sequences, key=key, reverse=reverse)