Simplest Python K-Way Merging Sort|最简单的Python k路归并排序

想做这个好长时间了，因为有一篇Dreamworks的论文《Coherent Out-of-Core Point-Based Global Illumination》提到了这个，一直没时间做，于是今天抽了十几分钟搞了一下，基于Python的，非常简单。由于基于点云的GI已经毫无疑问的不会使用了，所以Weta Digital的PantaRay和Dreamworks的这些方法都会直接宣布作废，权当一个过渡阶段（从REYES到纯RT）的折中方法了。

k是线程数目，n是每个线程处理的数字个数。可以直接替换为外部的IO访问代码，每一个线程读取外部待排序数据的索引，写出各自排序后的结果，主线程再来读取所有的文件做一次归并输出即可。这里用了Python的heapq，C++的话直接就是std::priority_queue，也非常方便。

import heapq
import random
import threading

# k threads
k = 4

# Generate n numbers for each thread to process.
n = 10

def GenerateNumbers(a, b):
    numbers = []
    for i in xrange(n):
        numbers.append(random.randint(a, b))
    return numbers

class SortingThread(threading.Thread):
    def __init__(self):
        super(SortingThread, self).__init__()
        self.numbers = GenerateNumbers(1, 100)

    def run(self):
        self.numbers.sort()
        
if __name__ == '__main__':
    # Parallel sort with multiple threads.
    #
    sortingThreads = []
    for i in xrange(k):
        sortingThreads.append(SortingThread())
    for i in xrange(k):
        sortingThreads[i].start()
    for i in xrange(k):
        sortingThreads[i].join()
        print i , sortingThreads[i].numbers

    # Use heap to output the final sorted list.
    # We fill the heap with several numbers firstly
    #
    theHeap = []
    for i in xrange(1):
        for t in xrange(len(sortingThreads)):
            number = sortingThreads[t].numbers[i]
            heapq.heappush(theHeap, number)

    sortedNumbers = []

    # In the while loop, people may replace the code by reading file routines.
    # Since IO is always the bottleneck, so single thread should be enough.
    p = 1
    while (len(theHeap) > 0):
        if p < len(sortingThreads[t].numbers):
            for t in xrange(len(sortingThreads)):
                number = sortingThreads[t].numbers[p]
                heapq.heappush(theHeap, number)
            p += 1
        sortedNumbers.append(heapq.heappop(theHeap))

    # Done
    print sortedNumbers