数据结构和算法（三）单链表

最新推荐文章于 2022-07-05 11:54:17 发布

充值修改昵称

最新推荐文章于 2022-07-05 11:54:17 发布

阅读量340

点赞数

分类专栏： python数据结构和算法文章标签： python 链表数据结构算法

本文链接：https://blog.csdn.net/qq_42806068/article/details/105487823

版权

python数据结构和算法专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

为什么需要链表
链表
节点的实现
单链表的实现
完整代码
链表与顺序表的对比

为什么需要链表

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

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

链表

链表是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点里存放下一个节点的位置信息（即地址）
#单链表
单向链表简称单链表，是链表中最简单的一种形式，它的节点包含两部分信息，一部分存储的元素本身，一部分存储的是下一个节点的地址，而最后一个节点的下一个节点的地址为空。

表元素域elem用来存放具体的数据。
链接域next用来存放下一个节点的位置（python中的标识）。
变量p指向链表的头节点（首节点）的位置，从p出发能找到表中的任意节点。

节点的实现

链表是一个个节点连接而成，而python主要实现单个节点对象，从而构成链条。

class Node(object):
	"""
	单链表节点
	"""
	def __init__(self, item):
		# 数据原素
		self.item = item
		# 连接下一个节点
		self.next = None
	def __repr__(self):
		return '{} ==> {}'.format(self.item, self.next)

单链表的实现

class SingleLinkList(object):
	"""
	单链表
	"""
	def __init__(self):
		self._head = None

	def is_empty(self):
		"""
		判断链表是否为空
		"""
		return self._head == None

	def length(self):
		"""
		链表的长度
		"""
		# cur初始指向头
		cur = self._head
		count = 0
		# 尾节点指向None，当未到尾部时
		while cur is not None:
			count += 1
			# cur后移一个节点
			cur = cur.next
		return count

	def traverse(self):
		"""
		遍历链表
		"""
		cur = self._head
		while cur is not None:
			print(cur)
			cur = cur.next
		print("")

	def search(self, value):
		"""
		查找节点是否存在
		"""
		cur = self._head
		while cur is not None:
			if cur.item == value:
				return True
			cur = cur.next
		return False

头部插入节点

def add(self, value):
		"""
		链表头部添加元素
		"""
		# 创建插入元素的一个节点
		node = Node(value)
		# 将新节点的链接域指向头节点
		node.next = self._head
		# 将链表的头指向新节点
		self._head = node

尾部插入节点

def append(self, value):
		"""
		链表尾部插入元素
		"""
		# 创建节点
		node = Node(value)
		# 先判断链表是否为空，若是空链表，则将_head指向新节点
		if self.is_empty():
			self._head = node
		# 不为空 找到尾部，将尾部节点指向新节点
		else:
			cur = self._head
			while cur.next is not None :
				cur = cur.next
			cur.next = node

指定位置插入

def insert(self, index, value):
		"""
		指定位置插入元素
		"""
		# 若指定位置为第一个元素之前，执行头插法
		if index <= 0:
			self.add(value)
		# 若指定位置为最后一个元素之后，执行尾插法
		elif index > (self.length() - 1):
			self.append(value)
		else:
			# 创建节点
			node = Node(value)
			count = 0
			# cur用来指向指定位置index的前一个位置index-1，初始从头节点开始移动到指定位置
			cur = self._head
			while count < (index - 1):
				count += 1
				cur = cur.next
			# 将新节点的node的next指向插入位置的节点
			node.next = cur.next
			# 将插入位置的前一个节点的next指向新节点
			cur.next = node

删除节点

def remove(self, value):
		"""
		删除节点
		"""
		# 节点为空情况
		if self.is_empty():
			raise ValueError
		cur = self._head
		# 记录删除节点的上一个节点
		pre = None
		while cur is not None:
			# 找到指定元素
			if cur.item == value:
				# 如果第一个就是删除的节点
				if not pre:
					# 将头指针指向头节点的后一个节点
					self._head = cur.next
				else:
					# 将删除位置的前一个节点的next指向删除位置的后一个节点
					pre.next = cur.next
				break
			else:
				# 继续后移
				pre = cur
				cur = cur.next

完整代码

class Node(object):
	"""
	单链表节点
	"""
	def __init__(self, item):
		# 数据原素
		self.item = item
		# 连接下一个节点
		self.next = None
	def __repr__(self):
		return '{} ==> {}'.format(self.item, self.next)


class SingleLinkList(object):
	"""
	单链表
	"""
	def __init__(self):
		self._head = None

	def is_empty(self):
		"""
		判断链表是否为空
		"""
		return self._head == None

	def length(self):
		"""
		链表的长度
		"""
		# cur初始指向头
		cur = self._head
		count = 0
		# 尾节点指向None，当未到尾部时
		while cur is not None:
			count += 1
			# cur后移一个节点
			cur = cur.next
		return count

	def traverse(self):
		"""
		遍历链表
		"""
		cur = self._head
		while cur is not None:
			print(cur)
			cur = cur.next
		print("")

	def add(self, value):
		"""
		链表头部添加元素
		"""
		# 创建插入元素的一个节点
		node = Node(value)
		# 将新节点的链接域指向头节点
		node.next = self._head
		# 将链表的头指向新节点
		self._head = node

	def append(self, value):
		"""
		链表尾部插入元素
		"""
		# 创建节点
		node = Node(value)
		# 先判断链表是否为空，若是空链表，则将_head指向新节点
		if self.is_empty():
			self._head = node
		# 不为空 找到尾部，将尾部节点指向新节点
		else:
			cur = self._head
			while cur.next is not None :
				cur = cur.next
			cur.next = node

	def insert(self, index, value):
		"""
		指定位置插入元素
		"""
		# 若指定位置为第一个元素之前，执行头插法
		if index <= 0:
			self.add(value)
		# 若指定位置为最后一个元素之后，执行尾插法
		elif index > (self.length() - 1):
			self.append(value)
		else:
			# 创建节点
			node = Node(value)
			count = 0
			# cur用来指向指定位置index的前一个位置index-1，初始从头节点开始移动到指定位置
			cur = self._head
			while count < (index - 1):
				count += 1
				cur = cur.next
			# 将新节点的node的next指向插入位置的节点
			node.next = cur.next
			# 将插入位置的前一个节点的next指向新节点
			cur.next = node

	def remove(self, value):
		"""
		删除节点
		"""
		# 节点为空情况
		if self.is_empty():
			raise ValueError
		cur = self._head
		# 记录删除节点的上一个节点
		pre = None
		while cur is not None:
			# 找到指定元素
			if cur.item == value:
				# 如果第一个就是删除的节点
				if not pre:
					# 将头指针指向头节点的后一个节点
					self._head = cur.next
				else:
					# 将删除位置的前一个节点的next指向删除位置的后一个节点
					pre.next = cur.next
				break
			else:
				# 继续后移
				pre = cur
				cur = cur.next

	def search(self, value):
		"""
		查找节点是否存在
		"""
		cur = self._head
		while cur is not None:
			if cur.item == value:
				return True
			cur = cur.next
		return False

if __name__ == '__main__':
	link_node = Node(100)
	single_link_list = SingleLinkList()
	print("当前链表是否为空：", single_link_list.is_empty())
	print("当前链表长度为：", single_link_list.length())

	single_link_list.append(99)
	print("当前链表是否为空：", single_link_list.is_empty())
	print("当前链表长度为：", single_link_list.length())

	single_link_list.append(23)
	single_link_list.append(89)
	single_link_list.append("python")
	single_link_list.append(12.66)
	single_link_list.add(27)
	single_link_list.insert(4, 0)
	single_link_list.remove(27)
	single_link_list.traverse()
	print(single_link_list._head)
	print(single_link_list.search(23))

结果

当前链表是否为空： True
当前链表长度为： 0
当前链表是否为空： False
当前链表长度为： 1
99 ==> 23 ==> 89 ==> 0 ==> python ==> 12.66 ==> None
23 ==> 89 ==> 0 ==> python ==> 12.66 ==> None
89 ==> 0 ==> python ==> 12.66 ==> None
0 ==> python ==> 12.66 ==> None
python ==> 12.66 ==> None
12.66 ==> None
99 ==> 23 ==> 89 ==> 0 ==> python ==> 12.66 ==> None
False

链表与顺序表的对比

链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。

链表与顺序表的各种操作复杂度如下所示：

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

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