# 栈、队列、堆随笔

1/ Leetcode 225 使用队列实现栈

1. 队列的初始化： Queue是接口，队列由链表实现 ： Queue<> q = new LinkedList<>();

2.Queue的基本使用方法：

• offer        添加一个元素并返回true        如果队列已满，则返回false
• poll          移除并返问队列头部的元素    如果队列为空，则返回null
• peek        返回队列头部的元素              如果队列为空，则返回null
```class MyStack {
private Queue<Integer> a;
private Queue<Integer> b;

/** Initialize your data structure here. */
public MyStack() {
}

/** Push element x onto stack. */
public void push(int x) {
b.offer(x);
while(!a.isEmpty())
{
b.offer(a.poll());
}

Queue<Integer> temp;
temp = b;
b = a;
a = temp;

}

/** Removes the element on top of the stack and returns that element. */
public int pop() {
return a.poll();
}

/** Get the top element. */
public int top() {
return a.peek();
}

/** Returns whether the stack is empty. */
public boolean empty() {
return a.isEmpty();

}
}

/**
* Your MyStack object will be instantiated and called as such:
* MyStack obj = new MyStack();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.top();
* boolean param_4 = obj.empty();
*/```

2/Leetcode 232用栈实现队列

1.Stackh是类 直接初始化

2.基本操作

* push : 把项压入堆栈顶部 ，并作为此函数的值返回该对象
* pop : 移除堆栈顶部的对象，并作为此函数的值返回该对象
* peek : 查看堆栈顶部的对象，，并作为此函数的值返回该对象，但不从堆栈中移除它
* empty : 测试堆栈是否为空

```class MyQueue {

private Stack<Integer> stack;
private Stack<Integer> a;
/** Initialize your data structure here. */
public MyQueue() {
stack = new Stack<>();
a = new Stack<>();
}

/** Push element x to the back of queue. */
public void push(int x) {
while(!stack.empty())
{
a.push(stack.pop());
}
stack.push(x);
while(!a.empty())
{
stack.push(a.pop());
}
}

/** Removes the element from in front of queue and returns that element. */
public int pop() {
return stack.pop();
}

/** Get the front element. */
public int peek() {
return stack.peek();
}

/** Returns whether the queue is empty. */
public boolean empty() {
return stack.empty();
}
}

/**
* Your MyQueue object will be instantiated and called as such:
* MyQueue obj = new MyQueue();
* obj.push(x);
* int param_2 = obj.pop();
* int param_3 = obj.peek();
* boolean param_4 = obj.empty();
*/```

3/Leetcode 255 设计最小栈

```class MinStack {

Stack<Integer> stack;
Stack<Integer> stackmin;
/** initialize your data structure here. */
public MinStack() {
stack = new Stack<>();
stackmin = new Stack<>();
}

public void push(int x) {
stack.push(x);
if(!stackmin.empty())
{
if(stackmin.peek()<x)
{
stackmin.push(stackmin.peek());
}
else
{
stackmin.push(x);
}
}
else
{
stackmin.push(x);
}
}

public void pop() {
stack.pop();
stackmin.pop();

}

public int top() {
return stack.peek();
}

public int getMin() {
return stackmin.peek();

}
}

/**
* Your MinStack object will be instantiated and called as such:
* MinStack obj = new MinStack();
* obj.push(x);
* obj.pop();
* int param_3 = obj.top();
* int param_4 = obj.getMin();
*/```

4/Leetcode 946 验证栈序列

1. 构造辅助栈。将pushed序列推入栈中，比较栈顶元素与popped数组。相同时弹出

```class Solution {
public boolean validateStackSequences(int[] pushed, int[] popped) {
Stack<Integer> s = new Stack<>();
int index = 0;
for(int i=0;i<pushed.length;i++)
{
s.push(pushed[i]);
while(!s.empty()&&s.peek()==popped[index])
{
index++;
s.pop();
}
}
if(s.empty())
{
return true;
}
else return false;
}
}```

4/Leetcode 224 基本计算器 经典的栈应用

。。。。。好难md

5/Leetcode 215  数组中第K个最大元素

## 理解 &quot;栈&quot; &quot;队列&quot;,&quot;堆&quot;(后进先出)

[栈] ??函数调用形成了一个栈帧 function foo(b) { var a = 10; return a + b + 11; } function bar(x) { var y = 3; return foo(x * y); } console.log(bar(7)); 当调用bar时,创建了第一个帧 ,帧中包含了bar的参数和局部变量.当bar调用foo时,第二个帧就被创建,并被压到第一个帧之上,帧中包含了foo的参数和局部变量.当foo返回时,最上层的帧就被弹出栈(剩下bar函数的调

## 【C/C++学院】0828-STL入门与简介/STL容器概念/容器迭代器仿函数算法STL概念例子/栈队列双端队列优先队列/数据结构堆的概念/红黑树容器

STL入门与简介 #include<iostream> #include <vector>//容器 #include<array>//数组 #include <algorithm>//算法 using namespace std; //实现一个类模板,专门实现打印的功能 template<class T> //类模板实现了方法 class myvectorprint { public: void operator ()(const T &

## JAVA中的栈和堆

JAVA在程序运行时,在内存中划分5片空间进行数据的存储.分别是:1:寄存器.2:本地方法区.3:方法区.4:栈.5:堆. 基本,栈stack和堆heap这两个概念很重要,不了解清楚,后面就不用学了. 以下是这几天栈和堆的学习记录和心得.得些记录下来.以后有学到新的,会慢慢补充. 一.先说一下最基本的要点 基本数据类型.局部变量都是存放在栈内存中的,用完就消失.new创建的实例化对象及数组,是存放在堆内存中的,用完之后不定期自动消除. 二.先明确以上两点,以下示例就比较好理解了 示例1 main