〖Python〗-- 列表與鏈表

【列表與鏈表】

列表

關於列表的存儲：

　　列表開闢的內存空間是一塊連續的內存，把這個內存等分紅幾份(單位是字節)，他是連續存儲的。
　　若是一個列表長度已滿，再append添加元素的話，會在內存中從新開闢一個2倍的內存空間以存儲新元素，原列表內存會被清除。

列表與鏈表複雜度：

1 2 3 4 5 6 7 8 9 10 11 12

按元素值查找:      按順序查找，複雜度是同樣的。      按二分查找，鏈表無法查找. 按下標查找:      列表是O( 1 )      鏈表是O(n) 在某元素後插入:      列表是O(n)      鏈表是O( 1 ) 刪除某元素:      列表是O(n)      鏈表是O( 1 )

鏈表------->列表相對應的數據結構

　　鏈表是一種線性數據結構（與樹形結構相對），不是進行連續存儲的。
　　鏈表中每個元素都是一個對象，每一個對象稱爲一個節點，包含有數據域key和執行下一個節點的指針next。經過各個節點之間的相互鏈接，最終串聯成一個鏈表。
一、存儲的過程當中，須要先建立節點，而後進行定義。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# 節點定義： class  Node( object ):       　　 def  __init__( self ,item):      self .item  =  item  # 數據域      self . next  =  None  # 指針域   n1  =  Node( 1 ) n2  =  Node( 2 ) n3  =  Node( 3 )   n1. next  =  n2 n2. next  =  n3 # 經過 n1 找到n3的值 print (n1. next . next .item)

只保留頭結點，執行第一個位置，剩下的都是next去指定。

二、鏈表遍歷：(頭節點的變更)

1 2 3 4 5

def  traversal(head): 　　curNode  =  head  # 臨時指針，用於指定頭節點 　　 while  curNode  not  None :      print (curNode.item)  # 打印當前節點的值      curNode  =  curNode. next  # 把下一節點賦給臨時指針，以做爲頭節點

三、鏈表節點的插入和刪除操做(很是方便，時間複雜度低)

插入：

1 2 3 4 5

p  =  Node( 5 )  # 要插入的值 curNode  =  Node( 1 )  # 標誌位 # 順序不能亂，不然就找不到原鏈表中的下一個值 p. next  =  curNode. next  # 指定插入值以後的值爲標誌位以後的值 curNode. next  =  p   # 而後再把原先的鏈next指向改爲插入的值

刪除：

1 2 3 4

curNode 表明當前值 p  =  curNode. next  # 表示要刪除的數 curNode. next  =  p. next  # 從新指定創建鏈表 del  p 刪除數

四、創建鏈表（單鏈表）

1）頭插法：是在head頭節點的位置後插入數；獲得的鏈表與原先的列表順序是相反的。

1 2 3 4 5 6 7

def  createLinkListF(li): 　　l  =  Node()  # 始終指向頭節點 　　 for  num  in  li:      s  =  Node(num)      s. next  =  l. next      l. next  =  s 　　 return  l

2）尾插法：在鏈表的尾巴上插入。至關因而追加，必須時刻記住尾巴在哪兒

1 2 3 4 5 6 7

def  createLinkListR(li): 　　l  =  Node() 　　r  =  l  # r指向尾節點 　　 for  num  in  li:      s  =  Node(num):      r. next  =  s      r  =  s  # 從新指定尾節點

雙鏈表

　　雙鏈表中每一個節點有兩個指針：一個指向後面節點，一個指向前面節點。

一、節點定義：

1 2 3 4 5

class  Node( object ): 　　 def  __init__( self ,item = None ):      self .item  =  item    # 記錄當前值      self . next  =  None    # 記錄下一個值      self .prior  =  None   # 記錄前置的一個值

二、雙鏈表節點的插入和刪除

1	curNode  =  Node( 1 )  # 取一數據做爲標誌位

1）插入：

1 2 3 4 5

p  =  Node( 2 )  # 要插入的數 p. next  =  curNode. next  # 指定插入數的next 是 當前數的next curNode. next .prior  =  p  # 指定插入數的下一個數的 前置數爲當前的數值 p.prior  =  curNode  # 插入數的前置數爲 標誌位 curNode. next  =  p  # 指定，標誌位的next數是當前要插入的數

2）刪除：

1 2 3 4

p  =  curNode. next  # 標誌位的下一個數，要刪除的數 curNode. next  =  p. next  # 將next指向下一個數 p. next .prior  =  curNode # 將要刪除數的下一個數的前置數改成標誌位 del  p  # 刪除當前數

三、創建雙鏈表

1 2 3 4 5 6 7 8 9 10

尾插法： def  createLinkListR(li): 　　l  =  Node() 　　r  =  l 　　 for  num  in  li:      s  =  Node(num)      r. next  =  s      s.prior  =  r      r  =  s 　　 return  l,r

 

單鏈表逆置

　　循環反轉單鏈表。在循環的方法中，使用pre指向前一個節點，cur指向當前節點，每次把cur->next指向pre便可。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

# 建立節點  class  Node( object ):            def  __init__( self ,item = None , next = None ):          self .item  =  item  # 數據域          self . next  =  next  # 指針域    # 循環逆置方法 def  revLinkList(link):            if  link  is  None  or  link. next  is  None :          return  link                pre  =  link  # 記錄當前節點的值      cur  =  link. next  # 記錄下一節點的值      pre. next  =  None  # 先將當前節點的next指向定爲None            while  cur:  # 鏈表中一直有值          tmp  =  cur. next  # 獲取cur的下一個值，臨時賦值給tmp          cur. next  =  pre  # 將cur值指向pre          pre  =  cur  # 從新指定          cur  =  tmp            return  pre  # 把當前值返回   #應用 link  =  Node( 1 , Node( 2 , Node( 3 , Node( 4 , Node( 5 , Node( 6 , Node( 7 , Node( 8 , Node( 9 ))))))))) r  =  revLinkList(link):   # 鏈表逆置以後，獲得的head值 while  r:      print ( "{0}---->" . format (r.item))  # 輸出逆置後的當前值      r  =  r. next  # 獲取下一個，從新賦給r，而後交給上邊輸出