7-3 堆栈模拟队列(25 point(s)) 【数据结构】

7-3 堆栈模拟队列(25 point(s))

设已知有两个堆栈S1和S2,请用这两个堆栈模拟出一个队列Q。

所谓用堆栈模拟队列,实际上就是通过调用堆栈的下列操作函数:

int IsFull(Stack S):判断堆栈S是否已满,返回1或0;
int IsEmpty (Stack S ):判断堆栈S是否为空,返回1或0;
void Push(Stack S, ElementType item ):将元素item压入堆栈S;
ElementType Pop(Stack S ):删除并返回S的栈顶元素。

实现队列的操作,即入队void AddQ(ElementType item)和出队ElementType DeleteQ()。
输入格式:

输入首先给出两个正整数N1和N2,表示堆栈S1和S2的最大容量。随后给出一系列的队列操作:A item表示将item入列(这里假设item为整型数字);D表示出队操作;T表示输入结束。
输出格式:

对输入中的每个D操作,输出相应出队的数字,或者错误信息ERROR:Empty。如果入队操作无法执行,也需要输出ERROR:Full。每个输出占1行。
输入样例:

3 2
A 1 A 2 A 3 A 4 A 5 D A 6 D A 7 D A 8 D D D D T

输出样例:

ERROR:Full
1
ERROR:Full
2
3
4
7
8
ERROR:Empty

思路
用小容量栈 来作为 入队栈 大容量栈 来作为出队栈
当小容量栈 满 并且 大容量栈不为空的时候 这时候就是队满
因为 出队栈还没出完 也就是 入队栈的元素还不能够转移到出队栈 而入队栈 又满了 这时候 就没法入队了

然后 出队的时候 两栈均为空的时候 就是 栈空

如果出队栈为空 那么先要把 入队栈的所有元素都转移到 出队栈 然后再从 出队栈 出队 这就是为什么要用 小容量栈 来作为 入队栈

然后 为什么要这样做呢

因为 栈的特点是 先入后出

那么 入队栈 的所有元素 压入 出队栈后 出队栈的栈顶元素 就是先入的
就满足队列的性质

比如 1 2 3 4 5

然后 进入 入队栈

就是 这里写图片描述

但是 出队的顺序 应该是

这里写图片描述

所以 我们借用另一个 出队栈

这里写图片描述

通过从 入队栈 一个一个 pop 然后 一个一个 push 进 出队栈

然后要出队 就可以实现了

所以 要满足 出队栈的容量 大于等于 入队栈的容量

AC代码

#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <stack>
#include <set>
#include <numeric>
#include <sstream>
#include <iomanip>
#include <limits>

#define CLR(a) memset(a, 0, sizeof(a))
#define pb push_back

using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair<string, int> psi;
typedef pair<string, string> pss;

const double PI = 3.14159265358979323846264338327;
const double E = exp(1);
const double eps = 1e-30;

const int INF = 0x3f3f3f3f;
const int maxn = 1e4 + 5;
const int MOD = 1e9 + 7;

stack <int> s1, s2;

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    if (n > m)
        swap(n, m);
    char c;
    int len, num;
    while (scanf(" %c", &c) && c != 'T')
    {
        if (c == 'A')
        {
            scanf("%d", &num);
            if (s1.size() == n && s2.size() != 0)
                printf("ERROR:Full\n");
            else if (s1.size() == n)
            {
                len = s1.size();
                while (len--)
                {
                    int temp = s1.top();
                    s1.pop();
                    s2.push(temp);
                }
                s1.push(num);
            }
            else
                s1.push(num);
        }
        else
        {
            if (s1.size() == 0 && s2.size() == 0)
                printf("ERROR:Empty\n");
            else 
            {
                if (s2.size() == 0)
                {
                    int len = s1.size();
                    while (len--)
                    {
                        int temp = s1.top();
                        s1.pop();
                        s2.push(temp);
                    }
                }
                printf("%d\n", s2.top());
                s2.pop();
            }
        }
    }
}






<think>嗯,用户之前问过Python中不同数据结构的录入方式,现在他们进一步询问所有高级结构在Python中怎么录入。我需要明确用户所说的“高级结构”具体指哪些。通常,除了列表、元组、字典、集合这些基础数据结构,高级结构可能包括队列堆栈、链表、树、图、堆、链表等,或者是像命名元组、默认字典这样的collections模块中的结构。 首先,要确认用户是否了解基础结构,之前的回答已经涵盖了列表、元组、字典、集合和字符串,以及简单的队列堆栈实现。现在用户可能想了解更复杂或更专门的数据结构。比如链表、树、图这些可能需要用类来实现,或者使用内置模块如collections、heapq等。 接下来,我需要考虑用户的使用场景。可能是学生或刚入门的开发者,想要更深入地了解Python中如何处理更复杂的数据结构。他们可能需要具体的代码示例和实际应用场景,以便更好地理解和应用。 还要检查是否有遗漏的结构。比如堆(heapq)、双向队列(deque)、默认字典(defaultdict)、有序字典(OrderedDict)、命名元组(namedtuple)、链式映射(ChainMap)等。此外,树和图这类结构通常需要自定义实现,但也有一些库如graphlib或第三方库,不过标准库中可能需要用类来手动构建。 需要确保回答的结构清晰,分点说明每种高级结构的录入方法,包括必要的导入模块和示例代码。同时,要强调这些结构的使用场景,帮助用户理解何时选择哪种结构。 另外,注意用户可能对某些术语不太熟悉,比如“堆”和“优先队列”的关系,需要简要说明。同时,像链表这样的结构在Python中虽然没有内置,但可以用类来模拟,这部分也要给出例子。 最后,总结部分要再次对比各种高级结构的特点,帮助用户做出合适的选择。避免使用过于专业的术语,保持解释的易懂性,并确保代码示例正确,符合Python语法。</think>在Python中,除了基础数据结构(如列表、字典等),高级数据结构通常需要通过 **自定义类** 或 **内置模块** 实现。以下是常见高级结构的定义和录入方式: --- ### ✨ 高级数据结构分类及实现 #### **1. 队列(Queue)** - **类型**:普通队列、双端队列、优先队列 - **实现方式**: ```python # 普通队列(FIFO) from queue import Queue q = Queue() q.put("A") # 入队 q.get() # 出队 # 双端队列(支持两端操作) from collections import deque dq = deque([1,2,3]) dq.appendleft(0) # 左侧入队 → deque([0,1,2,3]) dq.pop() # 右侧出队 → 3 # 优先队列(堆实现) import heapq heap = [] heapq.heappush(heap, 3) # 录入元素 heapq.heappush(heap, 1) # 自动按最小堆排序 → [1,3] heapq.heappop(heap) # 弹出最小值 → 1 ``` --- #### **2. 堆栈(Stack)** - **实现方式**:直接用列表模拟(LIFO) ```python stack = [] stack.append(10) # 入栈 → [10] stack.append(20) # → [10,20] stack.pop() # 出栈 → 20 ``` --- #### **3. 链表(Linked List)** - **实现方式**:自定义类 ```python class Node: def __init__(self, data): self.data = data self.next = None # 创建链表 head = Node(1) head.next = Node(2) head.next.next = Node(3) # 1 → 2 → 3 ``` --- #### **4. 树(Tree)** - **示例**:二叉树 ```python class TreeNode: def __init__(self, value): self.val = value self.left = None self.right = None # 录入树结构 root = TreeNode(10) root.left = TreeNode(5) root.right = TreeNode(15) # 10 # / \ # 5 15 ``` --- #### **5. 图(Graph)** - **实现方式**:邻接表或邻接矩阵 ```python # 邻接表(字典实现) graph = { "A": ["B", "C"], "B": ["D"], "C": ["E"], "D": [], "E": [] } # 邻接矩阵(二维列表) matrix = [ [0,1,1,0,0], # A连接B,C [0,0,0,1,0], # B连接D [0,0,0,0,1], # C连接E [0,0,0,0,0], [0,0,0,0,0] ] ``` --- #### **6. 集合增强型结构** - **命名元组(Named Tuple)** ```python from collections import namedtuple Point = namedtuple("Point", ["x", "y"]) # 定义结构 p = Point(3, y=4) # 录入数据 → Point(x=3, y=4) ``` - **默认字典(DefaultDict)** ```python from collections import defaultdict d = defaultdict(list) # 未定义键时默认返回空列表 d["colors"].append("red") # 自动创建键 → {&#39;colors&#39;: [&#39;red&#39;]} ``` --- ### ✨ **关键总结** | 数据结构 | 实现方式 | 核心方法/模块 | 典型场景 | |----------------|------------------------------|--------------------------|------------------------| | 队列 | `queue.Queue`/`deque` | `put()`, `get()` | 任务调度、广度优先搜索 | | 堆 | `heapq` | `heappush()`, `heappop()`| 优先队列、Top K问题 | | 链表/树/图 | 自定义类 | 节点与指针操作 | 动态数据关系管理 | | 命名元组 | `collections.namedtuple` | 字段名定义 | 结构化数据存储 | | 邻接表/矩阵 | 字典或二维列表 | 键值对/二维索引 | 网络关系建模 | --- ### 📌 **选择建议** - 优先使用内置模块(如 `collections`、`heapq`),性能更优 - 复杂结构(如树、图)需根据操作需求选择存储方式 - 需要键值对默认值时,使用 `defaultdict` 更简洁 如果需要具体结构的详细操作示例,可以进一步说明场景! 🚀
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值