一、栈
1、概述
一种先入后出的线性数据结构,类似于叠盘子,先放下的盘子得最后才能拿到。在最上面的盘子我们称为栈顶,在最底下的盘子我们称为栈底,将盘子添加到栈顶的操作叫做入栈,将盘子从栈顶抽走的操作叫做出栈。
将上述的盘子替换为元素,就是我们常说的栈了。
2、常见操作
常见的操作一般是入栈,出栈,访问栈顶元素。
# 初始化一个栈
stack: list[int] = []
# 元素入栈
stack.append(1)
stack.append(2)
stack.append(3)
stack.append(4)
stack.append(5)
stack.append(6)
# 访问栈顶元素
peek: int = stack[-1]
# 元素出栈
pop: int = stack.pop()
# 获取栈的长度
size: int = len(stack)
# 判空
is_empty: bool = len(stack) == 0
3、实现
因为栈遵循先入后出的原则,因此我们只能对栈顶的元素进行操作,包括添加、删除动作,而我们熟悉的两种数据结构都可以在任意的位置添加和删除元素,所以我们在模拟栈的时候,一般将其功能做一定的限制,将栈不能实现的功能给禁用掉,使他对外表现的逻辑符合栈的特性。
(一)链表实现
概述
在用链表实现时,我们可以用链表的头节点作为栈顶,尾节点作为栈底。入栈时,我们只需要将元素加入到链表头部,出栈时,我们只需要将元素从链表头部删除。
例如
class ListNode():
def __init__(self, val):
self.val = val
self.next : ListNode | None = None
self._size = 0
# 基于链表实现栈的效果,链表需要提前定义好
class LinkListStack():
def __init__(self):
self._head: ListNode | None = None
self._size: int = 0
# 获得栈的长度
def get_size(self) -> int:
return self._size
# 判断栈是否为空
def is_empty(self) -> bool:
return self._size == 0
# 入栈
def push_ele(self, val):
node = ListNode(val)
node._head = node
node._size += 1
# 栈顶元素
def head(self):
if self.is_empty():
raise IndexError('栈为空,无元素')
return self._head.val
# 出栈
def pop_ele(self):
num = self.head()
self._head = self._head.next
self._size -= 1
return num
# 转化为列表用于打印
def to_list(self):
arr = []
node = self._head
while node:
arr.append(node.val)
node = node.next
arr.reverse()
return arr
(二)数组实现
概述
使用数组实现栈,可以将数组的结尾作为栈顶,入栈就是在尾部加入一个元素,出栈就是在尾部删除一个元素。
代码
# 数组实现
class ArrayStack():
# 定义数组
def __init__(self):
self._stack: list[int] = []
# 查询长度
def size(self):
return len(self._stack)
# 判空
def is_empty(self):
return self.size() == 0
# 入栈
def get_push(self, item):
self._stack.append(item)
# 出栈
def get_pop(self):
if self.is_empty():
raise IndexError('栈为空,无元素')
return self._stack.pop()
# 获得栈顶元素
def head(self):
if self.is_empty():
raise IndexError('栈为空,无元素')
return self._stack[-1]
# 打印
def to_list(self):
return self._stack
二、队列
1、概述
队列是一种先入先出的线性数据结构,类似于我们生活中的排队,先排队的人先离开,后排队的人后离开。队伍的头部我们称为队首,队伍的尾部我们称为队尾,加入队伍尾部我们称为入队,删除队伍头部我们称为出队。
2、常见操作
一般是元素入队,元素出队,访问队首元素。
因为python中自带了双向队列,所以我们直接引用双向队列来模拟队列。
from collections import deque
# 初始化
que = deque()
que.append(1)
que.append(2)
que.append(3)
que.append(4)
que.append(5)
# 队首元素
first = que[0]
# 元素出队
pop = que.popleft()
# 长度
size = len(que)
# 判空
is_empty = (len(que) == 0)
3、实现
(一)、链表实现
概述
链表的头结点表示队首,链表的尾结点表示队尾。队尾只能添加元素,队首只能删除元素。
代码
# 定义链表
class ListNode():
def __init__(self, val):
self.val = val
self.next : ListNode | None = None
self._size = 0
# 链表实现
class LinkListQueue():
def __init__(self):
self._front: ListNode | None = None
self._rear: ListNode | None = None
self._size: int = 0
# 获取长度
def size(self):
return self._size
# 判空
def is_empty(self):
return self._size == 0
# 入队
def get_push(self, num):
# 在尾结点后加
node = ListNode(num)
# 如果本身是空的,则头尾都指向该元素
if self._front is None:
self._front = node
self._rear = node
# 如果队列不是空,则加到尾结点
else:
self._rear.next = node
self._rear = node
self._size += 1
# 出队
def get_pop(self):
num = self.head()
self._front = self._front.next
self._size -= 1
return num
# 队首元素
def head(self):
if self.is_empty():
raise IndexError('队列为空')
# 转为列表输出
def to_list(self):
queue = []
tmp = self._front
while self._front:
queue.append(tmp.val)
tmp = tmp.next
return queue
(二)数组实现
概述
数组删除元素不如链表方便,时间复杂度在O(n),我们可以采用一种取巧的方式来避免这种情况,也就是设置两个指针,front和rear,分别指向队列的首个元素和最后一个元素。这样的话可以实现在删除时,通过直接移动队首指针,不体现删除元素的方式来模拟队列。
代码
class ArrayQueue():
def __init__(self, size):
self._nums: list[int] = [0] * size
self._front: int = 0
self._size: int = 0
# 获取队列的容量
def how_many(self):
return self._size
# 获取队列的长度
def size(self):
return self._size
# 判空
def is_empty(self):
return self._size == 0
# 入队
def get_push(self, num):
if self._size == self.how_many():
raise IndexError('队列已经满了嗷~')
rear = (self._front + self._size) % self.how_many()
self._nums[rear] = num
self._size += 1
# 出队
def get_pop(self):
num = self.head()
self._front = (self._front + 1) % self.how_many()
self._size -= 1
return num
# 获得队首
def head(self):
if self.is_empty():
raise IndexError('队列是空的嗷~')
return self._nums[self._front]
# 输出
def to_list(self):
res = [0] * self.size()
j = self._front
for i in range(self.size()):
res[i] = self._nums[(j % self.how_many())]
j += 1
return res
三、双向队列
1、概述
队列中我们只能,对队列的队首做删除,对队尾做添加动作,而双向队列更加灵活,可以对队首或者队尾做删除或者添加动作。
2、常见操作
获取队首元素,获取队尾元素,删除队首元素,删除队尾元素,增加队首元素,增加队尾元素
# 双向队列
deq = deque()
# 添加至队尾
deq.append(1)
deq.append(2)
# 添加至队首
deq.appendleft(3)
deq.appendleft(4)
# 队首元素
front = deq[0]
# 队尾元素
rear = deq[-1]
# 队首出队
get_pop_front = deq.popleft()
# 队尾出队
get_pop_rear = deq.pop()
# 获取长度
lenth = len(deq)
# 判空
is_empty: bool = (len(deq) == 0)
3、实现
(一)、链表实现
# 双向队列--链表实现
# 创建链表结点
class ListNode():
def __init__(self, val):
self.val = val
self.next : ListNode | None = None
self.prev : ListNode | None = None
self._size = 0
class LinkListDeque():
# 定义结点
def __init__(self):
self._front: ListNode | None = None
self._rear: ListNode | None = None
self._size = 0
# 长度
def size(self):
return self._size
# 判空
def is_empty(self):
return self._size == 0
# 入队
def get_push(self, num, is_front):
node = ListNode(num)
if self.is_empty():
self._front = self._rear = node
elif is_front:
self._front.next = node
node.next = self._front
self._front = node
else:
self._rear.next = node
node.prev = self._rear
self._rear = node
self._size += 1
# 队首入队
def get_push_front(self, num):
self.get_push(num, True)
# 队尾入队
def get_push_rear(self, num):
self.get_push(num, False)
# 出队
def get_pop(self, is_front):
if self.is_empty():
raise IndexError('双向队列为空~')
if is_front:
val = self._front.val
fnext: ListNode | None = self._front.next
if fnext != None:
fnext.prev = None
self._front.next = None
self._front = fnext
else:
val = self._rear.val
rprev: ListNode | None = self._rear.prev
if rprev != None:
rprev.prev = None
self._rear.next = None
self._rear = rprev
self._size -= 1
return val
# 队首出队
def get_pop_front(self):
return self.get_pop(True)
# 队尾出队
def get_pop_rear(self):
return self.get_pop(False)
# 获得队首
def peek_front(self):
if self.is_empty():
raise IndexError('双向队列为空~')
return self._front.val
# 获得队尾
def peek_rear(self):
if self.is_empty():
raise IndexError('双向队列为空~')
return self._rear.val
# 返回打印
def to_array(self):
node = self._front
res = [0] * self.size()
for i in range(self.size()):
res[i] = node.val
node = node.next
return res
(二)、数组实现
# 环形数组实现双向队列
class ArrayDeque():
def __init__(self, how_many):
self._nums = [0] * how_many
self._front = 0
self._size = 0
# 容量
def how_many(self):
return len(self._nums)
# 大小
def size(self):
return self._size
# 判空
def is_empty(self):
return self._size == 0
# 获取当前位置
def index(self, i):
res = (i + self.how_many()) % self.how_many()
return res
# 加入队首
def get_push_front(self, num):
if self._size == self.how_many():
print('双向队列满了~')
return
self._front = self.index(self._front - 1)
self._nums[self._front] = num
self._size += 1
# 加入队尾
def get_push_rear(self, num):
if self._size == self.how_many():
print('双向队列满了~')
return
rear = self.index(self._front + self._size)
self._nums[rear] = num
self._size += 1
# 删除队首
def get_pop_front(self):
num = self.peek_front()
self._front = self.index(self._front + 1)
self._size -= 1
return num
# 删除队尾
def get_pop_rear(self):
num = self.peek_rear()
self._size -= 1
return num
# 获得队首
def peek_front(self):
if self.is_empty():
raise IndexError('双向队列为空~')
return self._nums[self._front]
# 获得队尾
def peek_rear(self):
if self.is_empty():
raise IndexError('双向队列为空~')
rear = self.index(self._front + self._size - 1)
return self._nums[rear]
# 做数组输出
def to_array(self):
res = []
for i in range(self._size):
res.append(self._nums[self.index(self._front + i)])
return res