• 🍁 个人主页：爱编程的Tom
• 💫 本篇博文收录专栏：Java专栏
• 👉 目前其它专栏：c系列小游戏     c语言系列--万物的开始_               
• 🎉 欢迎 👍点赞✍评论⭐收藏💖三连支持一下博主🤞
• 🧨现在的沉淀就是对未来的铺垫🎨 

目录

前言

栈（Stack）

栈的定义

栈的使用 

栈的模拟实现 

栈的应用场景

改变元素的序列  

将递归转化为循环 

队列(Queue) 

队列的定义 

队列的使用 

队列模拟实现 

循环队列 

双端队列 (Deque) 

泛型

---

 

前言

本篇文章将带你深入了解栈和队列的底层知识和基础架构，学会使用对数据的组织和运用！

栈（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());   // 获取栈中有效元素个数---> 4System.out.println(s.peek());   // 获取栈顶元素---> 4s.pop();   // 4出栈，栈中剩余1   2   3，栈顶元素为3System.out.println(s.pop());   // 3出栈，栈中剩余1 2   栈顶元素为3if(s.empty()){System.out.println("栈空");}else{System.out.println(s.size());}
}

栈的模拟实现 

 

从上图中可以看到，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。 

Stack的具体模拟实现如下： 

public class MyStack {public int[] elem;public int usedSize;public static final int DEFAULT_CAPACITY = 10;public MyStack() {this.elem = new int[DEFAULT_CAPACITY];}//压栈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;}//出栈public int pop() {if (isEmpty()) {throw new EmptyStackException("栈为空！！！！");}int oldVal = elem[usedSize-1];usedSize--;//elem[usedSize] = null;return oldVal;}public boolean isEmpty() {return usedSize == 0;}public int peek() {if(isEmpty()) {throw new EmptyStackException("栈为空！！！！！");}return elem[usedSize - 1];}
}

栈的应用场景

改变元素的序列  

如上图两题在栈的理解上，解决可得选项为 C 和 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 + " ");}
}

这里还有一些练习的题目：如果想更深入了解栈的相关机理，可以尝试做一做

1.括号匹配

2.逆波兰表达式 

3.出栈入栈次序匹配 

4.最小栈 

这里提出一个思考题：栈、虚拟机栈、栈帧有什么区别呢？

栈：栈是一种数据结构，具有后进先出（LIFO）的特性，用于存储函数调用、局部变量等数据。在计算机中，栈通常是指操作系统管理的内存区域，用于存储函数调用时的参数、返回地址、局部变量等。

虚拟机栈：虚拟机栈是指在Java虚拟机中用来执行Java方法的内存区域，用于存储方法的局部变量、操作数栈、动态链接、方法出口等信息。虚拟机栈与操作系统的栈类似，但是在Java虚拟机中，每个线程都有自己的虚拟机栈，用于执行方法时的数据存储。

栈帧：栈帧是指在方法调用时压入虚拟机栈中的数据结构，用于存储方法的局部变量、操作数栈、动态链接、方法出口等信息。每个方法调用都会创建一个对应的栈帧，用于存储该方法执行时需要的数据。栈帧是虚拟机栈中的一个重要组成部分，用于支持方法的执行和调用。

队列(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());}
}

队列模拟实现 

队列中既然可以存储元素，那底层肯定要有能够保存元素的空间

常见的空间类型有两种：顺序结构 和 链式结构。

思考题：队列的实现使用顺序结构还是链式结构好？ 

顺序结构：

优点：顺序结构的队列使用数组实现，插入和删除操作的时间复杂度为O(1)，在空间上比较节省。

缺点：在插入和删除元素时，需要移动其他元素，可能会导致性能下降。而且顺序结构的队列有容量限制，当队列满时需要进行扩容操作。

链式结构：

优点：链式结构的队列使用链表实现，插入和删除操作的时间复杂度为O(1)，不需要移动其他元素。而且链式结构的队列没有容量限制，可以动态增加或减少元素。

缺点：链式结构的队列在内存占用上比顺序结构更大，因为每个节点都需要额外的指针指向下一个节点。

总结：如果对内存占用要求比较高，且队列的大小是固定的，可以选择顺序结构实现队列；如果对插入和删除操作的性能要求比较高，且队列的大小是动态变化的，可以选择链式结构实现队列。

队列实现场景图：

 

下面给出模拟实现的代码（仅供参考）： 

public class Queue {// 双向链表节点public static class ListNode{ListNode next;ListNode prev;int value;ListNode(int value){this.value = value;}}ListNode first;   // 队头ListNode last;    // 队尾int size = 0;// 入队列---向双向链表位置插入新节点public void offer(int e){ListNode newNode = new ListNode(e);if(first == null){first = newNode;// last = newNode;}else{last.next = newNode;newNode.prev = last;// last = newNode;}last = newNode;size++;}// 出队列---将双向链表第一个节点删除掉public int poll(){// 1. 队列为空// 2. 队列中只有一个元素----链表中只有一个节点---直接删除// 3. 队列中有多个元素---链表中有多个节点----将第一个节点删除int value = 0;if(first == null){return null;}else if(first == last){last = null;first = null;}else{value = first.value;first = first.next;first.prev.next = null;first.prev = null;}--size;return value;}// 获取队头元素---获取链表中第一个节点的值域public int peek(){if(first == null){return null;}return first.value;}public int size() {return size;}public boolean isEmpty(){return first == null;}
}

循环队列 

 

数组下标循环的小技巧

1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length  

 

2. 下标最前再往前(offset 小于 array.length): index = (index + array.length - offset) % array.length 

 

如何区分空与满 

1. 通过添加 size 属性记录 

2. 保留一个位置

3. 使用标记  

 

感兴趣的可以试试这道相关题目：设计循环队列 

双端队列 (Deque) 

双端队列（deque）是指允许两端都可以进行入队和出队操作的队列，deque 是 “double ended queue” 的简称。 那就说明元素可以从队头出队和入队，也可以从队尾出队和入队。  

Deque是一个接口，使用时必须创建LinkedList的对象。 

 

在实际工程中，使用Deque接口是比较多的，栈和队列均可以使用该接口。

这里给出两种实现方式：

Deque stack = new ArrayDeque<>();//双端队列的线性实现

Deque queue = new LinkedList<>();//双端队列的链式实现 

泛型

泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。 

主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。 

在编译的过程当中，将所有的T替换为Object这种机制，这种机制称为：擦除机制。  

class MyArray<T> {public T[] array = (T[])new Object[10];//1public T getPos(int pos) {return this.array[pos];}public void setVal(int pos,T val) {this.array[pos] = val;}
}
public class TestDemo {public static void main(String[] args) {MyArray<Integer> myArray = new MyArray<>();//2myArray.setVal(0,10);myArray.setVal(1,12);int ret = myArray.getPos(1);//3System.out.println(ret);myArray.setVal(2,"bit");//4}
}

对上述代码进行一个说明：

1. 类名后的代表占位符，表示当前类是一个泛型类

了解：【规范】类型形参一般使用一个大写字母表示，

常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等 - 第二、第三、第四个类型

2. 注释1处，不能new泛型类型的数组 ,说明：

T[] ts = new T[5];//是不对的

3. 注释2处，类型后加入 指定当前类型

4. 注释3处，不需要进行强制类型转换

5. 注释4处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时 候帮助我们进行类型检查。

此处只对泛型做一个简单的介绍，不作过多解释，理解就好......