Question

这是python中的合并排序逻辑:(这是第一部分，忽略函数merge（））问题点是将递归逻辑转换为while循环。代码礼貌：Rosettacode Merge Sort

def merge_sort(m):
    if len(m) <= 1:
        return m

    middle = len(m) / 2
    left = m[:middle]
    right = m[middle:]

    left = merge_sort(left)
    right = merge_sort(right)
    return list(merge(left, right))

是否有可能在while循环中使其成为一种动态，而每个左右数组分成两个，一种指针根据左右数组的数量不断增加并将它们分开直到只有一个长度大小清单还有吗？因为每当下一次分割进入左右两侧时，阵列就会不断分解，直到只剩下单个长度列表，因此左侧（左 - 左，右 - 右）和右侧（右 - 左，右 - 右）中断将增加，直到达到所有大小为1的列表。

Answer 1

一种可能的实现方式可能是：

def merge_sort(m):
    l = [[x] for x in m]                  # split each element to its own list
    while len(l) > 1:                     # while there's merging to be done 
        for x in range(len(l) >> 1):      # take the first len/2 lists
            l[x] = merge(l[x], l.pop())   # and merge with the last len/2 lists
    return l[0] if len(l) else []

递归版本中的堆栈帧用于存储需要合并的逐渐变小的列表。您正确地识别出在堆栈的底部，无论您要排序的是什么，每个元素都有一个单元素列表。因此，通过从一系列单元素列表开始，我们可以迭代地构建更大的合并列表，直到我们有一个单独的排序列表。

Answer 2

应读者的要求从alternative to recursion based merge sort logic转发：

消除递归的一种方法是使用queue来管理未完成的工作。例如，使用内置的collections.deque：

from collections import deque
from heapq import merge

def merge_sorted(iterable):
    """Return a list consisting of the sorted elements of 'iterable'."""
    queue = deque([i] for i in iterable)
    if not queue:
        return []
    while len(queue) > 1:
        queue.append(list(merge(queue.popleft(), queue.popleft())))
    return queue[0]

Answer 3

It's said，每个递归函数都可以以非递归方式编写，所以简短的答案是：是的，它是可能的。我能想到的唯一解决方案是使用基于堆栈的方法。当递归函数调用自身时，它会在内部堆栈上放置一些上下文（其参数和返回地址），这对您来说是不可用的。基本上，为了消除递归，你需要做的就是编写自己的堆栈，每次进行递归调用时，都要将参数放到这个堆栈中。

有关更多信息，请阅读this article，或参阅Robert Lafore的“Java中的数据结构和算法”中的“消除递归”一节（尽管本书中的所有示例都是用Java语言提供的，但它是很容易掌握主要想法）。

Answer 4

采用上述Dan的解决方案，并采取流行的建议，我仍尝试消除，而不是那么pythonic方法。这是我建议的解决方案： PS：l = len

我对Dans解决方案的疑问是，如果L.pop（）和L [x]相同并且产生冲突，如在迭代超过L的长度的一半之后的奇数范围的情况下<？p >

def merge_sort(m):
    L = [[x] for x in m]  # split each element to its own list
    for x in xrange(l(L)):      
        if x > 0:
            L[x] = merge(L[x-1], L[x])
    return L[-1]

这可以继续进行所有的学术讨论，但我得到了一个替代递归方法的答案。

替代基于递归的合并排序逻辑

4 个答案: