链表(python版)

最新推荐文章于 2024-07-25 22:14:03 发布
最新推荐文章于 2024-07-25 22:14:03 发布
阅读量678 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40725653/article/details/123340226
版权

链表是数据结构中基础且重要的一环，其主要分为：

1.单项链表
2. 单项循环链表
3. 双向链表
4. 双向循环链表

单向链表

在这里插入图片描述

class ListNode():
	def __init__(self,val,next=None):
		"定义节点"
		self.val = val
		self.next = next

class SingelLinkList():
	def __init__(self):
		self.head = None

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

	def __len__(self):
		"获取链表长度"
		count = 0
		cur = self.head
		while cur!=None:# 当指针无指向便代表链表结束
			count += 1
			cur = cur.next
		return count

	def travel(self):
		"遍历链表"
		cur = self.head
		while cur!=None:
			print(cur.val,end=' ')
			cur = cur.next
		print()

	def add(self,value):
		"头部添加节点"
		node = ListNode(value)
		if self.is_empty():
			self.head = node
		else:
			node.next = self.head
			self.head = node

	def append(self,value):
		"尾部添加节点"
		node = ListNode(value)
		cur = self.head
		if self.is_empty():
			self.add(value)
			return
		else:
			while cur.next!=None:
				cur = cur.next
		cur.next = node

	def insert(self,pos,value):
		"指定位置添加节点"
		count = 1
		cur = self.head
		if self.is_empty() or pos<=1:
			self.add(value)
			return
		elif pos>=self.__len__():
			self.append(value)
			return
		node = ListNode(value)
		while count<pos-1 and count<self.__len__():
			count += 1
			cur = cur.next
		node.next = cur.next
		cur.next = node

	def remove(self,value):
		"删除指定值节点"
		cur = self.head
		if self.is_empty():
			return
		if cur.val == value:
			self.head = cur.next
			return
		while cur.next!=None:
			if cur.next.val == value:
				cur.next = cur.next.next
				break
			else:
				cur = cur.next

	def remove_pos(self,pos):
		"指定位置删除节点"
		count = 1
		cur = self.head
		if self.is_empty():
			return
		if pos<=1:
			self.head = cur.next
			return
		while count<pos-1 and count<self.__len__()-1:
			count += 1
			cur = cur.next
		if pos>=self.__len__():
			cur.next = None
		else:
			cur.next = cur.next.next

	def search(self,value):
		"查找节点"
		count = 1
		cur = self.head
		while cur!=None:
			if cur.val == value:
				print('%s位于链表中，为%d号节点'%(value,count))
				return
			else:
				count += 1
				cur = cur.next
		print('%s不存在链表'%value)

	def clear(self):
		"清空链表"
		self.head = None

单向循环链表

在这里插入图片描述

class ListNode():
	def __init__(self,val,next=None):
		self.val = val 
		self.next = next

class SingelCycleList():
	def __init__(self,node=None):
		self.head = None
		if node:#生成链表对象时，若传入一个非空节点，要使第一个节点的next指针指向自身
			node.next = node

	def is_empty(self):
		return self.head is None

	def __len__(self):
		count = 1
		cur = self.head
		if self.is_empty():
			return 0
		while cur.next!=self.head:
			count += 1
			cur = cur.next
		return  count

	def travel(self):
		cur = self.head
		if self.is_empty():
			return
		while cur.next!=self.head:
			print(cur.val,end=' ')
			cur = cur.next
		print(cur.val)

	def add(self,value):
		cur = self.head
		node = ListNode(value)
		if self.is_empty():
			self.head = node
			node.next = node
		else:
			# self.head = node
			# node.next = cur
			while cur.next!=self.head:
				cur = cur.next
			node.next = self.head
			self.head = node
			cur.next = node 

	def append(self,value):
		cur = self.head
		node = ListNode(value)
		if self.is_empty():
			self.add(value)
		else:
			while cur.next!=self.head:
				cur = cur.next
			node.next = self.head
			cur.next = node 

	def insert(self,pos,value):
		count = 1
		cur = self.head
		node = ListNode(value)
		if self.is_empty() or pos<=1:
			self.add(value)
		elif pos>=self.__len__():
			self.append(value)
		else:
			while count<pos-1 and count<self.__len__() -1:
				count += 1
				cur = cur.next
			node.next = cur.next
			cur.next = node

	def remove(self,value):
		pre = cur = self.head
		if self.is_empty():
			return
		elif cur.val == value:
			while cur.next!=self.head:
				cur =  cur.next
			self.head = pre.next
			cur.next = pre.next
		while cur.next!=self.head:
			if cur.next.val == value:
				cur.next = cur.next.next
				break
			else:
				cur = cur.next

	def remove_pos(self,pos):
		count = 1
		pre = cur = self.head
		if self.is_empty():
			return
		elif pos<=1:
			while cur.next!=self.head:

				cur =  cur.next
			self.head = pre.next
			cur.next = pre.next
			return
		else:
			while count<pos-1 and count<self.__len__()-1:
				count += 1
				cur = cur.next
			if pos>=self.__len__():
				cur.next = self.head
			else:
				cur.next = cur.next.next

	def search(self,value):
		count = 1
		cur = self.head
		if self.is_empty():
			print('%s不存在链表'%value)
			return
		while cur.next!=self.head:
			if cur.val == value:
				print('%s位于链表中，为%d号节点'%(value,count))
				return
			else:
				count += 1
				cur = cur.next
		if cur.val == value:
			print('%s位于链表中，为%d号节点'%(value,count))
		else:
			print('%s不存在链表'%value)

	def clear(self):
		self.head = None

双向链表

在这里插入图片描述

class ListNode():
	def __init__(self,val,next=None,prev=None):
		self.val = val
		self.next = next
		self.prev = prev


class DoubleLinkList():
	def __init__(self):
		self.head = None

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

	def __len__(self):
		"获取链表长度"
		count = 0
		cur = self.head
		while cur!=None:
			count += 1
			cur = cur.next
		return count

	def travel(self):
		"遍历链表"
		cur = self.head
		while cur!=None:
			print(cur.val,end=' ')
			cur = cur.next
		print()

	def add(self,value):
		"头部添加节点"
		node = ListNode(value)
		if self.is_empty():
			self.head = node
		else:
			node.next = self.head
			self.head.prev = node
			self.head = node


	def append(self,value):
		"尾部添加节点"
		node = ListNode(value)
		cur = self.head
		if self.is_empty():
			self.add(value)
		else:
			while cur.next!=None:
				cur = cur.next
			cur.next = node
			node.prev = cur

	def insert(self,pos,value):
		"指定位置添加节点"
		count = 1
		cur = self.head
		node = ListNode(value)
		if self.is_empty() or pos<=1:
			self.add(value)
		elif pos>=self.__len__():
			self.append(value)
		else:
			while count<pos and count<self.__len__():
				count += 1
				cur = cur.next
			node.next = cur
			cur.prev.next = node 
			node.prev = cur.prev
			cur.prev = node

	def remove(self,value):
		"删除指定值节点"
		cur = self.head
		if self.is_empty():return
		if cur.val == value:
			self.head = cur.next
			return
		while cur!=None:
			if cur.val == value:
				cur.prev.next = cur.next
				if cur.next:
					cur.next.prev = cur.prev
				break
			else:
				cur = cur.next

	def remove_pos(self,pos):
		"指定位置删除节点"
		count = 1
		cur = self.head
		if self.is_empty() or pos<=1:
			self.head = cur.next
			if cur.next:
				cur.next.prev = None
			return
		while count<pos and count<self.__len__():
			count += 1
			cur = cur.next
		if pos>=self.__len__():
			cur.prev.next = None
		else:
			cur.prev.next = cur.next
			cur.next.prev = cur.prev




	def search(self,value):
		"查找节点"
		count = 1
		cur = self.head
		while cur!=None:
			if cur.val == value:
				print('%s位于链表中，为%d号节点'%(value,count))
				return
			else:
				count += 1
				cur = cur.next
		print('%s不存在链表'%value)

	def clear(self):
		"清空链表"
		self.head = None

双向循环链表

在这里插入图片描述


class ListNode():
	def __init__(self,val,prev=None,next=None):
		self.val = val
		self.prev = prev
		self.next = next

class DoubleCycleList():
	def __init__(self,head=None,node=None):
		self.head = head
		if node:
			node.next = node
			node.prev = node

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

	def __len__(self):
		"获取链表长度"
		cur = self.head
		count = 1
		if self.is_empty():
			return 0
		while cur.next!=self.head:
			count += 1
			cur = cur.next
		return count

	def travel(self):
		cur = self.head
		if self.is_empty():
			return
		else:
			while cur.next!=self.head:
				print(cur.val,end=' ')
				cur = cur.next
			print(cur.val)

	def add(self,value):
		"头部添加节点"
		node = ListNode(value)
		cur = self.head
		if self.is_empty():
			self.head = node
			node.prev = node
			node.next = node
		else:
			while cur.next!=self.head:
				cur = cur.next
			node.next = self.head
			self.head.prev = node
			self.head = node
			node.prev = cur
			cur.next = node

	def append(self,value):
		"尾部添加节点"
		node = ListNode(value)
		cur = self.head
		if self.is_empty():
			self.add(value)
		else:
			while cur.next!=self.head:
				cur = cur.next
			cur.next = node
			node.prev = cur
			node.next = self.head
			self.head.prev = node

	def insert(self,pos,value):
		"指定位置插入节点"
		node = ListNode(value)
		cur = self.head
		count = 1
		if self.is_empty() or pos<=1:
			self.add(value)
			return
		elif pos>=self.__len__():
			self.append(value)
			return
		while count<pos and count<self.__len__():
			cur = cur.next
			count += 1
		node.next = cur
		cur.prev.next = node
		node.prev = cur.prev
		cur.prev = node

	def remove(self,value):
		"删除指定值节点"
		cur = self.head
		if self.is_empty():
			return
		if cur.val == value:
			while cur.next!=self.head:
				cur = cur.next
			cur.next = self.head.next
			self.head.next.prev = cur
			self.head = self.head.next
			return
		while cur.next!=self.head:
			if cur.val == value:
				cur.prev.next = cur.next
				cur.next.prev = cur.prev
				return
			else:
				cur = cur.next
		if cur.val == value:
			cur.prev.next = self.head
			self.head.prev = cur.prev

	def remove_pos(self,pos):
		"指定位置删除节点"
		count = 1
		cur = self.head
		if self.is_empty():
			return
		if self.__len__() == 1:
			self.head = None
			return
		elif pos<=1:
			while cur.next!=self.head:
				cur = cur.next
			cur.next = self.head.next
			self.head.next.prev = cur
			self.head = self.head.next
			return
		while count<pos and count<self.__len__():
			cur = cur.next
			count += 1
		if pos>=self.__len__():
			cur.prev.next = self.head
			self.head.prev = cur.prev
		else:
			cur.prev.next = cur.next
			cur.next.prev = cur.prev

	def search(self,value):
		"查找节点是否存在"
		count = 1
		cur = self.head
		if self.is_empty():
			print('%s不存在链表'%value)
			return
		while cur.next!=self.head:
			if cur.val == value:
				print('%s位于链表中，为%d号节点'%(value,count))
				return
			else:
				cur = cur.next
				count += 1
		if cur.val == value:
			print('%s位于链表中，为%d号节点'%(value,count))
		else:
			print('%s不存在链表'%value)

	def clear(self):
		self.head = None
迷叶沙
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 实现链表
算法笨蛋
01-09 7651
python实现链表，python单向链表，python循环链表，python双向链表。
单向循环链表python
07-26
单向循环链表（Singly Circular Linked List）是一种特殊的链表，它与普通的单向链表非常相似，唯一的区别在于尾节点的next指针指向头节点而不是空。这样就形成了一个循环，使得链表中的节点可以通过循环遍历而不会...
Python - 链表
Harrison509的博客
07-10 925
链表是一系列数据元素，通过链接连接在一起。每个数据元素都以指针的形式包含到另一个数据元素的连接。Python在其标准库中没有链接列表。我们使用前一章讨论过的节点概念来实现链表的概念。我们已经看到了我们如何创建节点类以及如何遍历节点的元素。在本章中，我们将研究被称为单链表的链表的类型。在这种类型的数据结构中，任何两个数据元素之间只有一个链接。我们创建这样一个列表并创建其他方法来插入，更新和从列表中移...
Leetcode141环形链表 Python版
m0_49289284的博客
03-07 230
Leetcode141环形链表 Python版问题描述求解法思路一：遍历所有的节点思路二：快慢指针法 题目来源：力扣题库 问题描述 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回 true 。 否则，返回
python数据结构 —— 链表
2301_77774241的博客
05-15 733
简要介绍了链表这一数据结构，并且详细介绍了如何进行链表初始化、打印列表、append和pop操作
反转部分单向链表 Python 版
dongrixinyu的专栏
11-28 949
题目： 给定一个单链表的头指针 head， 以及两个整数 a 和 b，在单链表中反转 linked_list[a-b] 的结点，然后返回整个链表的头指针。 例如： 单链表[1000, 5, 12, 100, 45, ‘cecil’, 999]， a = 4， b = 6， 返回的链表是[1000, 5, 12, 100, 999, ‘cecil’, 45]，也就是说， a 和 b分别为索
单向链表Python
泰敢人辣的博客
07-26 3642
链表是一种常见的数据结构，用于存储和组织数据。它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。 链表相对于数组的优势在于灵活性。由于链表的节点并不一定连续存储在内存中，因此可以动态地插入和删除节点，而不需要移动其他节点。然而，链表的缺点是访问特定位置的节点较慢，需要从头节点开始遍历到指定位置。
链表python基础知识
热门推荐
qq_44941689的博客
01-10 1万+
跟着datawhale刷力扣，以下基本来自于其文档，感谢 链表基本类型 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。即「链表」 是实现线性表的链式存储结构的基础。 单链表每个数据元素占用若干存储单元的组合称为一个「链节点」，还要存放一个指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址，该地址被称为「后继指针 next」。 双向链表（Doubly Linked List）：链表的一种，也叫做双链表。它的
python实现双向链表
谁家的喵
04-27 3347
写一个双向链表，实现append,pop,insert,remove,__iter__，__getitem__功能。最后将链表改造为容器和带头链表
leetcode 143. 重排链表 python
ganggang的博客
09-18 666
题目描述： 题解： 1.通过slow fast指针找到链表中间位置。 2.对后半部分链表进行反转。 3.将前半部分链表和反转后的后半部分进行交叉。 尝试一（使用链表长度作为终止判断，未通过）链表节点为偶数正确，奇数结果不正确。 class Solution(object): def reorderList(self, head): head1 = head length = 0 while head1: .
Python 数据库——链表
思则变的专栏
09-12 3144
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表在逻辑上是连续的，但是在物理空间上可能是不连续的，因为链表的内存都是临时申请的，不一定会申请到连续的内存空间。常用的链表有单向链表和双向链表。这里主要介绍单项链表。单项链表的组成节点有两部分构成：数据和下一个列表的存储地址。单节点结构图：链表结构图：可以看到每一个节点中的addr都指向下一个节点的地址，phead为整个链表的头节点，不能改变，否则就会找不到整个链表。
Python循环链表
m0_74099096的博客
02-21 959
链表：把数据通过“指针”连接起来，并标记一个head起点，方便增删改查 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：撤销：Ctrl/Command + Z 重做：Ctrl/Command + Y 加粗：Ctrl/Command + B 斜体：Ctrl/Command + I 标题：Ctrl/Command + Shift + H 无序列表：Ctrl/Command + Shift + U 有序列表：Ctrl/Co
单链表双链表python示例.rar
05-22
本资源“单链表双链表python示例.rar”包含了关于链表的Python实现，特别是单链表和双链表。 单链表是一种每个节点包含数据和指向下一个节点的引用的数据结构。在Python中，我们可以使用类来表示链表的节点，如下所...
LeetCode解题心得——反转链表（python）
12-21
在LeetCode中，反转链表是一个常见的数据结构问题，它主要考察了对链表操作的理解以及递归或迭代解决问题的能力。本题的目标是反转给定的单链表，例如，对于输入1->2->3->4->5->NULL，期望得到的输出是5->4->3->2->1...
python实现链表去重
09-16
链表去重 链表去重是指从一个链表中删除重复出现的元素，使得链表中的每个元素都是唯一的。
python算法题 链表反转详解
01-20
链表的反转是一个很常见、很基础的数据结构题，输入一个单向链表，输出逆序反转后的链表，如图：上面的链表转换成下面的链表。实现链表反转有两种方式，一种是循环迭代，另外一种方式是递归。 第一种方式：循坏...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 761
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
（数据结构）二叉树
2401_83526138的博客
07-24 621
树是一种非线性的数据结构，它是由n（n>=0）个有限节点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：有一个特殊的节点，称为根节点，根节点没有前驱节点除根节点外，其余节点被分成M（M > 0）个互不相交的集合T1, T2, ......, Tm，其中每一个集合Ti(1 <= i <= m)又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继树是递归定义的。
【C语言】数组栈的实现
最新发布
2301_80840905的博客
07-25 745
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端
单向链表python
08-27
在 Python 中，可以用类来表示单向链表。下面是一个简单的单向链表的 Python 实现示例： ```python class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值