双向链表和单向循环链表

最新推荐文章于 2024-07-30 21:09:58 发布
最新推荐文章于 2024-07-30 21:09:58 发布
阅读量444 收藏
点赞数
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49383182/article/details/118382762
版权

一.双向链表的操作

1.双向链表的具体阐述

双向链表 ： 双向链表即表示链表的节点拥有两个方向，链表节点不仅有后继指针next指向下一个节点，而且还有前驱节点prev指向对应的前一个节点，从而形成两节点之间的相互指向，故这样的链表就成为双向链表

双向链表数据结构图如下：
在这里插入图片描述

双链表单个节点的数据结构如下：
在这里插入图片描述

2.双向链表以及链表节点的创建

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node


'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

3.在双向链表类的内部定义一个方法来判断双向链表是否为空链表，若为空则返回True,否则返回False

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双链表是否为空'''
	def is_empty(self):
		return self.__head == None



'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''判断双链表是否为空链表'''
print(link.is_empty())
print(dou_link.is_empty())

输出结果：

True
False

4.在双向链表类中定义一个方法检查链表的长度

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		

	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''检查双链表的长度'''
print(link.length())              #空双链表的长度为0
print(dou_link.length())          #拥有一个节点的双链表的长度为1

输出结果：

0
1

5.定义一个方法来遍历双链表的元素

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
			
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''遍历双向链表'''
link.traversal()            #若为空链表则遍历后不会有任何结果输出

dou_link.traversal()        #若为非空链表则遍历会显示对应元素值

输出结果：

20

6.定义一个方法向双向链表的尾部添加元素

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
	
	'''定义一个方法向双向链表的尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		cur = self.__head
		if cur:
			while cur.next != None:
				cur = cur.next
			cur.next = node
			node.prev = cur
		else:
			self.__head = node
					
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''双向链表尾部添加元素'''
link.append(100)         #链表尾部添加元素100
link.append(110)		 #链表尾部添加元素110	
link.traversal()         #遍历链表
dou_link.append('a')     #链表尾部添加元素'a'
dou_link.append('ll')    #链表尾部添加元素'11'
dou_link.append('amy')   #链表尾部添加元素'amy'
dou_link.traversal()     #遍历链表

输出结果：

100
110
20
a
11
amy

7.在双向链表类内部定义一个方法用于在双链表的头部添加元素

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
	
	'''定义一个方法向双向链表的尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		cur = self.__head
		if cur:
			while cur.next != None:
				cur = cur.next
			cur.next = node
			node.prev = cur
		else:
			self.__head = node
	'''定义一个方法向双向链表的头部添加元素'''


	def add(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		if self.is_empty():        
			self.__head = node       #当为空链表时
		else:                        #当双链表非空时
			self.__head.prev = node    
			node.next = self.__head
			self.__head = node
		
					
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''向双向链表的头部添加元素'''
link.add(10)
link.add(20)
link.traversal()

dou_link.add('aa')
dou_link.add('bb')
dou_link.traversal()

输出结果：

20
10
bb
aa
20

8.类中定义一个方法用于在双向链表的对应位置插入元素

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
	
	'''定义一个方法向双向链表的尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		cur = self.__head
		if cur:
			while cur.next != None:
				cur = cur.next
			cur.next = node
			node.prev = cur
		else:
			self.__head = node


	'''定义一个方法向双向链表的头部添加元素'''
	def add(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		if self.is_empty():        
			self.__head = node       #当为空链表时
		else:                        #当双链表非空时
			self.__head.prev = node    
			node.next = self.__head
			self.__head = node

	'''定义一个方法用于在双向链表的指定位置插入元素'''
	def insert(self,pos,item):
		'''指定位置插入元素'''
		if pos <= 0:
			self.add(item)
		elif pos > (self.length()-1):
			self.append(item)
		else:
			node = Node(item)
			count = 0
			cur = self.__head
			while count < pos:
				count += 1
				cur = cur.next
			node.next = cur
			cur.prev.next = node
			node.prev = cur.prev
			cur.prev = node		
					
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)



'''在双向链表指定位置添加元素'''
link.insert(0,1)
link.insert(0,'a')
link.insert(1,'second')
link.insert(0,33)
link.insert(4,66)
link.insert(10,0000)
link.traversal()

输出结果：

33
a
second
1
66
0

9.类中定义一个方法搜索指定元素是否存在

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
	
	'''定义一个方法向双向链表的尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		cur = self.__head
		if cur:
			while cur.next != None:
				cur = cur.next
			cur.next = node
			node.prev = cur
		else:
			self.__head = node


	'''定义一个方法向双向链表的头部添加元素'''
	def add(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		if self.is_empty():        
			self.__head = node       #当为空链表时
		else:                        #当双链表非空时
			self.__head.prev = node    
			node.next = self.__head
			self.__head = node

	'''定义一个方法用于在双向链表的指定位置插入元素'''
	def insert(self,pos,item):
		'''指定位置插入元素'''
		if pos <= 0:
			self.add(item)
		elif pos > (self.length()-1):
			self.append(item)
		else:
			node = Node(item)
			count = 0
			cur = self.__head
			while count < pos:
				count += 1
				cur = cur.next
			node.next = cur
			cur.prev.next = node
			node.prev = cur.prev
			cur.prev = node	

	'''定义一个方法用于搜索指定元素'''
	def search(self,item):
		cur = self.__head
		while cur != None:
			if cur.item == item:
				return True
			else:
				cur = cur.next
		return False	
	
					
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''搜索元素是否在双向链表中'''
print(link.search(10))
print(dou_link.search(20))
print(dou_link.search(30))

输出结果：

False
True
False

10.删除双向链表中指定的元素

'''双向链表节点模板的创建'''
class Node(object):
	def __init__(self,item):
		self.item = item
		'''单个节点的后继指针初始值设为None'''
		self.next = None 
		'''单个节点的前驱指针初始值设为None'''     
		self.prev = None

'''双向链表模板的创建'''
class DoubleLink(object):
	def __init__(self,node = None):
		self.__head = node
	
	'''定义一个方法判断双向链表是否为空'''
	def is_empty(self):
		return self.__head == None    
		                              
	'''定义一个方法检查双向链表的长度'''                        			          
	def length(self):
		cur = self.__head
		count = 0
		while cur != None:
			count += 1
			cur = cur.next
		return count           #返回count的值即为双链表的长度
		
	'''定义一个方法遍历双向链表'''
	def traversal(self):
		cur = self.__head
		while cur != None:
			print(cur.item)         #输出双向链表中的每个元素
			cur = cur.next
	
	'''定义一个方法向双向链表的尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		cur = self.__head
		if cur:
			while cur.next != None:
				cur = cur.next
			cur.next = node
			node.prev = cur
		else:
			self.__head = node


	'''定义一个方法向双向链表的头部添加元素'''
	def add(self,item):
		'''首先创建一个节点'''
		node = Node(item)
		if self.is_empty():        
			self.__head = node       #当为空链表时
		else:                        #当双链表非空时
			self.__head.prev = node    
			node.next = self.__head
			self.__head = node

	'''定义一个方法用于在双向链表的指定位置插入元素'''
	def insert(self,pos,item):
		'''指定位置插入元素'''
		if pos <= 0:
			self.add(item)
		elif pos > (self.length()-1):
			self.append(item)
		else:
			node = Node(item)
			count = 0
			cur = self.__head
			while count < pos:
				count += 1
				cur = cur.next
			node.next = cur
			cur.prev.next = node
			node.prev = cur.prev
			cur.prev = node	

	'''定义一个方法用于搜索指定元素'''
	def search(self,item):
		cur = self.__head
		while cur != None:
			if cur.item == item:
				return True
			else:
				cur = cur.next
		return False

	'''定义一个方法用来删除双向链表中指定的元素'''
	def remove(self,item):
		cur = self.__head
		while cur != None:
			if cur.item == item:
				if cur == self.__head:
					if self.__head.next:
						self.__head = cur.next
						cur.next.prev = None
					else:
						self.__head = None
				elif cur.next:
					cur.prev.next = cur.next
					cur.next.prev = cur.prev
				else:
					cur.prev.next = None
				break
			else:
				cur = cur.next	
	
					
			
	
'''实例化创建一个具体数据值为20的节点'''
node = Node(20)

'''实例化创建一个空的双向链表'''
link = DoubleLink()

'''实例化创建含有一个节点且节点具体数据值为20的双向链表'''
dou_link = DoubleLink(node)

'''删除双向链表中指定元素'''
link.append(1)
link.append(2)
link.append(3)
link.append(4)
link.append(5)
link.traversal()
link.remove(11)
link.remove(3)
link.traversal()

输出结果：

1
2
3
4
5
1
2
4
5

二.单向循环链表的操作

1.什么是单向循环链表

单向循环链表 ：循环链表是一种特殊的单向链表，单向链表的最后一个节点的后继指针指向的是链表的头节点，这样的单向链表称为单向循环链表
在这里插入图片描述

2.单向循环链表的创建

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

3.单向循环链表的操作

1.判断循环链表是否为空

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''判断链表是否为空'''
print(link.is_empty())
print(lin.is_empty())

输出结果：

True
False

2.定义一个方法求循环链表的长度

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''求循环链表的长度'''
print(link.length())
print(lin.length())

输出结果：

0
1

3.遍历循环链表元素

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''遍历单向循环链表'''
link.traversal()
lin.traversal()

输出结果：

20

4.定义一个方法用于循环链表头部添加元素

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass

	'''定义一个方法用于循环链表头部添加元素'''
	def add(self,item):
		'''先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			node.next = self.__head
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			self.__head = node
			cur.next = self.__head
		else:
			self.__head = node
			node.next = self.__head
		
		
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''循环链表头部随意添加元素'''
link.add(10)
link.add('q')
link.add('a')
link.add(40)
'''遍历循环链表'''
link.traversal()

输出结果：

40
a
q
10

5.定义一个方法用于循环链表尾部添加元素

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass

	'''定义一个方法用于循环链表头部添加元素'''
	def add(self,item):
		'''先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			node.next = self.__head
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			self.__head = node
			cur.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法用于循环链表尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			'''创建游标'''
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			cur.next = node
			node.next = self.__head
		else:
			self.__head = node
			node.next = self.__head
		
		
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''循环链表尾部随意添加元素'''
link.append(1)
link.append(2)
link.append(3)
link.append(4)

'''遍历循环链表'''
link.traversal()

输出结果：

1
2
3
4

6.定义一个方法在循环链表指定位置添加元素

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass

	'''定义一个方法用于循环链表头部添加元素'''
	def add(self,item):
		'''先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			node.next = self.__head
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			self.__head = node
			cur.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法用于循环链表尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			'''创建游标'''
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			cur.next = node
			node.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法在循环链表指定位置添加元素'''
	def insert(self,pos,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if pos <= 0:
			self.add(item)
		elif pos > (self.length() - 1):
			self.append(item)
		else:
			count = 0
			cur = self.__head
			while count < pos-1:
				cur = cur.next
				count += 1
			node.next = cur.next
			cur.next = node
		
		
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)



'''循环链表指定位置添加元素'''
link.insert(1,'a')
link.insert(0,'b')
link.insert(8,'c')
link.insert(1,'second')

'''遍历循环链表'''
link.traversal()

输出结果：

b
second
a
c

7.定义一个方法查看指定元素是否在循环链表中，若在则返回True,否则返回False

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass

	'''定义一个方法用于循环链表头部添加元素'''
	def add(self,item):
		'''先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			node.next = self.__head
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			self.__head = node
			cur.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法用于循环链表尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			'''创建游标'''
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			cur.next = node
			node.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法在循环链表指定位置添加元素'''
	def insert(self,pos,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if pos <= 0:
			self.add(item)
		elif pos > (self.length() - 1):
			self.append(item)
		else:
			count = 0
			cur = self.__head
			while count < pos-1:
				cur = cur.next
				count += 1
			node.next = cur.next
			cur.next = node

	'''定义一个方法查看指定元素是否在循环链表中'''
	def search(self,item):
		if self.is_empty():
			return False
		else:
			cur = self.__head
			while cur.next != self.__head:
				if cur.item  == item:
					return True
				else:
					cur = cur.next
			if cur.item == item:
				return True
			else:
				return False
			 
		
		
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''搜索指定元素是否在循环链表中'''
print(link.search(30))
print(lin.search(20))
print(lin.search(66))

输出结果：

False
True
False

8.定义一个方法删除循环链表中指定元素

'''创建单向循环链表节点模板'''
class CircularNode(object):
	'''创建单向循环链表节点'''
	def __init__(self,item):
		self.item = item
		self.next = None

'''创建单向循环链表模板'''
class SinglecircularLink(object):
	'''创建单向循环链表'''
	def __init__(self,node = None):
		self.__head = node
		if self.__head:
			node.next = self.__head

	'''定义一个方法判断一个循环链表是否为空链表,若为空链表则返回True,否则返回False'''
	def is_empty(self):
		return self.__head == None

	'''定义一个方法求循环链表的长度'''
	def length(self):
		count = 1
		cur = self.__head
		if self.__head:
			while cur.next != self.__head:
				count += 1
				cur = cur.next
		else:
			count = 0
		return count

	'''定义一个方法用于遍历循环链表的元素'''
	def traversal(self):
		if self.__head:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.item)
				cur = cur.next
			print(cur.item)
		else:
			pass

	'''定义一个方法用于循环链表头部添加元素'''
	def add(self,item):
		'''先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			node.next = self.__head
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			self.__head = node
			cur.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法用于循环链表尾部添加元素'''
	def append(self,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if self.__head:
			'''创建游标'''
			cur = self.__head
			while cur.next != self.__head:
				cur = cur.next
			cur.next = node
			node.next = self.__head
		else:
			self.__head = node
			node.next = self.__head

	'''定义一个方法在循环链表指定位置添加元素'''
	def insert(self,pos,item):
		'''首先创建一个节点'''
		node = CircularNode(item)
		if pos <= 0:
			self.add(item)
		elif pos > (self.length() - 1):
			self.append(item)
		else:
			count = 0
			cur = self.__head
			while count < pos-1:
				cur = cur.next
				count += 1
			node.next = cur.next
			cur.next = node

	'''定义一个方法查看指定元素是否在循环链表中'''
	def search(self,item):
		if self.is_empty():
			return False
		else:
			cur = self.__head
			while cur.next != self.__head:
				if cur.item  == item:
					return True
				else:
					cur = cur.next
			if cur.item == item:
				return True
			else:
				return False

	'''定义一个方法删除循环链表中指定元素'''
	def remove(self,item):
		cur = self.__head
		prev = None
		if self.is_empty():
			return
		elif self.__head.item == item:
			if self.__head.next != self.__head:
				while cur.next != self.__head:
					cur = cur.next
				self.__head = self.__head.next
				cur.next = self.__head
			else:
				self.__head = None
		else:			
			while cur.next != self.__head:
				if cur.item == item:
					prev.next = cur.next
					break
				else:
					prev = cur
					cur = cur.next
			if cur.item == item:
				prev.next = cur.next
			else:
				return
				
				
			 
		
		
			

'''实例化创建循环链表节点'''
node = CircularNode(20)

'''实例化创建空循环链表'''
link = SinglecircularLink() 

'''实例化创建循环链表'''
lin = SinglecircularLink(node)

'''随意添加元素'''
link.append(1)
link.append(2)
link.append(3)
link.append(4)

'''遍历循环链表'''
link.traversal()

'''删除指定元素'''
link.remove(2)

'''遍历循环链表'''
link.traversal()

输出结果：

1
2
3
4
1
3
4

三.定义一个函数实现将字符串的前n位进行左旋

def trval(element,n):
	s1 = element[:n]
	s2 = element[n:]
	a = s2 + s1
	return a

print(trval('hello',3))

输出结果：

lohel
吴喜钟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【稳住，can win】Python双向链表和单向循环链表
caoDanLife的博客
11-12 658
代码实现 实现简易版本的双向不循环链表和单向循环链表。定义了头插、尾插、任意位置插入、删除和查找函数接口。 双向链表 class Node(): def __init__(self, data): self.data = data self.pre = None self.next = None class DoubleLinkList(): def __init__(self): self._head = None
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
单向循环链表改成双向循环链表
weixin_46034571的博客
11-28 641
【代码】单向循环链表改成双向循环链表。
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3129
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
双向链表，单向循环链表和栈
qq_57106106的博客
07-30 508
由于单向链表只能通过指针单向的访问后继节点，不能向前遍历前驱节点，所以要引入双向链表。双向链表：在保持单向链表的基础上，既可以向后遍历后继节点，也可以向前遍历前驱节点。头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域//普通节点的数据域//指向下一个节点的指针//指向前一个节点的指针函数返回值：节点指针类型注意判断申请的空间是否合法。
单向循环链表和双向循环链表
指弹键盘哼民谣
11-25 2293
单向循环链表和双向循环链表1.单向循环链表2.双向循环链表 关于顺序表、单向链表和双向链表请将鼠标移步 此处点击 1.单向循环链表 代码实现： //#pragma once //作为头文件时加上这行 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef int DataType; t...
【循环链表】数据结构——单向循环链表和双向循环链表操作&笔记
皮皮不调皮的博客
03-23 8859
一、单向循环链表 将单链表的首尾节点相连就形成了单向循环链表。 1、单向循环链表的节点 2、单向循环链表的结构 单向循环链表只有一个节点时： 二、双向循环链表 1、双向循环链表示意图 2、双向循环链表节点设计 struct d_node{ int data; //数据域 struct d_node *next; struct d_node *prev; }; 3、双向循环链表的一般性结构 1）只有头结点的情况 2）有多个节点的情况 4、双向循环链表头插法插入节点 步骤： 1）p-&
每日一课 | 单向链表、双向链表和循环链表图文解析
Python大本营的博客
07-07 1220
02.单向链表、双向链表、循环链表大家好，我是营长，上期给大家分享——数组内存及数组面试常问算法全解析本期分享内容：单向链表、双向链表和循环链表图文解析本期邀请的是春晨溅雨·4位算法工程...
单向、双向链表
大树
12-08 2859
链表 一、介绍 1、介绍 ​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域 （1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针 （2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链
换汤不换药——Python实现双向链表与单向循环链表
the best messi的博客
03-23 364
前面我们讲到了Python中如何在没有指针的情况下来实现一个单链表这种数据结构，面向对象程序很高明啊，用一个类实现结点，有了结点就可以串联起来形成链表。既然大家都是链表，那么双向链表和单向循环链表跟单向链表不就是爸爸和儿子的关系嘛！那么我们就可以使用继承来实现双向链表和单向循环链表了，使得其中的很多代码都可以重用，提高了代码编写的效率。 ...
C语言中双向链表和双向循环链表详解
12-26
双向链表和双向循环链表 和单向链表相比，多了一个前驱结点。如果他为空，那么next和prior都指向自己。而对于双循环链表，只需要最后一个元素的next指向head->next，head->next的prior指向最后一个节点即可。 插入...
如何用C++实现双向循环链表
12-31
单向循环链表：不同于单向链表以 NULL 判断链表的尾部，单向循环链表的尾部链接到表头，因此当迭代操作到表头前即是尾部；双向链表：比单向链表多出指向前一个节点的指针，但实际上使用双向链表时很少使用不循环的；...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
【Python】pandas：排序、重复值、缺省值处理、合并、分组
yannan20190313的博客
07-30 511
【Python】pandas：排序（sort_index,sort_values,nsmallest,nlargest）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 997
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1093
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 271
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
十个好用到爆炸的Python技巧
最新发布
qq_36807888的博客
07-30 523
生成器表达式与列表推导式类似，但它创建的是一个迭代器，而不是一个完整的列表。zip(names, ages) 创建一个迭代器，该迭代器生成由 names 和 ages 列表中对应位置的元素组成的元组。defaultdict(int) 创建一个字典，如果访问的键不存在，则默认值为 0 (int 类型的默认值)。惰性求值: 元素是在需要时才计算的，而不是预先计算好存储在内存中，这在处理包含复杂计算的序列时非常有用。wrapper 函数是装饰器函数内部定义的函数，它调用被装饰的函数，并将结果转换为大写。
双向链表和循环链表区别
07-23
相比于单向链表，双向链表可以更方便地进行双向遍历和插入/删除操作。 循环链表是一种特殊的链表结构，它的最后一个节点的指针指向第一个节点，形成一个闭环。这样的设计使得在循环链表中可以通过任意节点的指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值