堆栈和队列的java实现

原创 2015年11月19日 18:53:22

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到它们的长度总和,这个时候使用链式实现方法要更好。

版权声明:本文为博主原创文章,未经博主允许不得转载。

【数据结构】堆栈、队列的原理及java实现

栈(stack)又名堆栈,它是一种先进后出(FILO)的线性表。其限制是仅允许在表的一端进行插入和删除运算。 队列 是一种先进先出的线性表。其限制仅在表的一端(尾端)进行插入,另一端(首端)进行删除的...

java用链表实现堆栈和队列

链表是基本的数据结构,在C语言中的基本结构如下:         struct  List {                  int data;//数据                  s...
  • zzobin
  • zzobin
  • 2011年12月13日 22:43
  • 4328

java中堆栈和队列的实现方式

java中堆栈和队列的实现方式队列和栈区别:队列先进先出,栈先进后出。 队列的实现—利用Queue接口 堆栈的实现—利用Deque接口 使用ArrayDeque类实例化队列和栈 队列的实现—利用Que...

Java中链表、堆栈、队列、二叉树、散列表等数据结构的实现

温习数据结构:Java中链表、堆栈、队列、二叉树、散列表等数据结构的实现 1.Java链表类List的源代码如下: import java.io.*;  public class Lis...
  • adxcq
  • adxcq
  • 2014年07月02日 10:08
  • 1327

用堆栈实现模拟队列

  • 2013年11月24日 21:41
  • 23KB
  • 下载

C#实现冒泡堆栈队列

  • 2011年11月23日 15:43
  • 74KB
  • 下载

java LinkedList 堆栈队列

package com.hao947.p004.Collection.LinkedList; import java.util.*; public class LinkStack { publi...
  • hao947
  • hao947
  • 2013年10月06日 14:02
  • 555

java数据结构链表,堆栈,队列,串相关专题分析与扯谈-概述

这几天看了java的数据结构相关,深有感触,也因此接触到了堆栈 ,表,队列等储存结构,它们分别都有相应的顺序结构和离散结构,我打算针对这些内容写一个系列专题博客吧我是第一次在csdn写博客,可能有地方...

java 使用LinkedList模拟一个堆栈或者队列数据结构

java 使用LinkedList模拟一个堆栈或者队列数据结构

java堆栈与队列

java中自带实现堆栈与队列的方法 堆栈
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:堆栈和队列的java实现
举报原因:
原因补充:

(最多只允许输入30个字)