Python;链表和遍历！

Question

现在在学校开始用python编程，我不知道如何继续解决这个问题。有什么想法吗？

输入由由换行符分隔的整数组成。你的程序应该将它们提交到一个链表中，遍历链表并打印最大的数字。

采取第一个数字，并执行一个操作，表示“如果下一个数字更大，则采用该数字，否则，保留当前数字，然后沿着列表向下重复”

然后当它到达列表末尾时，它打印它所具有的值。

from sys import stdin

class Kubbe:
    vekt = None
    neste = None
    def __init__(self, vekt):
        self.vekt = vekt 
        self.neste = None 

def spor(kubbe):
    # WRITE YOUR CODE HERE
    # Creates linked list
    forste = None
    siste = None
    for linje in stdin:
        forrige_siste = siste
        siste = Kubbe(int(linje))
        if forste == None:
            forste = siste
        else:
            forrige_siste.neste = siste

# Calls the solution function and prints the result
print spor(forste)

输入：示例

54
37
100
123
1
54

所需输出

123

Answer 1

“链表”在 Python 中很少使用——通常，人们只使用 Python 内置列表 list，它实际上更像是一种“动态向量”。因此，看到指定为练习约束的一部分的链表是很奇怪的。

但要点是，您显示的代码已经创建一个链表 - 头位于forste，并且对于每个节点，下一个节点指针位于.neste，有效负载位于.vekt。因此，无论问题的内容如何，​​这可能都不是您要问的问题。

完全构造链表后（即在 spor 的当前代码末尾）循环遍历链表的简单方法是

current = forste
while current is not None:
   ...process current.vekt...
   current = current.neste

在您的情况下，“过程”部分的逻辑是当然，正如您的 Q 文本已经说过的：

   if current.vekt > themax:
       themax = current.vekt

唯一的微妙之处是，您需要在 while 循环之前将 themax 初始设置为“尽可能低的数字”；在Python的最新版本中，“负无穷大”被可靠地记录和比较（尽管只是作为浮点数，它仍然可以正确地与整数进行比较），所以

themax = float('-inf')

可以工作。更优雅的方法可能是最初将最大值设置为第一个有效负载，避免弄乱无穷大。

Answer 2

这是基于您自己的代码和语言的答案。抱歉，如果新变量和函数名称翻译得不好，因为我不会说挪威语（Google 语言工具 是我的朋友）。

评论：像飞机空中交通管制一样，大多数国际编程论坛（例如StackOverflow）的默认语言都是英语。如果你使用它，你可能会得到更快、更好和更多的答案——而且它可能会让问题和相关答案对大多数其他人有用。只是我的 2 øre...;-)

from sys import stdin

class Kubbe:
    vekt = None
    neste = None
    def __init__(self, vekt):
        self.vekt = vekt
        self.neste = None

def spor():
    # WRITE YOUR CODE HERE
    # Creates linked list
    forste = None
    siste = None
    while True:
        try:
            linje = raw_input()
        except EOFError:
            break
        forrige_siste = siste
        siste = Kubbe(int(linje))
        if forste == None:
            forste = siste
        else:
            forrige_siste.neste = siste
    return forste

def finne_maksimal(lenketliste):
    storste = None
    if lenketliste is not None:
        storste = lenketliste.vekt
        gjeldende = lenketliste.neste
        while gjeldende is not None:
            if gjeldende.vekt > storste:
                storste = gjeldende.vekt
            gjeldende = gjeldende.neste
    return storste

lenketliste = spor()
storste = finne_maksimal(lenketliste)
if lenketliste is None:
    print "tom liste"
else:
    print "storste er", storste

Answer 3

Python 中有一个名为 reduce 的内置函数，它遍历列表并使用给定函数“压缩”它。也就是说，如果您有一个包含五个元素 [a,b,c,d,e] 和一个函数 f 的列表，那么它将有效地执行

temp = f(a,b)
temp = f( temp, c )
...

您应该能够用它来编写一个非常简洁的解决方案。

如果您想不那么抽象，则需要依次迭代列表中的每个元素，将迄今为止最大的数字存储在变量中。仅当您到达的元素大于所述变量的值时才更改变量。

Answer 4

这似乎适用于您的输入（适用于 python 2 和 3）。注意 max 如何与 Python 的鸭子类型一起工作！

此版本也可从文件与 Python3 一起使用。

import sys
class Kubbe:
    vekt = None
    neste = None
    def __init__(self, vekt):
        self.vekt = vekt 
        self.neste = None 

def spor():
    # WRITE YOUR CODE HERE
    # Creates linked list
    forste = None
    siste = None
    while True:
        linje = sys.stdin.readline().rstrip()
        if not linje:
            break

        forrige_siste, siste = siste, Kubbe(int(linje))
        if forste is None:
            forste = siste
        else:
            forrige_siste.neste = siste
    return forste

def traverse(linkedlist):
    while linkedlist is not None:
        yield linkedlist.vekt
        linkedlist=linkedlist.neste

# Calls the solution function and prints the result
linkedlist=spor()

for item in traverse(linkedlist):
    print(item)

# use builtin max:
print('Maximum is %i' % max(traverse(linkedlist)))
# if not allowed:
m = linkedlist.vekt
for item in traverse(linkedlist.neste):
       if item > m:  m = item 
print(m)

Answer 5

下面的代码可以工作。 Node 类表示 LinkedList 节点。 LinkedList 类定义了在链表末尾添加节点的方法，find_max 将遍历链表并返回具有最大键的节点。

   class Node(object):
        def __init__(self, key, next_node):
            self.key = key 
            self.next_node = next_node

    class LinkedList(object):
        def __init__(self):
            self.head = None

        def append(self, key):
            # Create a new Node
            new_node = Node(key, None)
            if (self.head == None):
                self.head = new_node
            else:
                tmp = self.head
                while(tmp.next_node != None):
                    tmp = tmp.next_node
                tmp.next_node = new_node

        def find_max(self):
            tmp = self.head
            max_num = 0 
            while(tmp != None):
                if (tmp.key > max_num):
                    max_num = tmp.key
                tmp = tmp.next_node
            return max_num