python中鏈表

❶ python中的鏈表和列表有什麼區別

列表是python的一種數據結構，每個列表可以沒有或者是多個元素，每個元素可以是字元，數據，列表，或者是字典。
python中沒有指針，所以對於C語言來的鏈表，只能是一個模擬鏈表，一般都是通過一個class來定義node，node中的self。value就是對應的數據，self。p指向下一個node。
通過上面的分析我們可以看到他們有相同的地方就是他們都是數據存儲的手段，列表是python的基礎元素，范圍很廣，數據是連續存放，鏈表相對來說應用的范圍比較少，數據是不連續存放，一般都是用於高效合並的數據結構。

❷ Python 如何實現單鏈表按照奇偶位置拆分成兩個鏈表

看見最佳答案回答的那麼垃圾，真心傷心，python這個偷懶的編程語言，寫的這冗餘......

#coding=utf-8
nums=[1,2,3,4,5,6,7]

defsplit(nums):
a,b=[],[]
[a.append(num)ifnums.index(num)%2elseb.append(num)fornuminnums]
returna,b

if__name__=='__main__':
a,b=split(nums)
print('偶數角標鏈表:',a)
print('奇數角標鏈表:',b)

❸ python編程中實現linkedlist(鏈表）報錯是因為什麼，怎麼解決

樓主你好！

看你的代碼存在很多問題，一個個來說明

1）首先你代碼的報錯源於你想用list來展開你的SLinkedList類，在python中，除非內置的可迭代對象外，其他都需要實現__iter__()函數，才能用list來進行展開。注意：判斷一個對象是否可迭代，請使用isinstance(obj, Iterable)來判斷obj是不是可以迭代，Iterable需要從collections中導入

2）插入的方法存在嚴重問題，按樓主的方法插入的話，因為頭節點始終在變，所以當你需要遍歷鏈表的時候就會找不到頭節點；

3）pop的方法實現也有問題，因為是單向鏈，所以無法從末節點開始刪除，只能刪除頭節點

4）top方法的意圖未知

其他：

下面列舉了一下我修改後的方案，做了一些錦上添花的操作，每個基本操作都會返回鏈表對象，這樣就可以使用鏈式操作來寫代碼；迭代函數使用yield來實現，避免展開時佔用不必要的內存。

另：我的展開時直接取鏈表中各個節點的元素，加了一些關鍵注釋在代碼中；

#-*-coding:utf-8-*-
classNode:
def__init__(self):
'''
elm:節點元素
nxt:下個節點指針
'''
self.elm,self.nxt=None,None

classSLinkedList:
def__init__(self):
'''
head:鏈表頭
end_point:鏈表尾
'''
self.head=None
self.end_point=None

defpush(self,x):
p=Node()
p.elm=x
ifself.headisNone:
self.head=p
self.end_point=p
returnself
self.end_point.nxt=p
self.end_point=p
returnself

defpop(self):
'''因為實現的是一個單鏈表，所以只能從頭開始刪除節點'''
ifself.head.nxtisNone:
return
self.head=self.head.nxt
returnself

def__iter__(self):
temp_node=self.head
whiletemp_nodeisnotNone:
yieldtemp_node.elm
temp_node=temp_node.nxt


if__name__=='__main__':
'''增加1,2,5三個元素，並刪除一個頭節點'''
mylinklist=SLinkedList().push(1).push(2).push(5).pop()
print(list(mylinklist))

其實python這個語言使用鏈表有些畫蛇添足，但是如果拿來當作需求練手也無妨。

望採納，謝謝！

❹ python 如何用單向循環鏈表實現堆棧

Node沒什麼問題，就是變數定義的時候是一個下劃線而不是兩個

Stack這里有點問題，

（不知道你這里為啥需要做成一個循環的鏈表，不過不管了）

1. 首先你得定義一個head和一個tail，這樣的話才能把tail和head連接形成一個循環

2. 初始化Stack的話把head和tail都設置成None表示這是個空的stack

3. push的話看你喜歡這么寫了，比較喜歡的是把push進去的Node作為新的head，然後修改一下self._head為新Node，然後修改新Node的next為老的head，再連接一下Tail和Head便可，這樣就省掉一些循環

4. pop的話就加一些判定好了，首先看Head是不是None，如果是就說明Stack是空的。如果發現Tail和Head都是同一個的話就說明Stack里就一項了，提取完Head之後就設置Stack為空吧。然後先提取Head，然後讀取Head後面的那一個Node並且設置為新的Head，然後再連接一下Tail和Head便可

5. 附上代碼供參考.

classNode:
def__init__(self,newData):
self._data=newData
self._next=None

defgetData(self):
returnself._data

defgetNext(self):
returnself._next

defsetData(self,newData):
self._data=newData

defsetNext(self,newNode):
self._next=newNode

classStack:
def__init__(self):
self._head=None
self._tail=None

defpush(self,data):
print'Push',data,'intostack'
new=Node(data)
cur=self._head
end=self._tail
ifcurisNone:
self._head=new
new.setNext(new)
self._tail=new
else:
new.setNext(self._head)
self._head=new
self._tail.setNext(new)

defpop(self):
ifself._headisnotNone:
cur=self._head
print'pop',cur.getData(),'outofstack'
ifcur.getNext()isnotcur:
self._head=cur.getNext()
self._tail.setNext(self._head)
else:
self._head=None
self._tail=None
else:
print'Stackisempty'


my=Stack()
foriinrange(5):
my.push(i)

foriinrange(6):
my.pop()

❺ 用Python實現單鏈表的頭插，尾插和中插

頭插，從鏈豎困表的頭啟跡部插入一個節點，依次類推。中插，就是給定任意位置（index），然後插入該節點。尾插就是從鏈表的尾部悄纖並依次插入節點Node

❻ python如何判斷一個鏈表是否為環狀

設置兩個指針，開始都指向鏈表頭，然後其中一個指針每次向前走一步，另一個指針每次向前走兩步，如果快的遇到NULL了，證明該鏈表中沒有環，如果有環，快的指針每次都要比慢的多走一步，最終兩個指針會相遇，（注意：這里快指針不會跳過慢指針而不相遇，因為它每次都只比慢指針多走一個單位） bool judge(list *head){if(head == NULL){return false;//沒有環} list *pFast = head; list *pSlow = head; while(pFast-next != NULL && pFast-next-next != NULL){pFast = pFast-next-next; pSlow = pSlow-next;

❼ python-033-實現棧-使用鏈表實現-提高時間復雜度

棧在我們之前的文章中就說陵前明過了，想了解的去看一下030即可。

之前我們實現的棧穗汪高，演算法時間復雜度在攤銷的情況下，是O(1)，其底層是python的列表，是一種動態數組，在內存中是一個固定長度的數組，是無法改變大小的，只有重新換一個更大的數組來裝新的數據猜尺。雖然實現起來非常簡單，但是並不夠完美。

在我們最開始的幾篇文章中，很詳細的介紹了鏈表的各種使用方式。之前實現鏈表時，只聲明了節點對象，但是我們在程序的使用中應該把鏈表作為一個整體，作為一個對象來使用，這樣封裝性更好。

今天就不寫這個鏈表了，我們利用在棧類中定義一個 嵌套類 來做為鏈表的節點對象，因為創建節點的操作非常多，所以我們用 slots 來聲明節點的兩個成員變數，來減少內存的使用，提高效率。

鏈表是一種可以隨時改變的數據結構。我們可以隨時改變他的結構。

實現如下：

這次實現的棧的每一個方法操作，其時間復雜度都為O(1)，不需要攤銷。這與用數組實現的棧形成了對比。

鏈表實現的更快，明天用鏈表實現隊列。