Python数据结构与算法 3.链表

Python数据结构与算法 3.链表

为什么需要链表：

顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。

链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

链表的定义：

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址），也就是数据区+链接区的形式。

1. 单向链表

   单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。
   
   · 表元素域elem用来存放具体的数据。
   · 链接域next用来存放下一个节点的位置（python中的标识）
   · 变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

   Python特色：a, b = b, a，变量名保存的不是数值，而是一块内存，指向数值的地址。Python中的等号就是一个指向。（对比c++中 int a = 1）

   节点实现 ：

   class Node(object):
   	"""链表节点"""
   	def __init__(self, elem):
   		self.elem = elem
   		self.next = None
   

   单链表操作：
   is_empty() 链表是否为空
   length() 链表长度
   travel() 遍历整个链表
   add(item) 链表头部添加元素
   append(item) 链表尾部添加元素
   insert(pos, item) 指定位置添加元素
   remove(item) 删除节点
   search(item) 查找节点是否存在

   单链表操作 代码实现：

   class SingleLinkList(object):
   	"""单链表"""
   	def __init__(self, node = None):
   		self.__head = node
   		
   	def is_empty(self):
   		"""链表是否为空"""
   		return self.__head == None
   		
   	def length(self):
   		"""链表长度"""
   		# cur游标，用来移动遍历节点
   		cur = self.__head
   		# count记录数量
   		count = 0
   		while cur != None:
   			count += 1
   			cur = cur.next
   		return count
   		
   	def travel(self):
   		"""遍历整个链表"""
   		cur = self.__head
   		while cur != None:
   			print(cur.elem, end = " ")
   			cur = cur.next
   		
   	def add(self, item):
   		"""链表头部添加元素，头插法""" 
   		node = Node(item)
   		node.next = self.__head
   		self.__head = node
   
   	def append(self, item):
   		"""链表尾部添加元素，尾插法""" 
   		node = Node(item)
   		if self.is_empty():
   			self.__head = node
   		else:
   			cur = self.__head
   			while cur.next != None:
   				cur = cur.next
   			cur.next = node
   		
   	def insert(self, pos, item):
   		"""指定位置添加元素 
   		:param pos 从0开始
   		"""
   		if pos <= 0：
   			self.add(item)
   		elif pos > (self.length() - 1):
   			self.append(item)
   		else: 
   			pre = self.__head
   			count = 0
   			while count < (pos-1)：
   				count += 1
   				pre = pre.next
   			# 当循环推出后，pre指向pos-1位置
   			node = Node(item)
   			node.next = pre.next
   			pre.next = node
   
   	def remove(self, item):
   		"""删除节点""" 
   		cur = self.__head
   		pre = None
   		while cur != None:
   			if cur.elem == item:
   				#先判断此节点是否是头节点
   				#头节点
   				if cur == self.__head:
   					self.__head = cur.next
   				else:
   					pre.next = cur.next
   				break
   			else:
   				pre = cur
   				cur = cur.next
   				   			
   	def search(self, item):
   		"""查找节点是否存在"""
   		cur = self.__head
   		while cur != None:
   			if cur.elem == item:
   				return True
   			else：
   				cur = cur.next
   

   链表与顺序表的对比：

   操作	链表	顺序表
   访问元素	O(n)	O(1)
   在头部插入/删除	O(1)	O(n)
   在尾部插入/删除	O(n)	O(1)
   在中间插入/删除	O(n)	O(n)

   虽然表面看起来复杂度都是 O(n)，但是链表和顺序表在插入和删除时进行的是完全不同的操作。
   链表的主要耗时操作是遍历查找，删除和插入操作本身的复杂度是O(1)。顺序表查找很快，主要耗时的操作是拷贝覆盖。因为除了目标元素在尾部的特殊情况，顺序表进行插入和删除时需要对操作点之后的所有元素进行前后移位操作，只能通过拷贝和覆盖的方法进行。

2. 双向链表
   一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

   双向链表操作：
   is_empty() 链表是否为空
   length() 链表长度
   travel() 遍历链表
   add(item) 链表头部添加
   append(item) 链表尾部添加
   insert(pos, item) 指定位置添加
   remove(item) 删除节点
   search(item) 查找节点是否存在

   双向链表代码实现：
   （主要改变了插入和删除元素的操作逻辑）

   class Node(object):
   	"""节点"""
   	def __init__(self, item):
   		self.elem = item
   		self.next = None
   		self.prev = None
   
   class DoubleLinkList(object):
   	"""双链表"""
   	def __init__(self, node = None):
   		self.__head = node
   		
   	def is_empty(self):
   		"""链表是否为空"""
   		return self.__head == None
   		
   	def length(self):
   		"""链表长度"""
   		# cur游标，用来移动遍历节点
   		cur = self.__head
   		# count记录数量
   		count = 0
   		while cur != None:
   			count += 1
   			cur = cur.next
   		return count
   		
   	def travel(self):
   		"""遍历整个链表"""
   		cur = self.__head
   		while cur != None:
   			print(cur.elem, end = " ")
   			cur = cur.next
   		
   	def add(self, item):
   		"""链表头部添加元素，头插法""" 
   		node = Node(item)
   		node.next = self.__head
   		self.__head = node
   		node.next.prev = node
   
   	def append(self, item):
   		"""链表尾部添加元素，尾插法""" 
   		node = Node(item)
   		if self.is_empty():
   			self.__head = node
   		else:
   			cur = self.__head
   			while cur.next != None:
   				cur = cur.next
   			cur.next = node
   			node.prev = cur
   		
   	def insert(self, pos, item):
   		"""指定位置添加元素 
   		:param pos 从0开始
   		"""
   		if pos <= 0：
   			self.add(item)
   		elif pos > (self.length() - 1):
   			self.append(item)
   		else: 
   			cur = self.__head
   			count = 0
   			while count < pos：
   				count += 1
   				cur = cur.next
   			# 当循环推出后，pre指向pos-1位置
   			node = Node(item)
   			node.next = cur
   			node.prev = cur.prev
   			cur.prev.next = node
   			cur.prev = node
   
   	def remove(self, item):
   		"""删除节点""" 
   		cur = self.__head
   		while cur != None:
   			if cur.elem == item:
   				#先判断此节点是否是头节点
   				#头节点
   				if cur == self.__head:
   					self.__head = cur.next
   					if cur.next:
   						#判断链表是否只有一个节点
   						cur.next.prev = None
   				else:
   					cur.prev.next = cur.next
   					if cur.next:
   						cur.next.prev = cur.prev
   				break
   			else:
   				cur = cur.next
   				   			
   	def search(self, item):
   		"""查找节点是否存在"""
   		cur = self.__head
   		while cur != None:
   			if cur.elem == item:
   				return True
   			else：
   				cur = cur.next
   		return False
   

3. 单向循环链表
   单向循环链表的尾节点不是None，而是指向头节点。

   class SingleLinkList(object):
   	"""单向循环链表"""
   	def __init__(self, node = None):
   		self.__head = node
   		if node:
   			node.next = node
   		
   	def is_empty(self):
   		"""链表是否为空"""
   		return self.__head == None
   		
   	def length(self):
   		"""链表长度"""
   		if self.is_empty():
   			return 0
   		# cur游标，用来移动遍历节点
   		cur = self.__head
   		# count记录数量
   		count = 1
   		while cur.next != self.__head:
   			count += 1
   			cur = cur.next
   		return count
   		
   	def travel(self):
   		"""遍历整个链表"""
   		cur = self.__head
   		while cur.next != self.__head:
   			print(cur.elem, end = " ")
   			cur = cur.next
   		# 退出循环，cur指向尾节点，但尾节点的元素未打印
   		print(cur.elem)
   		
   	def add(self, item):
   		"""链表头部添加元素，头插法""" 
   		node = Node(item)
   		if self.is_empty():
   			self.__head = node
   			node.next = node
   		else:
   			cur = self.__head
   			while cur.next != self.__head:
   				cur = cur.next
   			# 退出循环，cur指向尾节点
   			node.next = self.__head
   			self.__head = node
   			cur.next = node
   		
   
   	def append(self, item):
   		"""链表尾部添加元素，尾插法""" 
   		node = Node(item)
   		if self.is_empty():
   			self.__head = node
   			node.next = node
   		else:
   			cur = self.__head
   			while cur.next != self.__head:
   				cur = cur.next
   			node.next = cur.next
   			cur.next = node
   		
   	def insert(self, pos, item):
   		"""指定位置添加元素 
   		:param pos 从0开始
   		"""
   		if pos <= 0：
   			self.add(item)
   		elif pos > (self.length() - 1):
   			self.append(item)
   		else: 
   			pre = self.__head
   			count = 0
   			while count < (pos-1)：
   				count += 1
   				pre = pre.next
   			# 当循环推出后，pre指向pos-1位置
   			node = Node(item)
   			node.next = pre.next
   			pre.next = node
   
   	def remove(self, item):
   		"""删除节点""" 
   		if self.is_empty():
   			return
   		cur = self.__head
   		pre = None
   		while cur.next != self.__head:
   			if cur.elem == item:
   				#先判断此节点是否是头节点
   				#头节点
   				if cur == self.__head:
   					# 找尾节点
   					rear = self.__head
   					while rear.next != self.__head：
   						self.__head = cur.next
   						rear.next = self.__head
   				else:
   					# 中间节点
   					pre.next = cur.next
   				break
   			else:
   				pre = cur
   				cur = cur.next
   			if cur.elem == item：
   				if cur ==self.__head:
   					self.__head = None
   				pre.next = cur.next
   				
   				   			
   	def search(self, item):
   		"""查找节点是否存在"""
   		if self.is_empty():
   			return False
   		cur = self.__head
   		while cur.next != self.__head:
   			if cur.elem == item:
   				return True
   			else：
   				cur = cur.next
   		if cur.elem ==item:
   			return True
   		return False