栈(stack)
概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。
栈的使用
使用方法
方法使用示例
public static void main(String[] args) {
Stack<Integer> s = new Stack();
s.push(1);
s.push(2);
s.push(3);
s.push(4);
System.out.println(s.size()); // 获取栈中有效元素个数: 4
System.out.println(s.peek()); // 获取栈顶元素: 4
s.pop(); // 4出栈，栈中剩余1 2 3，栈顶元素为3
System.out.println(s.pop()); // 3出栈，栈中剩余1 2,栈顶元素为3
if(s.empty()){
System.out.println("栈空");
}else{
System.out.println(s.size());
}
}
栈的模拟实现
从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。
package Stackdemo;
public interface IStack {
void push(int x);
int pop();
int peek();
int size();
boolean empty();
boolean full();
}
package Stackdemo;
public class EmptyException extends RuntimeException{
public EmptyException(String msg) {
super(msg);
}
}
package Stackdemo;
import java.util.Arrays;
public class MyStack implements IStack{
private int[] elem;
private int usedSize; //有效数据的个数
private static final int DEFAULT_CAPACITY = 10;
public MyStack() {
elem = new int[DEFAULT_CAPACITY];
}
@Override
public void push(int x) {
if (full()) {
elem = Arrays.copyOf(elem,2*elem.length); //二倍扩容
}
elem[usedSize] = x;
usedSize++;
}
@Override
public int pop() {
if (empty()) {
//return -1;
throw new EmptyException("栈空了");
}
int old = elem[usedSize--];
usedSize--; //相当与是删除
//elem[usedSize] = null;
return old;
}
@Override
public int peek() {
if (empty()) {
//return -1;
throw new EmptyException("栈空了");
}
return elem[usedSize-1];
}
@Override
public int size() {
return usedSize;
}
@Override
public boolean empty() {
return false;
}
@Override
public boolean full() {
if (usedSize == elem.length) {
return true;
}
return false;
}
}
栈的应用场景
改变元素的序列
- 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A: 1,4,3,2
B: 2,3,4,1
C: 3,1,4,2
D: 3,4,2,1答案：C
- 一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺
序是（ ）。
A: 12345ABCDE
B: EDCBA54321
C: ABCDE12345
D: 54321EDCBA答案：B
将递归转化为循环
比如：逆序打印链表
// 递归方式
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 + " ");
}
}
栈的练习题
括号匹配
解题思路
我们只需要解决 不匹配 左括号多 右括号多
遇到的第一个右括号应该和最后一个左括号进行匹配
- 左括号入栈
- 遇到右括号，和栈顶元素的左括号比较，看是不是匹配的
什么时候匹配?
当栈当中的元素为空并且字符串也遍历完成了!!
- 当字符串遍历完成，但是栈当中仍然存在元素，那么说明左括号多
- 字符串还没有遍历完成遇到了右括号 但是栈当中没有元素右括号多
代码
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
//1、遍历字符串
for (int i = 0;i < s.length();i++){
char ch = s.charAt(i);
//2、判断是不是左括号
if (ch == '{' || ch == '[' || ch == '('){
stack.push(ch);
}else {
//3、遇到右括号
if (stack.empty()) {
return false;
}
char ch2 = stack.peek(); //看是哪个左括号？ch是右括号，ch2是左括号
if ((ch2 == '{' && ch == '}') || (ch2 == '[' && ch == ']') || (ch2 == '(' && ch == ')')) {
//出去这个匹配的左括号
stack.pop();
}else {
return false;
}
}
}
if (!stack.empty()) {
return false;
}
return true;
}
}
逆波兰表达式求值
逆波兰表达式
逆波兰表达式（Reverse Polish Notation，RPN）是一种用于表示数学表达式的方式，也称为后缀表达式。在逆波兰表达式中，操作符位于其相关的操作数之后。例如，中缀表达式 “3 + 4” 在逆波兰表达式中表示为 “3 4 +”。
下面是一个简单的例子，将中缀表达式转换为逆波兰表达式：
中缀表达式：(3 + 4) * 5 对应的逆波兰表达式：3 4 + 5 *
计算逆波兰表达式的方法是利用栈结构，从左到右扫描表达式，遇到操作数就入栈，遇到操作符就从栈中弹出相应数量的操作数进行运算，然后将结果入栈，直至表达式扫描结束，栈顶元素即为整个表达式的值。
解题思路
逆波兰表达式严格遵循「从左到右」的运算。计算逆波兰表达式的值时，使用一个栈存储操作数，从左到右遍历逆波兰表达式，进行如下操作：
- 如果遇到操作数，则将操作数入栈；
- 如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。
整个逆波兰表达式遍历完毕之后，栈内只有一个元素，该元素即为逆波兰表达式的值。
代码
class Solution {
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for (String x : tokens){
if (!isOperation(x)) {
//是数字
stack.push(Integer.parseInt(x));
} else {
int num2 = stack.pop();
int num1 = stack.pop();
switch (x){
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;
}
}
出栈入栈次序匹配
解题思路
- 遍历push数组，把元素放到栈中
- 每push一个元素，就和pop数组的元素比较
- 如果相等j++ 且出栈
- 如果不相等 想办法入栈1.遍历push数组，把元素放到栈中
代码
class Solution {
public boolean IsPopOrder(int[] pushV, int[] popV) {
Stack<Integer> stack = new Stack<>();
int j = 0;
for (int i = 0; i < pushV.length; i++) {
stack.push(pushV[i]);
while (!stack.empty() && j < popV.length && stack.peek() == popV[j]) {
stack.pop();
j++;
}
}
return stack.empty();
}
}
最小栈
解题思路
push:
- push的时候，普通的栈一定得放元素
- 最小栈如果是空的也要放，不为空且要存放的元素小于最小栈的栈顶，那么就也要放到最小栈
pop:
- pop的时候 =，要和栈顶元素去比较。
- 如果pop的元素和栈顶元素是一样的，那么两个栈都要出
- 不一样只出普通栈就行
代码
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()) {
minStack.push(val);
} else {
int peekVal = minStack.peek();
if (val <= peekVal) {
minStack.push(val);
}
}
}
public void pop() {
int val = stack.pop();
if (!minStack.empty()) {
if (val == minStack.peek()) {
minStack.pop();
}
}
}
//peek 获取当前普通栈的栈顶元素
public int top() {
return stack.peek();
}
//最小栈的peek 每次通过这个方法获取最小值
public int getMin() {
if (!minStack.empty()) {
return minStack.peek();
}
return -1;
}
}
概念区分
栈、虚拟机栈、栈帧有什么区别呢？
栈、虚拟机栈和栈帧是计算机科学中常见的概念，它们之间有着以下区别：
-
栈（Stack）：
- 栈是一种数据结构，遵循后进先出（LIFO）的原则，即最后进入的元素最先被访问或删除。
- 栈操作通常包括入栈（push）和出栈（pop）两种基本操作，用于向栈中添加元素或移除元素。
- 栈在计算机科学中常用于函数调用、表达式求值、内存管理等方面。
-
虚拟机栈（Virtual Machine Stack）：
- 虚拟机栈是指在Java虚拟机中用来存储方法调用和执行过程中的局部变量、操作数栈、动态链接、方法出口等信息的数据结构。
- 每个线程在Java虚拟机中都会有一个对应的虚拟机栈，用于存储线程执行方法时的状态信息。
- 虚拟机栈中的栈帧用于表示每个方法的调用信息和局部变量表等内容。
-
栈帧（Stack Frame）：
- 栈帧是指在程序执行过程中用于支持方法调用和返回的数据结构，在调用栈中每个方法对应一个栈帧。
- 栈帧包含了方法的局部变量表、操作数栈、动态链接、返回地址等信息，用于记录方法的运行状态。
- 当一个方法被调用时，会创建对应的栈帧并入栈，方法执行完毕后栈帧出栈，控制权返回到上一层方法的栈帧。
总结：
-
栈是一种数据结构，而虚拟机栈和栈帧则是在计算机系统和虚拟机中用于支持方法调用和执行的相关概念。
-
虚拟机栈是Java虚拟机（JVM）中的数据结构，用于存储线程执行方法的状态信息。
-
栈帧是虚拟机栈中的一个重要部分，用于表示每个方法的调用信息和状态。调用方法时，会在虚拟机当中给这个方法开辟一块内存。
队列(Queue)
概念
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾（Tail/Rear）
出队列：进行删除操作的一端称为队头 （Head/Front）
队列的使用
在Java中，Queue是个接口，底层是通过链表实现的。
注意：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());
}
}
队列模拟实现
队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有 两种：顺序结构 和 链式结构。
队列的实现使用顺序结构还是链式结构好？
队列的实现可以使用顺序结构或链式结构，每种结构都有其优点和局限性，选择哪种取决于具体的应用场景和需求。
-
顺序结构：
- 优点：使用数组实现队列的顺序结构可以更好地利用内存空间，具有较高的访问效率，尤其是在已知队列长度上限的情况下，可以预先分配好内存，不会频繁进行内存分配和释放操作。
- 局限性：在队列长度不确定的情况下，可能需要进行数组的扩容操作，导致数据搬移，影响性能。此外，在并发环境下，使用数组实现的队列需要考虑线程安全性。
-
链式结构：
- 优点：使用链表实现队列的链式结构可以方便地动态管理内存，不需要预先分配固定大小的内存空间，因此适合于长度变化较大或者无法确定长度的情况。
- 局限性：相比于顺序结构，链式结构可能会占用更多的内存空间存储指针，同时在访问元素时可能存在额外的指针跳转，导致访问效率略低于顺序结构。
综合来看:
- 如果对内存空间使用有严格要求，并且队列长度可预测，顺序结构可能更适合；
- 而如果对内存空间使用没有特别限制，或者队列长度变化较大，链式结构可能更合适。
- 另外，在并发环境下，需要考虑到线程安全性，这也是选择队列实现结构时需要考虑的因素之一。
package Queuedemo;
import java.util.List;
public class MyLinkQueue {
// 双向链表节点
static class ListNode {
public int val;
public ListNode next;
public ListNode prev;
public ListNode(int val) {
this.val = val;
}
}
public ListNode head; //队头
public ListNode last; //队尾
public int usedsize;
// 入队列--向双向链表位置插入新节点
public boolean offer(int val) {
ListNode node = new ListNode(val);
if (head == null) {
head = node;
last = node;
} else {
last.next = node;
node.next = last;
last = last.next;
}
usedsize++;
return true;
}
// 出队列--将双向链表第一个节点删除掉
public int poll() {
// 1. 队列为空
// 2. 队列中只有一个元素--链表中只有一个节点--直接删除
// 3. 队列中有多个元素--链表中有多个节点---将第一个节点删除
if (head == null) {
return -1;
}
//只有一个结点
int retVal = head.val;
if (head.next == null) {
head = null;
last = null;
return retVal;
}
head = head.next;
head.prev = null;
usedsize--;
return retVal;
}
// 获取队头元素--获取链表中第一个节点的值域
public int peek() {
if (head == null) {
return -1;
}
return head.val;
}
public boolean empty() {
return head == null;
}
public int size() {
return usedsize;
}
}
package Queuedemo;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.LinkedList;
public class Test {
public static void main(String[] args) {
MyLinkQueue myLinkQueue = new MyLinkQueue();
// 从队尾入队列
myLinkQueue.offer(1);
myLinkQueue.offer(2);
myLinkQueue.offer(3);
myLinkQueue.offer(4);
// 获取队头元素
System.out.println(myLinkQueue.peek()); //1
// 从队头出队列，并将删除的元素返回
System.out.println(myLinkQueue.poll()); //1
System.out.println(myLinkQueue.poll()); //2
}
}
循环队列
环形队列通常使用数组实现。
数组下标循环的小技巧
-
下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length
-
下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length
如何区分空与满
- 通过添加 size 属性记录
- 保留一个位置
- 使用标记
设计循环队列
class MyCircularQueue {
public int[] elem;
public int front; //队头
public int rear; //队尾
public MyCircularQueue(int k) {
elem = new int[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;
return elem[index];
}
public boolean isEmpty() {
return front == rear;
}
public boolean isFull() {
return (rear+1)%elem.length == front;
}
}
双端队列 (Deque)
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。 那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。
Deque是一个接口，使用时必须创建LinkedList的对象。
在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口。
//不仅可以当作队列，也可以当作栈
Deque<Integer> deque = new LinkedList<>();
Deque<Integer> deque2 = new ArrayDeque<>();
面试题
队列是先进先出的，栈是先进后出的。
用队列实现栈
解题思路
- 哪个队列不为空放到哪个队列里面，若两个都是空的，则指定放到第一个里面。
- 出栈的时候，哪个不为空出哪个，size-1
- 当两个队列都是空的时候 ，那么说明我们模拟的栈是空的
代码
class MyStack {
private Queue<Integer> qu1;
private Queue<Integer> qu2;
public MyStack() {
qu1 = new LinkedList<>();
qu2 = new LinkedList<>();
}
public void push(int x) {
if (!qu1.isEmpty()) {
qu1.offer(x);
} else if (!qu2.isEmpty()) {
qu2.offer(x);
} else {
//两个队列都是空的，指定存放到第一个队列当中
qu1.offer(x);
}
}
public int pop() {
if (empty()) {
return -1;
}
if (!qu1.isEmpty()) {
int size = qu1.size();
for (int i = 0; i < size-1; i++) {
int x = qu1.poll();
qu2.offer(x);
}
return qu1.poll();
} else {
int size = qu2.size();
for (int i = 0; i < size-1; i++) {
int x = qu2.poll();
qu1.offer(x);
}
return qu2.poll();
}
}
public int top() {
if (empty()) {
return -1;
}
if (!qu1.isEmpty()) {
int size = qu1.size();
int x = -1;
for (int i = 0; i < size; i++) {
x = qu1.poll();
qu2.offer(x);
}
return x;
} else {
int size = qu2.size();
int x = -1;
for (int i = 0; i < size; i++) {
x = qu2.poll();
qu1.offer(x);
}
return x;
}
}
public boolean empty() {
//两个队列同时为空的时候，说明模拟实现的栈是空的
return qu1.isEmpty() && qu2.isEmpty();
}
}
用栈实现队列
解题思路
- 入队的时候，放到第一个栈里面。
- 出队的时候，都出第2个栈当中的元素 ，当第2个栈没有元素的时候，把第一个栈当中的元素全部倒过来！
代码
class MyQueue {
private Stack<Integer> s1;
private Stack<Integer> s2;
public MyQueue() {
s1 = new Stack<>();
s2 = new Stack<>();
}
public void push(int x) {
s1.push(x);
}
public int pop() {
if (empty()) {
return -1;
}
if (s2.empty()) {
while (!s1.empty()) {
s2.push(s1.pop());
}
}
return s2.pop();
}
public int peek() {
if(empty()) {
return -1;
}
if (s2.empty()) {
while (!s1.empty()) {
s2.push(s1.pop());
}
}
return s2.peek();
}
public boolean empty() {
return s1.empty() && s2.empty();
}
}
1346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
