基本数据结构之栈、队列及其数组实现

最新推荐文章于 2023-04-03 22:25:54 发布
最新推荐文章于 2023-04-03 22:25:54 发布
阅读量643 收藏
点赞数 1
分类专栏： Java 文章标签： 队列 数据结构 stack queue 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43613793/article/details/119151789
版权

栈

栈是一种“先进后出”的数据结构
在这里插入图片描述

用数组实现栈：

接口IStack:

public interface IStack {
    /**
     * 元素入栈（压栈）
     *
     * @param o
     * @return
     */
    boolean push(Object o) throws Exception;

    /**
     * 元素出栈（弹栈）
     *
     * @return
     */
    Object pop() throws Exception;

    /**
     * 栈是否为空栈
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 栈是否满了
     *
     * @return
     */
    boolean isFull();

    /**
     * 获取栈顶元素
     *
     * @return
     */
    Object getPeek() throws Exception;

    /**
     * 获取元素在栈中的位置
     *
     * @param obj
     * @return
     */
    int getIndex(Object obj);

    /**
     * 获取栈的实际长度
     *
     * @return
     */
    int getSize();

    /**
     * 获取栈的容量
     *
     * @return
     */
    int getCapacity();

    /**
     * 打印栈
     */
    void print();

}

实现类StackImpl:

public class StackImpl implements IStack {
    public static void main(String[] args) throws Exception {}

    //用数组来模拟栈
    private Object[] stack;
    //栈的容量
    private int capacity;
    //栈顶指针
    private int top = -1;

    public StackImpl() {
        this(10);
    }

    public StackImpl(int initCapacity) {
        int capacity = initCapacity > 0 ? initCapacity : 10;
        this.capacity = capacity;
        stack = new Object[capacity];
    }

    @Override
    public boolean push(Object o) throws Exception {
        if (isFull()) {
            throw new Exception("栈已满，新元素 " + o + " 无法入栈！");
        }
        stack[++top] = o;
        return true;
    }

    @Override
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("栈为空，没有元素可以出栈！");
        }
        Object o = stack[top];
        stack[top--] = null;
        return o;
    }

    @Override
    public boolean isEmpty() {
        return top == -1;
    }

    @Override
    public boolean isFull() {
        return top == capacity - 1;
    }

    @Override
    public Object getPeek() throws Exception {
        if (isEmpty()) {
            throw new Exception("栈为空，无法获取栈顶元素！");
        }
        return stack[top];
    }

    @Override
    public int getIndex(Object obj) {
        for (int i = 0; i <= top; i++) {
            if (stack[i] == obj) {
                return i + 1;
            }
        }
        return -1;
    }

    @Override
    public int getSize() {
        return top + 1;
    }

    @Override
    public int getCapacity() {
        return capacity;
    }

    @Override
    public void print() {
        if (top == -1) {
            System.out.println("[]");
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i <= top; i++) {
                stringBuilder.append(i == 0 ? "[" : "")
                        .append(stack[i] != null ? stack[i] : "")
                        .append(i != top ? ", " : "]");
                System.out.print((stack[i] != null ? stack[i] : "") + (i != top ? ", " : "]"));
            }
            System.out.println(stringBuilder);
        }
    }
}

队列

  • 队列是一种“先进先出”的数据结构

  • 一般队列在初始时会有一个头指针和一个尾指针，他们都指向队列（数组）的头部（队首），当有元素入队时，尾指针后移；当有元素出队时，头指针后移。

顺序队列

顺序队列容易产生一个问题，即当队列满了时，此时头指针和尾指针都指向队尾，即便此时有元素出队给队列“腾出位置”，但是出队操作并不会改变尾指针的位置，所以即便此时所有元素都出了队，尾指针仍然在队尾的位置，新的元素仍然不能入队，这种问题又叫“假溢出”
在这里插入图片描述

用数组实现队列：

队列接口IQueue:

public interface IQueue {
    /**
     * 元素入队
     *
     * @param o
     * @return
     */
    boolean push(Object o) throws Exception;

    /**
     * 元素出队
     *
     * @return
     * @throws Exception
     */
    Object pop() throws Exception;

    /**
     * 队列是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 队列是否已满
     *
     * @return
     */
    boolean isFull();

    /**
     * 获取队首元素
     *
     * @return
     * @throws Exception
     */
    Object getPeek() throws Exception;

    /**
     * 获取元素在队列中的位置
     *
     * @param obj
     * @return
     */
    int getIndex(Object obj);

    /**
     * 获取队列的实际长度
     *
     * @return
     */
    int getSize();

    /**
     * 获取队列的容量
     *
     * @return
     */
    int getCapacity();

    /**
     * 打印队列
     */
    void print();
}

队列接口实现类顺序队列SequentialQueueImpl:

public class SequentialQueueImpl implements IQueue {
    public static void main(String[] args) throws Exception {}

    //用数组来模拟队列
    private Object[] queue;
    //队首指针
    private int front = 0;
    //队尾指针
    private int rear = 0;
    //队列的容量
    private int capacity;

    public SequentialQueueImpl() {
        this(10);
    }

    public SequentialQueueImpl(int initCapacity) {
        this.capacity = initCapacity;
        queue = new Object[capacity];
    }

    @Override
    public boolean push(Object o) throws Exception {
        if (isFull()) {
            throw new Exception("队列已满，新元素 " + o + " 无法入队！");
        }
        queue[rear++] = o;
        return true;
    }

    @Override
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，没有元素可以出队！");
        }
        Object o = queue[front];
        queue[front++] = null;
        return o;
    }

    @Override
    public boolean isEmpty() {
        return front == rear && (front == 0 || (queue[front - 1] == null));
    }

    @Override
    public boolean isFull() {
        return rear == capacity;
    }

    @Override
    public Object getPeek() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，无法获取队首元素！");
        }
        return queue[front];
    }

    @Override
    public int getIndex(Object obj) {
        for (int i = 0; i <= capacity; i++) {
            if (queue[i] == obj) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int getSize() {
        return rear - front;
    }

    @Override
    public int getCapacity() {
        return this.capacity;
    }

    @Override
    public void print() {
        if (getSize() == 0) {
            System.out.println("[]");
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("[");
            for (int i = front; i < rear; i++) {
                stringBuilder.append(queue[i]).append(i != rear - 1 ? ", " : "]");
            }
            System.out.println(stringBuilder);
        }
    }
}

上面这种顺序队列的“假溢出”现象：

SequentialQueueImpl sequentialQueue = new SequentialQueueImpl();
for (int i = 0; i < 10; i++) {
    sequentialQueue.push(i);
}
for (int i = 0; i < 10; i++) {
    sequentialQueue.pop();
}
sequentialQueue.print();
sequentialQueue.push(999);

在这里插入图片描述

“假溢出”现象的解决方案：

循环队列

循环队列通过将队列的首和尾连接起来，只要队列不是真正的满了，就不会溢出：

在这里插入图片描述

那么怎么判断循环队列是否满/空了呢？

循环队列的判满/判空的三种方法

法一：

  • 使用一个默认值为0的flag标签，每当有元素入队时，flag=1；每当有元素出队时，flag=0
  • 在front==rear的前提下，如果flag为0，该循环队列为空队列；否则如果flag为1，该循环队列则为满队列

flag标记的循环队列的数组实现：

public class CircleQueueWithFlagImpl implements IQueue {
    public static void main(String[] args) throws Exception {}

    //用数组来模拟队列
    private Object[] queue;
    //队首指针
    int front = 0;
    //队尾指针
    int rear = 0;
    //队列的容量
    int capacity;
    //判满/空标签
    int flag = 0;

    public CircleQueueWithFlagImpl() {
        this(10);
    }

    public CircleQueueWithFlagImpl(int initCapacity) {
        this.capacity = initCapacity;
        queue = new Object[capacity];
    }

    @Override
    public boolean push(Object o) throws Exception {
        if (isFull()) {
            throw new Exception("队列已满，新元素 " + o + " 无法入队！");
        }
        queue[rear++ % capacity] = o;
        flag = 1;
        return true;
    }

    @Override
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，没有元素可以出队！");
        }
        Object o = queue[front % capacity];
        queue[front++ % capacity] = null;
        flag = 0;
        return o;
    }

    @Override
    public boolean isEmpty() {
        return front == rear && flag == 0;
    }

    @Override
    public boolean isFull() {

        return rear - front == capacity && flag == 1;
    }

    @Override
    public Object getPeek() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，无法获取队首元素！");
        }
        return queue[front];
    }

    @Override
    public int getIndex(Object obj) {
        for (int i = 0; i <= capacity; i++) {
            if (queue[i] == obj) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int getSize() {
        return rear - front;
    }

    @Override
    public int getCapacity() {
        return this.capacity;
    }

    @Override
    public void print() {
        if (getSize() == 0) {
            System.out.println("[]");
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("[");
            for (int i = front; i < rear; i++) {
                stringBuilder.append(queue[i % capacity]).append(i != rear - 1 ? ", " : "]");
            }
            System.out.println(stringBuilder);
        }
    }
}

此时就不会碰到顺序队列可能会碰到的“假溢出”问题了：

CircleQueueWithFlagImpl circleQueueWithFlag = new CircleQueueWithFlagImpl();
for (int i = 0; i < 10; i++) {
    circleQueueWithFlag.push(i);
}
circleQueueWithFlag.print();
for (int i = 0; i < 10; i++) {
    circleQueueWithFlag.pop();
}
circleQueueWithFlag.print();
circleQueueWithFlag.push(999);
circleQueueWithFlag.print();

在这里插入图片描述

法二：

  • 使用一个计数器count，每当有元素入队时，count+1；每当有元素出队时，count-1
  • 如果count==0，该循环队列为空队列；否则如果count=capacity，该循环队列则为满队列
public class CircleQueueWithCountImpl implements IQueue {
    public static void main(String[] args) throws Exception {}

    //用数组来模拟队列
    private Object[] queue;
    //队首指针
    private int front = 0;
    //队尾指针
    private int rear = 0;
    //队列的容量
    private int capacity;
    //队列计数器
    private int count = 0;

    public CircleQueueWithCountImpl() {
        this(10);
    }

    public CircleQueueWithCountImpl(int initCapacity) {
        this.capacity = initCapacity;
        queue = new Object[capacity];
    }

    @Override
    public boolean push(Object o) throws Exception {
        if (isFull()) {
            throw new Exception("队列已满，新元素 " + o + " 无法入队！");
        }
        queue[rear++ % capacity] = o;
        count++;
        return true;
    }

    @Override
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，没有元素可以出队！");
        }
        Object o = queue[front % capacity];
        queue[front++ % capacity] = null;
        count--;
        return o;
    }

    @Override
    public boolean isEmpty() {
        return count == 0;
    }

    @Override
    public boolean isFull() {
        return count == capacity;
    }

    @Override
    public Object getPeek() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，无法获取队首元素！");
        }
        return queue[front];
    }

    @Override
    public int getIndex(Object obj) {
        for (int i = 0; i <= capacity; i++) {
            if (queue[i] == obj) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int getSize() {
        return rear - front;
    }

    @Override
    public int getCapacity() {
        return this.capacity;
    }

    @Override
    public void print() {
        if (getSize() == 0) {
            System.out.println("[]");
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("[");
            for (int i = front; i < rear; i++) {
                stringBuilder.append(queue[i % capacity]).append(i != rear - 1 ? ", " : "]");
            }
            System.out.println(stringBuilder);
        }
    }
}

法二同时也可以解决“假溢出”问题：

CircleQueueWithCountImpl circleQueueWithCount = new CircleQueueWithCountImpl();
for (int i = 0; i < 10; i++) {
    circleQueueWithCount.push(i);
}
circleQueueWithCount.print();
for (int i = 0; i < 10; i++) {
    circleQueueWithCount.pop();
}
circleQueueWithCount.print();
circleQueueWithCount.push(999);
circleQueueWithCount.print();

在这里插入图片描述

法一和法二的原理是类似的

法三：

  • 牺牲一个元素的位置用来判定
  • 如果front=rear，则该队列为空队列；否则如果(rear + 1) % capacity = front，则该队列为满队列

第三种方法和前两种方法的不同之处在于，第三种方法舍弃了一个元素的位置用来判定，但是没有使用额外的变量（flag、count之类的）来进行判定
在这里插入图片描述

public class CircleQueueWithSacrificeImpl implements IQueue {
    public static void main(String[] args) throws Exception {}

    //用数组来模拟队列
    private Object[] queue;
    //队首指针
    private int front = 0;
    //队尾指针
    private int rear = 0;
    //队列的容量
    private int capacity;

    public CircleQueueWithSacrificeImpl() {
        this(10);
    }

    public CircleQueueWithSacrificeImpl(int initCapacity) {
        this.capacity = initCapacity;
        queue = new Object[capacity];
    }

    @Override
    public boolean push(Object o) throws Exception {
        if (isFull()) {
            throw new Exception("队列已满，新元素 " + o + " 无法入队！");
        }
        queue[rear++ % capacity] = o;
        return true;
    }

    @Override
    public Object pop() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，没有元素可以出队！");
        }
        Object o = queue[front % capacity];
        queue[front++ % capacity] = null;
        return o;
    }

    @Override
    public boolean isEmpty() {
        return front == rear;
    }

    @Override
    public boolean isFull() {
        return (rear + 1) % capacity == front;
    }

    @Override
    public Object getPeek() throws Exception {
        if (isEmpty()) {
            throw new Exception("队列为空，无法获取队首元素！");
        }
        return queue[front];
    }

    @Override
    public int getIndex(Object obj) {
        for (int i = 0; i <= capacity; i++) {
            if (queue[i] == obj) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public int getSize() {
        return rear - front;
    }

    @Override
    public int getCapacity() {
        return this.capacity;
    }

    @Override
    public void print() {
        System.out.println(front+"  "+rear);
        if (getSize() == 0) {
            System.out.println("[]");
        } else {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append("[");
            for (int i = front; i < rear; i++) {
                stringBuilder.append(queue[i % capacity]).append(i != rear - 1 ? ", " : "]");
            }
            System.out.println(stringBuilder);
        }
    }
}
philpy_used
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序栈的一点问题
qq_42548153的博客
10-18 1558
初识顺序栈 问题描述： ①初次输出初始化的顺序表时出现 error: invalid use of void expression ②入栈时数据的插入和指针+1的顺序搞错 ③进栈操作时出现 error: incompatible types in assignment of ‘int’ to ‘int [10]’ 原因分析： ①很傻逼的 在InitStack方法中无效的使用了void进行返回。 ②必须先给top+1以后再向top中插入新的数据 ③数组名在参数传递中可以退化为指针，但它本身是一个地址
栈（上）之顺序栈
许我向你看丶的博客
04-16 708
一、栈的定义 定义：栈（stack）：栈是限定仅在表的一端进行插入或删除操作的线性表。 我们把允许插入和删除操作的一端称为栈顶（top），另一端称为栈底（bottom）。不含任何数据元素的栈称为空栈。栈又称为“后进先出（Last In First Out，简称LIFO）的线性表”，简称为LIFO结构。 栈的插入操作，称为进栈/入栈/压栈。 栈的删除操作，称为出栈/弹栈。 不过要注意的是，
队列及相关常见问题
CodePanda@GPF的博客
04-30 1047
队列、队列常见问题
数据结构--栈和队列学习小结
qq_44392254的博客
11-23 543
学习内容 栈 (Stack) 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 稍微介绍一下关键名词： 运算受限：也就是这个表你...
数据结构——栈与队列
m0_62955663的博客
03-20 1737
文章包含顺序栈和链式队列的基本操作详解
栈和队列数据结构的基本概念及其相关的Python实现
09-21
主要介绍了栈和队列数据结构的基本概念及其相关的Python实现,先进先出和后进先出的知识也已经成为了计算机学习中的老生常谈了:D需要的朋友可以参考下
数据结构实验与习题线性表栈和队列串数组树与二叉树
03-04
实习一 复数ADT及其实现实习二 线性表实习三 栈和队列 实习四 串实习五 数组实习六 树与二叉树 实习七 图实习八 查找实习九 排序 全部C语言代码
数据结构02331(苏仕华)
最新发布
07-25
第二节 线性表的顺序存储和基本运算的实现 第三节 线性表的链式存储结构 第四节 顺序表和链表的比较 第三章 栈和队列 第一节 栈 第二节 栈的应用举例 第三节 队列 第四节 栈和队列的应用举例 第四章 多维数组和广义...
考研-数据结构-殷人昆.zip
09-09
1.3 数据结构和算法的基本概念 14 1.3.1 数据结构的基本概念 14 1.3.2 算法的基本概念 15 习题 16 习题答案 17 2 章 线性表 20 大纲要求 20 考点与要点分析 20 核心考点 20 基础要点 20 知识点讲解 20 2.1 线性表的...
java二叉树算法源码-DataStructure:常用数据结构及其算法的Java实现，包括但不仅限于链表、栈，队列，树，堆，图等经典数据结构
06-05
队列(基于数组的实现、基于链表的实现和基于栈的实现)的数据结构及其相关算法：队列结构包含三个要素，即队头指针head、队尾指针rear和队列大小size，具体操作包括： 入队操作put 出队操作pop 查看队头元素p
栈与队列的几个问题与解析
m0_59691828的博客
11-11 1226
1、循环队列存储在数组A[0…m]中，则入队时的操作为：rear=(rear+1)%(m+1) 2、假设以数组A[m]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素个数为：(rear-front+m)%m 3、顺序循环队列存储于数组A[n]中，它的的判空和判满条件分别为front==rear，(rear+1)%n==front 4、用带头结点的单链表存储队列，在进行出队运算时头结点指针域要修改，尾指针可能要修改 循环队列的引入，目的是为了克服 假溢出。 ...
1.数据结构与算法相关问题与解决技巧
weixin_41207499的博客
10-08 918
一. 分割字符串问题 已知字符串"ab;cd|efg|hi,jk1|mn\topq;rst,uvw\txyz", 其中的',' ';' '|' '\t' 都是分割符，如何处理? 方法1、 连续使用str.split s = "ab;cd|efg|hi,jk1|mn\topq;rst,uvw\txyz" def my_split(s, seps): res = [s] fo...
栈与队列的经典问题（万字详细讲解+基础回顾+括号匹配\用队列实现栈\用栈实现队列\设计循环队列-用C语言描述）
华数云图小分队的博客
04-03 643
栈与队列的经典问题（详细讲解+基础回顾+括号匹配\用队列实现栈\用栈实现队列\设计循环队列）
顺序栈小解
LGUOQING的博客
05-27 313
栈的特性是先进后出，这种特性我们一直都在用。最经常用到的地方就是主函数调用子函数。 下面的程序为例子：main() 里面调用进栈函数——就是将元素入栈，存放。当调用存放函数的时候，main函数，也就是主函数的进程——运行到哪一步了，会被入栈，保存进度，在入栈函数完成了，结束了，就会回头看main函数，将入栈的进程调出，继续往后运行程序。这个就是栈在函数中的运用。 主体程序： #include <iostream> #define MAXLEN 100 typedef struct Stack{
实验三 栈和队列
Erill的专栏
01-14 989
一、实验题目：栈和队列   二．.实验目的 1. 巩固栈和队列数据结构，学会运用栈和队列。 2.回顾栈和队列的逻辑结构和受限操作特点，栈和队列的物理存储结构和常见操作。   3.学习运用栈和队列的知识来解决实际问题。 4.进一步巩固程序调试方法。   5.进一步巩固模板程序设计。   三．.实验内容 1.自己选择顺序或链式存储结构，定义一个空栈类，并定义入栈、出栈、取栈元素
数据结构：队列与栈问题
Kobe51920的博客
11-03 1253
1.队列与栈（栈有记忆功能，队列删除,插入效率比较低下） 1. 队列删除元素是在队首进行，队列是现进现出，相对来说，队首元素是最先进入队列的，因此出队应该是在队首进行。队列其实就和我们平时排队一样的 2. 栈与队列是非线性结构，应该是线性结构，再确切点说是访问受限的线性表 线性链表是非线性结构，应该是线性结构 二叉树是线性结构，应该是非线性结构（层次结构 3. BFS需要...
学习队列遇到的一些问题
Zz22333的博客
02-06 2455
1.什么是队列  队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。  队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。假设队列是q=(a1,a2,......,an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通
数据结构中的栈问题
weixin_42011265的博客
12-03 456
1.首先，栈的定义：栈(stack)又名堆栈，是一种线性表。仅允许在表的一端进行插入和删除运算。 2.栈的操作：先进后出原则，先进入的数据被压入栈低（push），最后的数据在栈顶；系统需要读取数据时，从栈顶弹出数据(pop). 3.做递归时要用到栈！ eg： // 调用栈 def green(name): print("Hello, "+name+"!") green2(name)...
顺序栈（含有栈顶指针，栈底指针）的实现以及编写过程中的一些疑惑的解决
zyh_helen的专栏
05-30 6573
参考文献：数据结构（c语言版）---严蔚敏p44----->p47 代码如下： #include//malloc realloc #include//cin cout using namespace std; typedef int ElemType;/*元素类型*/ #define STACK_INIT_SIZE 100 /*栈存储空间初始化容量*/ #define STACKINCR
介绍和分析基本数据结构及其高效实现:堆栈队列LinkedList哈希表堆learn
03-31
队列是一种先进先出(FIFO)的数据结构，可以通过enqueue和dequeue操作进行添加和删除元素。它可以用数组或链表来实现。在使用队列时，我们要注意队列是否为空，以避免出现队列溢出的情况。 队列的高效实现：在实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值