单向循环链表:
单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点
- is_empty() 判断链表是否为空
- length() 返回链表的长度
- travel() 遍历
- add(item) 在头部添加一个节点
- append(item) 在尾部添加一个节点
- insert(pos, item) 在指定位置pos添加节点
- remove(item) 删除一个节点
- search(item) 查找节点是否存在
class Node():
'''节点'''
def __init__(self,elem):
self.elem = elem
self.next = None
# node = Node(100)
class SingleLinkList():
'''单向循环链表'''
def __init__(self,node=None):
self._head = node
if node:
node.next = node
def is_empty(self):
'''链表是否为空'''
return self._head == None
def length(self):
'''链表长度'''
# cur游标,用来移动遍历节点
if self.is_empty():
return 0
cur = self._head
# count记录数量
count = 1
while cur.next != self._head:
count += 1
cur = cur.next
return count
def travel(self):
# '''遍历整个链表'''
if self.is_empty():
return
cur = self._head
while cur.next != self._head:
print(cur.elem,end=" ")
cur = cur.next
#退出循环 cur指向尾节点 尾节点元素未打印
print(cur.elem)
print("")
def add(self,item):
'''链表头部添加元素'''
node = Node(item)
if self.is_empty():
self._head = node
node.next = node
else:
cur = self._head
while cur.next != self._head:
cur = cur.next
#退出循环,cur指向尾节点
node.next = self._head
self._head = node
cur.next = self._head
def append(self,item):
# '''链表尾部添加元素'''
node = Node(item)
if self.is_empty():
self._head = node
node.next = node
else:
cur = self._head
while cur.next != self._head:
cur = cur.next
node.next = self._head
cur.next = node
def insert(self,pos,item):
'''指定位置添加元素
:param pos 从0开始
'''
if pos<=0:
self.add(item)
elif pos>(self.length()-1):
self.append(item)
else:
pre = self._head
count = 0
while count < (pos-1):
count += 1
pre = pre.next
# 当循环推出后,pre指向pos-1
node = Node(item)
node.next = pre.next
pre.next = node
def remove(self,item):
'''删除节点'''
if self.is_empty():
return
cur = self._head
pre = None
while cur.next != self._head:
if cur.elem == item:
# 先判断此节点是否为头节点
if cur == self._head:
#头节点的情况
#找尾节点
rear = self._head
while rear.next != self._head:
rear = rear.next
self._head= cur.next
rear.next = self._head
else:
# 中间节点
pre.next = cur.next
return
else:
pre = cur
cur = cur.next
# 退出循环,cur指向尾节点
if cur.elem == item:
if cur == self._head:
#链表只有一个节点
self._head = None
else:
pre.next = cur.next
def search(self,item):
'''查找节点是否存在'''
if self.is_empty():
return False
cur = self._head
while cur.next != self._head:
if cur.elem == item:
return True
else:
cur = cur.next
#退出循环,cur指向尾部节点
if cur.elem == item :
return True
return False
# 遍历整个链表
# add(item)
# 链表头部添加元素
# append(item)
# 链表尾部添加元素
# insert(pos, item)
# 指定位置添加元素
# remove(item)
# 删除节点
# search(item)
# 查找节点是否存在
if __name__ =="__main__":
linklist = SingleLinkList()
print(linklist.is_empty())
print(linklist.length())
linklist.append(1)
print(linklist.is_empty())
print(linklist.length())
linklist.append(2)
linklist.add(8)
linklist.append(3)
linklist.append(4)
linklist.append(5)
linklist.append(6)
# 8 1 2 3 4 5 6
linklist.insert(-1,9) #9 8 1 2 3 4 5 6
linklist.travel()
linklist.insert(2,100)#9 8 1 100 2 3 4 5 6
linklist.travel()
linklist.insert(10,200)#9 8 1 100 2 3 4 5 6 200
linklist.travel()
linklist.remove(100)
linklist.travel()
linklist.remove(9)
linklist.travel()
linklist.remove(200)
linklist.travel()
linklist.insert(2,300)
linklist.travel()
结果:
True
0
False
1
9 8 1 2 3 4 5 6
9 8 100 1 2 3 4 5 6
9 8 100 1 2 3 4 5 6 200
9 8 1 2 3 4 5 6 200
8 1 2 3 4 5 6 200
8 1 2 3 4 5 6
8 1 300 2 3 4 5 6
Process finished with exit code 0
栈:
栈(stack),有些地方称为堆栈,是一种容器,可存入数据元素、访问元素、删除元素,它的特点在于只能允许在容器的一端(称为栈顶端指标,英语:top)进行加入数据(英语:push)和输出数据(英语:pop)的运算。没有了位置概念,保证任何时候可以访问、删除的元素都是此前最后存入的那个元素,确定了一种默认的访问顺序。
由于栈数据结构只允许在一端进行操作,因而按照后进先出(LIFO, Last In First Out)的原理运作。
栈结构实现:
栈可以用顺序表实现,也可以用链表实现。
栈的操作:
- Stack() 创建一个新的空栈
- push(item) 添加一个新的元素item到栈顶
- pop() 弹出栈顶元素
- peek() 返回栈顶元素
- is_empty() 判断栈是否为空
- size() 返回栈的元素个数
#!usr/bin/env python
# -*- coding:utf-8 _*-
"""
@author: yxy
@file: 06_stack.py
@time: 2022/06/14
@desc:
"""
class Stack():
'''栈'''
def __init__(self):
self.__list = []
def push(self,item):
'''添加一个新的元素item到栈顶'''
self.__list.append(item)
def pop(self):
'''淡出栈顶元素'''
return self.__list.pop()
def peek(self):
'''返回栈顶元素'''
if self.__list:
return self.__list[-1]
else:
return None
def is_empty(self):
'''判断栈是否为空'''
return self.__list == []
def size(self):
'''返回栈的元素个数'''
return len(self.__list)
if __name__ == "__main__":
s = Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
结果:
4
3
2
1
Process finished with exit code 0
队列
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。
队列是一种先进先出的(First In First Out)的线性表,简称FIFO。允许插入的一端为队尾,允许删除的一端为队头。队列不允许在中间部位进行操作!假设队列是q=(a1,a2,……,an),那么a1就是队头元素,而an是队尾元素。这样我们就可以删除时,总是从a1开始,而插入时,总是在队列最后。这也比较符合我们通常生活中的习惯,排在第一个的优先出列,最后来的当然排在队伍最后。
队列的实现
同栈一样,队列也可以用顺序表或者链表实现。
操作
- Queue() 创建一个空的队列
- enqueue(item) 往队列中添加一个item元素
- dequeue() 从队列头部删除一个元素
- is_empty() 判断一个队列是否为空
- size() 返回队列的大小
class Queue():
'''队列'''
def __init__(self):
self.__list = []
def enqueue(self,item):
'''往队列里添加一个item元素'''
self.__list.append(item)
def dequeue(self):
'''从队列头部删除一个元素'''
return self.__list.pop(0)
def is_empty(self):
'''判断一个队列是否为空'''
return self.__list == []
def size(self):
'''返回队列的大小'''
return len(self.__list)
if __name__ == "__main__":
s = Queue()
s.enqueue(1)
s.enqueue(2)
s.enqueue(3)
s.enqueue(4)
print(s.dequeue())
print(s.dequeue())
print(s.dequeue())
print(s.dequeue())
结果:
1
2
3
4
Process finished with exit code 0
双端队列
双端队列(deque,全名double-ended queue),是一种具有队列和栈的性质的数据结构。
双端队列中的元素可以从两端弹出,其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。
操作
- Deque() 创建一个空的双端队列
- add_front(item) 从队头加入一个item元素
- add_rear(item) 从队尾加入一个item元素
- remove_front() 从队头删除一个item元素
- remove_rear() 从队尾删除一个item元素
- is_empty() 判断双端队列是否为空
- size() 返回队列的大小
实现
class deque():
'''双端队列'''
def __init__(self):
self.__list = []
def add_front(self, item):
'''往队列里头部添加一个item元素'''
self.__list.insert(0,item)
def add_rear(self, item):
'''往队列尾部添加一个item元素'''
self.__list.append(item)
def pop_front(self):
'''删除队列头部一个item元素'''
return self.__list.pop(0)
def pop_rear(self):
'''删除队列尾部一个item元素'''
return self.__list.pop()
def is_empty(self):
'''判断一个队列是否为空'''
return self.__list == []
def size(self):
'''返回队列的大小'''
return len(self.__list)