目录
【本节目标】
- 栈的概念及使用
- 队列的概念及使用
- 相关OJ题
1. 栈(Stack)
1.1 概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守**后进先出LIFO（Last In First Out）**的原则。
-
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
-
出栈：栈的删除操作叫做出栈。出数据在栈顶。
1.2 栈的使用
| 方法 | 功能 |
|---|---|
| Stack() | 构造一个空的栈 |
| E push(E e) | 将e入栈，并返回e |
| E pop() | 将栈顶元素出栈并返回 |
| E peek() | 获取栈顶元素 |
| int size() | 获取栈中有效元素个数 |
| boolean empty() | 检测栈是否为空 |
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());
}
}
1.3 栈的模拟实现
从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的
public class EmptyStackException extends RuntimeException{
public EmptyStackException() {
}
public EmptyStackException(String message) {
super(message);
}
}
import java.util.Arrays;
public class MyStack {
public int[] elem;
public int usedSize;
public static final int DEFAULT_CAPACITY = 10;
public MyStack() {
this.elem = new int[DEFAULT_CAPACITY];
}
/**
* 压栈/入栈
* @param val
*/
public void push(int val) {
if (isFull()){
this.elem = Arrays.copyOf(elem, 2 * elem.length);
}
elem[usedSize++] = val;
}
public boolean isFull(){
return usedSize == elem.length;
}
/**
* 出栈
* @return
*/
public int pop(){
if (isEmpty()){
throw new EmptyStackException("栈为空");
}
usedSize--;
return elem[usedSize];
}
public boolean isEmpty() {
return usedSize == 0;
}
public int peek(){
if (isEmpty()){
throw new EmptyStackException("栈为空");
}
return elem[usedSize - 1];
}
}
-
入栈出栈等操作，时间复杂度均为O(1)
-
通过链表实现栈，可以使用单链表，也可以使用双链表
-
不管使用哪种链表，你一定得保证入栈，出栈等操作时间复杂度均为O(1)
- 使用单向链表来实现栈，入栈采用头插法，出栈采用删除头节点的方式
- 使用双向链表来实现栈，前后都可以实现
public static void main(String[] args) { LinkedList<Integer> stack = new LinkedList<>(); stack.push(1); stack.push(2); stack.push(3); System.out.println(stack.pop()); System.out.println(stack.peek()); }
1.4 栈的应用场景
-
改变元素的序列
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 2.一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（） A: 12345ABCDE B: EDCBA54321 C: ABCDE12345 D: 54321EDCBA 参考答案： 1. C 2. B -
将递归转化为循环
import java.util.LinkedList; import java.util.List; import java.util.Stack; public class PrintReverseOrder { static class Node{ public int val; Node next; public Node(int val) { this.val = val; } } /** * 循环方式逆序打印链表 * @param head */ public static void PrintList(Node head){ if (head == null){ return; } Stack<Node> s = new Stack<>(); //将链表中的节点保存在栈中 Node cur = head; while (cur != null){ s.push(cur); cur = cur.next; } //将栈中的元素出栈 while (!s.empty()){ System.out.print(s.pop().val + " "); } } /** * 递归方式逆序打印链表 * @param head */ public static void PrintList1(Node head) { if (head == null) { return; } PrintList1(head.next); System.out.print(head.val + " "); } public static void main(String[] args) { Node head = new Node(1); Node A = new Node(2); Node B = new Node(3); Node C = new Node(4); Node D = new Node(5); head.next = A; A.next = B; B.next = C; C.next = D; D.next = null; PrintList(head); System.out.println(); PrintList1(head); } } -
class Solution { public boolean isValid(String s) { //只要是左括号就入栈，遇到右括号就看是否匹配，不匹配，直接返回false //字符串没有遍历完成，但是栈是空的，此时也是不匹配 //字符串遍历完成，但是栈还是不为空，此时也是不匹配的 //只要能够找到所有不匹配的情况，剩下的都是匹配的 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.右括号 //3.1 栈为空 if (stack.isEmpty()){ return false; } //3.2 栈不为空 char ch2 = stack.peek();//左括号 if((ch == ')' && ch2 == '(') || (ch == ']' && ch2 == '[') || (ch == '}' && ch2 == '{')){ stack.pop(); }else { return false; } } } //字符串遍历完，考虑栈是否为空 if(!stack.isEmpty()){ return false; } return true; } } -
class Solution { public int evalRPN(String[] tokens) { Stack<Integer> stack = new Stack<>(); for(int i = 0; i < tokens.length; i++) { String str = tokens[i]; if(!isOperations(str)) { //不是运算符，说明是数字 int val = Integer.valueOf(str); stack.push(val); }else { //运算符 int num2 = stack.pop(); int num1 = stack.pop(); switch(str) { 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 isOperations(String str) { if(str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/") ) { return true; } return false; } } -
import java.util.*; public class Solution { /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * * * @param pushV int整型一维数组 * @param popV int整型一维数组 * @return bool布尔型 */ public boolean IsPopOrder (int[] pushV, int[] popV) { // write code here //1.遍历pushV的数组，把pushV数组的元素放到栈当中 //2.每次放一个元素，就看和popV的元素是否一样 //3.j++ //直到遍历完popV Stack<Integer> stack = new Stack<>(); int j = 0; for(int i = 0; i < pushV.length; i++){ stack.push(pushV[i]); while (!stack.isEmpty() && j < popV.length && stack.peek() == popV[j] ){ stack.pop(); j++; } } return j >= popV.length; //return stack.isEmpty(); } } -
class MinStack { //1. 普通栈一定要存储数据 //2. 最小栈：如果是第一次存放数据，直接放，否则需要和最小栈的栈顶元素比较，小于的时候才能进，等于的时候也要放 Stack<Integer> stack; 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 peekNum = minStack.peek(); if (val <= peekNum) { minStack.push(val); } } } public void pop() { //1.从普通栈pop出去 //2.最小栈是否pop，判断普通栈pop的数据是否和最小栈的栈顶元素一样，如果一样那么最小栈也要出去 if(stack.peek().equals(minStack.peek())){ minStack.pop(); } stack.pop(); } public int top() { return stack.peek(); } public int getMin() { return minStack.peek(); } } /** * Your MinStack object will be instantiated and called as such: * MinStack obj = new MinStack(); * obj.push(val); * obj.pop(); * int param_3 = obj.top(); * int param_4 = obj.getMin(); */
1.5 概念区分
栈、虚拟机栈、栈帧有什么区别呢
- 栈：数据结构
- 虚拟机栈：JVM的内存
- 栈帧：调用方法的时候，开辟的内存
2. 队列(Queue)
2.1 概念
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
- 入队列：进行插入操作的一端称为队尾（Tail/Rear）
- 出队列：进行删除操作的一端称为队头（Head/Front）
2.2 队列的使用
在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());
}
}
2.3 队列模拟实现
队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构和链式结构。那么，队列的实现使用顺序结构还是链式结构好？
public class MyQueue {
public static class ListNode{
int val;
ListNode next;
ListNode prev;
public ListNode(int val) {
this.val = val;
}
}
ListNode first;//队头
ListNode last;//队尾
int size = 0;
/**
* 入队列
* 向双向链表位置插入新节点
* @param e
*/
public void offer(int e){
ListNode newNode = new ListNode(e);
if (first == null){
first = newNode;
}else {
last.next = newNode;
newNode.prev = last;
}
last = newNode;
size++;
}
/**
* 出队列
* 将双向链表第一个节点删除掉
* @return
*/
public void poll(){
if (first == null){
return;
}
if (first.next == null){
first = null;
last = null;
return;
}
first = first.next;
}
public int size() {
return size;
}
public boolean isEmpty() {
return first == null;
}
public int peek() {
if (first == null){
return -1;
}
return first.val;
}
}
2.4 循环队列
实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现
数组下标循环的小技巧
-
下标最后再往后(offset 小于 array.length):
index = (index + offset) % array.length
-
下标最前再往前(offset 小于 array.length):
index = (index + array.length - offset) % array.length
如何区分空与满
-
通过添加
usedSize属性记录 -
保留一个位置（浪费空间来表示满）
rear = (rear + 1) % lenpublic class MyCircularQueue { public int[] elem; public int front; public int rear; public MyCircularQueue(int k) { this.elem = new int[k + 1]; } /** * 入队 * @param value * @return */ public boolean enQueue(int value){ if (isFull()){ return false; } elem[rear] = value; rear = (rear + 1) % elem.length; return true; } /** * 判断是否队列满了 * 浪费一个空间 * rear指向的是无元素 * @return */ public boolean isFull(){ return (rear + 1) % elem.length == front; } /** * 删除队头操作 * @return */ public boolean deQueue(){ if (isEmpty()){ return false; } front = (front + 1) % elem.length; return true; } /** * 判断是否队列为空 * front和rear相遇的时候为空 * @return */ public boolean isEmpty(){ return rear == front; } /** * 得到队头元素不删除 * @return */ public int Front(){ if (isEmpty()){ return -1; } return elem[front]; } /** * 得到队尾元素不删除 * @return */ public int Rear(){ if (isEmpty()){ return -1; } int index = (rear == 0) ? elem.length - 1 : rear - 1; return elem[index]; } } -
使用标记，定义一个
boolean flg
3. 双端队列 (Deque)
双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。那就说明元素可以从队头出队和入队，也可以从队尾出队和入队
Deque是一个接口，使用时必须创建LinkedList的对象
在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口
Deque<Integer> stack = new ArrayDeque<>();//双端队列的线性实现
Deque<Integer> queue = new LinkedList<>();//双端队列的链式实现
- 双端队列也可以作为栈
- Stack这个类不是唯一的
4. 面试题
-
//1.当两个队列都是空的时候，放到第一个队列 //2.再次“入栈”的时候，放到不为空的队列 //3.“出栈”的时候，出不为空的队列，出size-1个元素，剩下的元素就是要出栈的元素 import java.util.LinkedList; import java.util.Queue; public class MyStack { private Queue<Integer> qu1; private Queue<Integer> qu2; public MyStack() { qu1 = new LinkedList<>(); qu2 = new LinkedList<>(); } /** * 入栈 * @param x */ public void push(int x) { if (empty()){ qu1.offer(x); return; } if (!qu1.isEmpty()){ qu1.offer(x); }else { qu2.offer(x); } } /** * 出栈 * @return */ public int pop() { if (empty()){ return -1; } if (!qu1.isEmpty()){ int size = qu1.size();; for (int i = 0; i < size - 1; i++) { qu2.offer(qu1.poll()); } return qu1.poll(); }else { int size = qu2.size();; for (int i = 0; i < size - 1; i++) { qu1.offer(qu2.poll()); } return qu2.poll(); } } /** * 获取栈顶元素 * @return */ public int top() { if (empty()){ return -1; } if (!qu1.isEmpty()){ int size = qu1.size();; for (int i = 0; i < size - 1; i++) { qu2.offer(qu1.poll()); } int tmp = qu1.peek(); qu2.offer(qu1.poll()); return tmp; }else { int size = qu2.size();; for (int i = 0; i < size - 1; i++) { qu1.offer(qu2.poll()); } int tmp = qu2.peek(); qu1.offer(qu2.poll()); return tmp; } } /** * 判断栈是否为空 * @return */ public boolean empty() { if (qu1.isEmpty() && qu2.isEmpty()){ return true; } return false; } } -
class MyQueue { //"入队"：把数据放到第一个栈当中 //“出队”：出s2这个栈当中的栈顶元素即可，如果s2为空，把s1里面所有的元素全部放到s2中 //当两个栈都为空，说明模拟的队列为空 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.isEmpty()) { //弹出s1当中所有的元素放到s2当中 while (!s1.isEmpty()) { s2.push(s1.pop()); } } return s2.pop(); } public int peek() { if (empty()) { return -1; } if (s2.isEmpty()) { //弹出s1当中所有的元素放到s2当中 while (!s1.isEmpty()) { s2.push(s1.pop()); } } return s2.peek(); } public boolean empty() { return s1.isEmpty() && s2.isEmpty(); } } /** * 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(); */
915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
