五、栈与队列（1）

最新推荐文章于 2024-08-06 21:36:54 发布
最新推荐文章于 2024-08-06 21:36:54 发布
阅读量679 收藏 14
点赞数 23
分类专栏： 算法 文章标签： windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49206002/article/details/140794703
版权

五、栈与队列（1）

理论基础

在Python中，与栈（stack）[]和队列（queue）= deque()相关的问题可以通过一些内置的数据结构和模块来解答。

1. Python中的stack是容器么？

是的，栈（stack）是一种常用的数据容器。在Python中，栈通常使用列表（list）来实现，虽然Python没有专门的栈数据结构，但列表提供的append()和pop()方法可以非常方便地实现栈的功能。

2. 我们使用的stack是属于哪个版本的STL？

Python中没有C++标准模板库（STL）的概念，因为Python的标准库已经包含了许多内置的容器类型和模块来实现类似的功能。栈在Python中可以使用内置的list实现，也可以使用collections模块中的deque来实现。

3. 我们使用的stack是如何实现的？

在Python中，可以通过list或collections.deque来实现栈：

  • 使用list实现栈：

    stack = []
stack.append(1)  # 压栈
stack.append(2)  # 压栈
item = stack.pop()  # 出栈，item = 2

  • 使用collections.deque实现栈：

    from collections import deque

stack = deque()
stack.append(1)  # 压栈
stack.append(2)  # 压栈
item = stack.pop()  # 出栈，item = 2

deque（双端队列）在性能上比list更优，因为它是为高效的头部和尾部操作而设计的。

4. stack提供迭代器来遍历stack空间么？

是的，Python中的list和deque都提供迭代器来遍历其元素。例如：

  • 使用list迭代：

    stack = [1, 2, 3, 4]
for item in stack:
    print(item)

  • 使用deque迭代：

    from collections import deque

stack = deque([1, 2, 3, 4])
for item in stack:
    print(item)

这两种方法都可以方便地遍历栈中的所有元素。

在Python中，collections.deque（双端队列）是一个可以高效地在两端添加和删除元素的容器。要实现先进先出（FIFO）队列，可以使用deque的以下方法：

  • append() 在队列尾部添加元素
  • pop()尾部弹出并返回元素
  • popleft() 从队列头部删除并返回元素
  • appendleft(）队列头部添加元素

deque 的其他方法

collections.deque 还提供了其他有用的方法，如：

  • extend(iterable)：在队列尾部添加多个元素
  • extendleft(iterable)：在队列头部添加多个元素（注意，这些元素会以倒序添加到队列中）
  • remove(value)：移除队列中第一次出现的value
  • rotate(n)：旋转队列，正数n将元素右移，负数n将元素左移

这些方法使得deque非常灵活，可以用于多种不同的数据处理需求。

代码示例

from collections import deque

# 创建一个deque并添加一些元素
queue = deque(['a', 'b', 'c'])

# 在尾部添加元素
queue.append('d')
print(queue)  # 输出: deque(['a', 'b', 'c', 'd'])

# 在头部添加元素
queue.appendleft('z')
print(queue)  # 输出: deque(['z', 'a', 'b', 'c', 'd'])

# 从尾部删除元素
print(queue.pop())  # 输出: d
print(queue)        # 输出: deque(['z', 'a', 'b', 'c'])

# 从头部删除元素
print(queue.popleft())  # 输出: z
print(queue)            # 输出: deque(['a', 'b', 'c'])

# 扩展队列
queue.extend(['e', 'f'])
print(queue)  # 输出: deque(['a', 'b', 'c', 'e', 'f'])

# 头部扩展队列
queue.extendleft(['y', 'x']) # 倒序插入
print(queue)  # 输出: deque(['x', 'y', 'a', 'b', 'c', 'e', 'f'])

# 旋转队列
queue.rotate(2)
print(queue)  # 输出: deque(['e', 'f', 'x', 'y', 'a', 'b', 'c'])

queue.rotate(-3)
print(queue)  # 输出: deque(['y', 'a', 'b', 'c', 'e', 'f', 'x'])

232.用栈实现队列

借助另一个出栈，栈实现队列的出队操作效率低下：栈底元素（对应队首元素）无法直接删除，需要将上方所有元素出栈。
可以设计栈 A 用于加入队尾操作，栈 B 用于将元素倒序，从而实现删除队首元素。
法一，老老实实每次倒出来再倒回去.

class MyQueue:

    def __init__(self):
        self.a, self.b = [], []


    def push(self, x: int) -> None:
        self.a.append(x)


    def pop(self) -> int:
        # a not null
        while self.a:
            self.b.append(self.a.pop())
        ans = self.b.pop()
        while self.b:
            self.a.append(self.b.pop())
        return ans


    def peek(self) -> int:
        # a not null
        while self.a:
            self.b.append(self.a.pop())
        ans = self.b[-1]
        while self.b:
            self.a.append(self.b.pop())
        return ans


    def empty(self) -> bool:
        return not self.a


# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

法二，始终保持B是倒序A是正序B是倒序的，反正要peek完B里面的才轮到后面新A加进来的。而且也没说要返回一个完整的队列。
如果B不为空，返回B的最后一个，也就是原来最先进A的；如果B为空，这时有两个情况，A也为空，返回-1，A不为空，说明（可能一开局或者已经pop完了），就把A倒序倒到B中。`刚开始不理解，万一后面A又push新的了怎么办？新的还在A里面，如果要pop或者peek，反正先把B 里面的搞完，如果还要继续peek，此时B空了，又回到A不空，B空的条件，把A倒进B。

类内部函数互相调用也得self，不可以直接从B里面pop，因为不知道B是否空return self.B.pop()虽然能直接返回，但是错错错
代码复用，减少错的可能

class MyQueue:

    def __init__(self):
        self.A, self.B = [], []


    def push(self, x: int) -> None:
        self.A.append(x)


    def pop(self) -> int:
        # peek返回的元素肯定是从B里面来的
        # 删除也在B里面删 直接pop即可
        # 要返回删除的值
        val = self.peek()  # 类内部调用
        self.B.pop() 
        return val  
        # 不可以直接从B里面pop，因为不知道B是否空
        # return self.B.pop()


    def peek(self) -> int:
        if self.B:
            return self.B[-1]
        elif not self.A:
            return -1
        else:
            while self.A:
                self.B.append(self.A.pop())
            return self.B[-1]



    def empty(self) -> bool:
        return not self.A and not self.B  # A B都是空(false)才true,



# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

时间复杂度: push和empty为O(1), pop和peek为O(n)
空间复杂度: O(n)

225. 用队列实现栈

只用一个队列实现，此时队列只能popleft(),拿出来再放到末尾,用len()控制循环

class MyStack:

    def __init__(self):
        self.a = deque()
        


    def push(self, x: int) -> None:
        self.a.append(x)


    def pop(self) -> int:
        for _ in range(len(self.a)-1):
            self.a.append(self.a.popleft())
        return self.a.popleft()


    def top(self) -> int:
        for _ in range(len(self.a)-1):
            self.a.append(self.a.popleft())
        ans = self.a.popleft()
        self.a.append(ans)
        return ans


    def empty(self) -> bool:
        return not self.a



# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

20. 有效的括号

利用先进后出（更早期待，更晚遇到）
先想有哪些错误类型1 左括号多了 2 右括号多了 3 括号不匹配（即与预判的不相等）

class Solution:
    def isValid(self, s: str) -> bool:
        stack = []

        # 不考虑空
        for c in s:
            if c == '(':
                stack.append(')')
            elif c == '{':
                stack.append('}')
            elif c == '[':
                stack.append(']')
            elif stack and c == stack.pop() :
                continue
            else:
                return False  # 匹配不上的,或者右边多，stack已空
            
        return not stack

时间复杂度: O(n)
空间复杂度: O(n)

1047. 删除字符串中的所有相邻重复项

这种重复or对称的都可以用更早预判放入栈，更晚遇到相比较的栈的数据结构处理

class Solution:
    def removeDuplicates(self, s: str) -> str:
        stack = []
        for c in s:
            if stack:
                temp = stack.pop()
                if c == temp:
                    s = s.replace(c+c, "")
                else:
                    stack.append(temp)
                    stack.append(c)
            else:
                stack.append(c)
            
        return s

想知道栈的最后一个直接[-1]即可
类似消消乐，也可以把所有都放入栈，遇到相同的消除，最后"".join(res)字符串拼接一下

小霖同学onism
关注
  • 23
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
栈与队列。
10-11
栈和队列是两种重要的线性结构，定义，表示方法，代码实现
C++数据结构实验二：栈与队列的应用
03-31
1．熟练掌握栈和队列的基本运算。 2．掌握在两种存储结构上对栈和队列所施加的入栈、出栈、入队和出队的实现。 3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列...
如何使用JavaScript实现栈与队列
12-11
栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。如果你是一个程序员，那么请听我讲两个启发性的例子:使用堆栈来组织数据，来实现文本编辑器的“撤消”操作;...
栈与队列的基本操作
11-11
1. 掌握栈的先进后出的特点。 2. 掌握栈的初始化、进栈、退栈、取栈顶、判栈空等基本操作。 3. 运用栈的基本操作解决一些简单的实际问题。 4. 掌握队列的先进先出的特点。 5. 掌握队列的初始化、入队、出队、取队首...
C++中栈与队列的函数
12-22
栈的应用： 　头文件include 　定义栈 　stack<type>q; 　其中type是栈中数据的类型、q是定义的栈的名字； 　比较常用的函数： 　q.push();将元素压入栈中； 　q.pop(); 将栈顶元素删除； 　q.empty();判断...
Linux学习笔记：Linux基础知识汇总（个人复习版）
欢迎相互探讨交流知识呀~
08-05 604
使用fdisk -l查看分区挂载情况，或者查看/etc/mtab文件，然后找到最接近的挂载点信息。4、创建站点主页 【eg.在/var/www/html内新建index.html】write_enable=YES//ftp可写，即上传权限；下载权限是默认赋予的。将数据同步写入硬盘中的指令，在关机之前输入，可以多输几次。使用df命令，如df -h，查看磁盘分区的挂载点。使用lsblk命令，查看系统的磁盘设备使用情况。-a：显示所有文件（包括隐藏文件），简洁版。-R：显示所有文件以及子目录下文件，简洁版。
使用ollama取代openai的api进行graphRAG失败记录
caoyongsheng的博客
08-06 57
【代码】使用ollama取代openai的api进行graphRAG失败记录。
Stream 33
2301_81744437的博客
08-02 272
【代码】Stream 33。
Spring AOP
最新发布
c1tenj2的博客
08-06 369
StudentServiceImpl实现StudentService接口@Service@Override@Override@Override@Override通知类和通知（在里面定义切入点，绑定切入点和通知）@Component@Aspect //让context知道我们这里要用aop//切入点//打印时间。
conda-pack基于同一种操作系统的环境打包教程
qq_60815011的博客
08-06 669
conda-pack基于同一种操作系统的环境打包教程
Linux 常用命令 - df 【显示磁盘空间的使用情况】
随便转转
08-06 514
df 这个命令源自于 “disk free” 的简写，主要用于显示文件系统的磁盘空间占用情况。它能够帮助用户了解各个挂载点的可用空间和已用空间，以便于管理存储资源。
Litestar GET function blocks OpenAI
suiusoar
08-06 386
Litestar GET 函数阻塞 OpenAI
40.组合综合Ⅱ
argcargv的博客
08-02 232
中的每个数字在每个组合中只能使用。给定一个候选人编号的集合。中所有可以使数字和为。解集不能包含重复的组合。
顺序表和链表
2401_84421190的博客
08-06 253
线性表（linearlist）是。线性表是⼀种在实际中⼴泛使⽤的 数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...线性表在，也就说是连续的⼀条直线。但是在，线性 表在物理上存储时，通常以数组和链式结构的形式存储。物理结构：数据在内存上的存储形式逻辑结构：人为想象出来的数据的组织形式，如排队顺序表是⽤⼀段物理地址连续的存储单元依次存储数据元素的线性结构，⼀般情况下采⽤存储。
Windows 常用命令集锦
AngelCryToo的专栏
07-29 464
Windows 操作系统提供了大量命令行工具，用于管理系统、执行任务和调试问题。本文将介绍 Windows 系统中最常用的命令，涵盖文件和目录管理、系统信息、网络管理、进程管理和磁盘管理等方面。
java学习记录
qq_62499218的博客
08-06 239
1.当修改数据时，会先判断该属性是否存在或者是否为空串2.在Dao层声明该方法3.在Controller类中，编写代码来接收http请求。
如何高效率组装树形数据
码眼的博客
08-06 62
说到组装树形结构数据，一般首先想到的就是递归或者反射处理，这种处理数据的方式比较直观简单，但是有个缺点，如果数据量过大比如几万几十万，处理的速度就会非常慢。下面是一种高效处理树形数据的代码。
Mybatis
m0_73570063的博客
08-06 751
在查询的时候我们需要用到resultMap关键字，这样查出来的每一行的数据都会映射这个类型的对象，再resultMap中最好写类的全名，这样肯定不会出错，但是不写类的全名有可能会出错，在查询的时候一般会用到条件语句，我们mybatis提供了一些动态SQL语句供我们使用，是一些动态sql的标签例如：where，if，bind 等等上面bind标签中是重新定义参数内容，这样传入的参数前面或者后边可以有任意个字符，就达到了模糊查询的条件在接口中我们就需要有与上面id相同的方法名在controller类里面。
『 C++11 』模板可变参数包,Lambda表达式与 function 包装器
小侯宝的博客
08-03 1149
这篇文章深入探讨了C++11引入的几个关键特性:可变参数模板、Lambda表达式和std::function包装器。文章通过详细的解释和丰富的代码示例,阐述了这些特性的概念、语法和使用方法,展示了它们如何增强C++的泛型编程能力和函数式编程特性。同时,文章还介绍了std::bind的用法,进一步丰富了C++11的函数对象操作能力。整体而言,本文为理解和应用这些现代C++特性提供了全面而实用的指导。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值