数据结构与算法----栈和队列(Stack &amp； Queue）

本文链接：https://blog.csdn.net/2401_84159911/article/details/138929739

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

    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

顺序栈和链栈的区别

顺序存储：存储空间预先分配，可能会出现空间闲置或溢出的现象，元素个数不能自由扩充。
链式存储：动态分配，不会出现闲置或者栈溢出的现象，数据元素可以自由扩充。

栈的实战题目

实战的题目这里选择的就是牛客网中系列题 👉传送门
在这里插入图片描述
由于篇章的限制，这里我就写一个比较经典的算法有效括号匹配，其余的题目我会出新的文章
有效括号序列

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("队列已满，无法入队")


![img](https://img-blog.csdnimg.cn/img_convert/a4710827904c698a9f95b900a04a23a2.png)
![img](https://img-blog.csdnimg.cn/img_convert/eff5c1fccc0eec802b2a1626ea95c28c.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

front = 0
        self.rear = 0

    def enqueue(self, arg):
        """入队"""
        if (self.rear + 1) % self.maxsize == self.front:
            print("队列已满，无法入队")


[外链图片转存中...(img-avLeCdIQ-1715791791718)]
[外链图片转存中...(img-lrMBVNtM-1715791791718)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**