手写栈和队列底层实现(java实现)

最新推荐文章于 2024-08-27 14:03:14 发布
最新推荐文章于 2024-08-27 14:03:14 发布
阅读量738 收藏 6
点赞数 2
分类专栏： 数据结构与算法 文章标签： java实现 栈 队列 数据结构原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_ym_ww/article/details/102385287
版权

文章目录

打造属于自己的栈和队列

​ 前一篇博客介绍了如何打造属于自己的数组，在实现数组的基础上，我们来完成对栈和队列的实现。

栈

栈

  • 在栈顶压栈
  • 在栈顶出栈

栈的应用

  • 无处不在的Undo操作（撤销操作）
  • 程序调用的系统栈，函数A中调用另外的函数B，先将函数B入栈，执行完毕函数B出栈，在执行函数A。

实现一个栈的接口

实现一个Stack的接口：
package design.stack;

/**
 * @author cyj
 */
public interface Stack<E> {
    /**
     * 获取栈的长度
     *
     * @return
     */
    int getSize();

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

    /**
     * 将一个数压入栈中
     *
     * @param e
     */
    void push(E e);

    /**
     * 移除栈顶元素,返回被删除的元素
     *
     * @return
     */
    E pop();

    /**
     * 获取栈顶元素
     *
     * @return
     */
    E peek();
}

实现一个栈（基于数组）

package design.stack;

import design.array.ArrayObject;

/**
 * @program: design
 * @description: 数组栈具体实现类
 * @author: cyj
 * @create: 2019-03-20 10:42
 **/
public class ArrayStack<E> implements Stack<E> {

    ArrayObject<E> array;

    public ArrayStack(int capacity) {
        array = new ArrayObject<>(capacity);
    }

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

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

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

    public int getCapacity() {
        return array.getCapacity();
    }

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

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

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

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Stack: ");
        res.append('[');
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if (i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("] top");
        return res.toString();
    }
}

测试栈类

package design.stack;

/**
 * @program: design
 * @description: 栈测试类
 * @author: cyj
 * @create: 2019-03-20 11:03
 **/
public class StackTest {
    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<>();

        //循环赋值，将整数压入栈中
        for (int i = 0; i < 5; i++) {
            stack.push(i);
            System.out.println(stack);
        }
		//在去除栈顶元素
        stack.pop();
        System.out.println(stack);
    }
}

运行结果：(top)为栈顶元素
Stack: [0] top
Stack: [0, 1] top
Stack: [0, 1, 2] top
Stack: [0, 1, 2, 3] top
Stack: [0, 1, 2, 3, 4] top
Stack: [0, 1, 2, 3] top

队列

队列

  • 在队尾入队
  • 在队首出队

实现一个数组队列

​ 在数组的基础上实现一个队列，需要实现以下方法

在这里插入图片描述

  • 先定义一个队列接口：
package design.queue;

/**
 * @author cyj
 */
public interface Queue<E> {
    /**
     * 获取队列的大小
     *
     * @return
     */
    int getSize();

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

    /**
     * 将一个数添加入队尾中
     *
     * @param e
     */
    void enqueue(E e);

    /**
     * 去除队首元素,返回被删除的元素
     *
     * @return
     */
    E dequeue();

    /**
     * 获取队列元素
     *
     * @return
     */
    E getFront();
}
  • 实现Queue接口
package design.queue;

import design.array.ArrayObject;

/**
 * @program: design
 * @description: Array的队列实现类
 * @author: cyj
 * @create: 2019-03-20 14:16
 **/
public class ArrayQueue<E> implements Queue<E> {
    private ArrayObject<E> array;

    public ArrayQueue(int capacity) {
        array = new ArrayObject<>(capacity);
    }

    public ArrayQueue() {
        array = new ArrayObject<>();
    }

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

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

    public int getCapacity() {
        return array.getCapacity();
    }

    @Override
    public void enqueue(E e) {
        //入队在队尾入队
        array.addLast(e);
    }

    @Override
    public E dequeue() {
        //时间复杂度为O(n),删除队首元素之后，需要将队列元素往前移一位，数据量一上去就会非常耗时间，因此需要改进
        //下文会对循环队列进行介绍
        return array.removeFirst();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("Queue: ");
        res.append("front [");
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if (i != array.getSize() - 1) {
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        ArrayQueue<Integer> queue = new ArrayQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}

//每在队尾入队3个元素之后再出队一个队首元素
运行结果：
Queue: front [0] tail
Queue: front [0, 1] tail
Queue: front [0, 1, 2] tail
Queue: front [1, 2] tail
Queue: front [1, 2, 3] tail
Queue: front [1, 2, 3, 4] tail
Queue: front [1, 2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5] tail
Queue: front [2, 3, 4, 5, 6] tail
Queue: front [2, 3, 4, 5, 6, 7] tail
Queue: front [2, 3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8] tail
Queue: front [3, 4, 5, 6, 7, 8, 9] tail

实现一个循环队列

​ 因为在数组队列中，每出队一个队首元素，都需要将之后的元素往前位移，这相当的耗时间，时间复杂度为O(n)。那有没有方法降低时间复杂度呢？

​ 这个时候就轮到循环队列闪亮登场，循环队列通过双指针的方式维护整个队列，出队的情况下不用整个位移，而是将指向队首的指针往后移一位就可以。那么在入队的时候，则将指向队尾的指针向后移。那么问题来了，指向队尾的指针如果已经到了队列的最长长度，但是队首之前由于执行过出队操作而腾出来空间，这时就可以把指向队尾的指针指向队列的前端，形成一个闭环，因此也有了判断队列是否为空为满的判断依据。

  • 判断循环队列为空：front==tail

  • 判断循环队列为满：(tail+1)%length=front 进行取余操作

  • 根据判断为满的条件可以看出，循环队列实际上浪费了一个空间，因此在实例化中需要将循环队列的空间+1
    在这里插入图片描述

package design.queue;

/**
 * @program: design
 * @description: 循环队列实现类
 * @author: cyj
 * @create: 2019-03-20 14:46
 **/
public class LoopQueue<E> implements Queue<E> {
    private E[] data;
    private int front, tail;
    private int size;

    public LoopQueue(int capacity) {
        //循环队列判断条件，有意的会浪费一个单位，这样才能容纳下用户期望的队列长度
        data = (E[]) new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue() {
        this(10);
    }

    public int getCapacity() {
        return data.length - 1;
    }

    @Override
    public int getSize() {
        return size;
    }

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

    @Override
    public void enqueue(E e) {
        if ((tail + 1) % data.length == front) {
            resize(getCapacity() * 2);
        }
        data[tail] = e;
        tail = (tail + 1) % data.length;
        size++;
    }

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(i + front) % data.length];
        }
        data = newData;
        front = 0;
        tail = size;
    }

    /**
     * O(1) 均摊复杂度
     *
     * @return
     */
    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size--;
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
            resize(getCapacity() / 2);
        }
        return ret;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("Cannot dequeue from an empty queue.");
        }
        return data[front];
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size= %d , capacity= %d\n", size, getCapacity()));
        res.append("front [");
        //重点！！判断条件多想想
        for (int i = front; i != tail; i = (i + 1) % data.length) {
            res.append(data[i]);
            if ((i + 1) % data.length != tail) {
                res.append(", ");
            }
        }
        res.append("] tail");
        return res.toString();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> queue = new LoopQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if (i % 3 == 2) {
                queue.dequeue();
                System.out.println(queue);
            }
        }
    }
}


//每在队尾入队3个元素之后再出队一个队首元素
//注意观察循环队列的capacity
输出结果：
Queue: size= 1 , capacity= 10
front [0] tail
Queue: size= 2 , capacity= 10
front [0, 1] tail
Queue: size= 3 , capacity= 10
front [0, 1, 2] tail
Queue: size= 2 , capacity= 5
front [1, 2] tail
Queue: size= 3 , capacity= 5
front [1, 2, 3] tail
Queue: size= 4 , capacity= 5
front [1, 2, 3, 4] tail
Queue: size= 5 , capacity= 5
front [1, 2, 3, 4, 5] tail
Queue: size= 4 , capacity= 5
front [2, 3, 4, 5] tail
Queue: size= 5 , capacity= 5  //实际开闭了6个空间，所以在下一步才进行扩容
front [2, 3, 4, 5, 6] tail
Queue: size= 6 , capacity= 10
front [2, 3, 4, 5, 6, 7] tail
Queue: size= 7 , capacity= 10
front [2, 3, 4, 5, 6, 7, 8] tail
Queue: size= 6 , capacity= 10
front [3, 4, 5, 6, 7, 8] tail
Queue: size= 7 , capacity= 10
front [3, 4, 5, 6, 7, 8, 9] tail

数组队列与循环队列的比较

分别执行100000次的入队操作和100000次的出队操作，查看运行时间

package design.queue;

import java.util.Random;

/**
 * @program: design
 * @description: 数组队列和循环队列的比较
 * @author: cyj
 * @create: 2019-03-20 16:20
 **/
public class QueueTest {
    /**
     * 测试使用q运行opCount个enqueue和dequeue操作所需要的时间，单位：秒
     *
     * @param q
     * @param opCount
     * @return
     */
    private static double testQueue(Queue<Integer> q, int opCount) {
        long startTime = System.nanoTime();
        Random random = new Random();
        for (int i = 0; i < opCount; i++) {
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i = 0; i < opCount; i++) {
            q.dequeue();
        }
        long endTime = System.nanoTime();
        return (endTime - startTime) / 1000000000.0;
    }

    public static void main(String[] args) {
        int opCount = 100000;

        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = testQueue(arrayQueue, opCount);
        System.out.println("ArrayQueue , time: " + time1 + " s");

        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = testQueue(loopQueue, opCount);
        System.out.println("LoopQueue , time: " + time2 + " s");

    }
}



运行结果：
ArrayQueue , time: 3.311457298 s
LoopQueue , time: 0.012101963 s


可以看出有明显的区别，甚至可以说100倍的区别，主要是因为数组队列在出队操作上耗费了太多的时间。
央小木
关注
专栏目录
硬核！手写一个优先队列
bigsai
10-22 3105
前言 事情还要从一个故事讲起： 对于上面那只可爱的小狗狗不会，本篇即为该教程，首先，我要告诉这只可爱的小狗狗，这种问题你要使用的数据结构为优先队列，每次操作的时间复杂度为O(logn),而整个过程的时间复杂度为O(nlogn). 对于本片的设计与实现和堆排序可能有些相似，因为他们都借助堆来实现算法和数据结构，下面详细介绍优先队列的设计与实现。 堆 而堆就是一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树(完全)的数组对象。且总是满足以下规则： 堆总是一棵完全二叉树 每个节点总是大于(或小于)
Java底层堆栈的实现
huxian1234的专栏
12-17 1878
1）java底层的Stack是继承Vector的，也就是说是直接实现Collection的（满足后进先出）      class Stack extends Vector  2）向堆栈中压入数据      /**      * Pushes an item onto the top of this stack. This has exactly      * the same eff
【数据结构 Java 版】详解栈和队列的实现
吞吞吐吐大魔王的博客
10-24 6513
文章目录1. 栈1.1 概念1.2 助解图题1.3 栈的数组实现1.4 问题1.5 栈的单链表实现2. 队列2.1 概念2.2 问题2.3 队列的单链表实现2.4 数组实现队列2.5 循环队列2.6 双端队列3. 栈和队列练习题3.1 有效的括号3.2 用队列实现栈3.3 用栈实现队列3.4 实现一个最小栈3.5 设计循环队列 1. 栈 1.1 概念 栈：是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 特点：栈中的数据元素遵循先进后出的原则，但要注意进的同时也可以出，元素不是要全部进展
数据结构——栈的实现（java实现）与相应的oj题
2301_77993957的博客
07-17 792
2. 后缀表达式先进栈的是左操作数，后进栈的是右操作数，当我们需要出栈时，第一次获取栈顶元素是右操作数，第二次获取栈顶元素才是左操作数。实现思想：遍历字符串，遇到左括号则存入栈中，遇到右括号则与栈顶元素比较，相匹配，则继续循环，如果不匹配或栈为空，则返回false。栈也是一种线性表，栈只允许在表的一端进行插入与删除操作，所以栈中数据的特征的先进后出（先进来的后出去）。，获取两个操作数进行计算（需要注意的是第一次出栈的是右操作数，第二次出栈的是左操作数）
java栈的底层实现_Java底层堆栈的实现
weixin_39669202的博客
02-26 632
1)java底层的Stack是继承Vector的，也就是说是直接实现Collection的(满足后进先出)class Stack extends Vector2)向堆栈中压入数据/*** Pushes an item onto the top of this stack. This has exactly* the same effect as:* * addElement(item)** @pa...
栈和队列的底层实现-Java描述
小小本科生
07-14 1115
栈和队列的两种底层实现一：双向链表实现1.栈2.队列二：数组实现1.栈2.队列 一：双向链表实现 双向链表实现可以从头部进，头部出，以及尾部进，尾部出的结构 public static class Node<T> { public T value; public Node<T> last; public Node<T> next; public Node(T value) {
栈和队列的底层数组实现
zwz2011303359的博客
03-17 1224
public class MyStack { private int[] arr; //栈点 private int top; //构造方法 public MyStack(){ arr=new int[20]; top=-1; } public MyStack(int maxsize){ arr=new int[maxsize]; top=-1; } //
Java 用数组和链表手写栈和队列 笔记
zxcsjf的博客
07-10 263
Java 栈和队列 手写 用数组和链表实现
java 手写数据结构之栈，队列和链表的基本实现
weixin_41644977的博客
10-08 331
以前看到有人说程序员的三大基本功：程序逻辑，数据结构和sql语句。 闲暇之余，突然想起栈，队列和链表的数据结构，对于他们的底层实现已经很久没接触了，就准备手写一下感受感受。 栈结构就是实现了先进后出，浏览器的退回，函数栈都是这样的结构，如下就是栈的简单实现： /** * 栈 * 基于数组 * * @author zeng wenbin * @date Created in 2019/...
2024年Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
2301_82257383的博客
05-02 998
在多线程编程中,线程池是一种非常重要的工具。它可以帮助我们高效地管理线程资源,避免频繁创建和销毁线程带来的性能开销。Java中提供了强大的线程池实现,如 ThreadPoolExecutor ,但有时我们可能希望了解其内部原理,并实现一个简单的线程池来加深对其工作机制的理解，手写线程池也是很多大厂常考的笔试题。开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。
从基础到实战：如何用 Java 手写一个阻塞队列？
最新发布
孤芳不自赏
08-27 611
阻塞队列顾名思义是一种支持阻塞操作的队列。生产者阻塞：当队列满时，生产者会等待，直到队列不满。消费者阻塞：当队列为空时，消费者会等待，直到队列不为空。这个机制保证了生产者和消费者的平衡，同时避免了空轮询造成的 CPU 资源浪费。
java 模拟栈底层_Java 底层实现 Stack 栈
weixin_39587822的博客
02-16 177
1、Stack栈概述栈这个数据结构有着自己的性质，也就是 先进后出，后进先出 的结构。最经典的就是调用函数这一块。不断向栈中加入缓存，最后执行完的函数会回调用放在栈顶的缓存。和它类似的就是队列的数据结构。队列有着先进先出，后进后出的结构。两者应用不同的场景。这里将栈设计为Java接口，目的是实现栈的底层有很多。例如数组、链表、二叉树等等。他们都将调用这个Stack接口。涉及的函数方法：涉及的函数不...
Java数据结构--栈的实现
DR的专栏
03-30 213
Java中是没有栈这种数据结构的，如果想利用栈的先进后出（FILO），就必须自己动手实现。栈的底层可以使用数组，也可以使用Java中的容器类，如ArrayList、LinkList等。栈最常用的操作主要是压栈（push）、出栈（pop）、查看栈顶元素（peek）、判断栈是否为空（isEmpty）、返回栈的当前大小。原则上栈中有一个指针指向栈顶元素。 1、底层基于数组的栈实现： import...
我用Java学数据结构之栈底层实现
路途遥远’s blog
05-20 608
栈和队列在很多地方都有应用，比如非递归前序遍历二叉树，还有做题的时候会经常用到 首先定义栈的接口，与java内置的栈接口相同，依然使用泛型实现 public interface Stack<E> { int getSize(); boolean isEmpty(); void push(E e); E pop(); E p...
java虚拟机工作原理图_JVM 底层原理总结
weixin_39900180的博客
02-17 344
JAVA虚拟机：一、如上图所示，JAVA虚拟机运行时主要由以下三个部分构成：A. 本地库接口负责把描述类的数据从Class文件加载到内存，并对数据进行校验、装换解析、以及初始化，最终形成可以被虚拟机直接使用的Java类型。在Java语言中，类型的加载、连接和初始化过程都是在程序运行期间完成的。B. 运行时数据区1)方法区。2)堆。3)虚拟机栈。4)本地方法栈。5)程序计数器。C. 执行引擎输入的是...
栈与队列（Java实现）
敲敲敲
01-27 1743
栈Stack 1.定义： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 实际应用：常见的诸如撤销操作，网页后退操作，以及开发中程序的“调用栈”操作系统栈底层 2.三个常用方法： push方法——入栈 pop方法——出栈，即将栈顶元素删除并返该元素 peek方法——返回栈顶元素 3.实现基于数组的顺序栈 为什么选用数组呢，其实链表也可
栈与队列的实现逻辑以及底层代码
yanlou233的博客
03-27 892
栈和队列不是一种语言独有的结构，而是一个由代码语言设计的一种数据结构。是由人设计出的一种具有特定意义的结构。
栈和队列的实现（详解+图解！文末附完整代码）
逃离枷锁，冲向天空！
11-25 607
当capacity和top相等时其实是有两种情况的，一种时为空，另一种是栈满，，我们在这里就用一个三目操作符，如果为0，就将capacity初始化为4，否则将capacity的原来的值乘2，然后动态开辟realloc一块新的空间，大小就是newcapacity，这样我们就完成了扩容。在后面的增删查改等操作我们需要断言，为了增加代码的可读性，我们直接写一个函数 ，更加容易理解，如果栈顶元素下标为0，那么这个栈就为空 ，所以直接return top等于 0这个表达式的值，为空则返回 1，不为空则返回0。
栈和队列（手写）
zhachengxi的博客
02-17 411
其实已经发过一次栈和队列了，不过那个是直接利用STL的用法，这里写一写利用数组完成的栈和队列操作，顺便写一写单调栈和单调队列的操作和一般用途。 1.栈和队列基本特点 没啥好讲的，栈是FILO，队列是FIFO， 偷个懒，需要的点这里。 2.栈 <1>手写栈 我们一般用数组来存储栈，我通常写作stk[i]，然后用tt来表示栈顶，实现代码一系列操作。 const int N = 100010...
手写实现一个队列java
04-01
// 队列头部指针 private int tail; // 队列尾部指针 private int size; // 队列大小 // 构造函数 public Queue(int capacity) { data = new int[capacity]; head = 0; tail = 0; size = 0; } // 入队 ...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值