Python與數據結構[0] -> 鏈表[1] -> 雙鏈表與循環雙鏈表的 Python 實現

阿新 • • 發佈：2018-01-14

ont dual from fin @property end all 自身 lan

雙鏈表 / Doubly Linked List

雙鏈表
循環雙鏈表

1 雙鏈表

雙鏈表和單鏈表的不同之處在於，雙鏈表需要多增加一個域（C語言），即在Python中需要多增加一個屬性，用於存儲指向前一個結點的信息。

Doubly linked list:
       node_1 <---> node_2 <---> node_3

完整代碼

 1 from linked_list import LinkedList, test
 2 
 3 
 4 class NodeDual:
 5     def __init__(self, val=None, nxt=None, pre=None):
 
 6         self.value = val
 7         self.next = nxt
 8         self.prev = pre
 9 
10     def __str__(self):
11         return ‘<NodeDual, prev=%s, value=%s, next=%s>‘ % (self.prev.value if self.prev else self.prev,
12                                                            self.value, 
13 
                                                            self.next.value if self.next else self.next)
14 
15 
16 class DoublyLinkedList(LinkedList):
17     """
18     Doubly linked list:
19             node_1 <---> node_2 <---> node_3
20     """
21     def __str__(self):
22         def 
 _traversal(self):
23             node = self.header
24             while node and node.next:
25                 yield node
26                 node = node.next
27             yield node
28         return ‘<->\n‘.join(map(lambda x: str(x), _traversal(self)))
29 
30     def init(self, iterable=()):
31         if not iterable:
32             return
33         self.header = NodeDual(iterable[0])     # header value
34         pre = None
35         node = self.header
36         for i in iterable[1:]:                  # add all node
37             node.prev = pre
38             node.next = NodeDual(i)
39             pre = node
40             node = node.next
41         node.prev = pre
42 
43     def find_previous(self, item):
44         return self.find(item).prev
45 
46     def delete(self, item):
47         pre = self.find_previous(item)
48         if pre:
49             pre.next = pre.next.next
50             pre.next.prev = pre
51 
52     def insert(self, item, index):
53         if abs(index) > self.length:
54             return
55         if index < 0:
56             self.insert(item, self.length+index+1)
57             return
58         elif index == 0:
59             self.insert(self.header.value, 1)
60             self.header.value = item
61             return
62         node = self.header
63         i = 0
64         while i < index-1:
65             node = node.next
66             i += 1
67         n = node.next
68         node.next = NodeDual(item, nxt=n, pre=node)
69         if n:
70             n.prev = node.next
71 
72 
73 if __name__ == ‘__main__‘:
74     test(DoublyLinkedList())

View Code

分段解釋

雙鏈表可以的基本特性與單鏈表相同，因此可以繼承單鏈表。首先導入前面寫好的單鏈表類和測試函數。

1 from linked_list import LinkedList, test

然後定義一個雙向結點，包含前後兩個屬性，用於存放前後結點的信息。同時重定義__str__方法，在顯示結點時顯示該結點的前後結點及自身值，從而方便查看。

 1 class NodeDual:
 2     def __init__(self, val=None, nxt=None, pre=None):
 3         self.value = val
 4         self.next = nxt
 5         self.prev = pre
 6 
 7     def __str__(self):
 8         return ‘<NodeDual, prev=%s, value=%s, next=%s>‘ % (self.prev.value if self.prev else self.prev,
 9                                                            self.value, 
10                                                            self.next.value if self.next else self.next)

定義雙鏈表類，基類為單鏈表，構造函數可以使用單鏈表的構造函數。

 1 class DoublyLinkedList(LinkedList):
 2     """
 3     Doubly linked list:
 4             node_1 <---> node_2 <---> node_3
 5     """
 6     def __str__(self):
 7         def _traversal(self):
 8             node = self.header
 9             while node and node.next:
10                 yield node
11                 node = node.next
12             yield node
13         return ‘<->\n‘.join(map(lambda x: str(x), _traversal(self)))

init方法，與單鏈表不同的地方在於，添加結點時需要同時修改結點的前後屬性（引用指針）。

 1     def init(self, iterable=()):
 2         if not iterable:
 3             return
 4         self.header = NodeDual(iterable[0])     # header value
 5         pre = None
 6         node = self.header
 7         for i in iterable[1:]:                  # add all node
 8             node.prev = pre
 9             node.next = NodeDual(i)
10             pre = node
11             node = node.next
12         node.prev = pre

find_previous方法，查找前一個結點的方法將變得很簡單，只需要找到需要找的結點後，通過結點獲取前一個結點即可。

1     def find_previous(self, item):
2         return self.find(item).prev

刪除和插入類似於單鏈表的思路，只不過需要多處理一個前驅結點引用。

 1     def delete(self, item):
 2         pre = self.find_previous(item)
 3         if pre:
 4             pre.next = pre.next.next
 5             pre.next.prev = pre
 6 
 7     def insert(self, item, index):
 8         if abs(index) > self.length:
 9             return
10         if index < 0:
11             self.insert(item, self.length+index+1)
12             return
13         elif index == 0:
14             self.insert(self.header.value, 1)
15             self.header.value = item
16             return
17         node = self.header
18         i = 0
19         while i < index-1:
20             node = node.next
21             i += 1
22         n = node.next
23         node.next = NodeDual(item, nxt=n, pre=node)
24         if n:
25             n.prev = node.next

同樣利用測試單鏈表的函數對雙鏈表進行測試，

1 if __name__ == ‘__main__‘:
2     test(DoublyLinkedList())

得到結果

Show linked list:
None

Init linked list:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=8><->
<NodeDual, prev=xd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=None>

Insert element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=None>

Append element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None>

Find element:
xd

Find previous element:
6

Delete element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None>

Find element not exist:
None

Insert element to header:
<NodeDual, prev=None, value=cc, next=1><->
<NodeDual, prev=cc, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None>

Clear linked list:
None

Current length: 0

Is empty: True

2 循環雙鏈表

循環雙鏈表類似於雙鏈表，但是將表的頭尾兩個結點相連，形成了一個循環鏈表結構，即頭結點的前一個結點為尾結點，尾結點的下一個結點為頭結點。

    Doubly linked list with loop:
         ________________________________________________________
        |                                                        |
        <===> node_1 <---> node_2 <---> node_3 <---> node_4 <===>
        |________________________________________________________|

首先導入需要的結點和雙鏈表類以及測試函數，

1 from linked_list_doubly import NodeDual, DoublyLinkedList, test

接著定義循環雙鏈表類，對鏈表的顯示輸出同樣要先遍歷鏈表，而這裏的遍歷函數需要額外增加一個判斷條件，即當再次遇到頭結點時，遍歷停止，否則將無限循環遍歷下去。

 1 class DoublyLinkedListLoop(DoublyLinkedList):
 2     """
 3     Doubly linked list with loop:
 4          ________________________________________________________
 5         |                                                        |
 6         <===> node_1 <---> node_2 <---> node_3 <---> node_4 <===>
 7         |________________________________________________________|
 8     """
 9     def __str__(self):
10         def _traversal(self):
11             node = self.header
12             while node and node.next is not self.header:
13                 yield node
14                 node = node.next
15             yield node
16         return ‘<->\n‘.join(map(lambda x: str(x), _traversal(self)))

循環雙鏈表的生成函數比雙鏈表多了一個步驟，即將雙鏈表的頭尾結點相接。

 1     def init(self, iterable=()):
 2         if not iterable:
 3             return
 4         self.header = NodeDual(iterable[0])     # header value
 5         pre = None
 6         node = self.header
 7         for i in iterable[1:]:                  # add all node
 8             node.prev = pre
 9             node.next = NodeDual(i)
10             pre = node
11             node = node.next
12         node.prev = pre
13 
14         node.next = self.header
15         self.header.prev = node

用於獲取表長度的屬性方法同樣需要更改，增加一個頭結點判斷來終止循環遍歷。

 1     @property
 2     def length(self):
 3         if self.header is None:
 4             return 0
 5         node = self.header
 6         i = 1
 7         while node.next is not self.header:
 8             node = node.next
 9             i += 1
10         return i

兩個查找函數也是同樣需要加入頭結點判斷來停止循環。

 1     def find(self, item):
 2         node = self.header
 3         while node.next is not self.header and node.value != item:
 4             node = node.next
 5         if node.value == item:
 6             return node
 7         return None
 8 
 9     def find_previous(self, item):
10         node = self.header
11         while node.next is not self.header and node.next.value != item:
12             node = node.next
13         if node.next is not self.header and node.next.value == item:
14             return node
15         return None

最後用測試函數進行測試，

if __name__ == ‘__main__‘:
    test(DoublyLinkedListLoop())

測試結果為

Show linked list:
None

Init linked list:
<NodeDual, prev=9, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=8><->
<NodeDual, prev=xd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=1>

Insert element:
<NodeDual, prev=9, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=1>

Append element:
<NodeDual, prev=10, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=1>

Find element:
xd

Find previous element:
6

Delete element:
<NodeDual, prev=10, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=1>

Find element not exist:
None

Insert element to header:
<NodeDual, prev=10, value=cc, next=1><->
<NodeDual, prev=cc, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=cc>

Clear linked list:
None

Current length: 0

Is empty: True

相關閱讀

1. 單鏈表

Python與數據結構[0] -> 鏈表[1] -> 雙鏈表與循環雙鏈表的 Python 實現

Python與數據結構[0] -> 鏈表[0] -> 單鏈表與帶表頭單鏈表的 Python 實現

per pty traversal main xxd return 是否為空其中完整單鏈表 / Linked List 目錄單鏈表帶表頭單鏈表鏈表是一種基本的線性數據結構，在C語言中，這種數據結構通過指針實現，由於存儲空間不要求連續性，因此插入和刪

Python與數據結構[0] -> 鏈表[1] -> 雙鏈表與循環雙鏈表的 Python 實現

ont dual from fin @property end all 自身 lan 雙鏈表 / Doubly Linked List 目錄雙鏈表循環雙鏈表 1 雙鏈表雙鏈表和單鏈表的不同之處在於，雙鏈表需要多增加一個域（C語言），即在Python中需要多增

Python與數據結構[0] -> 鏈表[2] -> 鏈表有環與鏈表相交判斷的 Python 實現

lis 退出測試 htm 判斷鏈表是否有環 += 帶環鏈表 off long 鏈表有環與鏈表相交判斷的 Python 實現目錄有環鏈表相交鏈表 1 有環鏈表判斷鏈表是否有環可以參考鏈接，有環鏈表主要包括以下幾個問題（C語言描述）：判斷環是否存在：

Python與數據結構[2] -> 隊列/Queue[0] -> 數組隊列的 Python 實現

return 閱讀位置 pri end 實現 http family 隊列實現隊列 / Queue 數組隊列數組隊列是隊列基於數組的一種實現，其實現類似於數組棧，是一種FIFO的線性數據結構。 Queue: <--| 1 | 2 | 3

Python與數據庫[0] -> 數據庫概述

dep nis text nes 行鎖 transacti 成熟產品控制數據庫概述 / Database Overview 1 關於SQL / About SQL 構化查詢語言(Structured Query Language)簡稱SQL，是一種特殊目的的編

Python與數據結構[1] -> 棧/Stack[1] -> 中綴表達式與後綴表達式的轉換和計算

目錄 end elif fix 圖片 alt join time pytho 中綴表達式與後綴表達式的轉換和計算目錄中綴表達式轉換為後綴表達式後綴表達式的計算 1 中綴表達式轉換為後綴表達式中綴表達式轉換為後綴表達式的實現方式為：依次獲取中綴表達式的元

Python的數據類型與數據結構

out 一是增加是否 bar 元素如果 python代碼 .so 對Python的數據類型與數據結構進行的復習，基本的數據類型與數據結構都已經概況出了。大家可以參考學習。如有有錯誤的地方，希望留言告訴我。數據類型 Python 數據主要分為：整數型；數字的整數

數據結構(0)_聲明與目標

數據結構本系列文章（數據結構）。目標：使用泛型編程的思想，逐步實現常用的數據結構和體操做算法，中打造出一個可復用的數據接口庫(DTLib)，類似於字節實現一個簡化的STL標準庫。參考：自狄泰軟件學院唐老師數據結課程。網絡博客，後續會將整理過程中重點參考的博客記錄在此。數據結構(0)_聲明與目標

php--->底層的運行機制與數據結構原理

組成 C/C++ BE 怎麽用戶特定交互註意快速 PHP 底層的運行機制與數據結構原理 1. PHP的設計理念及特點多進程模型：由於PHP是多進程模型，不同請求間互不幹涉，這樣保證了一個請求掛掉不會對全盤服務造成影響，當然，隨著時代發展，PHP也早已支持多線程

python拓展3 算法與數據結構

方法 clas 能夠條件 mage ESS 復習返回分解知識內容： 1.遞歸復習 2.常用算法 3.常用數據結構 4.python cookbook算法與數據結構整理參考資料： http://python3-cookbook.readthedocs.io/zh

算法與數據結構(二)：鏈表

單獨而是方法但是 oid 每一個技術 next 找到上一篇簡單的開了一個頭，簡單介紹了一下所謂的時間復雜度與空間復雜度，從這篇開始將陸陸續續寫一下常用的數據結構：鏈表、隊列、棧、樹等等。鏈表當初是我在學校時唯一死磕過的數據結構，那個時候自己還算是一個好學生，雖

新書創作談：周立功教授數十年之心血力作《程序設計與數據結構》

發生技術資源進行面向接口推導知識以及指針近日，周立功教授公開了數十年之心血力作《程序設計與數據結構》，此書在4月28日落筆，電子版已無償性分享到電子工程師與高校群體，在致遠電子公眾號後臺回復關鍵字【程序設計】可在線閱讀。在程序設計過程中，很多開發人員在

6.6-2-數組與數據結構（用數組及其函數實現堆棧等數據結構）

var 元素 shift () span bsp key 數組數字 9.5.6.1使用數組實現堆棧實現棧 1. int array_push ( array array ,mixed var [,mixed.] ) 添加參數到數組尾部，key+1 ，返回數組元素個數即

Python之數據結構：集合

ict 轉換成創建可變 discard 重復如果 upper amp 一、set集合 1、集合是一個無序不重復元素集,有去重的作用 set集合類需要的參數必須是叠代器類型的，如：序列、字典等，然後轉換成無序不重復的元素集。由於集合是不重復的，所以可以對字符串、列表、元

算法與數據結構3

表結構區分定位一次常數但是目標方法我們 1.序列：一次排列的多個對象； 2.向量（數組列表）：向量提供一些訪問方法，使我們可以直接通過下標訪問序列中的元素，也可以更新對應位置的元素，為與index區分，我們稱這裏的下標為秩 rank，基於可擴充數組實現；

源碼架設教程之麻將AI算法與數據結構棋牌

算法麻將ID構架　用一維數組PAICAPTION(143)來記錄每張牌的ID和文字信息，數組內容為文字描述，下標用作ID(0-143，共144張牌) 1、胡牌判斷基本構架　　　　用一維數組來記錄各個牌型的數量，例如　　　　 int PAI[38] = { 0,

bzoj3290: Theresa與數據結構

logs amp str rip 一段時間 log bzoj nbsp cal Description 【題目背景】 Theresa是個愛思考的女孩…… 【問題描述】這是個復雜的世界。人類社會，自然界，還

【算法與數據結構】漢諾塔問題Java實現

== oid logs pri pan pre nbsp 問題移動思路：遞歸【代碼】 1 public class Main { 2 public static void hanoi(int n, int x, int y, int z) { 3

PHP系列（三）PHP數組與數據結構

php數組與數據結構 PHP數組與數據結構數組是把若幹變量按有序的形式組織起來的一種形式。這些數據元素的集數組分為一維二維三維、索引數組（數組索引是整數）和關聯數組（1）數組的聲明1、一個數組中存的多個內容、數組中的內容叫作“元素”2、每個元素都是由健和值組成的Key/

深入淺出數據結構C語言版（22）——排序決策樹與桶式排序

不改變自然只需要都是變種限定 style buck oid 　　在（17）中我們對排序算法進行了簡單的分析，並得出了兩個結論：　　1.只進行相鄰元素交換的排序算法時間復雜度為O(N2) 　　2.要想時間復雜度低於O(N2)，算法必須進行遠距離的元素交換　　　

Python與數據結構[0] -> 鏈表[1] -> 雙鏈表與循環雙鏈表的 Python 實現

相關推薦