def push(self):
"""入栈"""
pass
def pop(self):
"""出栈"""
pass
def gethead(self):
"""得到栈顶的元素"""
pass
def isempty(self):
"""判断栈是否为空"""
pass
def size(self):
"""栈中的元素"""
pass
def next(self):
"""从栈顶遍历到栈底"""
pass
def clear(self):
"""清空栈"""
pass
#### 栈的初始化
栈的初始化就是创建一个空的栈，在本文章中栈的初始化就是创建`sequencestack`对象
stack = SequenceStack()
#### 入栈
将新的元素添加到栈顶的位置，`top`指针向上移1
代码实现
def push(self,arg):
"""入栈"""
if self.top + 1 >= self.maxsize:
print("栈已满，请重新选择操作")
return
self.stack_arr.append(arg)
self.top+=1
#### 出栈
删除栈顶的数据元素
代码实现
def pop(self):
"""出栈"""
if self.top < 0:
print("栈以空无法出栈")
return
self.top -= 1
return self.stack_arr.pop()
#### 取栈顶的元素
取栈顶的数据元素，但是不会影响栈的内容
代码实现
def gethead(self):
"""得到栈顶的元素"""
if self.top < 0:
print("栈以空")
return
return self.stack_arr[self.top]
#### 判断栈是否为空
判断栈是否为空
代码实现
def isempty(self):
"""判断栈是否为空"""
if len(self.stack_arr) == 0:
return True
else:
return False
#### 求栈中数据元素的个数
返回栈中的数据元素的个数
代码是实现
def size(self):
"""栈中的元素"""
return len(self.stack_arr)
#### 遍历栈中的所有元素
依次访问栈中的元素
代码实现
def next(self):
"""从栈顶遍历到栈底"""
for i in self.stack_arr:
print(i)
#### 清空栈
清空栈中的所有内容
代码实现
def clear(self):
"""清空栈"""
self.stack_arr.clear()
self.top = -1
### 栈的存储结构
#### 顺序存储
>
> 顺序栈：利用一组地址连续的的存储单元依次存放自栈底到栈顶的所有数据元素，利用了数组实现，我们将数组索引为0的一端作为栈底，另一端作为栈顶。
>
>
>
代码实现
class SequenceStack: """顺序栈"""
def \_\_init\_\_(self):
"""初始化"""
self.stack_arr = []
self.top = -1
self.maxsize = 10 # 设置栈的最大长度
def push(self, arg):
"""入栈"""
if self.top + 1 >= self.maxsize:
print("栈已满，请重新选择操作")
return
self.stack_arr.append(arg)
self.top += 1
def pop(self):
"""出栈"""
if self.top < 0:
print("栈以空无法出栈")
return
self.top -= 1
return self.stack_arr.pop()
def gethead(self):
"""得到栈顶的元素"""
if self.top < 0:
print("栈以空")
return
return self.stack_arr[self.top]
def isempty(self):
"""判断栈是否为空"""
if len(self.stack_arr) == 0:
return True
else:
return False
def size(self):
"""栈中的元素"""
return len(self.stack_arr)
def next(self):
"""从栈顶遍历到栈底"""
for i in self.stack_arr:
print(i)
def clear(self):
"""清空栈"""
self.stack_arr.clear()
self.top = -1
#### 链式存储
>
> 栈的链式存储结构称为链栈，利用的链表实现，链表中的每个元素由两个部分组成，一部分是存储本身的数据信息，一部分存储其直接后继的内存地址，分别叫做为`数据域`，`地址域`
>
>
>
链表和顺序表的功能都一样，我就不分开介绍了。因为存储结构的不同，导致代码内部的实现方法不同，大家仔细看一下代码实现的区别就行了。
链栈的基本结构
入栈出栈
代码实现
class LinkStack: def __init__(self): self.length = 0 self.top = None
def push(self, arg):
"""入栈"""
self.top = Node(data=arg, next=self.top)
self.length += 1
def pop(self):
"""出栈"""
if self.top == None:
print("栈已空，无法删除元素")
return
x = self.top.data
self.top = self.top.next
self.length -= 1
return x
def gethead(self):
"""获取栈顶的元素"""
if self.top == None:
print("栈已空，无法删除元素")
return
return self.top.data
def size(self):
"""求出栈中数据元素的个数"""
return self.length
def isEmpty(self):
"""判断栈是否为空"""
return self.top == None
def next(self):
"""遍历"""
p = self.top
while p != None:
print(p.data)
p = p.next
def clear(self):
"""清空栈"""
self.top = None
self.length = 0
### 顺序栈和链栈的区别
顺序存储：存储空间预先分配，可能会出现空间闲置或溢出的现象，元素个数不能自由扩充。
链式存储：动态分配，不会出现闲置或者栈溢出的现象，数据元素可以自由扩充。
### 栈的实战题目
实战的题目这里选择的就是牛客网中系列题 👉[传送门](https://gitee.com/vip204888)
由于篇章的限制，这里我就写一个比较经典的算法`有效括号匹配`，其余的题目我会出新的文章
**有效括号序列**
class SequenceStack: # 这个类可以选择上面的任意一个类，这里就不再进行重复了，主要说算法的实现方式 pass
def brace_match(s): """验证括号是否合法""" if len(s) == 0: """当长度为0的时候直接返回""" return False match = {'}': '{', ']': '[', ')': '('} # 右括号和左括号的键值队，用于后面的判断 stack = SequenceStack() # 创建栈 for ch in s: if ch in {'{', '[', '('}: # 只让左括号进栈 stack.push(ch) else: if stack.isEmpty(): return False elif stack.gethead() == match[ch]: # 当元素为右括号的时候，如果和栈顶的元素是一对括号的时候，栈顶的元素出栈 stack.pop() # stack_top() != match(ch) else: return False # 最后判断栈是否为空，如果栈为空则代表该序列是有效的括号序列 # 如果栈非空则代表栈不为空 if stack.isEmpty(): return True else: return False
## 队列
>
> 队列是一种运算受限的线性表，元素的添加操作在表的一端进行，而另一端的删除在另一端进行，允许插入的一端称为**队尾**，允许删除的一端称为**队头**。
>
>
>
假设队列 `q = [x1,x2,x3,,,,,xn]` `x1`是队头，`x2`是队尾，队列中的数据的入队序列是`x1,x2,x3,,,xn`,队列也只能按这个顺序进行出队，队列的特点是先进入队列的先出来，后进队的必须等前面的数据出队完成以后才可以出队，所以队列也成为先进先出表(`First in First out`)
### 队列的操作
队列由由多种实现方式，这里就选三个比较有代表性的实现方式讲解’`基础队列`,`循环队列`，`链队列`，代码放在后面，在讲解的途中就在分别展示了
>
> 说明：循环队列也是用数组来实现的，只不过通过，一些算法实现了数组空间的复用，而且不用频繁的移动数组中的元素。
>
>
>
初始化队列
#### 入队
#### 出队
原队列
>
> 出队
> 顺序队列：就是将第一个元素返回出去，其余的元素向前移动一单位
> 循环队列：就是将队头的指针向后移动一个单位，里面的元素变为无效数据，等待覆盖
> 链队列：就是链表的删除，将头部指针`front`，指向队头的的指针移动到，指向队头后一个元素
>
>
>
#### 遍历队列
>
> 顺序队列：将数组中的中的数据从开头一直遍历到最后
> 循环队列：创建一个临时的指针`tmp`该指针的位置和`front`指针一样,根据这个临时指针`tmp`的移动一次访问元素，直至临时指针和`rear`指针指向同一个位置的时候停止。
> 链队列：从头部直接遍历，循环调用`next`方法，直至到`next==null`的时候停止遍历
>
>
>
#### 清空队列
清空队列就是将队列中的所有元素清空，让队列回归最初的状态
>
> 顺序队列：清空列表中的元素，并将rear指针回归到最初的位置
> 循环队列：清空列表中的元素，并将指针回归到最初的位置
> 链队列：将头部指针指向为null
>
>
>
### 队列的存储结构
#### 顺序存储
基础队列的队头始终在数组的头部，每删除一个元素，整个队列就会向前移动一个单位，保证队列头始终在数组的第一个元素。这样我门就可以发现每执行删除操作(出队)，队列就要移动一次，这样会造成系统的额外开销。
class BaseQueue: def __init__(self): self.data = [] self.front = 0 self.rear = 0 # 记录队尾 self.maxlength = 10 # 设置队列的最大长度
def enqueue(self, arg):
"""入队"""
if self.rear >= self.maxlength:
print("队列已满")
return
self.rear += 1
self.data.append(arg)
def dequeue(self):
"""出队"""
if self.rear == 0:
print("队列已空")
return
self.rear -= 1
return self.data.pop(0)
def gethead(self):
"""获取队头"""
if self.rear == 0:
print("队列已空")
return
return self.data[0]
def size(self):
"""返回队列的长度"""
return self.rear
def isEmpty(self):
"""判断队列是否为空"""
return self.rear == 0
def next(self):
"""遍历并输出"""
p = self.rear
for i in range(0, p):
print(self.data[i])
def clear(self):
"""清空队列"""
self.data.clear()
self.rear = 0
#### 循环队列
>
> 循环队列，本质上还是使用数组进行实现，只是在逻辑上将首部、尾部连接起来，形成一个环状的循环队列，循环队列存储的元素个数比数组的长度少一，用来区分队满还是对待队空。
>
>
>
class LoopQueue: def __init__(self): self.maxsize = 10 self.data = [0 for i in range(self.maxsize)] self.front = 0 self.rear = 0
def enqueue(self, arg):
"""入队"""
if (self.rear + 1) % self.maxsize == self.front:
print("队列已满，无法入队")
return
self.data[self.rear] = arg
self.rear = (self.rear + 1) % self.maxsize
def dequeue(self):
"""出队"""
if self.isEmpty():
print("队列已空，无法读取元素")
return
tmp = self.data[self.front]
self.front = self.front + 1 % self.maxsize
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
