• Java版的数据结构——栈和队列

    目录

    1. 栈（Stack）

    1.1 概念

    1.2 栈的使用

    1.3 栈的模拟实现

    1.4 栈的应用场景

    1.4.1 改变元素的序列

    1.4.2 将递归转化为循环

    2. 队列（Queue）

    2.1 概念

    2.2 队列的使用

    2.3 队列模拟实现

    2.4 循环队列

    3. 双端队列（Deque）

    1. 栈（Stack）

    1.1 概念

    栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
    压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
    出栈：栈的删除操作叫做出栈。出数据在栈顶。

    1.2 栈的使用

    方法功能
    Stack()构造一个空的栈
    E push(E e)将e入栈，并返回e
    E pop()将栈顶元素出栈并返回
    E peek()获取栈顶元素
    int size()获取栈中有效元素个数
    boolean empty()检测栈是否为空
    1. public static void main(String[] args) {
    2.   Stack s = new Stack();
    3.   s.push(1);
    4.   s.push(2);
    5.   s.push(3);
    6.   s.push(4);
    7.   System.out.println(s.size());  // 获取栈中有效元素个数---> 4
    8.   System.out.println(s.peek());  // 获取栈顶元素---> 4
    9.   s.pop();  // 4出栈，栈中剩余1  2  3，栈顶元素为3
    10.   System.out.println(s.pop());  // 3出栈，栈中剩余1 2  栈顶元素为3
    11.   if(s.empty()){
    12.     System.out.println("栈空");
    13.  }else{
    14.     System.out.println(s.size());
    15.  }
    16. }

    1.3 栈的模拟实现

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

    1. import java.util.Arrays;
    2.  
    3. public class MyStack {
    4.     //创建一个顺序栈
    5.     public int[] elem;
    6.     public int usedSize;
    7.  
    8.     public MyStack(){
    9.         this.elem = new int[10];
    10.     }
    11.  
    12.     //压栈
    13.     public void push(int val){
    14.         //首先判断栈是不是满了
    15.         if(isFull()){
    16.             //扩容
    17.             elem = Arrays.copyOf(elem,elem.length * 2);
    18.         }
    19.         elem[usedSize++] = val;
    20.     }
    21.  
    22.     //出栈
    23.     public int pop(){
    24.         if (isEmpty()){
    25.             throw new EmptyException("栈是空的！");
    26.         }
    27.         return elem[--usedSize];
    28.     }
    29.  
    30.     //查看栈顶
    31.     public int peek(){
    32.         if(isEmpty()){
    33.             throw new EmptyException("栈是空的！");
    34.         }
    35.         return elem[usedSize - 1];
    36.     }
    37.  
    38.     //判断栈是不是空了
    39.     public boolean isEmpty(){
    40.         return usedSize == 0;
    41.     }
    42.  
    43.     //栈的大小
    44.     public int size(){
    45.         return usedSize;
    46.     }
    47.     
    48.     //判断栈是不是满了
    49.     public boolean isFull(){
    50.         return usedSize == elem.length;
    51.     }
    52. }

    1.4 栈的应用场景

    1.4.1 改变元素的序列

    1. 若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（C）
     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依次入栈，然后再依次出栈，则元素出栈的顺序是（C）。
    A: 12345ABCDE  B: EDCBA54321  C: ABCDE12345  D: 54321EDCBA

    1.4.2 将递归转化为循环

    1. // 递归方式
    2. void printList(Node head){
    3.   if(null != head){
    4.     printList(head.next);
    5.  }
    6.   System.out.print(head.val + " ");
    7. }
    1. Stack s = new Stack<>();
    2.   // 将链表中的结点保存在栈中
    3.   Node cur = head;
    4.   while(null != cur){
    5.     s.push(cur);
    6.     cur = cur.next;
    7.   }
    8.  
    9.  // 将栈中的元素出栈
    10.  while(!s.empty()){
    11.     System.out.print(s.pop().val + " ");
    12.  }

    2. 队列（Queue）

    2.1 概念

    队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First
    In First Out) 入队列：进行插入操作的一端称为队尾（Tail/Rear） 出队列：进行删除操作的一端称为队头
    （Head/Front）

    2.2 队列的使用

     在Java中，Queue是个接口，底层是通过链表实现的。

    方法功能
    boolean offer(E e)入队列
    E poll()出队列
    peek()获取队头元素
    int size()获取队列中的有效元素个数
    boolean isEmpty()检测队列是否为空

    注意：Queue是个接口，在实例化时必须实例化LinkedList的对象，因为LinkedList实现了Queue接口。

    1. public static void main(String[] args) {
    2.   Queue q = new LinkedList<>();
    3.   q.offer(1);
    4.   q.offer(2);
    5.   q.offer(3);
    6.   q.offer(4);
    7.   q.offer(5);          // 从队尾入队列
    8.   System.out.println(q.size());
    9.   System.out.println(q.peek());  // 获取队头元素
    10.  
    11.   q.poll();
    12.   System.out.println(q.poll());  // 从队头出队列，并将删除的元素返回
    13.  
    14.   if(q.isEmpty()){
    15.     System.out.println("队列空");
    16.  }else{
    17.     System.out.println(q.size());
    18.  }
    19. }

    2.3 队列模拟实现

    队列中既然可以存储元素，那底层肯定要有能够保存元素的空间，通过前面线性表的学习了解到常见的空间类型有两种：顺序结构 和 链式结构。

    小伙伴们思考下：队列的实现使用顺序结构还是链式结构好？【在下列的循环队列解释】

    1. //链式队列
    2. public class MyQueue {
    3.     //首先创建结点，用内部类实现
    4.     static class Node{
    5.         public int val;
    6.         public Node next;
    7.         //构造方法
    8.         public Node(int val){
    9.             this.val = val;
    10.         }
    11.     }
    12.     //有个队头指针和队尾指针
    13.     public Node head;
    14.     public Node last;
    15.     //队列的大小
    16.     public int usedSize;
    17.     
    18.     //入队
    19.     public void offer(int val){
    20.         Node node = new Node(val);
    21.         if(head == null){//证明队列为空
    22.             head = node;
    23.             last = node;
    24.         }else{//如果有元素了
    25.             last.next = node;
    26.             last = node;
    27.         }
    28.         usedSize++;
    29.     }
    30.     
    31.     
    32.     
    33.     //出队
    34.     public int poll() {
    35.         //判断队列是否为空
    36.         if (empty()) {
    37.             throw new EmptyException("队列为空");//自定义异常类
    38.         }
    39.         int ret = head.val;
    40.         head = head.next;
    41.         if (head == null) {
    42.             last = null;//只有一个结点时，那么last也要置空。因为如果last不置空，出队的结点还是有引用指向它，它就不会被gc回收
    43.         }
    44.         usedSize--;
    45.         return ret;
    46.     }
    47.  
    48.     //判断队列是否为空
    49.     public boolean empty() {
    50.         return usedSize == 0;
    51.     }
    52.     
    53.     //查看队头元素
    54.     public int peek(){
    55.         //判断队列是否为空
    56.         if (empty()) {
    57.             throw new EmptyException("队列为空");//自定义异常类
    58.         }
    59.         return head.val;
    60.     }
    61.     
    62.     //获得队列大小
    63.     public int getUsedSizeize(){
    64.         return usedSize;
    65.     }
    66.  
    67. }

    2.4 循环队列

    实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列通常使用数组实现。

    如果是普通的顺序队列，就会导致队头标记跑到了数组的末尾，导致存储空间的浪费，这也就是上面的队列实现要使用链式队列的原因

    数组下标循环的小技巧
    1. 下标最后再往后(offset 小于 array.length): index = (index + offset) % array.length

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

     如何区分空与满

    1. 通过添加 size 属性记录
    2. 保留一个位置
    3. 使用标记

    代码实现： 

    1. //循环队列
    2. public class MyCircularQueue {
    3.     private int elem[];
    4.     private int front;//表示队列的头
    5.     private int rear;//表示队列的尾
    6.  
    7.     //创建循环队列
    8.     public MyCircularQueue(int k) {
    9.         //如果是浪费空间，这里必须多加一个1
    10.         this.elem = new int[k + 1];
    11.     }
    12.  
    13.     //判断队列是否为满
    14.     public boolean isFull() {
    15.         return (rear + 1) % elem.length == front;
    16.     }
    17.  
    18.     //入队列
    19.     public boolean enQueue(int value) {
    20.         //1. 检查是否队列是满的
    21.         if (isFull()) {
    22.             return false;
    23.         }
    24.         rear = (rear + 1) % elem.length;
    25.         elem[rear] = value;
    26.         return true;
    27.     }
    28.  
    29.  
    30.     //出队列
    31.     public boolean deQueue() {
    32.         //队列为空
    33.         if (isEmpty()) {
    34.             return false;
    35.         }
    36.         front = (front + 1) % elem.length;
    37.         return true;
    38.     }
    39.  
    40.     //得到队头元素
    41.     public int Front() {
    42.         if (isEmpty()) {
    43.             return -1;
    44.         }
    45.         return elem[front];
    46.     }
    47.  
    48.     //得到队尾元素
    49.     public int Rear() {
    50.         if(isEmpty()) {
    51.             return -1;
    52.         }
    53.         int index = (rear == 0) ? elem.length - 1 : rear-1;
    54.         return elem[index];
    55.  
    56.     }
    57.  
    58.     //判读队列是否为空
    59.     public boolean isEmpty() {
    60.         return front == rear;
    61.     }
    62. }

    3. 双端队列（Deque）

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

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

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

  • 相关阅读:
    利用游标给数据库所有表添加同一个字段
    【OpenDDS开发指南V3.20】第三章：服务质量
    高新技术企业认定标准是什么？
    玩转ChatGPT：Kimi测评（科研写作）
    SpringBoot过滤器和拦截器
    MySQL 快速入门之第二章 数据类型、建表以及约束
    【Java】封装的实现，访问限定符、包
    基于STM32L431的Liteos低功耗Runstop模式的实现
    STM32CubeMX教程4 EXTI 按键外部中断
    【概率论基础进阶】多维随机变量及其分布-二维均匀分布和二维正态分布
  • 原文地址：https://blog.csdn.net/ANNE_fly/article/details/132842150