Question

class LN:
    def __init__(self,value,next=None):
        self.value = value
        self.next  = next

def list_to_ll(l):
   if l == []:
       return None
   front = rear = LN(l[0])
   for v in l[1:]:
       rear.next = LN(v)
       rear = rear.next
   return front

def str_ll(ll):
    answer = ''
    while ll != None:
        answer += str(ll.value)+'->'
        ll = ll.next
    return answer + 'None'

def pair_sum(ll):
    sum = 0
    while ll != None:
        sum == ll.value 
        ll = ll.next
        sum = sum + ll.value
        ll = ll.next 
        return sum

我需要编写一个名为pair_sum的迭代函数（其他三个函数不能改变）;它作为参数传递一个链表（ll）。它返回对新链接列表前面的引用，其中包含每对相邻值的总和（我不能在代码中使用列表，元组，集合或词组）。例如，如果我定义了

a = list_to_ll([1,2,3,4,5,6,7,8])
pair_sum(a) returns the linked list 
3->7->11->15->None.

我需要致电

ll = list_to_ll([1,2,3,4,5,6,7,8,9])
print('resulting list             = ',str_ll(pair_sum(ll)))

打印结果，但它显示错误“AttributeError：'int'对象没有属性'value'”

如何修复pair_sum函数？

Answer 1

您的功能的主要问题是您甚至没有创建新的LN;相反，你只需计算一笔金额。如果你真的，真的需要一个迭代解决方案，你可以尝试这样的事情：

def pair_sum(ll):
    res = last = LN(ll.value + ll.next.value) if ll.next else LN(ll.value)
    ll = ll.next.next if ll.next else None
    while ll:
        last.next = LN(ll.value + ll.next.value) if ll.next else LN(ll.value)
        ll = ll.next.next if ll.next else None
        last = last.next
    return res

即使我把所有这些next指针缠绕在一起也有麻烦，我写了那段代码。那些三元... if ll.next else ...用于处理奇数列表。

无论如何，当您要求迭代解决方案时，让我向您展示一个recursive解决方案。这样做的原因是链表是recursive data structure，因此对于递归算法更好地提供很多，这样的算法通常可归结为一行或两行：

def pair_sum(ll):
    try:
        # case 1: list has two or more elements left
        return LN(ll.value + ll.next.value, pair_sum(ll.next.next))
    except AttributeError:
        # only one or zero elements left -> return list itself (or None)
        return ll

偶数和奇数列表的示例：

>>> pair_sum(list_to_ll([1,2,3,4,5,6,7,8]))
3->7->11->15->None
>>> pair_sum(list_to_ll([1,2,3,4,5,6,7,8,9]))
3->7->11->15->9->None

程序的其他（给定）部分也可以以递归方式更简单地重写：

class LN:
    def __init__(self,value,next=None):
        self.value = value
        self.next  = next

    def __repr__(self):
        return "%r->%r" % (self.value, self.next)

def list_to_ll(l):
    if l:
        front, *rear = l
        return LN(front, list_to_ll(rear))

回到迭代解决方案。如果你真的，真的，真的需要一个迭代解决方案，你也可以尝试这样做：首先，构建一个反向版本的结果，可以从内部创建 - out，类似于递归函数的工作方式。然后逆转反转的结果。

def pair_sum(ll):
    reverse = None
    while ll:
        reverse, ll = (LN(ll.value + ll.next.value, reverse), ll.next.next) \
                if ll.next else (LN(ll.value, reverse), None)
    result = None
    while reverse:
        result, reverse = LN(reverse.value, result), reverse.next
    return result

恕我直言，这个版本感觉更自然，更容易理解，因为链接列表易于访问，一端快速插入和删除。

如何修复pair_sum函数

1 个答案: