栈
栈是一种特殊的线性表，只允许在固定的一端进行插入和删除操作，即“后进先出”，进行数据插入和删除的一端称为栈顶，另一端则是栈底。
栈的插入操作叫做进栈，压栈，入栈。
栈的删除操作叫做出栈。
栈的使用
| 方法 | 功能 |
|---|---|
| Stack() | 构造一个空的栈 |
| E push(E e) | 将e入栈，并返回e |
| E pop() | 将栈顶元素出栈并返回 |
| E peek() | 获取栈顶元素 |
| int size() | 获取栈中有效元素个数 |
| boolean empty() | 检测栈是否为空 |
Stack<Integer> stack = new Stack<>();//创建一个元素为Integer的栈
stack.push(10);
stack.push(20);//放元素，入栈
int x = stack.pop();//出栈
//x = 20
int y = stack.peek()//获取当前栈顶元素，但不删除
//y = 10
boolean ret = stack.empty();
//ret = false
栈的模拟实现
栈的底层是一个数组，当然也可以用链表来实现。
public class MyStack {
private int[] elem;//用数组实现
private int usedSize;//元素的个数
public MyStack() {
this.elem = new int[5];//分配内存
}
public void push(int val) {
if(isFull()) {
//判满，如果满了二倍扩容
elem = Arrays.copyOf(elem, 2 * elem.length);
}
elem[usedSize++] = val;
}
public boolean isFull() {
return usedSize == elem.length;
}
public int pop() {
//判断栈不为空
if(empty()) {
throw new EmptyException("stack is empty");
}
return elem[--usedSize];
//把元素个数减一就可，下一个数据可以覆盖
}
public boolean empty() {
return usedSize == 0;
}
public int pick() {
if(empty()) {
throw new EmptyException("stack is empty");
}
return elem[usedSize - 1];
}
}
栈的使用
- 改变元素的序列
- 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2 B: 2,3,4,1 C: 3,1,4,2 D: 3,4,2,1
A：进1，出1，进2，进3，进4，出4，出3，出2.
B：进1，进2，出2，进3，出3，进4，出4，出1.
C：进1，进2，进3，出3，error
D：进1，进2，进3，出3，进4，出4，出2，出1.
2.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ）。
A: 12345ABCDE B: EDCBA54321 C: ABCDE12345 D: 54321EDCBA
栈底 ----------->栈顶
1 2 3 4 5 A B C D E
出栈顺序：
E D C B A 5 4 3 2 1
- 将递归转化为循环
逆序打印链表
// 递归方式 void printList(Node head){ if(null != head){ printList(head.next); System.out.print(head.val + " "); } } // 循环方式 void printList(Node head){ if(null == head){ return; } Stack<Node> s = new Stack<>(); // 将链表中的结点保存在栈中 Node cur = head; while(null != cur){ s.push(cur); cur = cur.next; } // 将栈中的元素出栈 while(!s.empty()){ System.out.print(s.pop().val + " "); } }
( [ ) ] 闭合顺序不对
( ( ) 左括号多
( ) ) 右括号多
我们可以把右括号放入栈中，等到当前括号为左括号时，将它与栈顶元素进行匹配，如果相同，则匹配成功，将栈顶元素弹出。如果不相同，则匹配失败，直接返回false。如果栈空了，而外面还有左括号，则匹配失败，如果栈内有元素，而外面没有左括号了，则匹配失败。
public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); for(int i = 0; i < s.length(); i++) { char str = s.charAt(i); if(str == '(' || str == '{' || str == '[') { stack.push(str); } else { if(stack.empty()) { //左括号多 return false; } else { char str2 = stack.peek(); if(str2 == '(' && str == ')' || str2 == '{' && str == '}' || str2 == '[' && str == ']') { stack.pop(); } else {//左右括号不匹配 return false; } } } } if(!stack.empty()) { //右括号多了 return false; } return true; }
逆波兰表达式也叫后缀表达式。
常见题型有：
①根据中缀表达式，求后缀表达式
中缀表达式a+b*c+(d*e+f)*g ,将其转化成后缀表达式
方法：先乘除，后加减，加括号
( (a + (b*c)) + ( ( (d*e)+f)*g ) )
然后将运算符放到当前括号的后面（前缀表达式就是放在括号前面）
( (a (b c)*)+ ( ( (d e)*f)+g )* )+
最后去掉括号,得到后缀表达式
a b c* + d e* f + g * +
如果我们将字母赋值
1+2*3+(4*5+6)*7 = 179
那么后缀表达式该如何计算呢？
1 2 3* + 4 5 * 6 + 7 * + = ?
这时，我们就需要借助栈了
如果当前字符是数字的话，我们就直接放进栈内
但如果当前字符是运算符，那么我们就需要从栈中pop出两个数字，第一个放在运算符的右边，第二个放在运算符的左边。将算出来的数再push到栈中。
以此类推
我们就可以得到 ，1 2 3* + 4 5 * 6 + 7 * + =179
这样我们就可以解出这个题了
public boolean isOpera(String x) { if(x.equals("+") || x.equals("-") || x.equals("*") || x.equals("/")){ return true; } return false; } public int evalRPN(String[] tokens) { Stack<Integer> stack = new Stack<>();//实例化一个栈存储数字 for(String s : tokens) { //遍历字符串 if(!isOpera(s)) {//判断是否为运算符 //如果不是运算符，就将字符串转化成数字push进栈 stack.push(Integer.parseInt(s)); } else { //如果是运算符，那么进行相应的运算 int num2 = stack.pop(); int num1 = stack.pop(); switch(s) { 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(); }
pushA：1 2 3 4 5
popA：4 5 3 2 1用
i来遍历pushA，用j来遍历popA，将pushA中的元素放入栈内，直到pushA的元素与popA的元素匹配，那么将pushA的栈顶元素弹出，ij往后移，以此类推
public boolean IsPopOrder(int [] pushA,int [] popA) { Stack<Integer> stack = new Stack<>(); int j = 0; for (int i = 0; i < pushA.length; i++) { stack.push(pushA[i]);//每次都入栈 while(!stack.empty() && j < popA.length && stack.peek() == popA[j]) { //判断栈和j，防止越界 stack.pop();//当栈顶元素与popA[j]相同时，可以出栈 j++; } } return stack.empty();//如果栈全空了，并且popA也遍历完了，证明匹配成功 }
MinStack()初始化堆栈对象。
void push(int val)将元素val推入堆栈。
void pop()删除堆栈顶部的元素。
int top()获取堆栈顶部的元素。
int getMin()获取堆栈中的最小元素。前四个都是比较基础的内容，在上文的栈的模拟实现都实现过，关键是最后一个：获取栈中最小的元素。
栈中的最小值是在随时发生变化的，这个最小值拿的是当前栈中剩下元素的最小值，随着弹出数据，最小值也是发生改变的，类似于更新的最小值倒着往回取。
举个例子，在一个栈
stack里，我们依次放入了1 5 12，现在要获取最小元素1，该如何获取呢？此时我们可以再创建一个minStack,放入此刻为止最小的元素。那么从头开始，
stack放入1，此刻最小的元素为1，则minStack也放入1，继续放5，与minStack栈顶元素相比，还是1大，所以5不会放入minStack，如果此时我将stack放入-1，与minStack栈顶元素相比，比1小，那么-1就可以放入minStack中，现在minStack中就有了-1，1两个元素。如果当前元素与minStack中的栈顶元素相同，也需要放入。
这样我们就可以轻松的获取当前栈中最小的元素了。
如果要
popstack中的栈顶元素，一定要和minStack的栈顶元素比较，如果相同的话，也需要popminStack的元素。class MinStack { private Stack<Integer> stack; private Stack<Integer> minstack; public MinStack() { this.stack = new Stack<>(); this.minstack = new Stack<>(); } public void push(int val) { stack.push(val); if(minstack.empty()) { //当栈第一次存放数据的时候，两个栈都要存储数据 minstack.push(val); } else { if(val <= minstack.peek()) { //放入小于等于最小值的元素 minstack.push(val); } } } public void pop() { if(stack.empty()) { return; } int n = stack.pop(); if(n == minstack.peek()) { //如果stack要弹出的元素与minstack的栈顶元素相同，那么两个栈都要出 minstack.pop(); } } public int top() { if(stack.empty()) { return -1; } else { return stack.peek(); } } public int getMin() { return minstack.peek(); } }
概念区分
栈，虚拟机栈，栈帧有什么区别？
栈是一种数据结构；虚拟机栈是一块内存；栈帧是指函数开辟时在虚拟机栈占用的一块内存。
队列
概念
是一种先进先出的数据结构。有队头和队尾。数据从队尾进从队头出。
这里我们用链表来实现队列。当然也可以用数组来实现。
栈是用数组来实现的，那他可不可以用链表来实现呢？当然也可以。
我们知道用数组来实现的栈，他的入栈和出栈时间复杂度均为O(1),如果用链表能不能做到O(1)？
可以的：如果是双向链表，不管从那边入栈出栈，时间复杂度均是O(1)，
LinkedList也经常被当作栈来使用；如果是单链表，可以采用头插法的方式入栈，以删除头节点的方法出栈；用链表实现队列
如果用双向链表，那么入队和出队都能达到O(1);如果使用单链表并且记录了最后一个结点的位置，那么可以从尾入队，从头出队。如果头进尾出，那么出队的复杂度会达到O(n)。
使用
在Java中，Queue是个接口，底层是通过链表实现的。
| 方法 | 功能 |
|---|---|
| boolean offer(E e) | 入队列 |
| E poll() | 出队列 |
| peek() | 获取队头元素 |
| int size() | 获取队列中有效元素个数 |
boolean isEmpty() | 检测队列是否为空 |
注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。
public static void main(String[] args) {
Queue<Integer> q = new LinkedList<>();
q.offer(1);
q.offer(2);
q.offer(3);
q.offer(4);
q.offer(5); // 从队尾入队列
System.out.println(q.size());
System.out.println(q.peek()); // 获取队头元素
q.poll();
System.out.println(q.poll()); // 从队头出队列，并将删除的元素返回
if(q.isEmpty()){
System.out.println("队列空");
}else{
System.out.println(q.size());
}
}
队列的模拟实现
队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构 和 链式结构。那么队列的实现使用顺序结构还是链式结构好？
当然是链式结构，如果用顺序结构（数组），那么可能会出现很多空余的内存。
这样一看，队列似乎并没有满，但就是放不下元素了，让空间利用率大大降低，这就是使用顺序表的弊端。
public class MyQueue {
static class ListNode {
public int val;
public ListNode next;
public ListNode(int val) {
this.val = val;
}
}
public ListNode head;
public ListNode last;
private int usedSize;
public void offer(int val) {
ListNode node = new ListNode(val);
if(head == null) {
//队列为空
head = node;
last = node;
} else {
last.next = node;
last = last.next;
}
usedSize++;
}
public int poll() {
if(head == null) {
//队列为空
return -1;
}
int val = 0;
val = head.val;
if(head.next == null) {
//只有一个元素
head = null;
last = null;
return val;
}
//有多个元素
head = head.next;
usedSize--;
return val;
}
public int peek() {
if(head == null) {
return -1;
}
return head.val;
}
public int size() {
return usedSize;
}
}
循环队列
我们知道如果用顺序表来实现队列的话会浪费空间，但是如果将队首和队尾连接起来，那么队伍的空间就能循环利用起来。
一开始没有数据的时候，front和rear指向同一个空间，当数组满了之后，front和rear依然指向同一个空间，那么到底以什么条件判定队列为空，队列为满呢？
当 front == rear 时，队列为空
①定义一个
usedSize，usedSize==len时，队列为满②浪费一个空间表示满（以上图为例，当rear指向7下标时，就不能入队了，表示满了）
那么问题又来了，rear和front怎么从7下标走到0下标？(用上面的方法2时)
rear = (rear + 1) % len
front = (front + 1) % len
//使用了方法2
class MyCircularQueue {
private int[] elem;
private int front;
private int rear;
public MyCircularQueue(int k) {
this.elem = new int[k + 1];
//因为我们是采用的浪费一个空间的方法，所以我们需要多创建一个空间，才能放得开想放的k个元素，如果不多创建，那么只能放入k-1个元素。
}
//入队
public boolean enQueue(int value) {
if(isFull()) {
//满了不加
return false;
}
elem[rear] = value;
rear = (rear + 1) % elem.length;
return true;
}
public boolean deQueue() {
if(isEmpty()) {
return false;
}
front = (front + 1) % elem.length;
//从队头出
return true;
}
public int Front() {
if(isEmpty()) {
return -1;
}
//获得队头元素
return elem[front];
}
public int Rear() {
//得到队尾元素
if (isEmpty()) {
return -1;
}
int index = (rear == 0) ? elem.length - 1 : rear - 1;
//如果rear == 0，那么就不能直接让index = rear - 1，没有下标是-1的元素，所以直接让index = elem.length - 1即可获得队尾元素。
return elem[index];
}
public boolean isEmpty() {
return rear == front;
}
public boolean isFull() {
return (rear + 1) % elem.length == front;
}
}
双端队列(Deque)
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
它的用途十分的广泛，不仅可以用作队列，还可以用做栈，链表。
public static void main(String[] args) {
Deque<Integer> queue = new LinkedList<>();//链式队列，双端队列的链式实现
deque.offer(1);//队列的方法
Deque<Integer> stack = new LinkedList<>();//链式栈
stack.push(2);//栈的方法
Deque<Integer> stack1 = new ArrayDeque<>();//顺序栈，双端队列的线性实现
}
队列和栈的相互实现
-
队列是先进先出，栈是先进后出，如果想用队列来实现栈的话，一个队列肯定是不能完成的，这是需要借助两个队列。
例如如果我入了12，23这里两个数据，我想拿到23，就可以把12放到另一个队列中，这样就可以拿到23了。
假如队列里有n个元素，如果要拿栈顶元素，就可以先把n - 1个元素放到另一个队列中。之后再存放数据的时候，哪个队列不为空就放到哪里。
- push元素时，把元素放到不为空的队列中。
- pop的时候，出不为空的队列中的size - 1个元素，剩下的元素就是我们要出栈的元素。
class MyStack {
private Queue<Integer> queue1;
private Queue<Integer> queue2;
public MyStack() {
this.queue1 = new LinkedList<>();
this.queue2 = new LinkedList<>();
}
public void push(int x) {
if(empty()) {
//队列都为空的时候默认放到队列1
queue1.offer(x);
} else if(!queue1.isEmpty()) {
queue1.offer(x);
} else {
queue2.offer(x);
}
}
public int pop() {
if(empty()) {
//两个队列都为空，说明没有元素
return -1;
} else if(!queue1.isEmpty()) {
int curSize = queue1.size();
//把n-1个数据放到空队列里
//不能这么写：i < queue.size() - 1
//因为size一直在变化
for(int i = 0; i < curSize - 1; i++) {
int x = queue1.poll();
queue2.offer(x);
}
return queue1.poll();
} else {
int curSize = queue2.size();
for(int i = 0; i < curSize - 1; i++) {
int x = queue2.poll();
queue1.offer(x);
}
return queue2.poll();
}
}
public int top() {
if(empty()) {
return -1;
} else if(!queue1.isEmpty()) {
int curSize = queue1.size();
int x = 0;
//把所有的元素都放到空队列中，记录下最后一个元素并返回。
for(int i = 0; i < curSize; i++) {
x = queue1.poll();
queue2.offer(x);
}
return x;//最后一个元素返回
} else {
int curSize = queue2.size();
int x = 0;
for(int i = 0; i < curSize; i++) {
x = queue2.poll();
queue1.offer(x);
}
return x;
}
}
public boolean empty() {
return queue1.isEmpty() && queue2.isEmpty();
}
}
-
显然，拿一个栈也不可能能实现队列，所以我们也需要使用两个栈。
以下图为例，模拟出栈假如我们要出12这个数字，我们可以把12和23全部移到
stack2中，然后将栈顶元素12弹出。我们可以让所有的出栈操作都在stack2中完成，如果没有数据了，再将stack1中的数据全部到在stack2中。
模拟入栈 无论
stack1是空还是非空，都往stack1里入。总结：
入队 统一入到第一个栈中
出队 统一在第二个栈出，如果没有元素就将栈1元素倒入栈2，出栈顶元素。
class MyQueue { private Stack<Integer> stack1; private Stack<Integer> stack2; public MyQueue() { stack1 = new Stack<>(); stack2 = new Stack<>(); } public void push(int x) { stack1.push(x); //所有放在栈1 } public int pop() { if(stack2.empty()) { //如果栈2为空，将栈1元素倒入栈2 while(!stack1.empty()) { int val = stack1.pop(); stack2.push(val); } } return stack2.pop(); } public int peek() { if(stack2.empty()) { while(!stack1.empty()) { int val = stack1.pop(); stack2.push(val); } } return stack2.peek(); } public boolean empty() { return stack1.empty() && stack2.empty(); } }
543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
