列表與鏈表

列表

關於列表的存儲：

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

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

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

# 節點定義：
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去指定。

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

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

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

插入：

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

刪除：

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

四、創建鏈表（單鏈表）

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

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

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

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

雙鏈表

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

一、節點定義：

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

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

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

1）插入：

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

2）刪除：

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

三、創建雙鏈表

尾插法：
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便可。

# 建立節點	
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，而後交給上邊輸出