数据结构——Java实现栈和队列

已于 2024-01-19 20:49:21 修改
阅读量715 收藏 9
点赞数 15
文章标签： 数据结构 java 开发语言
于 2024-01-19 20:48:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77116754/article/details/135706336
版权

一、栈 Stack

1.特点

（1）栈是一种线性数据结构

（2）规定只能从栈顶添加元素，从栈顶取出元素

（3）是一种先进后出的数据结构（Last First Out）LIFO

2.具体实现

Java中可以直接调用方法来实现栈

如何自己写代码来实现栈呢？

先定义一个接口，方便后边进行调用

package com.algo.lesson.lesson02.stack;

public interface Stack_I<T> {
    //入栈
    void push(T ele);
    //出栈
    T pop();
    //查看栈顶元素
    T peek();
    //判断是否为空
    boolean isEmpty();
    //后去栈中元素
    int getSize();
}

接下来来实现栈的方法，调用接口，完善方法：

package com.algo.lesson.lesson02.stack;

import com.algo.lesson.lesson01.MyArr;

//以数组作为栈顶的底层数据结构
public class ArrStack<T> implements Stack_I<T> {

    private MyArr<T>data;

    int size;

    public ArrStack() {
        this.data=new MyArr<>(100);
        this.size=0;
    }

    @Override
    public void push(T ele) {
        //在数组尾部添加元素
        this.data.add(ele);
        this.size++;
    }

    @Override
    public T pop() {
        if(isEmpty()){
            return null;
        }
        this.size--;
        return this.data.removeBFromLast();
    }

    @Override
    public T peek() {
        return this.data.getLastValue();
    }

    @Override
    public boolean isEmpty() {
        return this.size==0;
    }

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

以上就是方法的代码，接下来，写个main函数来调用，检查方法是否正确

package com.algo.lesson.lesson02.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class StackTest<T> {
    public void test(Stack_I<T>stack, List<T> list){
        //开始时间
        long startTime=System.nanoTime();

        for(int i=0;i<list.size();i++){
            stack.push(list.get(i));
        }
        System.out.println(stack.getSize());
        while(!stack.isEmpty()){
            T ele=stack.pop();
            System.out.println(ele+"  ");
        }

        //结束时间
        long endTime=System.nanoTime();
        System.out.println("总耗时："+(endTime-startTime)/100000000.0);
    }

    public static void main(String[] args) {
        StackTest<Integer>stackTest=new StackTest<>();
        Stack_I<Integer>stack=new ArrStack<>();
        List<Integer>list=new ArrayList<>();
        Random random=new Random();
        for(int i=0;i<100;i++){
            int val= random.nextInt(1000);
            list.add(val);
        }
        stackTest.test(stack,list);
    }
}

注：其中long startTime=System.nanoTime();方法是获取一个时间（单位毫秒）

在程序运行前和运行后个添加一个，最后将两个时间相减，得到程序运行时间。

3.时间复杂度分析

二、队列

1.特点

（1）队列也是一种线性数据结构

（2）只能从一端添加元素，另一端取出元素

（3）是一种先进先出的数据结构（FIFO——fist in fist out ）

2.具体实现

Java中也可以直接调用队列的方法：

自己的实现：

接口：

package com.algo.lesson.lesson02.queue;

public interface Queue_I<T> {
    void offer(T ele);//入队
    T poll();//出队
    T peek();//查找队首元素
    int getSize();
    boolean isEmpty();


}

方法代码：

package com.algo.lesson.lesson02.queue;

import com.algo.lesson.lesson01.MyArr;

public class ArrQueue<T>implements Queue_I<T> {

    private MyArr<T>data;

/*
    private int size;//队列中元素的个数
*/

    public ArrQueue(){
        this.data=new MyArr<>(50);
    }

    @Override
    public void offer(T ele) {
        this.data.add(ele);
    }

    @Override
    public T poll() {
        if(isEmpty()){
            return null;
        }
        return this.data.removeByIndex(0);
    }

    @Override
    public T peek() {
        if(isEmpty()){
            return null;
        }
        return this.data.getValueByIndex(0);
    }

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

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

3.出现的问题

入队列时间复杂度为O(n)，因为在出队时，元素要前移，会出现假溢出的情况。

所以就出现了循环队列来解决这个问题

循环队列：

front记录队首，tail记录队尾，队尾达到容积时，返回到队头，将空位置补上，可以继续存储数据。

package com.algo.lesson.lesson02.queue;

import java.util.Random;

/*
基于Java中的数组进行二次封装,制作一个可变数组
 */
//泛型:就是类型作为参数
public class LoopArr<T> {
    private T[] data;//保存数据

    private int size;//数组中实际存放元素的个数

    private int front;//队首

    private int tail;//队尾

    int capacity;//容积

    //构造函数
    public LoopArr(int capacity) {
        if (capacity <= 0) {
            this.capacity = 11;
        } else {
            this.capacity = capacity + 1;
        }
        this.size = 0;
        this.front = this.tail = 0;
        this.data = (T[]) (new Object[this.capacity]);
    }

    //获取数组中实际存放元素的个数
    public int getSize() {
        return this.size;
    }

    //获取数组的容积
    public int getCapacity() {
        return this.capacity;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return this.front == this.tail;
    }

    //向数组中添加元素(尾部)
    public void add(T item) {
        //判断数组是否满
        if ((this.tail + 1) % this.capacity == this.front) {
            //扩容
            resize((this.capacity-1)*2+1);
        }
        //从index位置开始元素需要进行后移
        this.data[this.tail] = item;
        this.tail = (this.tail + 1) % this.capacity;
        //更新this.size
        this.size++;
    }

    private void resize(int newCapacity) {
        System.out.println("resize:" + newCapacity);
        T[] newData = (T[]) (new Object[newCapacity]);
        //将原数组驾到新数组里

        for (int i = 0; i < this.size; i++) {
            newData[i] = this.data[(this.front+i)%this.capacity];
        }
        //改变容器
        this.data = newData;
        this.capacity = newCapacity;
        //将this.front置零
        this.front=0;
        this.tail=this.size;
    }

    //获取指定位置的值
    public T getValueByIndex() {
        if(isEmpty()){
            return null;
        }
        return this.data[this.front];
    }

    //移除队首元素
    public T remove() {
        if (isEmpty()) {
            return null;
        }
        //删除操作的核心
        /*
        1.找到删除的位置
        2.删除位置之后的元素要前移 arr[j-1]=arr[j]
         */
        T delValue = this.data[this.front];
        this.front = (this.front + 1) % this.capacity;
        this.size--;
        //判断是否缩容
        if (this.size < this.capacity / 4 && this.capacity / 2 > 0) {
            resize((this.capacity-1) / 2 +1);
        }
        return delValue;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < this.size; i++) {
            sb.append(this.data[i]);
            if (i != this.size - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}
package com.algo.lesson.lesson02.queue;

public class LoopQueue<T> implements Queue_I<T>{

    private LoopArr<T>data;//容器

    public LoopQueue(){
        this.data=new LoopArr<>(100);
    }




    @Override
    public void offer(T ele) {
        this.data.add(ele);
    }

    @Override
    public T poll() {
        return this.data.remove();
    }

    @Override
    public T peek() {
        return this.data.getValueByIndex();
    }

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

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

4.循环队列的复杂度分析

三、栈和队列的互相实现

既然我们了解了栈和队列，知道了这两种数据结构十分相似，也就可以大胆假设以下，可不可以相互实现，不是用上面所写的以数组为底层，而是相互为底层存储。

1.用栈来实现队列

import java.util.Stack;

class MyQueue {
    private Stack<Integer> A;
    private Stack<Integer> B;

    public MyQueue() {
        A = new Stack<>();
        B = new Stack<>();
    }

    public void push(int x) {
        while (!B.isEmpty()) {
            A.push(B.pop());
        }
        A.push(x);
        while (!A.isEmpty()) {
            B.push(A.pop());
        }
    }

    public int pop() {
        return B.pop();
    }

    public int peek() {
        return B.peek();
    }

    public boolean empty() {
        return B.isEmpty();
    }
}

2.用队列实现栈

import java.util.LinkedList;
import java.util.Queue;

class MyStack {
    private Queue<Integer> queue1;
    private Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        queue2.add(x);
        while (!queue1.isEmpty()) {
            queue2.add(queue1.remove());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }

    public int pop() {
        return queue1.remove();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

这就是这两种数据结构相互实现的代码

在LeetCode中也有相对应的题目：

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台（栈实现队列）

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台（队列实现栈）

刘伊珂
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
DataStructureJava:主要数据结构——java中的简单实现
07-01
数据结构Java 主要数据结构——java中的简单实现如何使用集合：-> JDK（Java集合）-> Guava（谷歌）-> Commons-collections（Apache） 主要抽象数据结构——ADS列表（ArrayList、LinkedList、Vector）栈（FIFO）队列...
Java数据结构与算法02——队列
12-21
标签：Java 数据结构 算法 作者 ： Maxchen 版本 ： V1.0.0 日期 ： 2020/3/29 目录1.队列的概念2.数组模拟队列3.队列运行测试 1.队列的概念 队列同样是一种特殊的线性表，其插入和删除的操作分别在表的两端进行，...
JAVA中的栈和堆
SUIFENG2401的专栏
02-08 3000
JAVA在程序运行时，在内存中划分5片空间进行数据的存储。分别是：1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。 基本，栈stack和堆heap这两个概念很重要，不了解清楚，后面就不用学了。 以下是这几天栈和堆的学习记录和心得。得些记录下来。以后有学到新的，会慢慢补充。 一、先说一下最基本的要点 基本数据类型、局部变量都是存放在栈内存中的，用完就消失。new创建的...
java堆栈详解
an-ping的博客
07-11 3582
原博地址:https://www.cnblogs.com/whgw/archive/2011/09/29/2194997.htmlJava中堆内存和栈内存详解Java把内存分成两种，一种叫做栈内存，一种叫做堆内存在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉...
栈和队列（Java实现）
最新发布
m0_46335449的博客
03-23 883
java的队列和栈的实现，由于之前学习的内容大部分都与数据结构无关，但是堆和队列在刷算法题的过程中会经常用到，所以还是得总结一下。尤其是LinkedList的多种用法。
【数据结构】Java实现栈
qq_53869058的博客
03-23 4514
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
Java实现--数据结构--栈
热爱生活，热爱她
02-14 169
Java语言实现栈数据结构
【Java---数据结构】栈(Stack)
.很冷的博客
04-07 8706
一、栈(Stack) 1、概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。 进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。 栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 Java虚拟机栈 JVM stack（Java虚拟机栈）只是JVM中的一块内存，该内存一般用于存放例如：局部变量...... 这块内存也具备栈的特性。例如在调用
算法和数据结构——左程云.zip
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构&算法——Java.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
《Java数据结构和算法》学习笔记(3)——栈和队列
03-14
NULL 博文链接：https://yuan.iteye.com/blog/305590
Java用LinkedList实现的Stack
01-04
栈是先进先出的原则，该类实现了栈的移入移除
Java中Stack详解
Arthur_Holmes的博客
09-27 3989
前言 开发过程中经常会用到集合，在不用思考的情况下，集合我们肯定是用ArrayList，HashMap，特别点的时候会用到 HashSet。但是，这几个集合类真的是万能的么？针对不同的开发场景，我们需要怎样选择正确的集合呢？那么,这节我们就将一个特别的集合----- Stack,它有一个响亮并且我们不陌生的名字：栈！ 今天涉及的知识有： Stack 原理 Stack 的使用 Stack 和 ArrayList 的区别 使用示例及结果 一.Stack 原理 首先看段源码： public class Sta
数据结构 -栈和队列(Java实现)
cj13106811623的博客
02-29 1146
栈和队列是数据结构知识的基础知识，因此我们在学习数据结构的时候需要牢牢记住栈和队列的实现原理以及如何去调用他们各自对应的方法，大家在学习栈和队列的时候可以多敲敲代码来加深理解。
【数据结构】—— Java实现栈
qq_59599094的博客
01-10 392
【数据结构】—— Java实现栈
Java数据结构 | 栈及其应用
m0_56361048的博客
10-05 2110
栈及相关应用详解
Java数据结构——第七节-栈和队列
蓝天it（让亿万孩子在蓝天下共享优质教育）
07-22 690
栈和队列
java中堆栈的实现总结
u013978512的博客
03-20 873
与Stack不同，Java里的Queue不是一个类，而是一个接口。Java集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue，因此Java集合大致也可分成List、Set、Queue、Map四种接口体系.接口中共定义了6个主要的方法方法描述add在队列尾部插入一个元素（队列满时抛异常）offer在队列尾部插入一个元素（队列满时返回false）remove返回队列头部的对象，并从栈中移除它（队列为空时，抛异常）
通过Java语言用栈实现队列
爱学习的JackYang的博客
01-15 364
【代码】通过Java语言用栈实现队列。
Java算法与数据结构测试——二叉树
04-06
非递归查找可以使用栈或队列实现，从根节点开始，每次将当前节点的左右子节点入栈/队列，直到找到要查找的值或者栈/队列为空。 4. 二叉树的插入与删除操作如何实现？ 二叉树的插入操作是将要插入的节点与当前节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

刘伊珂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值