栈(Stack)
概念
栈是一种先进后出的数据结构。
栈的使用
import java.util.Stack;
public class Test {
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());
}
}
}
栈的模拟实现
import java.util.Arrays;
public class MyStack {
public int[] elem;
public int usedSize;
public MyStack() {
this.elem = new int[10];
}
public void push(int val) {
if (isFull()) {
//扩容
elem = Arrays.copyOf(elem, 2 * elem.length);
}
elem[usedSize] = val;
usedSize++;
}
public boolean isFull() {
return usedSize == elem.length;
}
public int pop() {
if (empty()) {
return -1;
}
int oldVal = elem[usedSize - 1];
usedSize--;
//如果为引用类型 还需加上elem[usedSize]=null;
return oldVal;
}
public boolean empty() {
return usedSize == 0;
}
public int peek() {
if (empty()) {
return -1;
}
/* int oldVal=elem[usedSize-1];
usedSize--;
return oldVal;*/
return elem[usedSize - 1];
}
}
栈的应用场景
1. 改变元素的序列
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
2. 将递归转化为循环
比如:逆序打印链表
// 递归方式
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 + " ");
}
}
3.逆波兰表达式求值
class Solution {
public int evalRPN(String[] tokens) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < tokens.length; i++) {
String tmp = tokens[i];
if (!isOpearation(tmp)) {
Integer val = Integer.valueOf(tmp);
stack.push(val);
} else {
Integer val2 = stack.pop();
Integer val1 = stack.pop();
switch (tmp) {
case "+":
stack.push(val1 + val2);
break;
case "-":
stack.push(val1 - val2);
break;
case "*":
stack.push(val1 * val2);
break;
case "/":
stack.push(val1 / val2);
break;
}
}
}
return stack.pop();
}
public boolean isOpearation(String s) {
if (s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")) {
return true;
}
return false;
}
}
4.括号匹配
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>();
for (int i = 0; i < s.length(); i++) {
char ch = s.charAt(i);
// 1.左括号入栈
if (ch == '(' || ch == '{' || ch == '[') {
stack.push(ch);
} else {
// 2.遇到了右括号
if (stack.empty()) {
return false;
} else {
// 3.取栈顶元素的左括号 看和 当前右括号是否匹配
char chL = stack.peek();
if (chL == '(' && ch == ')' || chL == '[' && ch == ']'
|| chL == '{' && ch == '}') {
// 4.证明当前这一对括号是匹配的
stack.pop();
} else {
// 5.当前括号不匹配
return false;
}
}
}
}
return stack.empty();
}
}
5.出栈入栈次序匹配
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param pushV int整型一维数组
* @param popV int整型一维数组
* @return bool布尔型
*/
public boolean IsPopOrder (int[] pushV, int[] popV) {
// write code here
Stack<Integer> stack = new Stack<>();
int j = 0;
for (int i = 0; i < pushV.length; i++) {
stack.push(pushV[i]);
while (j < popV.length && !stack.empty()
&& stack.peek() == popV[j]) {
stack.pop();
j++;
}
}
return stack.empty();
}
}
6. 最小栈
class MinStack {
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 {
Integer peekVal = minStack.peek();
if (val <= peekVal) {
minStack.push(val);
}
}
}
public void pop() {
if (stack.empty()) {
return;
}
int popVal = stack.pop();
if (popVal == minStack.peek()) {
minStack.pop();
}
}
public int top() {
if (stack.empty()) {
return -1;
}
return stack.peek();
}
// 要求:常数时间范围内 获取到栈当中的最小值
public int getMin() {
if (minStack.empty()) {
return -1;
}
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();
*/
Java集合类的Stack底层是一个数组,这种栈叫做顺序栈,栈可以用链表实现。
import java.util.LinkedList;
public class Test {
public static void main(String[] args) {
LinkedList<Integer> stack = new LinkedList<>();
stack.push(10);//头插法入栈
stack.push(20);
stack.push(30);
stack.pop();
}
}