堆栈和队列的java实现

最新推荐文章于 2024-09-27 09:30:00 发布
最新推荐文章于 2024-09-27 09:30:00 发布
阅读量900 收藏 2
点赞数 1
文章标签： java 栈 数据结构 队列 链
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JeCode/article/details/49932039
版权

1.堆栈

堆栈是一种后进先出(LIFO)的数据结构。主要要实现的方法有判断堆栈是否为空，输出堆栈的顶部元素，添加元素，删除元素，创建一个包含这几个方法的接口如下:

public interface Stack {

    public boolean isEmpty();             //判断堆栈是否为空
    public Object peek();                 //返回堆栈的顶部元素
    public void push(Object theElement);   //从顶部添加元素
    public Object pop();                  //删除顶部元素并返回被删除的元素

}

1.数组实现

import java.lang.reflect.Array;
import java.util.EmptyStackException;

public class ArrayStack implements Stack{

    int top;            //current top of stack
    Object element[];    //element array

    /**create a stack with the given initial capacity
      *@throws IlleagalArgumentException when initialCapacity<1*/
    public ArrayStack(int initialCapacity){
        if(initialCapacity<1){
            throw new IllegalArgumentException ("initialCapacity must be >=1");
        }
        element=new Object[initialCapacity];
        top=-1;
    }

    /**create a stack with initial capacity 10*/
    public ArrayStack(){
        this(10);
    }

    /** @return true iff stack is empty*/
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return top==-1;
    }

    /** @return top element of stack
     *  @throw EmptyStackException when the stack is empty*/
    @Override
    public Object peek() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        return element[top];
    }

    /** add the element to the top of stack*/
    @Override
    public void push(Object theElement) {
        // TODO Auto-generated method stub

        //increase array size if necessary
        if(top==element.length-1){
            element=changeArrayLength1D(element,2*element.length);
        }
        //put the element at the top of stack
        element[++top]=theElement;
    }

    private Object[] changeArrayLength1D(Object[] element2, int i) {
        // TODO Auto-generated method stub
        if(element2.length>i){
            throw new IllegalArgumentException("new length too small");
        }
        Object newArray[]=(Object[])Array.newInstance(element2.getClass().getComponentType(), i);
        System.arraycopy(element2, 0, newArray, 0, element2.length);
        return newArray;
    }

    /** @return top element of stack
     *  remove top element of stack
     *  @throw EmptyStackException when the stack is empty*/
    @Override
    public Object pop() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        Object topElement=element[top];
        element[top--]=null;   //enable garbage collection
        return topElement;
    }

    /** @return string converted from stack*/
    public String toString(){
        StringBuilder s=new StringBuilder("[");
        for(int i=top;i>=0;i--){
            s.append(element[i].toString()+",");
        }
        s.append("]");
        return s.toString();
    }

}

构造方法的复杂度是O(n),isEmpty(),peek()，pop方法的复杂度为O(1),push的复杂度是O(n)(当不需要增加容量时为O(1)),toString()方法的复杂度为O(n)。

2.链式实现

import java.util.EmptyStackException;

class ChainNode{
    Object element;
    ChainNode next;   

    ChainNode(){}

    ChainNode(Object element){
        this.element=element;
    }

    ChainNode(Object element,ChainNode next){
        this.element=element;
        this.next=next;
    }
}

public class LinkedStack implements Stack{

    protected ChainNode topNode;

    public LinkedStack(int initialCapacity){}

    public LinkedStack(){}


    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return topNode==null;
    }

    @Override
    public Object peek() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        return topNode.element;
    }

    @Override
    public void push(Object theElement) {
        // TODO Auto-generated method stub
        topNode=new ChainNode(theElement,topNode);
    }

    @Override
    public Object pop() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        Object topElement=topNode.element;
        topNode=topNode.next;
        return topElement;
    }

    public String toString(){
        StringBuilder s=new StringBuilder("[");
        ChainNode p=topNode;
        while(p!=null){
            s.append(p.element.toString()+",");
            p=p.next;
        }
        s.append("]");
        return s.toString();
    }
}

除了toString()方法复杂度为O(n)外，其余方法复杂度都为O(1)。

2.队列

队列是一种先进先出(FIFO)的数据结构。主要要实现的方法和堆栈是差不多的，创建一个队列接口如下:

public interface Queue {

    public boolean isEmpty();
    public Object getFrontElement();//得到队列前端元素
    public Object getRearElement(); //得到队列末端元素
    public void put(Object theElement);
    public Object remove();
}

1.数组实现

import java.lang.reflect.Array;

public class ArrayQueue implements Queue{

    private int front,rear;
    private Object[] element;

    public ArrayQueue(int initialCapacity){
        front=0;
        rear=0;
        element=new Object[initialCapacity];
    }

    public ArrayQueue(){
        this(10);
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return rear==front;
    }

    @Override
    public Object getFrontElement() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        return element[front];
    }

    @Override
    public Object getRearElement() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        int r=0;
        if(rear>0){
            r=rear-1;
        }
        else
            r=element.length-1;
        return element[r];
    }

    @Override
    public void put(Object theElement) {
        // TODO Auto-generated method stub

        if((rear+1)%element.length==front){
            Object newQueue[]=(Object[])Array.newInstance(element.getClass().getComponentType(), 2*element.length);
            if(front==0)
                System.arraycopy(element, front, newQueue, front, element.length-1);
            else{
                System.arraycopy(element, front, newQueue, front, element.length-front);
                System.arraycopy(element, 0, newQueue, element.length, front-1);
            }
            rear=front+element.length;
            element=newQueue;
            element[rear-1]=theElement;
        }
        else{
            element[rear]=theElement;
            rear=(rear+1)%element.length;
        }
    }

    @Override
    public Object remove() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        Object removedElement=element[front];
        front=(front+1)%element.length;     
        return removedElement;
    }

    public String toString(){
        StringBuilder s=new StringBuilder("[");
        if(front<rear){
            for(int i=front;i<rear;i++){
                s.append(element[i].toString()+",");
            }
        }
        else{
            for(int i=front;i<element.length;i++){
                s.append(element[i].toString()+",");
            }
            for(int i=0;i<rear;i++){
                s.append(element[i].toString()+",");
            }
        }
        s.append("]");
        if(!isEmpty()){
            s.delete(s.length()-2,s.length()-1);
        }
        return s.toString();
    }
}

构造方法复杂度为O(n),put(),toString()方法复杂度为O(n),其余方法复杂度为O(1)。

2.链式实现

import java.util.EmptyStackException;

class ChainNode{
    Object element;
    ChainNode next;
    ChainNode(){}
    ChainNode(Object element){
        this.element=element;
    }
    ChainNode(Object element,ChainNode next){
        this.element=element;
        this.next=next;
    }
}

public class LinkedQueue implements Queue{

    ChainNode front,rear;
    public LinkedQueue(int initialCapacity){}
    public LinkedQueue(){}

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return front==null;
    }

    @Override
    public Object getFrontElement() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        return front.element;
    }

    @Override
    public Object getRearElement() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        return rear.element;
    }

    @Override
    public void put(Object theElement) {
        // TODO Auto-generated method stub
        ChainNode p=new ChainNode(theElement,null);
        if(front==null)
            front=p;
        else
            rear.next=p;
        rear=p;
    }

    @Override
    public Object remove() {
        // TODO Auto-generated method stub
        if(isEmpty()){
            throw new EmptyStackException();
        }
        Object removedElement=front.element;
        front=front.next;
        if(isEmpty())
            rear=null;        //enable garbage collection
        return removedElement;
    }

    public String toString(){
        StringBuilder s=new StringBuilder("[");
        ChainNode p=front;
        while(p!=null){
            s.append(p.element.toString()+",");
            p=p.next;
        }
        s.append("]");
        if(!isEmpty()){
            s.delete(s.length()-2,s.length()-1);
        }
        return s.toString();
    }
    public static void main(String args[]){
        LinkedQueue s=new LinkedQueue();
        System.out.println(s.isEmpty());
        for(int i=1;i<8;i++){
            s.put(new Integer(i));
        }
        System.out.println(s.isEmpty());
        System.out.println(s.toString());
        for(int i=1;i<6;i++){
            s.remove();
        }
        System.out.println(s.isEmpty());
        System.out.println(s.toString());
        for(int i=1;i<4;i++){
            s.put(new Integer(i));
        }
        System.out.println(s.toString());
        for(int i=1;i<5;i++){
            s.put(new Integer(i));
        }
        System.out.println(s.toString());
        for(int i=1;i<5;i++){
            s.put(new Integer(i));
        }
        System.out.println(s.toString());
        System.out.println(s.getFrontElement());
        System.out.println(s.getRearElement());
    }

}

toString()方法复杂度为O(n),其余方法复杂度为O(1)。

3.总结

用数组实现比链式实现的方法少用内存而且时间更快，但是如果存在多个堆栈或队列，而它们的长度总和是一定的，但每个数组的范围都差不多要到从0到它们的长度总和，这个时候使用链式实现方法要更好。

JeCode
关注
队列的实现（JAVA）
wodengniyujiul的博客
03-19 2930
数据结构(JAVA) 中队列的实现
堆栈和队列（Java语言）
weixin_44949462的博客
08-19 331
堆栈和队列堆栈和队列堆栈堆栈的抽象数据类型顺序堆栈链式堆栈堆栈的应用括号匹配问题表达式计算队列队列抽象数据类型顺序队列顺序循环队列链式队列优先级队列 堆栈和队列 堆栈和队列都是特殊的线性表。即，除了第一个元素和最后一个元素之外的其他元素只有一个前继元素和一个后继元素。 区别在于：线性表的插入和删除不受限制，而堆栈和队列的插入和删除则有一些特殊要求。具体下文将给出答案。 堆栈 类似弹夹一样的结构，只允许一端进行插入和删除操作。 允许插入和删除的一端称为栈顶，另一端称为栈低。 插入称为入栈或进栈，删除称为
Java中的堆栈和队列
最佳 Java 编程
05-18 517
我最近一直在研究一些需要堆栈和队列的Java代码。 使用的选择不是立即显而易见的。 有一个Queue接口，但没有明确的具体实现要使用。 还有一个Stack类，但是javadocs指出其他类“应该优先于此类使用”。 那么，您对Java中的堆栈和队列使用哪种实现？ 我发现我的经验法则是可以将ArrayDeque类同时用于Stack和Queues，但是下面提供了更多详细信息。 通用定义 首...
EmptyStackException产生原因及解决方案
境里婆娑
09-27 899
是在使用Stack类时，对空栈执行非法操作（如pop或peek）时抛出的异常。常见原因包括对空栈进行弹出或查看栈顶操作，以及未检查栈是否为空。为避免此异常，可以在进行栈操作前检查栈是否为空、使用更合适的数据结构、或捕获并处理。
java编程 队列_【数据结构】之队列的java实现（一）详解
weixin_29876033的博客
02-17 201
队列的定义：队列(Queue)是只允许在一端进行插入，而在另一端进行删除的运算受限的线性表。 (1)允许删除的一端称为队头(Front)。(2)允许插入的一端称为队尾(Rear)。(3)当队列中没有元素时称为空队列。(4)队列亦称作先进先出(First In First Out)的线性表，简称为FIFO表。队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾，每次离开的成员总是队列头上的(不...
Java 实现堆栈和队列
Coding
04-27 516
1.堆栈 package CareerCup; public class Stack { Node top; public Stack(){} public void push(int data) { Node node = new Node(data); node.next = top; top = node; } public Node pop() {
队列的java实现
记忆碎片
02-26 504
和栈相反，队列是一种先进后出的数据结构 这里还是采用最简单的数组来实现和前面栈的实现比较类似，只是这里用了两个指针: 下面贴出代码： package aa; public class Queue { private Object[] data=null; private int maxSize;//队列的大小 private int front;//队头 private
Java_Stack_Queue:Java中使用链表的堆栈和队列实现
07-03
通过提供的Java_Stack_Queue-master文件，你可以找到具体实现这些功能的示例代码，进一步学习和实践链表实现的堆栈和队列。这个项目可能包括了测试用例，展示了如何使用这些自定义的数据结构来处理不同的问题。在...
Java实现栈和队列面试题
09-03
栈和队列是数据结构中的基础概念，它们在编程中有着广泛的应用，特别是在Java面试中常常被用来测试候选人的算法和...在面试中，候选人可能需要现场编写代码，实现这些功能，因此熟悉这些概念和实现方式是非常必要的。
linear_data_structures：我提供堆栈和队列接口的实现
02-15
标题"linear_data_structures：我提供堆栈和队列接口的实现"暗示了这个项目或代码库实现了这两种线性数据结构的接口。 栈（Stack）是一种后进先出（LIFO，Last In First Out）的数据结构。在栈中，最后加入的元素...
数据结构之堆栈和队列教程1.zip
01-02
数据结构是计算机科学中的核心概念，它涉及到如何有效地...通过学习和理解堆栈和队列，你可以更好地设计和实现高效的算法，解决实际问题。在后续的课程资源中，你将有机会深入实践，掌握这些基本数据结构的使用技巧。
用Java实现一个队列
01-10
用Java实现一个队列
用java实现的队列类
02-23
java2里面没有提供标准类对队列的支持，我就编写了一个用java实现的队列类。可以供参考。
java堆栈与队列
u014000832的专栏
04-15 1015
java中自带实现堆栈与队列的方法 堆栈
java堆栈和队列_java-栈和队列-算法
weixin_31591833的博客
02-16 274
1，栈的实现1.1 栈-链表实现//定义Node类public classNode {public String data="";Node next=null;publicNode(){data="THE-HEAD";}publicNode(String data){this.data=data;}}View Code//基础//空？//长度-用成员变量表示//操作//入栈//出栈//返回栈顶元素...
队列（Java实现）
weixin_44720982的博客
04-18 2080
Java数据结构之队列的实现
Java实现队列
m0_52012606的博客
01-22 403
什么是队列：凡是满足数据先进先出的数据结构都叫做队列。 数据一般存储在数组或链表中，所以实现队列可以用链表也可以用数组。 我们用最简单的数组来实现，队列模型如下图所示： 代码实现 public class duilie { private int[] arr = new int[10];// 定义数组用于存放数据, 模拟队列 int f = 0;// 入队列指针 int j = 0;// 出队列指针 // 入队列 public void add(int value) { .
JAVA堆栈实现队列编码
最新发布
10-12
在Java中，虽然标准库提供的是基于数组或链表的Queue接口实现（如LinkedList、ArrayDeque等），但如果你想手动利用堆栈数据结构实现队列，可以使用类似`Stack`的类，比如`Vector`或`ArrayDeque`。这里是一个简单的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值