Question

我在使用乐高积木时设计了以下排序算法，基于这样的想法：总是将较小的碎片堆叠在较大的碎片上，直到遇到一个不适合堆叠两端的碎片。

我最初的印象是它的最佳案例行为是O（n），它的最坏情况行为是O（n ^ 2），因为它类似于链排序，但是我已经做了算法分析已经很久了在大学里，我不知道它的平均行为是什么。看起来它应该比strand sort的平均O（n ^ 2）更好，但我不知道如何证明它或它是什么。

我的实现使用链接列表允许两端插入，但是deque也可以正常工作。以下是Python代码以方便描述，但C ++版本更有效。

import math

def merge(x, y):
    output = []
    xp = 0
    yp = 0
    if len(y) == 0 or len(x) == 0 or y[0] > x[-1]:
        return x + y
    elif x[0] > y[-1]:
        return y + x
    while xp < len(x) and yp < len(y):
        if x[xp] < y[yp]:
            output.append(x[xp])
            xp = xp + 1
        else:
            output.append(y[yp])
            yp = yp + 1
    if xp < len(x):
        output = output + x[xp:]
    elif yp < len(y):
        output = output + y[yp:]
    return output

def treeMerge(heads, accum):
    currHead = 0
    while heads[currHead] is not None:
        accum = merge(heads[currHead], accum)
        heads[currHead] = None
        currHead = currHead + 1
    heads[currHead] = accum
    return heads

def legoSort(input):
    heads = [None] * int(math.log(len(input), 2) + 1)
    accum = []
    for i in input:
        # can be <= for speed at the cost of sort stability
        if len(accum) == 0 or i < accum[0]: 
            accum.insert(0,i)
        elif i >= accum[-1]:
            accum.append(i)
        else:
            heads = treeMerge(heads, accum)
            accum = [i]
    for i in heads:
        if i is not None:
            accum = merge(accum, i)
    return accum

Answer 1

研究用未知语言编写的未知代码是相当无聊的。你最好在分析

结束时在http://en.wikipedia.org/wiki/Merge_sort找到它

Answer 2

看起来你有类似于timsort或自然合并的东西。

这个排序函数的算法复杂度是多少？

2 个答案: