订购两个没有导入的排序生成器

Question

我正在解决 stuy 的编码问题中的一个问题，并遇到了这个问题。

因此，给定两个生成器，每个生成器都以升序输出数字，将两个生成器合并为一个生成器，该生成器以升序输出数字。如果出现重复，则输出出现的次数。

我的尝试：由于我更熟悉使用列表、元组、字典等，我想我只是创建一个助手来在生成器中创建项目列表。然后我会合并这两个列表并对其进行排序

def list_maker(gener):
    l1 = []
    for item in gener:
        l1.append(item)
    return l1

def merge_gens(first_gen, second_gen):
    first_list = list_maker(first_gen)
    second_list = list_maker(second_gen)

    first_list.extend(second_list)
    final_list = first_list
    final_list.sort()

    yield from final_list

虽然这种方法似乎适用于有限生成器，但它不适用于无限生成器（我忘了说明）。我显然不能列出无限项。我可以在不导入 python 库的情况下获得有关如何执行此操作的帮助吗？

Answer 1

你可以试试：

def merge(first, second):
    a = next(first)
    b = next(second)
    while(True):
        # yield the smaller one
        yield a if a < b else b

        # get the next number from the
        # generator that yielded the smaller one
        if a < b:
            a = next(first)
        elif a==b:
            # when the numbers are equal
            # yield second number a second time
            yield a
            # get the next numbers from both the generators. 
            a = next(first)
            b = next(second)
        else:
            b = next(second)

很抱歉缺少 cmets 和解释。我还没有测试过边缘情况。我希望您了解该方法的一般要点，并帮助您获得进一步完成任务的指针。

假设 - StopIteration 异常将由被调用者处理

Answer 2

处理边缘情况有点棘手，我玩得很开心。还没有完全测试它，现在它处于非常冗长的状态，几个帮助函数可以增加清晰度：

def merge(first, second):
    first = iter(first)
    second = iter(second)
    exhausted = object()
    f = next(first, exhausted)
    if f is exhausted:
        yield from second
    s = next(second, exhausted)
    if s is exhausted:
        yield f
        yield from first
        return
    while True:
        if f is exhausted:
            if s is not exhausted:
                yield s
            yield from second
            return
        elif s is exhausted:
            if f is not exhausted:
                yield f
            yield from first
            return
        elif f < s:
            yield f
            f = next(first, exhausted)
        elif f == s:
            yield f
            yield s
            f = next(first, exhausted)
            s = next(second, exhausted)
        else:
            yield s
            s = next(second, exhausted)

我认为通过删除一些更深层次的嵌套和重用逻辑，以下内容使其更具可读性：

def merge(first, second):
    first = iter(first)
    second = iter(second)
    exhausted = object() # just a unique sentinel value

    def _cleanup(item, iterator):
        if item is not exhausted:
           yield item
           yield from iterator

    f = next(first, exhausted)
    if f is exhausted:
        yield from second
    s = next(second, exhausted)
    if s is exhausted:
        yield from _cleanup(f, first)
        return

    while True:
        if f is exhausted:
            yield from _cleanup(s, second)
            return
        elif s is exhausted:
            yield from _cleanup(f, first)
            return
        elif f < s:
            yield f
            f = next(first, exhausted)
        elif f == s:
            yield f
            yield s
            f = next(first, exhausted)
            s = next(second, exhausted)
        else:
            yield s
            s = next(second, exhausted)

关键的想法是不断从每个迭代器请求一个值，产生最小的项目（或者如果它们相等，则产生两个项目），并且只从给你最小项目的迭代器中提取（或从两者都相等）直到一个迭代器用尽，然后通过委托给另一个迭代器来清理它。