- 🍁 个人主页：爱编程的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()); // 获取栈中有效元素个数---> 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());
}
}栈的模拟实现
从上图中可以看到，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];//1
public 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<>();//2
myArray.setVal(0,10);
myArray.setVal(1,12);
int ret = myArray.getPos(1);//3
System.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处，编译器会在存放元素的时 候帮助我们进行类型检查。
此处只对泛型做一个简单的介绍，不作过多解释，理解就好......
