数据结构# 笔记【栈&队列】@Gray

最新推荐文章于 2024-06-04 22:13:35 发布
最新推荐文章于 2024-06-04 22:13:35 发布
阅读量232 收藏
点赞数
文章标签： 队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45923029/article/details/109566001
版权

一.栈

1.1 简述

栈是一种后进先出的数据结构
Last in First Out(LIFO)

栈（Stack）又名堆栈，线性数据结构,它是一种重要的数据结构。从数据结构角度看，栈也是线性表，其特殊性在于栈的基本操作是线性表操作的子集，它是操作受限的线性表，因此，可称为限定性的数据结构。限定它仅在表尾进行插入或删除操作。表尾称为栈顶，相应地，表头称为栈底。栈的基本操作除了在栈顶进行插入和删除外，还有栈的初始化，判空以及取栈顶元素等。

  • 栈内存内存图
    在这里插入图片描述

在 LIFO 数据结构中，将首先处理添加到队列中的最新元素。
与队列不同，栈是一个 LIFO 数据结构。通常，插入操作在栈中被称作入栈 push 。与队列类似，总是在堆栈的末尾添加一个新元素。但是，删除操作，弹栈 pop ，将始终删除队列中相对于它的最后一个元素。

1.2 构造方法

Constructor描述
Stack​()创建一个空堆栈。

  • 常用方法

    Modifier and Type方法描述
    booleanempty()测试此堆栈是否为空。
    Epeek()查看此堆栈顶部的对象，而不从堆栈中删除它。
    Epop()删除此堆栈顶部的对象，并将该对象作为此函数的值返回。
    Epush(E item)将项目推送到此堆栈的顶部。
    intsearch(Object o)返回一个对象在此堆栈上的基于1的位置。

  • 代码示例

package com.Gray.DemoStack;

import java.util.Iterator;
import java.util.Stack;

public class PracticeStack {
    public static void main(String[] args) {
        //创建栈对象
        Stack<String> sta = new Stack<>();
        //向栈中添加数据
        sta.push("明里紬");
        sta.push("大桥未久");
        sta.push("三上悠亚");
        System.out.println(sta+" -->栈顶位置");
        System.out.println("------增强for遍历-----");
        for (String s : sta) {
            System.out.println(s);
        }
        System.out.println("------迭代器遍历------");
        Iterator<String> iterator = sta.iterator();
        while (iterator.hasNext()) {
            String next = iterator.next();
            System.out.println(next);
        }
        //找到元素的索引   最先加入的元素是最大索引
        int search = sta.search("明里紬");
        System.out.println(search);

        //拿到栈顶元素并删除
        String pop = sta.pop();
        System.out.println(pop);
        System.out.println(sta+" -->栈顶位置");

        //拿到栈顶元素不删除
        String peek = sta.peek();
        System.out.println(peek);
        System.out.println(sta+" -->栈顶位置");

        //判断栈是否为空
        boolean empty = sta.isEmpty();
        System.out.println(empty);


        //add方法是继承自stack的父类Vector中的方法,有线程安全问题,不用他
        sta.add("奥利给");
        System.out.println(sta+" -->栈顶位置");
    }
}

运行截图:
在这里插入图片描述

1.3 应用

  • Undo操作(撤销)-编辑器
  • 程序调用系统栈-操作系统
  • 括号匹配-编译器

实践案例:

  • LeetCode括号匹配问题
package com.Gray.Stack括号匹配;

import java.util.Stack;

public class Solution {
    public static void main(String[] args) {
        System.out.println(isValid("{}"));
        System.out.println(isValid("{}()[]"));
        System.out.println(isValid("{[{}]"));
    }

    public static boolean isValid(String s) {
        //创建栈
        Stack<Character> stack = new Stack<>();
        //遍历字符串
        for (int i = 0; i < s.length(); i++) {
            //拿到每一个字符
            char c = s.charAt(i);
            //如果他是[{(的其中一个,就把他放入栈中
            if (c == '(' || c == '{' || c == '[') {
                stack.push(c);//压入栈中
            }
            if (stack.isEmpty()) {//如果栈是空的,返回false
                return false;
            } else {
                if (c == ')' && stack.pop() != '(') {//跟栈顶元素进行比较
                    return false;
                } else if (c == '}' && stack.pop() != '{') {
                    return false;
                } else if (c == ']' && stack.pop() != '[') {
                    return false;
                }
            }
        }
        return stack.isEmpty();//最后如果栈为空,返回true
    }
}

1.4 栈的实现

  • 利用动态数组实现栈结构:
package com.Gray.Demo栈;
@SuppressWarnings("all")
public class Array<E> {
    private E[] data; //创建静态数组
    private int size;//数组的实际存入元素个数

    //有参构造 用户传进来数组需要多大容量capacity
    public Array(int capacity) {
        data = (E[]) new Object[capacity];//赋给原数组
        size = 0;
    }

    //默认的构造方法,默认数组的容量是 capacity = 10
    public Array() {
        this(10);//调用有参构造传入10
    }

    //获取元素个数
    public int getSize() {
        return size;
    }

    //获取数组的容量
    public int getCapacity() {
        return data.length;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //向所有元素后添加一个新的元素
    public void addLast(E e) {
        add(size, e);
    }

    //在数组0的位置添加一个元素
    public void addfirst(E e) {
        add(0, e);
    }

    //在第一个index个位置插入一个新的元素e
    public void add(int index, E e) {
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed. Array is full!");
        } else if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Require index >=0 Array is full.");
        } else {

            for (int i = size - 1; i >= index; i--) {
                data[i + 1] = data[i];
            }

            data[index]= e;
            size++;
        }
    }

    //获取index索引位置的元素
    public E get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("get failed. Index is illegal");
        }
        return data[index];
    }

    public E getLast(){
        return get(size-1);
    }

    public E getFirst(){
        return get(0);
    }


        //更改index索引位置的元素
    void set(int index, E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set failed. Index is illegal.");
        }
        data[index] = e;
    }

    //查找数组中是否有元素e
    public boolean contians(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    //查找该元素的索引,找不到返回-1 元素不存在
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    //删除元素方法 删除返回被删除的元素
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed. Index is illegal.");
        }
        E ret = data[index];//被删除的元素
        for (int i = index + 1; i < size; i++) {//将删除元素 后边的所有元素前移
            data[i - 1] = data[i];
        }
        size--;
        data[size] = null;
        return ret;
    }

    //删除首尾元素
    public E removeFirst() {
        return remove(0);
    }

    //删除末位元素
    public E removeLast() {
        return remove(size - 1);
    }

    //删除某个元素
    public void removeElement(E e) {
        int i = find(e);
        if (i != -1) {
            remove(i);
        }
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %d\n", size, data.length));
        res.append('[');
        for (int i = 0; i < size; i++) {
            res.append(data[i]);
            if (i != size - 1) {
                res.append(", ");
            }
        }
        res.append(']');
        return res.toString();
    }
}
  • stack接口
package com.Gray.Demo栈;
public interface Stack<E> {
    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E peek();
}
  • stack实现类
package com.Gray.Demo栈;
/**
 * 栈是一种后进先出的数据结构
 * Last in First Out(LIFO)
 */

public class ArrayStack<E> implements Stack<E> {

    Array<E> array;

    public ArrayStack(){
        array = new Array<>();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }
    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public String toString() {
        return "ArrayStack{" +
                "array=" + array +
                '}';
    }
}
  • 测试类
package com.Gray.Demo栈;

public class TestStack {
    public static void main(String[] args) {

        StackImpl<Integer> stack = new StackImpl<>();
        for (int i = 0; i < 5; i++) {
            stack.push(i);
            System.out.println(stack);
        }
        stack.pop();
        System.out.println(stack);
    }
}

二.队列

2.1 简述

队列（Queue）是一种先进先出（FIFO，First-In-First-Out）的线性表。
在具体应用中通常用链表或者数组来实现。 线性数据结构
队列只允许在后端（称为 rear）进行插入操作，在前端（称为 front）进行删除操作。
队列的操作方式和堆栈类似，唯一的区别在于队列只允许新数据在后端进行添加。
队列常用的方法有：add、remove、element、offer、poll、peek、put、take。

  • 队列内存图
    在这里插入图片描述
    在 FIFO 数据结构中，将首先处理添加到队列中的第一个元素。
    如上图所示，队列是典型的FIFO 数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素

2.2 常用方法

Modifier and Type方法描述
booleanadd​(E e)将指定的元素插入到此队列中，如果可以立即执行此操作而不违反容量限制， true成功返回 true ，如果当前没有可用的空间，则抛出 IllegalStateException 。
Eelement​()检索，但不删除，这个队列的头。
booleanoffer​(E e)如果在不违反容量限制的情况下立即执行，则将指定的元素插入到此队列中。
Epeek​()检索但不删除此队列的头，如果此队列为空，则返回 null 。
Epoll​()检索并删除此队列的头部，如果此队列为空，则返回 null 。
Eremove​()检索并删除此队列的头。

add 增加一个元素 如果队列已满，则抛出一个IIIegaISlabEepeplian异常
remove 移除并返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
element 返回队列头部的元素 如果队列为空，则抛出一个NoSuchElementException异常
offer 添加一个元素并返回true 如果队列已满，则返回false
poll 移除并返问队列头部的元素 如果队列为空，则返回null
peek 返回队列头部的元素 如果队列为空，则返回null
put 添加一个元素 如果队列满，则阻塞
take 移除并返回队列头部的元素 如果队列为空，则阻塞

  • 代码案例
package com.Gray.DemoQueue;

import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;

public class TestQueue {
    public static void main(String[] args) {
        //设置队列容量
        final int capacity = 1000;
        //创建队列数组
        Queue<String> que = new ArrayBlockingQueue<>(capacity);
        //添加元素
        que.add("波多野结衣");
        que.add("上原结衣");
        que.add("吉泽明步");
        //遍历
        System.out.println("------遍历------");
        for (String s : que) {
            System.out.println(s);
        }
        //看一眼队首元素
        System.out.println("-------查看队首元素------");
        String peek = que.peek();
        System.out.println("查看了:"+peek);
        System.out.println("队首"+que+"队尾");

        //删除队首元素
        System.out.println("-------删除队首元素-------");
        String poll = que.poll();
        System.out.println("删除了:"+poll);
        System.out.println("队首"+que+"队尾");
    }
}

运行截图
在这里插入图片描述

小赵同学么
关注
数据结构与算法Python版之北大慕课笔记（五）
冠军阿狗的博客
06-06 882
数据结构与算法Python版之北大慕课笔记（五）一、图Graph1. 图的基础知识2. 图的定义二、ADT Graph1. 邻接矩阵2. 邻接列表3. ADT Graph的实现三、图的应用1. 词梯Word Ladder问题2. 骑士周游问题3. 通用的深度优先搜索4. 拓扑排序Topological Sort5. 强连通分支6. 最短路径问题7. 最小生成树 一、图Graph 1. 图的基础知识...
JavaScript数据结构与算法笔记
qq_43645678的博客
07-28 631
JavaScript数据结构与算法笔记
JS数据结构与算法学习笔记大全 （温故而知新，可以为师矣。）
你好呀，很高兴你在看这里~
05-17 5420
一.数据结构简介（序）： 1.1 概念 程序设计 = 数据结构 + 算法。 1.2 概念 数据 = 符号 (1). 其可以输入到计算机中。 (2). 能够被计算机识别和处理。 1.3 分类 数据分为： (1).数据元素：数据的基本单位，也称为结点或者记录。 (2).数据对象: 相同特性的数据元素的集合，是数据的一个子集。 (3).数据项: 独立含义的数据的最小单位。 数据的目的是存储，存储的目的是后期的再利用。 1.4 作用 数据结构的主要作用是:阐述关系。 如何存储具有复杂关系的数据更有助于后期对数据的再
js数据结构与算法
qq_42638033的博客
06-11 483
常见的数据结构 常见的数据结构比较多 每一种都有其对应的应用场景，不同的数据结构的不同操作性能是不同的 有的查询性能很快，有的插入速度很快，有的是插入头和尾速度很快 有的做范围查找很快，有的允许元素重复，有的不允许重复 在开发中如何选择，要根据具体的需求来选择 注意：数据结构和语言无关，常见的编程语言都有直接或者间接的使用上述常见的数据结构 栈结构 栈是一种非常常见的数据结构，并且在程序中的应用非常广泛 数组 我们知道数组时一种线性结构，并且可以在数组的任意位置插入和删除 但是有时候，我们为了实现某
JVM简析@Gray
Gary的博客
12-27 185
1.JVM的概述 1.1JVM是什么? JDK、JRE和JVM对比 JVM，JRE，JDK 都是 java 语言的支柱，他们分工协作。但不同的是 Jdk 和 JRE是真实存在的，而 JVM 是一个抽象的概念，并不真实存在。 JDK JDK(Java Development Kit) 是 Java 语言的软件开发工具包（SDK）。JDK 物理存在，是 programming tools、JRE 和 JVM的一个集合。 JRE JRE（Java Runtime Environment）Java 运行
【数据结构与算法学习笔记-Graph与广度/深度优先搜索】
floating_heart的博客
04-07 473
本文为学习笔记，感兴趣的读者可在MOOC中搜索《数据结构与算法Python版》或阅读《数据结构（C语言版）》（严蔚敏）。 本文讨论了图结构的基本概念，存储方式，并以邻接表法通过Python实现了简单的图结构。在此基础上，通过词梯问题和骑士周游问题，尝试实现两种基础的算法：广度优先搜索和深度优先搜索。
JavaScript实现数据结构与算法(五）图结构
weixin_43545225的博客
03-01 1402
JavaScript实现数据结构与算法(五）图结构（五）图论1. 图的相关概念1.1 什么是图1.2 图的现实案例1.3 图结构的特点2. 图的表示2.1 邻接矩阵2.2 邻接表2.3 关联矩阵3. 自定义图4. 图的遍历4.1 广度优先搜素4.2 深度优先搜素 学习笔记：coderwhy的JavaScript实现数据结构与算法的课程 其他章节笔记链接 1. 重要性 2. 线性结构 3. 哈希表...
笔记-数据结构与算法-图
weixin_44938921的博客
06-04 274
例如公交网络中两个站点之间的“距离”、“通行时间”和“票价”都可以作为权重。一个图G可以定义为G=(V,E)，其中V是顶点的集合，E是边的集合，E中的每条边e=(v,w)，v和w都是集合V中的顶点；如下图的一条路径(v3,v4,v0,v1)，其边为{(v3,v4,7),(v4,v0,1),(v0,v1,5)}圈是首尾顶点相同的路径，如下图中(v5,v2,v3,v5)是一个圈；边可以是无向或者有向的，相应的图称作“无向图”和“有向图”图中的路径，是由边依次连接起来的顶点序列；带权路径的长度为所有边权重的和；
Python数据结构与算法
qq_35224503的博客
05-10 4248
https://zhuanlan.zhihu.com/p/478635700
LeetCode 从零单刷个人笔记整理（持续更新）
NJU_ChopinXBP的博客
04-19 3901
更新至2019.4.19 本人博客用于个人对知识点的记录和巩固。之前刷了《剑指Offer》，基本每道题都用两种语言过了一遍，比较用心地进行原理和方法的剖析，并且用几乎所有可行的方法进行了实现和调优，大多数题目都附上了测试用例，少数题目进行了一些升级和扩充。感兴趣的话可以看这里：#程序员面试必备#《剑指Offer》从零单刷个人笔记整理（66题全） 刷完剑指Offer后下一步就是LeetCode了。下...
Swift学习笔记七：实用进阶（一）
王者归来之英雄有梦
05-02 490
八、实用进阶1.Swift语言中的两种单利模式//单例模式可以保证一个类仅有一个实例。import UIKit//final修饰符：可以防止类被继承，还可以防止子类重写父类的属性、方法以及下标。该修饰符不能修饰结构体和枚举。final class SingleClass: NSObject{    //使用static修饰符，定义一个静态常量。静态常量在实例调用结束后不会消失，并且保留原值，即其内...
【Visual C++】游戏开发笔记三十六 浅墨DirectX提高班之四 顶点缓存的逆袭
热门推荐
【浅墨的游戏编程Blog】毛星云（浅墨）的专栏
12-10 4万+
本系列文章由zhmxy555（毛星云）编写，转载请注明出处。  文章链接： http://blog.csdn.net/zhmxy555/article/details/8276363作者：毛星云（浅墨）    邮箱： happylifemxy@163.com     顶点永远是3D图形学中不可或缺的元素。这篇文章里我们首先对3D世界里的一些概念和常识进行了阐述，然后详细剖析了顶点缓存相关的知识点，
uCOS-II学习笔记(一)
abc94的专栏
08-25 1100
第一章：范例   在这一章里将提供三个范例来说明如何使用 µC/OS-II。这一章是为了让读者尽快开始使用 µC/OS-II。 1.00 安装µC/OS-II 1.01 INCLUDES.H #include "includes.h"      INCLUDE.H可以使用户不必在工程项目中每个*.C文件中都考虑需要什么样的头文件。换句话说，INCL
辽宁对外经贸学院在湖南2021-2024各专业最低录取分数及位次表.pdf
09-23
全国各大学在湖南2021-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
【SCI2区】基于matlab VMD-灰狼算法GWO-LSTM光伏预测【含Matlab源码 7666期】.zip
最新发布
09-23
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2023b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 VMD-智能优化算法优化LSTM回归预测系列程序定制或科研合作方向： 4.4.1 VMD-遗传算法GA/蚁群算法ACO优化LSTM回归预测 4.4.2 VMD-粒子群算法PSO/蛙跳算法SFLA优化LSTM回归预测 4.4.3 灰狼算法GWO/狼群算法WPA优化LSTM回归预测 4.4.4 VMD-鲸鱼算法WOA/麻雀算法SSA优化LSTM回归预测 4.4.5 VMD-萤火虫算法FA/差分算法DE优化LSTM回归预测 4.4.6 VMD-其他优化算法优化LSTM回归预测
解读X-RFID芯片中的XLPM一次性编程存储特性
09-23
内容概要：本文解析了XLPM存储器的一次编程特性，并讨论了其基于比特级别单向不可逆变化的工作方式以及RFID设备中具体的写操作机制。此外，还探讨了协议规定对写操作时间和写失败情况的相关规定。 适用人群：硬件工程师和技术支持团队。 使用场景及目标：用于深入理解XLPM OTP存储技术并在X-RFID应用场景下进行可靠的程序烧录。 其他说明：对于理解OTP存储解决方案在无线射频标识（RFID）系统应用中的局限性和优化提供了帮助。
基于C语言的Horizon操作系统半成品设计源码
09-23
该项目是基于C语言的Horizon操作系统半成品设计源码，包含157个文件，其中包括62个头文件（.h），52个C源文件（.c），8个Makefile文件（.mk），6个JSON配置文件，4个汇编语言文件（.asm），2个链接脚本文件（.lds），1个Clang格式配置文件（.clang-format），1个YAML配置文件（.yml），1个Git忽略文件（.gitignore）和1个许可证文件（LICENSE）。这个系统是一个独立制作的半成品操作系统。
190号资源-源程序：论文+程序 基于在线优化的快速模型预测控制-本人博客有解读
09-23
该资源详细解读可关注博主免费专栏《论文与完整程序》190号博文 MPC通过预测未来一段时间内系统的行为来优化控制输入，以达到特定的控制目标。其核心思想是利用系统的动态模型，通过求解优化问题，实时调整控制策略。 在实施过程中，MPC需要实时获取系统状态，并基于当前状态和预测模型计算未来的控制动作。这一过程涉及多个关键步骤：首先，建立一个准确的系统模型以捕捉动态行为；其次，设定控制目标和约束条件；最后，通过优化算法求解控制输入，这一过程需要高效的计算能力。 快速MPC的关键在于优化算法的效率，通常采用迭代方法或简化模型来加速计算，从而满足实时性要求。这使得MPC在工业自动化、机器人控制以及无人驾驶等领域得到广泛应用。 总之，基于在线优化的快速模型预测控制通过其预测能力和在线调整特性，实现了对复杂系统的高效控制，能够有效应对动态变化和外部扰动，提升系统的稳定性和性能。
武汉大学数据结构考研详笔记：线性表与栈队列详解
数据结构考研复习笔记涵盖了武汉大学编写的详细资料，旨在帮助学生全面理解和掌握数据结构的基础知识。复习内容围绕清华大学出版社的教材展开，主要包括以下几个核心部分： 1. 第0章：概述 - 该章介绍了数据结构的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值