Java栈和队列·上
Posted 晓星航
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java栈和队列·上相关的知识，希望对你有一定的参考价值。
Java栈和队列·上
大家好，我是晓星航。今天为大家带来的是 Java栈和队列·上 的讲解！😀
1. 栈(Stack)
1.1 概念
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出数据在栈顶。(先进去的后出)
那么什么是栈帧呢？
答：我们调用函数时，计算机会为这个函数开辟一块内存，即为栈帧。在JVA stack上开辟。
提问：能不能用单链表实现栈？
1.2 实现
- 利用顺序表实现，即使用尾插 + 尾删的方式实现
- 利用链表实现，则头尾皆可
相对来说，顺序表的实现上要更为简单一些，所以我们优先用顺序表实现栈。
public class TestDemo
// 简单起见，我们就不考虑扩容问题了
private int[] array = new int[100];
private int size = 0;
public void push(int v)
array[size++] = v;
public int pop()
return array[--size];
public int peek()
return array[size - 1];
public boolean isEmpty()
return size == 0;
public int size()
return size;
push：增加栈中元素(压栈-在栈顶插入)
pop：弹出栈顶元素，并且删除
peek：获取栈顶元素，但是不删除
empty：判断栈中元素是否为空，为空返回true，不为空返回flase。
size：获取栈中元素个数，并返回数值
isEmpty：判断栈中元素是否为空，为空返回true，不为空返回flase。(继承于Vector父类)
代码示意图如上
自己实现栈：
import java.util.Arrays;
public class MyStack
public int[] elem;
public int useSize;
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.useSize] = val;
useSize++;
public boolean isFull()
return this.useSize == this.elem.length;
public int peek()
if (isEmpty())
throw new RuntimeException("栈为空");
return this.elem[useSize - 1];
public int pop()
if (isEmpty())
throw new RuntimeException("栈为空");
int oldVal = this.elem[useSize-1];
this.useSize--;
return oldVal;
public boolean isEmpty()
return this.useSize == 0;
1.3用法
1、入栈和出栈的顺序？
例如：一个栈的入栈序列是a、b、c、d、e则栈不可能的输出序列是：()
A.edcba B.decba C.dceab D.abcde
答：选C。
解析：这里我们后入的先出，但不一定要全部入进去才能出，所以例如选项D可以入一个出一个。
2、已知一个栈的入栈序列是mnxyz,则不可能出现的出栈顺序是？
A.mnxyz B.xnyzm C.nymxz D.nmyzx
答：选C
解析：这里和上面第一题解法相同也是后入的先出，随进随出，而C不符合这个规律，因此C错误。
3、中缀表达式 转 后缀表达式：
(5+4)*3-2
(((5+4)*3)-2)
(((54)+3)*2)-
54+3*2-
如何通过 这个后缀 表达式 来计算一个值呢？
具体图解过程如下：
i开始遍历我们的表达式：
i遍历到4，并将5放入栈中
i遍历到+，并将4放入栈中
此时因为i访问到了+号，因此开始计算前面两个元素的值，先入栈的放左边后入栈的放右边。
将计算好的结果9放入栈中，i继续向后走遇到3
i遍历到*，并将3放入栈中
此时因为i访问到了*号，因此开始计算前面两个元素的值，先入栈的放左边后入栈的放右边。
将计算好的结果27放入栈中，i继续向后走遇到2
i遍历到-，并将2放入栈中
此时因为i访问到了-号，因此开始计算前面两个元素的值，先入栈的放左边后入栈的放右边。
i往后走没有值停下，此时将计算好的结果25放入栈中
上述便是计算机计算后缀表达式的详细图解过程
转化方法为先按照计算顺序分别加上括号，然后再按照符号的顺序将他们分别放在各自的括号后面(后缀表达式)
如果此时是将中缀表达式 转 前缀表达式 则为：-*+54 3 2 (过程如下)
(5+4)*3-2
(((5+4)*3)-2)
-(*(+(54)3)2)
-*+54 3 2
如何用代码来实现中缀表达式转化为后缀表达式呢？
1.定义很多的常量，来标识每个运算符的优先级( ) + - * /
2.借助栈
下面为大家带来一个使用栈来计算后缀表达式的编程题目：
class Solution
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))
//如果不是运算符
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;
下面题目是通过计算机来计算出栈与入栈的可能性：
1、遍历pushA数组，存放元素到栈中。
2、获取栈顶元素和当前j下标元素是否一样？
3、如果一样哪么就弹出，j++ ……
注意事项：
1、栈是否为空？
import java.util.ArrayList;
public class TestDemo
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 (j < popA.length && stack.empty() && stack.peek() == popA[j])
stack.pop();
j++;
return stack.empty();
1.4栈练习题
- 括号匹配问题。OJ链接
import java.util.Stack;
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);
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;
题目描述的很清楚，左右括号如果不匹配，无非是以下几种情况：
1、左括号多余右括号
2、右括号多余左括号
3、左右括号顺序不想匹配
在使用代码将这几种情况考虑完全后，便可轻易通过测试。
思路如下：
如果是左括号我们直接使其进栈，如果是右括号我们先判断右括号是否比左括号多，再看其是否相匹配，匹配则弹出相对应的左括号继续下一个括号的判断，如果不匹配则返回不匹配错误，在右括号全部判断完毕后，我们判断一下栈此时是否为空，如果为空则我们所有的括号都匹配成功即正确，如果不为空则是左括号比右括号要多，我们就返回false。
- 实现一个最小栈。OJ链接
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();
思路：这里我们采取了使用两个栈(一个普通栈 一个最小栈)来比较的方法，例如我们在push元素时，普通栈我们是直接放进去的，而最小栈我们则是通过比较，如果要放的元素比我们最小栈栈顶的元素小或等于我们便在最小栈也放入一份。
在pop弹出栈顶元素时我们同样是直接弹出普通栈的栈顶元素，然后比较这个弹出的元素和最小栈栈顶元素的大小是否相等，如果相等我们则还需要再pop一次最小栈的栈顶元素。
top方法和我们stack栈中的peek方法一样，我们直接返回stack的peek方法即可。
getMin方法是返回栈中最小元素，我们这里有两个栈，而最小栈的原理就是将最小的元素通过压栈(头插)的方式进入最小栈，因此我们最小栈的最小值永远是栈顶的元素，我们直接返回最小栈的栈顶元素即可。
感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘
Java数据结构与算法-栈和队列
（摘录加总结）------
栈和队列不属于基础的数据结构，它们都属于线性表。
一、栈
对于栈存储操作元素只能在栈结构的一端进行元素的插入和删除，是一种性质上的线性表结构。按照“先进后出”的原则进行存储数据。先进的元素在栈底，后进的元素在栈顶。需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。比较常规的说明是：栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。
栈的实现结构包括顺序结构实现和链式结构实现。前者依据的是数组，后者是链表。
（1）利用数组实现栈
下面这个是一个基本的实现：①在Stack底层设置了一个int数组，当然可以使用泛型来指代不同的数据类型。最大容量和栈顶位置。特别需要注意的是在初始化时也看出来，一般在初始化的时候top位置设置为-1，这是利于后面在压入数据的时候数组的第一位是array[0]，并且maxSize最大容量和数组的length是一致的。②top表示这个数组的当前的没有被设置元素的第一个位置的标志位是多少，首先要判断是否小于maxSize-1，因为是从-1开始的，并且每次判断都是++top，是先自增的处理，示意如下，假如初始化了一个容量为3的数组：
③当压栈完成的时候自然top的索引值已经变成了数组最高项的值的大小，在进行pop弹栈操作的时候自然已经是完成了压栈操作的，此时的top的值是最大位置处，所以return array[top--]就完成了弹出最大的那个元素，并且将索引top值在弹栈之后再减一。④判断是否空栈是通过top == -1来判断的，即初始化的情况。
public class MyStack {
private int[] array;
private int maxSize;
private int top;
public MyStack(int size){
this.maxSize = size;
array = new int[size];
top = -1;
}
//压入数据
public void push(int value){
if(top < maxSize-1){
array[++top] = value;
}
}
//弹出栈顶数据
public int pop(){
return array[top--];
}
//访问栈顶数据
public int peek(){
return array[top];
}
//判断栈是否为空
public boolean isEmpty(){
return (top == -1);
}
//判断栈是否满了
public boolean isFull(){
return (top == maxSize-1);
}
}
（2）利用栈的后进先出的特性可以很容易的实现逆序的操作，比如下面这个利用栈实现字符串的输入的逆序：这里使用一个用Object类型数组来接收数据，并且加入了判断是否扩容的ArrayStack类来进行测试，实现字符串的逆序输出：
package stack.test;
import java.util.Arrays;
import java.util.EmptyStackException;
public class ArrayStack {
// 存储元素的数组,声明为Object类型能存储任意类型的数据
private Object[] elementData;
// 指向栈顶的指针
private int top;
// 栈的总容量
private int size;
// 默认构造一个容量为10的栈
public ArrayStack() {
this.elementData = new Object[10];
this.top = -1;
this.size = 10;
}
public ArrayStack(int initialCapacity) {
if (initialCapacity < 0) {
throw new IllegalArgumentException("栈初始容量不能小于0: " + initialCapacity);
}
this.elementData = new Object[initialCapacity];
this.top = -1;
this.size = initialCapacity;
}
// 压入元素
public Object push(Object item) {
// 是否需要扩容
isGrow(top + 1);
elementData[++top] = item;
return item;
}
// 弹出栈顶元素
public Object pop() {
Object obj = peek();
remove(top);
return obj;
}
// 获取栈顶元素
public Object peek() {
if (top == -1) {
throw new EmptyStackException();
}
return elementData[top];
}
// 判断栈是否为空
public boolean isEmpty() {
return (top == -1);
}
// 删除栈顶元素
public void remove(int top) {
// 栈顶元素置为null
elementData[top] = null;
this.top--;
}
/**
* 是否需要扩容，如果需要，则扩大一倍并返回true，不需要则返回false
*
* @param minCapacity
* @return
*/
public boolean isGrow(int minCapacity) {
int oldCapacity = size;
// 如果当前元素压入栈之后总容量大于前面定义的容量，则需要扩容
if (minCapacity >= oldCapacity) {
// 定义扩大之后栈的总容量
int newCapacity = 0;
// 栈容量扩大两倍(左移一位)看是否超过int类型所表示的最大范围
if ((oldCapacity << 1) - Integer.MAX_VALUE > 0) {
newCapacity = Integer.MAX_VALUE;
} else {
newCapacity = (oldCapacity << 1);// 左移一位，相当于*2
}
this.size = newCapacity;
elementData = Arrays.copyOf(elementData, size);
return true;
} else {
return false;
}
}
//测试字符串输入“drive”
public static void main(String[] args) {
String testString = "drive";
ArrayStack stack = new ArrayStack(10);
char[] cc = testString.toCharArray();
for (char c : cc) {
stack.push(c);
}
while (!stack.isEmpty()) {
System.out.print(stack.pop());
}
}
}
运行结果：
（3）这里在记录一个利用栈的原理来进行分隔符匹配：（摘录）
//分隔符匹配
//遇到左边分隔符了就push进栈，遇到右边分隔符了就pop出栈，看出栈的分隔符是否和这个有分隔符匹配
@Test
public void testMatch(){
ArrayStack stack = new ArrayStack(3);
String str = "12<a[b{c}]>";
char[] cha = str.toCharArray();
for(char c : cha){
switch (c) {
case \'{\':
case \'[\':
case \'<\':
stack.push(c);
break;
case \'}\':
case \']\':
case \'>\':
if(!stack.isEmpty()){
char ch = stack.pop().toString().toCharArray()[0];
if(c==\'}\' && ch != \'{\'
|| c==\']\' && ch != \'[\'
|| c==\')\' && ch != \'(\'){
System.out.println("Error:"+ch+"-"+c);
}
}
break;
default:
break;
}
}
}
栈操作所耗的时间不依赖栈中数据项的个数。
二、队列
队列区别于栈的最主要的特性就是“先进先出”。队列只允许在队列的前端（front）进行删除操作，即队头进行删除，在队列的后端（rear）进行插入操作，即队尾进行插入操作。这样子理解其实就类似于排队一样和名字一样，从队尾插入的数据是最先进入的，所以会一直“排”到队头的位置去，而删除操作是从队头的位置开始删除的，所以满足先进先出，示意：
队列的分类也有两种：单向队列（Queue）和双向队列（Deque）：主要是操作插入元素和删除元素的位置的不同导致的。实现方式也包括数组实现和链表实现。
（1）单向队列实现---（摘录和总结）
与栈不同的是，队列中的数据不总是从数组的0下标开始的，移除一些队头front的数据后，队头指针会指向一个较高的下标位置。也就是说与初始化的整体容量相比没有完全满溢的情况下，会出现下图所示的情况。一般队头指针在删除掉元素之后会向上移动，队尾指针在插入元素之后也会向上移动，这样子如果在删除掉一些队头元素之后再插入元素就会出现容量溢出的情况，这样子是不好的。
所以为了解决队列不满而不能插入新的元素所以引入了“循环队列”的概念。即让队尾指针绕到队头的位置。
具体实现：
public class MyQueue {
private Object[] queArray;
//队列总大小
private int maxSize;
//前端
private int front;
//后端
private int rear;
//队列中元素的实际数目
private int nItems;
public MyQueue(int s){
maxSize = s;
queArray = new Object[maxSize];
front = 0;
rear = -1;
nItems = 0;
}
//队列中新增数据
public void insert (int value) {
if (!isfull()) {
if (rear == maxsize - 1) {
rear = -1;
}
quearray[++rear] = value;
items++;
}
else
System.out.println("队列已经满了.");
}
//移除数据
public Object remove(){
Object removeValue = null ;
if(!isEmpty()){
removeValue = queArray[front];
queArray[front] = null;
front++;
if(front == maxSize){
front = 0;
}
nItems--;
return removeValue;
}
return removeValue;
}
//查看队头数据
public Object peekFront(){
return queArray[front];
}
//判断队列是否满了
public boolean isFull(){
return (nItems == maxSize);
}
//判断队列是否为空
public boolean isEmpty(){
return (nItems ==0);
}
//返回队列的大小
public int getSize(){
return nItems;
}
}
（2）优先级队列（专用数据结构）
在优先级队列中，数据项按照关键字进行排序，关键字最小（或者最大）的数据项往往在队列的最前面，而数据项在插入的时候都会插入到合适的位置以确保队列的有序。每个元素都有一个优先权。
处理方法：一般情况下，①查找操作用来搜索优先权最大的元素，②删除操作用来删除该元素 。③对于优先权相同的元素，可按先进先出次序处理或按任意优先权进行。
可用数组来实现优先级队列也可以用堆来实现，速度更快。数组实现优先级队列，声明为int类型的数组，关键字是数组里面的元素，在插入的时候按照从大到小的顺序排列，也就是越小的元素优先级越高。
同理nItems表示当前队列里面已经插入好了的元素，当然按照插入原则这nItems个元素在队列中肯定是按照从大到小的顺序插入的。
public class PriorityQue {
private int maxSize;
private int[] priQueArray;
private int nItems;
public PriorityQue(int s){
maxSize = s;
priQueArray = new int[maxSize];
nItems = 0;
}
//插入数据
public void insert(int value){
int j;
if(nItems == 0){
priQueArray[nItems++] = value;
}else{
j = nItems -1;
//选择的排序方法是插入排序，按照从大到小的顺序排列，越小的越在队列的顶端
while(j >=0 && value > priQueArray[j]){
priQueArray[j+1] = priQueArray[j];
j--;
}
priQueArray[j+1] = value;
nItems++;
}
}
//移除数据,由于是按照大小排序的，所以移除数据我们指针向下移动
//被移除的地方由于是int类型的，不能设置为null，这里的做法是设置为 -1
public int remove(){
int k = nItems -1;
int value = priQueArray[k];
priQueArray[k] = -1;//-1表示这个位置的数据被移除了
nItems--;
return value;
}
//查看优先级最高的元素
public int peekMin(){
return priQueArray[nItems-1];
}
//判断是否为空
public boolean isEmpty(){
return (nItems == 0);
}
//判断是否满了
public boolean isFull(){
return (nItems == maxSize);
}
}
insert() 方法，先检查队列中是否有数据项，如果没有，则直接插入到下标为0的单元里，否则，从数组顶部开始比较，找到比插入值小的位置进行插入，并把 nItems 加1。remove 方法直接获取顶部元素。优先级队列此处的优先级的体现是元素的大小的顺序，大的元素的优先级别更高，主要是在插入元素的时候体现的。
以上是关于Java栈和队列·上的主要内容，如果未能解决你的问题，请参考以下文章