【数据结构 Java 版】详解栈和队列的实现，如何搞定面试

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

return val;

}

// 得到队头元素不删除

public int peek(){

if(isEmpty()){

throw new RuntimeException(“队列为空”);

}else{

return this.front.val;

}

}

// 判断队列是否为空

public boolean isEmpty(){

return this.usedSize==0;

}

// 得到队列长度

public int size(){

return this.usedSize;

}

}

上述队列是用单链表实现的，也叫链式队列。大家也可以自行尝试一下双链表实现队列。

2.4 数组实现队列

---

假设现在我们用数组模拟入队列和出队列的模型

解决方法：

• 方法一：出队时，移动数组将后面的元素往前覆盖（时间复杂度为 O(N)）

• 方法二：使用循环的方法，实现循环队列（时间复杂度为 O(1)）

2.5 循环队列

---

循环队列即数组使用了循环的方式，让数组方便队列的入队和出队。那么怎么实现呢？模型如下

• front：指向的位置就是队列的头，既已经存放数据的第一个下标（删除数据一端）

• rear：指向的位置就是队列的尾巴，即可以存放数据的第一个下标（插入数据一端）

问题1：如何判断 front = rear 时是空还是满？

为了能够区别是空还是满，我们常假定当 front = rear 时为空。而对于满的话，我们则会将这个数组保留一个空的位置，那么当 rear+1 = front 时，则队列满了

问题2：当 front 在数组最后一个位置时，如何再移它到数组的第一个位置呢？

(下标+1)%数组长度

接下来让我们实现循环队列

public class MyCircularQueue {

private int[] elem;

private int front;

private int rear;

public MyCircularQueue(int k){

this.elem=new int[k+1];

}

// 判断队列是否满了

public boolean isFull(){

return (this.rear+1)%this.elem.length==this.front;

}

// 判断队列是否为空

public boolean isEmpty(){

return this.front==this.rear;

}

// 入队

public void enQueue(int val){

if(isFull()){

this.elem= Arrays.copyOf(this.elem,2*this.elem.length);

}

this.elem[this.rear]=val;

this.rear=(this.rear+1)%this.elem.length;

}

// 出队

public int deQueue(){

if(isEmpty()){

throw new RuntimeException(“队列为空”);

}

int val=this.elem[this.front];

this.front=(this.front+1)%this.elem.length;

return val;

}

// 得到队头元素

public int getFront(){

if(isEmpty()){

throw new RuntimeException(“队列为空”);

}

return this.elem[this.front];

}

// 得到队尾元素

public int getRear(){

if(isEmpty()){

throw new RuntimeException(“队列为空”);

}

if(this.rear==0){

return this.elem[this.elem.length-1];

}

return this.elem[this.rear - 1];

}

}

注意：

假设一个数组长度为3，做题时可能人家用例入队了3次，但是按照上述队列为满的方式，我们其实是保留了一个位置是不能存放数据的。因此对于这种题目我们可以将我们的数组开大一位

2.6 双端队列

---

• 双端队列：是指允许两端都可以进行入队和出队操作的队列

• 特点：元素可以从队头出队和入队，也可以从队尾出队和入队

双端队列较简单，可以使用双向链表实现，这里就展示一下双端队列的模型

3. 栈和队列练习题

==============================================================================

3.1 有效的括号

---

题目（OJ 链接）：

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：左括号必须用相同类型的右括号闭合，左括号必须以正确的顺序闭合。

题解：使用栈，遍历字符串，是左括号就进行入栈，是右括号就与栈顶元素比较。

public boolean isValid(String s) {

Stack stack=new Stack<>();

for(int i=0;i<s.length();i++){

char ch=s.charAt(i);

switch(ch){

case ‘)’:

if(stack.empty()||stack.pop()!=‘(’){

return false;

}

break;

case ‘}’:

if(stack.empty()||stack.pop()!=‘{’){

return false;

}

break;

case ‘]’:

if(stack.empty()||stack.pop()!=‘[’){

return false;

}

break;

default:

stack.push(ch);

break;

}

}

if(stack.empty()){

return true;

}

return false;

}

3.2 用队列实现栈

---

题目（OJ链接）：

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

题解：

由于队列是先进先出，栈是先进后出，故一个队列无法满足实现栈的能力。而使用两个队列，对于入栈，我们我只要找到栈不为空的队列进行入队就行；对于出栈，我们只要将不为空的队列的除最后一个入队的元素全部转移到另一个空队列中，再将留下的元素出队

代码：

class MyStack {

private Queue q1;

private Queue q2;

public MyStack() {

q1=new LinkedList<>();

q2=new LinkedList<>();

}

// 入栈

public void push(int x) {

if(!q1.isEmpty()){

q1.offer(x);

}else if(!q2.isEmpty()){

q2.offer(x);

}else{

q1.offer(x);

}

}

// 出栈

public int pop() {

if(empty()){

throw new RuntimeException(“栈为空”);

}

if(!q1.isEmpty()){

int val1=0;

while(!q1.isEmpty()){

val1=q1.poll();

if(!q1.isEmpty()){

q2.offer(val1);

}

}

return val1;

}else{

int val2=0;

while(!q2.isEmpty()){

val2=q2.poll();

if(!q2.isEmpty()){

q1.offer(val2);

}

}

return val2;

}

}

// 得到栈顶元素不删除

public int top() {

if(empty()){

throw new RuntimeException(“栈为空”);

}

if(!q1.isEmpty()){

int val1=0;

while(!q1.isEmpty()){

val1=q1.poll();

q2.offer(val1);

}

return val1;

}else{

int val2=0;

while(!q2.isEmpty()){

val2=q2.poll();

q1.offer(val2);

}

return val2;

}

}

// 判断栈是否为空

public boolean empty() {

return q1.isEmpty()&&q2.isEmpty();

}

}

3.3 用栈实现队列

---

题目（OJ 链接）：

请你仅使用两个栈实现先入先出队列。

题解：

我们可以创建两个栈 s1、s2，s1 用来入队，s2 用来出队

代码：

class MyQueue {

private Stack s1;

private Stack 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();

}

}

3.4 实现一个最小栈

---

题目（OJ 链接）：

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

题解：

我们可以创建两个栈，一个栈就是用来存储删除元素，另一个就是专门用来存储最小值的栈。注意这个最小值是存储该元素时该栈的最小值

代码：

class MinStack {

private Stack stack;

private Stack minStack;

public MinStack() {

stack=new Stack<>();

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() {

int val=stack.pop();

if(minStack.peek()==val){

minStack.pop();

}

}

// 得到栈顶元素，不删除

public int top() {

return stack.peek();

}

// 得到此时栈的最小值

public int getMin() {

return minStack.peek();

}

}

3.5 设计循环队列

---

题目（OJ 链接）：

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

题解：

通过 (下标+1)%数组长度 的方式将数组形成一个循环，先设定好数组为空和为满的条件。注意防止题目将数组存满，开数组时的大小要注意。

代码：

class MyCircularQueue {

private int[] elem;

private int front;

private int rear;

public MyCircularQueue(int k) {

this.elem=new int[k+1];

}

// 入队列

public boolean enQueue(int value) {

if(isFull()){

return false;

}

this.elem[rear]=value;

this.rear=(this.rear+1)%this.elem.length;

return true;

}

// 出队列

public boolean deQueue() {

if(isEmpty()){

return false;

}

this.front=(this.front+1)%this.elem.length;

return true;

}

// 得到队首元素，不删除

public int Front() {

if(isEmpty()){

return -1;

}

return this.elem[front];

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

false;

}

this.elem[rear]=value;

this.rear=(this.rear+1)%this.elem.length;

return true;

}

// 出队列

public boolean deQueue() {

if(isEmpty()){

return false;

}

this.front=(this.front+1)%this.elem.length;

return true;

}

// 得到队首元素，不删除

public int Front() {

if(isEmpty()){

return -1;

}

return this.elem[front];

最后

现在其实从大厂招聘需求可见，在招聘要求上有高并发经验优先，包括很多朋友之前都是做传统行业或者外包项目，一直在小公司，技术搞的比较简单，没有怎么搞过分布式系统，但是现在互联网公司一般都是做分布式系统。

所以说，如果你想进大厂，想脱离传统行业，这些技术知识都是你必备的，下面自己手打了一份Java并发体系思维导图，希望对你有所帮助。

[外链图片转存中…(img-h9NcIKzM-1713667526907)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-1SMiJYRa-1713667526908)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！