Python3 實現(xiàn)雙向鏈表

雙向鏈表

• 定義：雙向鏈表是鏈表中的一種，雙向鏈表也叫雙鏈表，它由多個節(jié)點組成，每個節(jié)點由一個數據域和兩個指針域組成，一個指針指向前驅元素，一個指向后繼元素
  
  雙向鏈表一般用來構造循環(huán)鏈表，這個后面我們也會學習到

定義簡單的雙向鏈表

class Node:"""The nodes of double linked list"""def __init__(self, item):self.prev = Noneself.item = itemself.next = Noneclass DoubleLinkedList:def __init__(self):self.head = Noneif __name__ == "__main__":DLL = DoubleLinkedList()DLL.head = Node(2)DLL.head.next = Node(1)DLL.head.next.prev = DLL.headprint(DLL.head.item)# Point to the second Nodeprint(DLL.head.next.item)# Point to the headprint(DLL.head.next.prev.item)print(DLL.head.next.next)

用起來實在很復雜，舉了兩個例子，要寫一大串
那么我們?yōu)樗鼘崿F(xiàn)一些常用的功能：

鏈表長度self.len，這次使用初始化屬性，根據操作的影響改變長度的方法

判斷是否為空is_empty()

展示所有節(jié)點show_items()，結果可用list()轉換

獲取元素get_value_by_index()，以偏移量獲取元素的值，超出偏移量會報錯IndexErorr，可以是負偏移

在指定index的前面插入節(jié)點insert_before()，當超過實際長度，在最后插入；當為負數倒序選擇插入，負數的絕對值大于實際長度則在最前面插入

在指定index之后插入節(jié)點insert_after()

在鏈表尾部追加append()

正序遍歷traverse_forward()，定義遍歷方法，要改寫到類中的__iter__()和__next__()

反序遍歷traverse_backward()，類似正序遍歷

移除指定index元素remove()，偏移可以為負偏移，但超出偏移范圍會報錯

判斷元素是否存在is_exist()

查找指定元素第一次出現(xiàn)的偏移indexOf()

清空鏈表clear()

鏈表的反轉reverse() 點我跳到鏈表反轉

代碼實現(xiàn)

• 定義節(jié)點

class Node:"""The nodes of double linked list"""def __init__(self, item):self.prev = Noneself.item = itemself.next = None

• 重寫正向遍歷方法：（不記得的同學可以參考兩個示例：重寫遍歷方法示例）

class ForwardIterator:"""Define a forward-direction iterator"""def __init__(self, node):self.head = node.headself.cur = self.headdef __iter__(self):return selfdef __next__(self):"""Return the next item's value of iterator"""try:self.temp = self.curself.cur = self.cur.nextreturn self.temp.itemexcept AttributeError as e:raise StopIteration

• 重寫反向遍歷方法：(跟正序遍歷差不多，只是指針的名字不同)

class ReversalIterator:"""Define a reverse-direction iterator"""def __init__(self, tail):self.cur = taildef __iter__(self):return selfdef __next__(self):"""Return the next item's value of iterator"""try:self.temp = self.curself.cur = self.cur.prevreturn self.temp.itemexcept AttributeError as e:raise StopIteration

• 功能實現(xiàn)

class DoubleLinkedList:def __init__(self):"""Initialize the head and the length of double linked list"""self.head = Noneself.len = 0def is_empty(self):"""Judge if a linked list is empty"""return self.head is Nonedef show_items(self):"""Show all the elements of linked list"""if self.is_empty():return Nonecur = self.headwhile cur.next:yield cur.itemcur = cur.nextyield cur.itemdef get_value_by_index(self, index):"""Get a value by index"""cur = self.headindex = self.len + index if index < 0 else indexif index < 0:raise IndexError('index out of range')try:for i in range(index):cur = cur.nextreturn cur.itemexcept AttributeError as e:raise IndexError('index out of range')# def length(self):# """Return the elements number of a linked list"""# return self.lendef insert_before(self, index, item):"""Insert an element before the given index of a node"""node = Node(item)cur = self.headif not cur:self.head = nodeelse:if -self.len < index < 0:index += self.lenprint(index)if index > 0: # 0 < index or 0 < (index + self.len)while cur.next:index -= 1if index <= 0:breakcur = cur.nextif cur.next:node.next = cur.nextcur.next.prev = nodecur.next = nodenode.prev = curelse:# node.next = cur.next # Not necessarycur.next = nodenode.prev = curelif index <= -self.len or index == 0: # index < -self.len or index == 0node.next = self.headself.head.prev = nodeself.head = nodeself.len += 1def insert_after(self, index, item):"""Insert an element after the given index of a node"""if index >= 0:self.insert_before(index+1, item)elif -self.len-1 <= index < 0: # insert_before(self.len+index+1) equals to insert_after(index)self.insert_before(self.len+index+1, item)else:self.insert_before(0, item)# Use insert_before(), so as to no self.len+=1def append(self, item):"""Append an element to the end of a linked list"""node = Node(item)if self.is_empty():self.head = nodeelse:cur = self.headwhile cur.next:cur = cur.next# node.next = cur.next # Not necessarycur.next = nodenode.prev = curself.len += 1def traverse_forward(self):"""Travel from the head and return the node one by one"""return ForwardIterator(self)def traverse_backward(self):"""Travel from the tail and return the node one by one"""cur = self.headwhile cur.next:cur = cur.nextreturn ReversalIterator(cur)def remove(self, index):"""Remove an element by index"""if not -self.len - 1 < index < self.len:raise IndexError('remove index out of range')if index < 0:index += self.lenif index == 0:self.head = self.head.nextelse:cur = self.headpre = curwhile index > 0:pre = curcur = cur.nextindex -= 1pre.next = cur.nextself.len -= 1def is_exist(self, item):"""Judge if an element in linked list"""return item in self.show_items()def indexOf(self, item):"""Find the first-appears-index of Node(item)"""return list(self.show_items()).index(item)def clear(self):"""CLear all nodes"""self.head = Noneself.len = 0def reverse(self):"""Reverse the linked list"""cur = self.headif not cur:returndef reverse(cur):if not cur.next:self.head = curreturn curprev = reverse(cur.next)prev.next = curcur.next = Nonereturn curreverse(cur)

• 驗證功能

if __name__ == '__main__':DLL = DoubleLinkedList()print(f"Is empty? {DLL.is_empty()}")for i in range(5):DLL.append(i)print(f"Show all items:{list(DLL.show_items())}")_index, _item = -6, 11DLL.insert_before(_index, _item)print(f"Insert {_item} before linked list[{_index}]: {list(DLL.show_items())}")_index, _item = -3, 22DLL.insert_after(_index, _item)print(f"Insert {_item} after linked list[{_index}]: {list(DLL.show_items())}")_item = 33DLL.append(_item)print(f"Append an element[{_item}] to the end: {list(DLL.show_items())}")import collections# Travel backwardprint("DLL.traverse_backward() is Iterable??", isinstance(DLL.traverse_backward(), collections.Iterable))print([i for i in iter(DLL.traverse_backward())])# for i in DLL.traverse_forward():# print(i)# Travel forwardprint("DLL.traverse_forward() is Iterable??", isinstance(DLL.traverse_forward(), collections.Iterable))print([i for i in iter(DLL.traverse_forward())])# for i in DLL.traverse_forward():# print(i)_index = -1DLL.remove(_index)print(f"Remove an element by index[{_index}]: {list(DLL.show_items())}")_item = 22print(f"Is item [{_item}] exists in this list? {DLL.is_exist(_item)}")_item = 1print(f"The first-appears-index of item [{_item}] in this list is {DLL.indexOf(_item)}")print(f"Clear all: {DLL.clear()}, the length of the list: {DLL.len} ")for i in range(3):DLL.append(i)print(f"Before reverse: {list(DLL.show_items())}")DLL.reverse()print(f"After reverse: {list(DLL.show_items())}")

• 輸出結果：

Is empty? True Show all items:[0, 1, 2, 3, 4] Insert 11 before linked list[-5]: [11, 0, 1, 2, 3, 4] Insert 22 after linked list[5]: [11, 0, 1, 2, 3, 4, 22] Append an element[33] to the end: [11, 0, 1, 2, 3, 4, 22, 33] DLL.traverse_backward() is Iterable?? True [33, 22, 4, 3, 2, 1, 0, 11] DLL.traverse_forward() is Iterable?? True [11, 0, 1, 2, 3, 4, 22, 33] Remove an element by index[-1]: [11, 0, 1, 2, 3, 4, 22] Is item [22] exists in this list? True The first-appears-index of item [1] in this list is 2 [11, 0, 1, 55, 2, 3, 4, 22] Clear all: None, the length of the list: 0 Before reverse: [0, 1, 2] After reverse: [2, 1, 0]

時間復雜度分析 點擊回到代碼實現(xiàn)

• show_items()每次查詢都需要遍歷整條鏈表，while循環(huán)n次，時間復雜度為O(n)
• get_value_by_index()每一次獲取元素，都需要從頭結點開始，向后for循環(huán)遍歷，循環(huán)次數與查詢的index成正比，為n次，時間復雜度為O(n)
• insert_before()最壞情況是在鏈表最后插入，需要while循環(huán)n次，時間復雜度為O(n)
• insert_after()同insert_before()，最多需要循環(huán)n次，時間復雜度為O(n)
• append()每次追加都要循環(huán)完畢列表，執(zhí)行n次，時間復雜度為O(n)
• remove()最壞情況下需要循環(huán)n次，時間復雜度為O(n)
  
  總結
• 相較于順序表，鏈表的插入和刪除操作時間復雜度雖然也是O(n)，但是實際鏈表操作的動作更加簡潔，因為鏈表的內存地址無需連續(xù)，大小隨時可變，在插入和刪除時無需改變容量來調整合適的大小，此外插入和刪除時，其他的元素也不用改變位置，因此當查詢和插入操作較多時，推薦使用鏈表
• 如果實際情況中使用查詢操作較多時，鏈表相對順序表而言操作性能會更低，此時建議使用順序表
  
  附加——鏈表的反轉 點擊回到代碼實現(xiàn)

def reverse(self):"""Reverse the linked list"""cur = self.headif not cur:returndef reverse(cur):if not cur.next:self.head = curreturn curprev = reverse(cur.next)prev.next = curcur.next = Nonereturn curreverse(cur)

鏈表的反轉通過遞歸實現(xiàn)將鏈表的head移動到尾節(jié)點
遞歸算法所體現(xiàn)的“重復”一般有三個要求：

• 一是每次調用在規(guī)模上都有所縮小(通常是減半)；
• 二是相鄰兩次重復之間有緊密的聯(lián)系，前一次要為后一次做準備(通常前一次的輸出就作為后一次的輸入)；
• 三是在問題的規(guī)模極小時必須用直接給出解答而不再進行遞歸調用，因而每次遞歸調用都是有條件的(以規(guī)模未達到直接解答的大小為條件)，無條件遞歸調用將會成為死循環(huán)而不能正常結束。

鏈表反轉：
分析遞歸達成的反轉過程：

重寫遍歷方法示例

• Example1

import collectionsclass MyIter(object):def __init__(self, num):self.num = numdef __next__(self):if self.num == 0:raise StopIterationself.num -= 1return self.numdef __iter__(self):return selffor i in MyIter(4):print(i) print(iter(MyIter(4)))print(isinstance(MyIter(4), collections.Iterable))

• Example2

# Example2 class Iteration:def __init__(self, iterable): # [1, 2, 3, 4]self.iterable = iterableself.stop = len(iterable)self.start = 0def __iter__(self):return selfdef __next__(self):"""Return the next item's value of iterator"""if self.start < self.stop:start = self.startself.start += 1return self.iterable[start]else:raise StopIterationdef add(self, item):self.iterable.append(item)alist = [1, 2, 3, 4] IT = Iteration(alist) print(f"[{IT.__class__.__name__}] is iterable? {isinstance(IT, collections.Iterable)}") print(f"[{IT.__class__.__name__}] is iterable? {iter(IT)}") for i in IT:print(i)

結果只需要用isinstance(IT, collections.Iterable)來判斷它兩是否相等即可，為True則可遍歷，為False則不可遍歷；用iter(object)也可以判斷，但是如果不可遍歷會報錯
回到代碼實現(xiàn)

總結

以上是生活随笔為你收集整理的数据结构链表之双向链表：Python3 实现双向链表——2的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。