合并两个排序列表返回运行时错误

Question

我正在尝试解决一个要求合并两个排序链表的问题。 尽管我的代码通过了大多数测试，但它不适用于大输入、很长的链表。 我可以改进什么？ 谢谢！ 这是我的代码：

#
# For your reference:
#
# SinglyLinkedListNode:
#     int data
#     SinglyLinkedListNode next
#
#
def mergeLists(head1, head2):
    if head1 is None:
        return head2
    if head2 is None:
        return head1

    p1=head1
    p2=head2
    while head1.data >= p2.data:
        nxt = p2.next
        p2.next = head1
        head1 = p2
        p2 = nxt
    p1 = head1
    while p1 is not None and p2 is not None:

        if p1.data <= p2.data and (p1.next is None or p1.next.data >= p2.data):

            next2 = p2.next
            p2.next = p1.next
            p1.next = p2
            p2 = next2



        p1 = p1.next
    return head1

Answer 1

看起来你做了很多重复的任务，以及重复的检查。 我试图用最少的两者编写代码。 当然，如果目标是编写易于阅读的代码，那么递归算法将是最佳解决方案。 但在我们的情况下不是。 另请注意，同时检查两个列表上的哨兵是没有意义的，因为列表的长度是未知的，并且可以随时不同。

class L(object):
    __slots__ = 'data', 'next'

    def __repr__(self): # just for tests
        return f'{self.data!r}, {self.next!r}'

    def __eq__(self, other): # just for tests
        return (self.data == other.data) and (self.next == other.next)

def merge0(a: L, b: L, sentinel=None):
    if a is sentinel:
        return b
    if b is sentinel:
        return a

    if a.data > b.data:
        head = last = b
        b = b.next
    else:
        head = last = a
        a = a.next

    while True:
        if a.data > b.data:
            last.next = last = b
            if (b := b.next) is sentinel:
                last.next = a
                return head
        else:
            last.next = last = a
            if (a := a.next) is sentinel:
                last.next = b
                return head

上面的代码使用 6 个主要指针进行操作：

• a - 第一个链表的头部。 a.next可以是sentinel ；
• b - 第二个链表的头部。 b.next可以是sentinel ；
• head - 新合并链表的头部。 它是a或b 。 在主循环期间没有用；
• last - 新合并链表的当前最后一个对象。 最初是head ；
• last.next - 该指针在主循环期间未定义。 它可以是a 、 b 、 a.next或b.next ；
• sentinel - 标记任何链表末尾的唯一单例对象。

循环的每一步，我们找出较小的元素并将其分配给last.next 。 然后我们创建新的last并使用此元素检查列表的可能结尾。 然后循环重复。

但是，这仍然不是最佳算法。 想象一下，我们有ll1(0, 2, 3, 5, 5, 7, 8) , ll2(6, 7, 9, 10)并合并了ll(0, 2, 3, 5, 5, 6, 7, 7, 8, 9, 10) 。 事实上， ll的前 5 个元素是ll1的五个元素。 根据merge0主循环，这些元素中的每一个（除了第一个）都已重新分配给其左邻居。 当合并列表的值分布很大时，这种方法的效率低下尤为明显。

其次，最好替换对每个列表的哨兵的显式检查。 sentinel对象不必是None并且可以实现为具有本机异常抛出机制的自定义对象。

改良版：

@object.__new__
class sentinel(object):
    __slots__ = ()

    @property
    def next(self):
        raise self.Signal()

    @property
    def data(self):
        raise self.Signal()

    class Signal(Exception):
        pass

    def __eq__(self, other):  # just for tests
        return (other is self) or (other is None)

def merge1(a: L, b: L, sentinel=sentinel):
    if a is sentinel:
        return b
    if b is sentinel:
        return a

    if a.data <= b.data:
        head = x = a
        y = b
    else:
        head = x = b
        y = a

    try:
        while True:
            while (x := (last := x).next).data <= y.data:
                pass
            last.next = y
            while (y := (last := y).next).data <= x.data:
                pass
            last.next = x
    except sentinel.Signal:
        last.next = y if (x is sentinel) else x
        return head

一些测试相关的代码：

def random_sorted_ll(length, min_num, span, sentinel=None):
    """creates sorted linked list of random integers"""
    assert length >= 1
    from random import randint
    from itertools import repeat

    head = last = L()
    head.data = d = randint(min_num, min_num + span)
    ll_factory = map(L.__new__, repeat(L, length-1))
    for l in ll_factory:
        last.next = last = l
        l.data = d = randint(d, d+span)

    last.next = sentinel
    # last.data should be close to (length * span / 2 + min_num)
    return head

def copy_ll(head, prev_sentinel=None, new_sentinel=None):
    """creates deepcopy of given linked list head with new sentinel"""
    if head is prev_sentinel:
        return new_sentinel
    head_copy = last = L()
    last.data = head.data
    head = head.next
    while head is not prev_sentinel:
        last.next = last = L()
        last.data = head.data
        head = head.next
    last.next = new_sentinel
    return head_copy

一些测试：

>>> j0 = random_sorted_ll(length=100, min_num=4, span=5)
>>> j1 = copy_ll(j0)
>>> j2 = copy_ll(j0, prev_sentinel=None, new_sentinel=sentinel)
>>> k0 = random_sorted_ll(length=111, min_num=4, span=5)
>>> k1 = copy_ll(k0)
>>> k2 = copy_ll(k0, prev_sentinel=None, new_sentinel=sentinel)
>>> (j0 == j1 == j2) and (k0 == k1 == k2)
True
>>> m0 = mergeLists(j0, k0)
>>> m1 = merge0(j1, k1)
>>> m2 = merge1(j2, k2)
>>> m0 == m1 == m2
True
>>> (m2 is j2) or (m2 is k2)
True

比较：

def compare_speed(len0, len1, mn0, mn1, span0, span1):
    print(f'\nll in an approximate range ({mn0:_d}, {len0*span0//2+mn0:_d}) with {len0=:_d}')
    j0 = random_sorted_ll(len0, mn0, span0)
    j1 = copy_ll(j0)
    j2 = copy_ll(j0, None, sentinel)
    print(f'll in an approximate range ({mn1:_d}, {len1*span1//2+mn1:_d}) with {len1=:_d}')
    k0 = random_sorted_ll(len1, mn1, span1)
    k1 = copy_ll(k0)
    k2 = copy_ll(k0, None, sentinel)
    from timeit import timeit

    print('mergeLists:', timeit((lambda: mergeLists(j0, k0)), number=1), 'sec')
    print('merge0:', timeit((lambda: merge0(j1, k1)), number=1), 'sec')
    print('merge1:', timeit((lambda: merge1(j2, k2)), number=1), 'sec')

compare_speed(1_111_111, 1_000_000, 0, 0, 5, 5)
compare_speed(1_111_111, 1_000_000, 0, -25_000_000, 5, 100)
compare_speed(9_000_000, 9_111_111, 0, 0, 5, 5)

我的结果：

ll in an approximate range (0, 2_777_777) with len0=1_111_111
ll in an approximate range (0, 2_500_000) with len1=1_000_000
mergeLists: 0.46664454099999997 sec
merge0: 0.2180013780000003 sec
merge1: 0.16215903499999996 sec

ll in an approximate range (0, 2_777_777) with len0=1_111_111
ll in an approximate range (-25_000_000, 25_000_000) with len1=1_000_000
mergeLists: 0.4489969129999736 sec
merge0: 0.16649408400007815 sec
merge1: 0.1128580580000289 sec

ll in an approximate range (0, 22_500_000) with len0=9_000_000
ll in an approximate range (0, 22_777_777) with len1=9_111_111
mergeLists: 4.245676940000003 sec
merge0: 1.9906823259999982 sec
merge1: 1.548923153000004 sec

Answer 2

以下是我们如何通过构建新列表而不是修改现有节点来执行合并操作：

def merge(p1, p2):
    while p1 is not None and p2 is not None:
        if p1.data < p2.data:
            yield p1.data
            p1 = p1.next
        else:
            yield p2.data
            p2 = p2.next

    while p1 is not None:
        yield p1.data
        p1 = p1.next

    while p2 is not None:
        yield p2.data
        p2 = p2.next

def mergeLists(p1, p2):
    return list(merge(p1, p2))

（除了yield ，你也可以.append()到一个临时列表。）

如果您必须修改节点，则需要更加小心，不要修改任何不应该修改的内容。 尝试使用我提出的方法作为模板。

Answer 3

def mergeLists(head1, head2):

  if not head1:
      return head2

  elif not head2:
      return head1

  if head1.data <= head2.data:
      res = head1
      res.next = mergeLists(head1.next, head2)
  else:
      res = head2
      res.next = mergeLists(head1, head2.next)

  return res