数据结构之栈和队列

最新推荐文章于 2024-07-12 17:39:03 发布
最新推荐文章于 2024-07-12 17:39:03 发布
阅读量713 收藏 1
点赞数
分类专栏： 2022 # 数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/124015468
版权

1. 栈

栈是一种特殊的线性表，只能够在一端进行操作。特点是后进先出LIFO。
每加入一个元素会放在栈顶，将之前的元素往栈顶的位置移动。
出栈的元素也只能是栈顶元素。

在这里插入图片描述

1.1 接口设计

  1. int size()：返回元素数量；
  2. boolean isEmpty()：栈是否为空；
  3. void push(E e)：元素入栈；
  4. E pop()：元素出栈；
  5. E top()：返回栈顶元素。

1.2 方法实现

栈中的方法实际上可以直接运用ArrayList或者是LinkedList中的方法，这里没有使用。

1.2.1 成员变量

这里的成员变量跟ArrayList一样。

	private E[] elements;

    private int size;

    // 默认容量
    private static final int DEFAULT_CAPACITY = 10;
1.2.2 方法实现
    /**
     * 入栈
     * @param e
     */
    public void push(E e){
        if (size >= elements.length){
            ensureCapacity(size + 1);
        }
        elements[size++] = e;
    }

	 /**
     * 出栈
     * @return
     * @throws IndexOutOfBoundsException
     */
    public E pop() throws IndexOutOfBoundsException {
        if (size < 1){
            throw new IndexOutOfBoundsException("Size:" + size);
        }
        return elements[--size];
    }

    /**
     * 查看栈顶元素
     * @return
     */
    public E top(){
        if (size < 1){
            throw new IndexOutOfBoundsException("Size:" + size);
        }
        return elements[size - 1];
    }

    /**
     * 保证要有capacity的容量
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity) {
            return;
        }
        // 新容量为旧容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[i];
        }
        elements = newElements;
    }

1.3 力扣题目

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
https://leetcode-cn.com/problems/valid-parentheses/

整体思路就是：将左括号的值加入到栈中，如果是右括号就弹出栈顶判断是否与左括号符合。

	public static boolean isValid(String s) {
        if (s == null || s.length() % 2 != 0 || s.length() == 0) {
            return false;
        }
        int len = s.length();
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < len; i++) {
            char c = s.charAt(i);
            if (c == '(' || c== '[' || c == '{' ){
                stack.push(c);
            }else {
                if (stack.isEmpty()) {
                    return false;
                }
                char left = stack.pop();
                if (left == '{' && c!= '}'){
                    return false;
                }
                if (left == '[' && c!= ']'){
                    return false;
                }
                if (left == '(' && c!= ')'){
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

2. 队列

队列是一种特殊的线性表，只能在头尾两端进行操作。
只能从队尾添加元素，在对头移除元素。
先进先出原则，FIFO

在这里插入图片描述

2.2 LinkedList实现队列

因为栈中队列中只能对头元素和尾元素进行操作，所以使用双向链表来实现是最合适的，这里直接选用Java官方的LinkedList来实现队列。Java官方的Queue接口也是由LinedList来实现的。

接口实现：

  1. int size()：队中元素数量；
  2. boolean isEmpty()：队列是否为空；
  3. void enQueue(E e)：入队；
  4. E deQueue()：出队；
  5. E front()：返回队头元素；
  6. void clear()：清空。
 /**
 * @Description 用双向链表实现队列
 * @date 2022/4/7 15:46
 */
public class Queue<E> {

    LinkedList<E> list = new LinkedList<>();

    /**
     * 返回队列元素数量
     * @return
     */
    public int size(){
        return list.size();
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return list.isEmpty();
    }

    /**
     * 入队
     * @param e
     */
    public void enQueue(E e){
        list.add(e);
    }

    /**
     * 出队
     * @return
     */
    public E deQueue(){
        return list.remove(0);
    }

    /**
     * 查看队中最前方元素
     * @return
     */
    public E front(){
        return list.get(0);
    }

    /**
     * 清空队列
     */
    public void clear(){
        list.clear();
    }
}

2.3 Stack实现队列

因为栈是在一端进行操作，而队列是在两端进行操作的，因此可以使用两个栈来实现队列。
相同与力扣题目：用栈实现队列。

实现思路：

  1. 准备两个栈：inStack和outStack；
  2. 入队时将元素添加到inStack中；
  3. 出队时如果outStack为空，就将inStack中的元素加入到outStack中，然后outStack弹出；如果outStack不为空，直接弹出。
    private Stack<Integer> inStack;
    private Stack<Integer> outStack;

    public StackQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }


    /**
     * 入队
     * @param x
     */
    public void push(int x) {
        inStack.push(x);
    }

    /**
     * 出队
     * @return
     */
    public int pop() {
        checkStack();
        return outStack.pop();
    }

    /**
     * 查看队头元素
     * @return
     */
    public int peek() {
        checkStack();
        return outStack.peek();
    }

    /**
     * 队列是否为空
     * @return
     */
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    /**
     * 检查outStack是否有元素。
     */
    private void checkStack(){
        if (outStack.isEmpty()){
            while (!inStack.isEmpty()){
                outStack.push(inStack.pop());
            }
        }
    }

2.3 双端队列

双端队列是能在头尾两端进行添加、删除的队列。Java官方中也是使用LinkedList来实现的Deque接口。

接口实现：

  1. int size()：队中元素数量；
  2. boolean isEmpty()：队列是否为空；
  3. void enQueueFront(E e)：从队头入队；
  4. void enQueueRear(E e)：从队尾入队；
  5. E deQueueRear()：从队尾出队；
  6. E deQueueFront()：从队头出队；
  7. E front()：返回队头元素；
  8. E rear()：返回队尾元素；
  9. void clear()：清空。
/**
 * @Description 双端队列实现
 * @date 2022/4/8 9:05
 */
public class Deque<E> {

    LinkedList<E> list = new LinkedList<>();

    /**
     * 返回队列元素数量
     * @return
     */
    public int size(){
        return list.size();
    }

    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty(){
        return list.isEmpty();
    }

    /**
     * 队尾入队
     * @param e
     */
    public void enQueueRear(E e){
        list.add(e);
    }

    /**
     * 队头入队
     * @param e
     */
    public void enQueueFront(E e){
        list.add(0,e);
    }

    /**
     * 队尾出队
     * @return
     */
    public E deQueueRear(){
        return list.remove(list.size() - 1);
    }

    /**
     * 队头出队
     * @return
     */
    public E deQueueFront(){
        return list.remove(0);
    }

    /**
     * 查看队中头元素
     * @return
     */
    public E front(){
        return list.get(0);
    }

    /**
     * 查看队中尾元素
     * @return
     */
    public E rear(){
        return list.get(list.size() - 1);
    }

    /**
     * 清空队列
     */
    public void clear(){
        list.clear();
    }
}

2.4 循环队列

其实就是将一个模拟成环形，加入一个就在尾端新增一个元素，出队一个就修改front的指向。实现环形

要加入节点：将新节点放到尾部
在这里插入图片描述
删除节点：front指向下一个元素
在这里插入图片描述
在这里插入图片描述

  1. int size()：队中元素数量；
  2. boolean isEmpty()：队列是否为空；
  3. void enQueue(E e)：入队；
  4. E deQueue()：出队；
  5. E front()：返回队头元素；
  6. void clear()：清空。
  • 成员变量&构造方法：
    // 队列长度
    private int size;

    // 存储元素数组
    private E[] elements;

    // 存储队头下标
    private int front;

    // 默认容量
    private static final int DEFAULT_CAPACITY = 10;

    public CircleQueue(){
        elements = (E[]) new Object[DEFAULT_CAPACITY];
    }
  • void enQueue(E e)：因为如果时的元素放到队的尾部，直接使用front + size在对数组长度进行取模可以实现。
	/**
     * 入队
     * @param e
     */
    public void enQueue(E e){
        ensureCapacity(size + 1);
        elements[(front + size) % elements.length] = e;
        size++;
    }
  • E deQueue()：出队时只需要将front下标的数组元素返回，并且赋值为空，再将front指向下一元素，为防止下标溢出所以需要对长度取模。
	/**
     * 出队
     * @return
     */
    public E deQueue(){
        E e = elements[front];
        elements[front] = null;
        front = (front + 1) % elements.length;
        size--;
        return e;
    }
  • 扩容方法：直接将front指向数组中第一个元素，剩余元素按顺序放到其后面。
    在这里插入图片描述
	/**
     * 保证要有capacity的容量
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if (oldCapacity >= capacity){
            return;
        }
        // 变成原先容量的 1.5 倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[capacity];
        for (int i = 0; i < size; i++) {
            newElements[i] = elements[(i + front) % elements.length];
        }
        elements = newElements;
        front = 0;
    }

2.5 双端循环队列

可以从两端进行添加和删除的循环队列。

接口实现：

  1. int size()：队中元素数量；
  2. boolean isEmpty()：队列是否为空；
  3. void enQueueFront(E e)：从队头入队；
  4. void enQueueRear(E e)：从队尾入队；
  5. E deQueueRear()：从队尾出队；
  6. E deQueueFront()：从队头出队；
  7. E front()：返回队头元素；
  8. E rear()：返回队尾元素；
  9. void clear()：清空。

因为从队尾入队和从队头出队等没有变化，这里直接就不写了。

  • 从队头入队：
    /**
     * 从头部入队
     * @param e
     */
    public void enQueueFront(E e){
        ensureCapacity(size + 1);
        front = getIndex(-1);
        elements[front] = e;
        size++;
    }
  • 从队尾出队：
	/**
     * 从尾部出队
     * @return
     */
    public E deQueueRear(){
        int rear = getIndex(size - 1);
        E e = elements[rear];
        elements[rear] = null;
        size--;
        return e;
    }
  • 获取队尾元素：
  	/**
     * 查看队中尾部元素
     * @return
     */
    public E rear(){
        return elements[getIndex(size - 1)];
    }
  • getIndex()：根据传入的索引，计算出新的索引值：因为使用取模运算%时CPU消耗内存过大，因此这里使用三元运算符来代替。循环队列也可以修改。
    /**
     * 针对front和index进行取模运算
     * @param index
     * @return
     */
    private int getIndex(int index){
        index += front;
        // 如果出现 -1 的情况，直接加上数组的长度，变成数组的最后一个元素。
        if (index < 0){
            return index + elements.length;
        }
        return index - (index >= elements.length ? elements.length : 0);
    }
  • 清空队列：这里的清空需要使用getIndex()方法转换索引才能实现真正的清空。
    /**
     * 清空队列
     */
    public void clear(){
        for (int i = 0; i < elements.length; i++) {
            elements[getIndex(i)] = null;
        }
        size = 0;
        front = 0;
        elements = null;
    }
江海i
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之栈和队列 基本的增删查改
04-03
数据结构之栈和队列 基本的增删查改。栈（Stack）和队列（Queue）是数据结构中常用的两种基本数据结构。栈是一种后进先出（Last In First Out, LIFO）的数据结构，只允许在栈顶进行插入和删除操作；而队列是一种先进...
数据结构之栈和队列-思路清晰纯C
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 22万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
Java数据结构之栈和队列
fear_wolf的博客
10-24 1089
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
【数据结构】栈(Stack)和队列(Queue)
炸掉地球的博客
05-09 1879
栈和队列都是一种特殊的线性表。栈的特点：后进先出，只能在表尾进行插入和删除。队列的特点：先进先出，只能在表头删除，在表尾插入。它们都可以用顺序存储和链式存储的方式。栈常用顺序存储结构即数组的方式，因为数组的尾插尾删效率高，但可能会存在频繁开辟内存空间和内存空间浪费的问题。而栈的链式存储结构，解决了空间浪费的问题，但每个节点都存放一个指针域，也会存在一定的内存开销，并且在每次申请和释放节点的过程中也存在一定的时间开销。队列常用链式存储结构即链表的方式，
【数据结构】栈和队列
最新发布
奋斗的小羊的博客
07-12 2118
栈超超超详解
高效学习数据结构之栈和队列篇（五千字超详细教程）
qq_59955115的博客
05-02 3万+
顺序表和链表的优缺点对比： 顺序表的优点： 1.按下标进行随机访问 2.顺序表的CPU高速缓存命中率比较高。 顺序表的缺点： 1.空间不够需要扩容，会存在一定的空间浪费。 2.当头部或者中间插入删除数据，需要挪动数据，效率较低。 链表的优点: 1.按需申请内存，不存在性能消耗，不存在空间浪费。 2.实现任意位置以O(1)的时间复杂度插入或者删除数据。 链表的缺点： 1.不支持下标的随机访问 2.顺序表的CPU高速缓存命中率比较高。 栈 1.栈的基本概念 栈是一种线性表，只允许在
[详解栈和队列]数据结构之栈与队列
Philosophy7的博客
05-12 3698
✅作者简介：大家好,我是Philosophy7？让我们一起共同进步吧！🏆 📃个人主页：Philosophy7的csdn博客 🔥系列专栏： 👑哲学语录: 承认自己的无知，乃是开启智慧的大门 💖如果觉得博主的文章还不错的话，请点赞👍+收藏⭐️+留言📝支持一下博>主哦🤞 文章目录栈和队列1.物理结构和逻辑结构2.什么是栈2.1栈的基本操作3.什么是队列队列的基本操作小结 栈和队列 1.物理结构和逻辑结构 再了解栈和队列之前，我们要先知道什么是逻辑结构和物理结构。 逻辑结构: 按照逻辑结构划分:数据结.
数据结构之栈与队列详解
Ruiren_的博客
01-20 1876
栈和队列是一种特殊的线性结构，他与之前学的线性结构不同，栈和队列是拥有一种特殊规则的线性结构，虽然它是用数组或者链表实现，但是只有符合这种规则才能被称作栈或者队列
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
C语言之数据结构之栈和队列的运用
2301_81988400的博客
05-04 2276
C语言数据结构——用两个队列实现栈和用两个栈实现队列的思路讲解和代码实现
数据结构之栈和队列（顺序栈、链栈、循环队列）
qq_43752469的博客
09-12 1311
一、栈 1、栈以及栈的基本操作 （1）栈：只允许在一端进行插入或删除操作的线性表。特点：先进后出。 栈顶：允许进行插入删除。 栈底：不允许进行插入和删除，固定的。 （2）栈的基本操作 2、栈的顺序存储结构 （1）顺序栈的实现 （2）顺序栈的基本操作 顺序栈的基本运算： （3）共享栈：栈底位置相对不变，两个顺序栈共享一个一维数组空间，将两个栈底分布设置在两端，两个栈顶向共享空间的中间延伸。 栈空：top0=-1，top1=maxsize 栈满：top1=top0+1 进栈：s.data[++top0
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
python数据结构之栈和队列.md
06-25
python数据结构之栈和队列.md
数据结构之栈和队列基本操作及实践
08-30
在实际编程中，我们经常会遇到需要利用栈和队列解决问题的情况，因此掌握这些基本数据结构及其应用是每个程序员的基础技能之一。 在提供的压缩包文件“栈和队列”中，可能包含了关于这两种数据结构的实例代码、练习...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构：栈和队列的判空操作
"判断链队列是否为空-数据结构 栈和队列" 在数据结构中，栈和队列是两种基本的线性数据结构，它们各有特定的操作规则和应用场景。本节主要聚焦于栈（Stack）和队列（Queue）的概念、表示以及它们在实际操作中的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值