蟒蛇; 鏈接列表和遍歷！

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中很少使用-通常，僅使用list （Python內置列表），它實際上更像是“動態向量”。 因此，將鏈接列表指定為練習約束的一部分是很特殊的。

但是要點是，您顯示的代碼已經在創建一個鏈接列表-頭位於forste ，對於每個節點，下一個節點指針位於.neste ，有效負載位於.vekt 。 因此，大概不管您要問的是什么內容，這都不是您要問的問題。

完全構建鏈接列表后（即在當前代碼末尾的spor ）， spor鏈接列表的簡單方法是

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

就您而言，“過程”部分的邏輯當然是正確的，因為您的Q文本已經說過：

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

唯一的themax是，您需要首先將themax設置themax while循環之前的“可能的最低編號”； 在最新版本的Python中，可靠地記錄和比較了“負無窮大”（盡管只是浮點數，它仍然可以與整數正確比較），因此

themax = float('-inf')

會工作。 更為優雅的做法可能是首先將最大值設置為第一個有效負載，以避免混亂為無窮大。

Answer 2

這是根據您自己的代碼和語言得出的答案。 很抱歉，如果新的變量和函數名稱不能很好地翻譯，因為我不會說挪威語（ Google語言工具是我的朋友）。

評論 ：與飛機空中交通管制一樣，大多數國際編程論壇（例如StackOverflow）的默認語言都是英語。 如果使用它，您可能會得到更快，更好和更多的答案-並且可能使問題和相關答案對大多數其他人有用。 只是我的2毫米... ;-)

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