一.双向链表的操作
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