栈和队列
1.栈(Stack)
1.1 概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈
顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。
1.2 栈的用处
（1）入栈和出栈的顺序
示例：
（2）中缀表达式转为后缀表达式（逆波兰表达式）（了解）
第一步：先乘除，后加减，给它加括号。
第二步：运算符放到当前颜色括号的后边。
第三步：把所有括号都去掉即可得到后缀表达式。
注意：要会计算后缀表达式（这个要会）
下标i向后遍历，遇到数字进栈，遇到运算符出栈，先出栈的放在运算符右边，依次计算即可。
1.3 实现
栈中的方法：
1.利用顺序表实现，即使用尾插 +尾删的方式实现
2.利用链表实现，则头尾皆可。（单链表用头插+头删法（尾插法不可以，太麻烦）。或者使用双向链表。）
相对来说，顺序表的实现上要更为简单一些，所以我们优先用顺序表实现栈。
public class MyStack {
public int[] elem;
public int usedSize;
public MyStack() {
this.elem = new int[5];
}
public void push(int val) {
if(isFull()) {
//扩容
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);//二倍扩容
}
this.elem[this.usedSize] = val;
this.usedSize++;
}
public boolean isFull() {
return this.usedSize == this.elem.length;
}
public int pop() {
if(isEmpty()) {
throw new RuntimeException("栈为空！");
}
int oldVal = this.elem[usedSize-1];
this.usedSize--;
return oldVal;
}
public int peek() {
if(isEmpty()) {
throw new RuntimeException("栈为空！");
}
return this.elem[usedSize-1];
}
public boolean isEmpty() {
return this.usedSize == 0;
}
}
如果是出栈，栈中是引用类型则需要，置位null，然后usedsize–；
相关题目：
Leetcode题：
150题 逆波兰表达式求值
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for(int i = 0;i < tokens.length;i++) {
String val = tokens[i];
if(isOperation(val) == false) {
//如果不是运算符
stack.push(Integer.parseInt(val));
}else {
//到底啥运算符？？？？
int num2 = stack.pop();
int num1 = stack.pop();
switch(val) {
case "+":
stack.push(num1+num2);
break;
case "-":
stack.push(num1-num2);
break;
case "*":
stack.push(num1*num2);
break;
case "/":
stack.push(num1/num2);
break;
}
}
}
return stack.pop();
}
private boolean isOperation(String x) {
if(x.equals("+") || x.equals("-") ||x.equals("*") ||x.equals("/")) {
return true;
}
return false;
}
155题 最小栈
class MinStack {
private Stack<Integer> stack;
private Stack<Integer> minStack;
public MinStack() {
stack = new Stack<>();
minStack = new Stack<>();
}
public void push(int val) {
stack.push(val);
if(!minStack.empty()) {
int top = minStack.peek();
//比较 小于等于的话 也要放进去
if(val <= top) {
minStack.push(val);
}
}else{
minStack.push(val);
}
}
public void pop() {
int popVal = stack.pop();
if(!minStack.empty()) {
int top = minStack.peek();
if(top == popVal) {
minStack.pop();
}
}
}
public int top() {
return stack.peek();
}
public int getMin() {
return minStack.peek();
}
}
20题 有效的括号
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for(int i = 0; i < s.length();i++) {
char ch = s.charAt(i);
if(ch == '(' || ch == '[' || ch == '{') {
//如果是左括号 直接入栈
stack.push(ch);
}else{
//遇到了右括号
if(stack.empty()) {
//右括号多
System.out.println("右括号多");
return false;
}
char top = stack.peek();//哪个左括号
if(top == '{' && ch == '}' || top == '[' && ch == ']' || top == '(' && ch == ')') {
stack.pop();
}else{
//左右括号不匹配
System.out.println("左右括号不匹配");
return false;
}
}
}
if(!stack.empty()) {
//左括号多
System.out.println("左括号多");
return false;
}
return true;
}
牛客：JZ31题 栈的压入、弹出序列
2.队列(Queue)
2.1 概念
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)入队列：进行插入操作的一端称为队尾（Tail/Rear）出队列：进行删除操作的一端称为队头（Head/Front）
2.2 实现
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
class Node {
int val;
Node next;
Node(int val, Node next) {
this.val = val;
this.next = next;
}
Node(int val) {
this(val, null);
}
}
public class MyQueue {
private Node head = null;
private Node tail = null;
private int size = 0;
public void offer(int v) {
Node node = new Node(v);
if (tail == null) {
head = node;
} else {
tail.next = node;
}
tail = node;
size++;
}
public int poll() {
if (size == 0) {
throw new RuntimeException("队列为空");
}
Node oldHead = head;
head = head.next;
if (head == null) {
tail = null;
}
size--;
return oldHead.val;
}
public int peek() {
if (size == 0) {
throw new RuntimeException("队列为空");
}
return head.val;
}
public boolean isEmpty() {
return size == 0;
}
public int size() {
return size;
}
}
2.3 循环队列
实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。
环形队列通常使用数组实现。
数组下标循环的小技巧
1.下标最后再往后(offset小于 array.length): index = (index + offset) % array.length
2.下标最前再往前(offset小于 array.length): index = (index + array.length - offset) % array.length
如何区分空与满
1.通过添加 usedsize属性记录
2.添加一个标志位flg
2.保留一个位置
3.双端队列 (Deque)
3.1概念
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque是“double ended queue”的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
4. java中的栈和队列
Stack
Queue
Deque
5.面试题
1.括号匹配问题。OJ链接
2.用队列实现栈。OJ链接
3.用栈实现队列。OJ链接
4.实现一个最小栈。OJ链接
5.设计循环队列。OJ链接
