java数组/链表实现栈和队列

最新推荐文章于 2023-09-04 21:02:13 发布
最新推荐文章于 2023-09-04 21:02:13 发布
阅读量541 收藏
点赞数
分类专栏： java基础 数据结构与算法 文章标签： java 数据结构 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woai3364/article/details/128905106
版权

一、栈结构介绍

​ 栈（stack) 是限定仅在表尾进行插入或删除操作和线性表（只有一端口能进出数据），对栈来说表尾和表头有特殊含义，表尾被称为栈顶，表头被称为栈底，没有元素的空表称为空栈，元素数量达到栈的容量称为满栈，数据添加到栈中叫入栈、压栈，数据从栈中删除叫出栈、弹栈，由于栈元素特殊添加和删除的规则，所以栈的元素会先进后出的现象，简称为LIFO（Last in first out）。

数组——代码实现栈：

1、私有变量和构造方法

    private static final int CAPACITY = 20;//栈容量
    private int topOfStack;//栈顶指针
    private  Object arrayStack[];
    public MyArrayStack(){//构造方法
        topOfStack = -1;
        arrayStack = new Object[CAPACITY];
    }

我们创建一个容量为20的数组，并用一个指针来记录栈顶元素。我们在构造方法里初始化栈顶指针为-1，代表着栈为空。

2、入栈

  /***** 入栈 *****/
    @Override
    public boolean push(Object o) {
        if(topOfStack >= (CAPACITY-1)){
            System.out.println("栈满了");
            return false;
        }
        arrayStack[++topOfStack] = o;
        return true;
    }

入栈的思路就是先将栈顶指针向上移一位，再直接赋值，前提需判断该栈是否满，当然栈满了，是不允许再进栈的。

3、出栈

/***** 出栈 *****/
    @Override
    public Object pop() {
        if(topOfStack<0){
            System.out.println("栈为空");
        }
        Object old = arrayStack[topOfStack];
        arrayStack[topOfStack--] = null;
        return old;
    }

出栈的思路和入栈差不多，先判断栈是否为空，再将栈顶元素赋值给一个变量并将其记录，将其设置为空指针向下移一位。

4、

   //查看当前栈顶元素
    @Override
    public Object peek() {
        if(topOfStack<0){
            System.out.println("栈为空");
        }

        return arrayStack[topOfStack];
    }
  @Override
    public int size() {
        return topOfStack+1;
    }

    @Override
    public boolean isEmpty() {
        return topOfStack<0;
    }

链表——代码实现栈：（用双向链表）

1、链表节点类

  static class Node<E>{
        Object element;
        Node prev;
        Node next;

        public Node(Object element){
            this.element = element;
        }
    }

2、私有变量和构造方法

    private Node<E> head;
    private Node<E> tail;
    private int size;
    private static final int MAX_CAP = 100;

    public MyLinkedStack(){
        head = new Node<>(null);
        tail = new Node<>(null);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }

我们设置最大容量为100的栈，在构造方法里首先将其头尾节点的值设置为null,并互相指向对方。

3、进栈

 /***** 进栈 *****/
    @Override
    public boolean push(Object o) {
        if(size<MAX_CAP) {
            Node<E> x = new Node<>(o);
            Node<E> temp = head.next;
            //head temp
            x.prev = head;
            x.next = temp;

            head.next = x;
            temp.prev = x;
            size++;
            return true;
        }
        return false;
    }

思路是先判断栈是否满，然后创建一个节点将要入栈的值装入，再运用头指针获取第一个节点（头指针后面的那个节点），将新节点加入，成为第一个节点。（把头节点的prev,next分别指向head,第一个节点。再将头节点的next指向新节点，将第一个节点的prev也指向新节点）。

4、出栈

/***** 出栈 *****/

    @Override
    public Object pop() {
        if (size>=1) {
            Node<E> x = head.next;
            Node<E> temp = x.next;

            head.next = temp;
            temp.prev = head;
            Object need = x.element;
            x.prev = x.next =null;
            size--;
            return need;
        }
        return null;
    }

出栈和进栈思路差不多，主要思路就是将第一个节点删除，删除前把值记录下来并返回。

5、


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

    @Override
    public boolean isEmpty() {
        return size==0;
    }
 /***** 查看栈顶元素 *****/
    @Override
    public Object peek() {
        return head.next.element;
    }

二、队列介绍

​ 它与栈刚好相反，是一种先进先出的线性表，它有两个端口添加、删除元素，一个端口只能添加元素，被称为入队，该端口被为队尾，另一个端口只能删除，被称为出队，该端口被称为队头。

链表——实现队列：（双链表）

package pgs0205;

public class MLinkedQueue<E> {
    public class Node<E>{
        E element;
        Node prev;
        Node next;
        public Node(E element){
            this.element = element;
        }
    }
    private static final int MAX_CAP = 20;
    private Node<E> head;
    private Node<E> tail;
    private int size;
    public MLinkedQueue(){
        head = new Node<>(null);
        tail = new Node<>(null);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }
    /***** 入队 *****/
    public boolean enqueue(E element){
        if(size<MAX_CAP) {
            Node<E> x = new Node<>(element);
            Node<E> temp = tail.prev;

            x.prev = temp;
            x.next = tail;
            temp.next = x;
            tail.prev = x;
            size++;

            return true;
        }
        return false;
    }
    /***** 出队 *****/
    public E dequeue(){
        if(size >=1){
            size--;
            return (E) head.next.element;
        }
        return null;
    }
    /***** 查看队列第一个 *****/

    public E getFront(){
        return (E) head.next.element;
    }
    /***** 获取队列长队 *****/
    public int getSize(){
        return size;
    }
    /***** 判断是否为空 *****/
    public boolean isEmpty(){
        return size==0;
    }

}

主要把握队列的性质（先进先出），然后注意链表的增删。

数组——实现队列：

package pgs0205;

public class MyArrayQueue<E> {
    private static final int MAX_CAP = 20;
    private Object arrayQueue[];
    private int topOfQueue;
    private int botOfQueue;

    public MyArrayQueue() {
        arrayQueue = new Object[MAX_CAP];
    }

    /***** 入队 *****/
    public void enqueue(E element) {
        if (isFull()) {
            System.out.println("队满");
        }
        arrayQueue[botOfQueue] = element;
        botOfQueue = (botOfQueue + 1) % MAX_CAP;
    }

    /***** 出队 *****/
    public E dequeue(){
        if(isEmpty()){
            throw new RuntimeException("队列为空!");
        }
        E temp = (E) arrayQueue[topOfQueue];
        topOfQueue = (topOfQueue+1)%MAX_CAP;
        return temp;
    }

    /***** 查看对头元素 *****/
    public E getFront() {
        if(isFull()){
            throw new RuntimeException("队列满了");
        }
        return (E) arrayQueue[topOfQueue];
    }

    /***** 获取队列长度 *****/
    //查看队列的第一个元素
    public E HeadNum(){
        if(isEmpty()){
            throw new RuntimeException("队列为空!");
        }
        return (E) arrayQueue[topOfQueue];
    }

    /***** 判断是否为空 *****/
    public boolean isEmpty() {
        return topOfQueue==botOfQueue;
    }

    /***** 判断是否满 *****/
    public boolean isFull() {
        return (botOfQueue + 1) % MAX_CAP == topOfQueue;  //最后一个位置没用到
    }
    /***** 显示队列所有数据 *****/
    //显示队列的所有数据
    public void ShowQueue(){
        if(isEmpty()){
            System.out.println("队列中没有数据");
            return;
        }
        for(int i = topOfQueue;i < topOfQueue+CountQueue();i++){
            System.out.println(arrayQueue[i%MAX_CAP]);
        }
    }
    /***** 队列中有效元素个数 *****/
    public int CountQueue(){
        if(isEmpty()){
            return 0;
        }
        return (botOfQueue+MAX_CAP-topOfQueue)%MAX_CAP;
    }

//    本文中有几个需要注意的公式，就是判断队列是否满了：
//
//            (topOfQueue+1)%MAX_CAP == botOfQueue
//    还要就是队尾指针和队头指针移动的操作：
//
//    topOfQueue = (topOfQueue+1)%MAX_CAP;
//    查看队列中有效元素的个数：
//
//            (topOfQueue+MAX_CAP-botOfQueue)%MAX_CAP
//    还有就是遍历队列：
//
//            for(int i = botOfQueue;i < botOfQueue+CountQueue();i++){
//        System.out.println(arrayQueue[i%MAX_CAP]);
//    }
}

运用固定大小的数组实现队列，首先我们给定大小为20的数组，入队指针和出队指针都指向数组第一个位置即索引为0，当入队一个元素时，botOfQueue指针就会往后移一位，当出队一个元素时，topOfQueue指针也会往后移一位，这样数组前部分位置都空出来了，当位置不够时，指针又回到索引0位置，这样这个固定大小数组就得以实现重复使用。

注意：判断队列是否满 isFull()；方法，判断依据是当botOfQueue指针+1刚好是topOfQueue指针位置则队列就满了。因此本队列真实大小容量为19。

woai3364
关注
专栏目录
使用数组和链表实现栈和队列的复杂度分析
mcrwayfun，欢迎你
11-13 2585
​ 抽象数据类型（abstract data type，ADT）是带有一组操作的一些对象的集合 1 表ADT A1,A2,⋯&amp;ThinSpace;,AN A_1,A_2,\cdots,A_N A1​,A2​,⋯,AN​ ​ 如上，这是一个大小为N的表。当然，若N为0，则称其为空表。 ​ 对于除空表以外的任何表，A1可以看作是A2的前驱，而A2则是A1的后继。在一个表中，表中第一个元素是A1...
Java 用数组和链表手写栈和队列 笔记
zxcsjf的博客
07-10 264
Java 栈和队列 手写 用数组和链表实现
Java-用数组实现栈-队列-线性列表
07-13
Java-用数组实现栈-队列-线性列表（最详细） 有注释 适合java新生 进行数组的练习 3个数据结构的数组实现练习
Java数组实现栈和队列
XuJiangDong
11-21 822
队列实现： package com.example.javabase.test; /** * @author XuJD * @create 2019-11-21 10:11 * 基于数组实现队列 **/ public class Queue3 { /** * 队列 */ private String[] data; /** * 队列最...
JAVA数组实现栈和循环队列
疾驰单车的博客
02-19 273
JAVA数组实现栈和循环队列 一、栈的实现 用一个封装好的类来实现，将变量设置为private类型，设置一个flag变量指向栈顶，向外提供栈的基本方法。 push()------------压栈 pop()-------------出栈 show()-----------栈内元素依次出栈 扩容机制 当栈满继续压栈时创建一个新的更大的数组，并将原数组中的元素复制到新数组中，将新数组的开始地址赋给原数组，原数组中的元素会自动回收。 public class Stack { private int[] ar
Java数组实现堆栈和队列
Java 之 道
03-11 2006
数组堆栈： public class Stack { private long[] stackArray; private int top; private int maxSize; public Stack(int maxSize){ this.maxSize = maxSize; top = -1; stackArray = new long[maxSize]; }
java的链表实现队列_Java链表和链表实现的队列
weixin_35056962的博客
02-15 165
链结点:在链表中,每个数据项都被包含在"链结点"(Link)中.一个链结点是某个类的对象,这个类可以叫Link.而每个Link对象中又包含着一个对下一个链结点引用的字段(通常叫next)image.png链节点:/*** 节点* 在Java中实现链表是非常简单的，每个节点都有一个值，然后把它链接到下一个节点。* @author JiaoNingbo**/public class Node {int...
java使用数组和链表实现队列示例
09-04
队列是一种特殊的线性表，它只允许在表的前端(front)进行删除操作，只允许在表的后端（rear）进行插入操作,下面介绍一下java使用数组和链表实现队列的示例
基于JAVA实现的常用数据结构代码，JAVA实现复杂度、动态数组、链表、栈、队列、二叉搜索树等
01-04
本压缩包"基于JAVA实现的常用数据结构代码"包含了多个关键的数据结构实现，包括复杂度分析、动态数组、链表、栈、队列以及二叉搜索树。以下是这些数据结构的详细说明： 1. **复杂度**：在计算机科学中，复杂度分为...
数组与链表实现队列
m0_52061250的博客
05-24 498
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、数组二、链表1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、数组 二、链表 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.
用java数组实现栈
bitcarmanlee的博客
05-30 7086
栈是一种常见的数据结构。如果用一句话来概括栈的特点，估计大部分同学都能脱口而出：后进先出，即先进来的元素保存在栈的最底部，新来的元素则在栈顶堆积，直到栈满为止；而取元素的时候，只能从栈顶取，直到栈空为止。整个过程，与摞书的过程很类似：放书的时候都是摞在最上面，取书的时候也是从最上面开始取。要想取出下面的书，就必须先将上面的书先取走。原理就讲这么多，本身也比较简单。接下来，照例是咱们的口号： tal
Java —— 用数组来实现数据结构中的栈和队列
最新发布
lyy281241的博客
09-04 208
栈(先进后出)：用Java的数组来实现。
Java用数组实现栈和队列
qq_45818845的博客
04-04 193
算法刷题笔记-day4（数据结构基础） 用数组实现基本的队列和栈及其常用方法 /** * 用数组结构实现大小固定的队列和栈 */ public class dataStructure { /** * 用数组实现了栈结构； */ public static class ArrayStack { private Integer[] arr; //用size记录栈内元素个数的情况 private Integer size;
java使用数组实现栈和队列_用数组实现栈、队列
weixin_42284052的博客
02-27 291
数组实现栈public static class ArrayStack {private Integer[] arr;private Integer size;public ArrayStack(int initSize) { //initsize 是要告诉我数组要开多大。if (initSize < 0) {throw new IllegalArgumentException("T...
数组实现栈---[java版]
ALi的博客
11-02 468
目录 项目简述： 项目用到的图片/gitee地址 项目代码： ArrayStack栈类 出栈方法pop 入栈的方法push 遍历栈的方法list() 测试以上的功能用main() 项目简述： 1.用数组的形式来模拟栈，入栈后的元素依然保存在数组中，无法真正的删除，但是用链表模拟栈时出栈就可以删除掉元素。 2.定义的stact类（栈类）：最大尺寸、数组、栈顶指针初始化为-1。 3.实现起来很简单，不难。 项目用到的图片/gitee地址 Stack文件夹 项目代码：
java使用数组实现栈和队列_数据结构与算法-java-数组实现队列和栈
weixin_30514427的博客
02-27 82
importjava.util.Scanner;public classQueue {public static voidmain(String[] args) {ArrQueue queue=new ArrQueue(3);char key=' ';Scanner scan=new Scanner(System.in); //标准输入，拿到一个扫描器boolean loop=true; //...
【Java数组实现的栈与队列】
leach
03-28 569
栈（先进后出） public class stack { SuperArray superArray=new SuperArray(); //压栈 public void push( int data){ superArray.addToTail(data); } // 出栈 public Integer pop(){ Integer select = superArray.select(superArray.size()-1
JAVA数组实现顺序栈与队列
江南一只猫
10-18 355
栈和队列是两种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制。本实例介绍如何使用顺序栈、顺序队列和优先队列以及使用的规则和要领。 package JAVA_Project_01_04;//创建一个包 /* 栈是一种数据结构，限制仅在表的一端进行插入和删除运算的线性表。其数据项的插入和删除（获取）都只能在称为栈顶的一端完成。 因为最后插入的数据项就是最先要删除的数据项。...
Java数组实现顺序栈与队列
sunyueqinghit的博客
10-04 632
栈和队列是两种特殊的线性表，他们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制。本文介绍如何使用顺序栈、顺序队列和优先队列以及使用的规则和要领。 技术要点 数组实现顺序栈与队列的技术要点如下： 栈是一种数据结构，限制仅在表的一端进行插入和删除运算的线性表。其数据项的插入和删除（获取）都只能在成为栈顶的一端完成。因为最后插入的数据项就是最先要删除的数据项。当数据项中没有元素时称为空栈。
Java数据结构详解：数组、链表、栈与队列
在这个框架内，Java编程语言提供了多种数据结构，如数组、链表、栈、队列和树，这些结构在不同的场景下有着各自的特性和用途。 首先，我们来看数据的逻辑结构。逻辑结构描述的是数据元素之间的关系，而不考虑具体...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值