栈(Stack)
概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出 LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。
栈的方法
| 方法 | 说明 |
|---|---|
| E push(E item) | 将元素放在栈顶 |
| E pop() | 将栈顶元素弹出 |
| E peek() | 返回栈顶元素 |
| boolean empty() | 判断栈是否为空 |
| int search(Object o) | 查找栈所处位置 |
测试方法：
Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.peek()); //3
System.out.println(stack.pop()); //3
System.out.println(stack.peek()); //2
System.out.println(stack.empty()); //false
System.out.println(stack.search(2)); //1
System.out.println(stack.search(1)); //2
逆波兰式
中缀表达式转后缀表达式
计算机时不会处理中缀表达式的，一般都是把中缀转换成后缀，在进行如下运算的：
数组实现栈
public class MyStack {
private int[] elem; //存放栈中元素
private int top; //代表下标，也代表当前有多少元素
//默认开辟大小为10的栈
public MyStack() {
this.elem = new int[10];
}
//判断栈是否为满
public boolean isFull() {
return this.top == this.elem.length;
}
//给栈中压入元素
public int push(int item) {
if(isFull()) {
throw new RuntimeException("栈为满");
}
this.elem[this.top] = item;
this.top++;
return this.elem[this.top-1];
}
//弹出栈顶元素
public int pop() {
if(empty()) {
throw new RuntimeException("栈为空");
}
this.top--;
return this.elem[this.top];
}
//显示栈顶元素
public int peek() {
if(empty()) {
throw new RuntimeException("栈为空");
}
return this.elem[this.top-1];
}
//判断栈是否为空
public boolean empty() {
return this.top == 0;
}
//栈中元素个数
public int size() {
return this.top;
}
}
用队列实现栈
class MyStack {
Queue<Integer> q1;
Queue<Integer> q2;
/** Initialize your data structure here. */
public MyStack() {
q1 = new LinkedList<>();
q2 = new LinkedList<>();
}
/** Push element x onto stack. */
public void push(int x) {
//谁不为空入到哪个队列中
if(q1.isEmpty() && q2.isEmpty()){
q1.offer(x);
return;
}
if(!q1.isEmpty()) {
q1.offer(x);
}
if(!q2.isEmpty()) {
q2.offer(x);
}
}
/** Removes the element on top of the stack and returns that element. */
public int pop() {
//每次出不为空的队列，出size-1个，到另一个为空的队列，最后弹出剩余的那个元素
if(q1.isEmpty() && q2.isEmpty()) return -1;
if(!q1.isEmpty()){
int i = 1;
int len = q1.size();
while(i < len) {
int en = q1.poll();
q2.offer(en);
i++;
}
return q1.poll();
}
if(!q2.isEmpty()){
int i = 1;
int len = q2.size();
while(i < len) {
int en = q2.poll();
q1.offer(en);
i++;
}
return q2.poll();
}
return -1;
}
/** Get the top element. */
public int top() {
if(q1.isEmpty() && q2.isEmpty()) return -1;
if(!q1.isEmpty()){
int i = 0;
int en = 0;
int len = q1.size();
while(i < len) {
en = q1.poll();
q2.offer(en);
i++;
}
return en;
}
if(!q2.isEmpty()){
int i = 0;
int en = 0;
int len = q2.size();
while(i < len) {
en = q2.poll();
q1.offer(en);
i++;
}
return en;
}
return -1;
}
/** Returns whether the stack is empty. */
public boolean empty() {
return q1.isEmpty() && q2.isEmpty();
}
public static void main(String[] args) {
MyStack a = new MyStack();
a.push(1);
a.push(2);
a.top();
}
}
有效的括号
class Solution {
public boolean isValid(String s) {
Stack ret = new Stack();
int i = 1;
ret.push(s.charAt(0));
while(i != s.length()) {
if(ret.empty() || s.charAt(i) != change((char)ret.peek())) {
ret.push(s.charAt(i));
}else {
ret.pop();
}
i++;
}
if(ret.empty()) return true;
return false;
}
public char change(char a) {
if(a == '(') return ')';
if(a == '[') return ']';
if(a == '{') return '}';
return '?';
}
}
最小栈
class MinStack {
Stack<Integer> a;
Stack<Integer> b;
/** initialize your data structure here. */
public MinStack() {
a = new Stack<>();
b = new Stack<>();
}
public void push(int x) {
if(a.empty() || x <= b.peek()) {
a.push(x);
b.push(x);
}else {
a.push(x);
}
}
public void pop() {
if(a.pop().equals(b.peek())) {
b.pop();
}
}
public int top() {
return a.peek();
}
public int getMin() {
return b.peek();
}
}