双向链表和单向循环链表

最新推荐文章于 2023-11-04 16:31:41 发布

吴喜钟

最新推荐文章于 2023-11-04 16:31:41 发布

阅读量503

点赞数

文章标签： python

本文链接：https://blog.youkuaiyun.com/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()        #若为非空链表则遍历会显示对应元素值

输出结果：

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.单向循环链表的创建

'''创建单向循环链表节点模板'''
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()

输出结果：

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()

输出结果：

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()

输出结果：

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

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

print(trval('hello',3))

输出结果：

lohel