【数据结构与算法（Java描述）】单链表，实现栈与队列

来源于书籍《数据结构与算法（Java描述）》邓俊辉 著 机械工业出版社

链表

前面我们介绍了栈与队列的 ADT，并利用数组加以实现。遗憾的是，尽管这种实现简单明了，但由于数组长度必须固定，在空间效率及适应性方面还存在不足。本节将介绍一种基于链表的实现，以消除上述缺陷。

java实现单链表

public interface Position {
    
    
    //返回该位置存放的元素
    Object getElem();
    //给定元素存放至该位置，返回之前该位置的元素
    Object setElem(Object e);
}

/**
 * @Auther: 
 * @Date: 2020/8/6 17:47
 * @Description:单向链表
 */
public class Node implements Position{
    
    

    private Object element;//数据对象
    private Node next;//后继节点

    /*************构造函数********************/
    public Node(){
    
    
        this(null,null);
    }

    public Node(Object obj,Node n){
    
    
        element=obj;
        next=n;
    }

    /************Position接口的方法***********/
    //返回该位置存放的元素
    @Override
    public Object getElem() {
    
    
        return element;
    }
    //给定元素存放至该位置，返回之前该位置的元素
    @Override
    public Object setElem(Object e) {
    
    
        Object old=element;
        element=e;
        return old;
    }


    public Node getNext() {
    
    
        return next;
    }

    public void setNext(Node next) {
    
    
        this.next = next;
    }
}

单链表实现栈

public class StackByList implements Stack {
    
    
    protected Node top;//栈顶元素
    protected int size;//栈中元素数目

    //构造方法，空栈
    public StackByList(){
    
    
        top=null;
        size=0;
    }


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

    @Override
    public boolean isEmpty() {
    
    
        return top==null?true:false;
    }

    @Override
    public Object top() throws StackEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new StackEmptyException("stack is empty!");
        }
        return top.getElem();
    }

    @Override
    public Object pop() throws StackEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new StackEmptyException("stack is empty!");
        }
        Object ele=top.getElem();
        top=top.getNext();
        size--;
        return ele;
    }

    //压栈
    @Override
    public void push(Object ele) {
    
    
        Node newNode=new Node(ele,top);//创建新节点，首节点处插入
        top=newNode;//首节点引用新节点
        size++;//规模增大
    }
}

单链表实现队列

public class QueueByList implements Queue {
    
    
    protected Node head;//队首
    protected Node tail;//队尾
    protected int size;


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

    @Override
    public boolean isEmpty() {
    
    
        return (0==size)?true:false;
    }

    @Override
    public Object front() throws QueueEmptyException {
    
    
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        return head.getElem();
    }

    @Override
    public void enqueue(Object obj) throws QueueFullException {
    
    
        //新节点作为末节点插入
        Node node=new Node(obj,null);
        if(0==size) head=node;//栈空直接插入
        else tail.setNext(node);//否则，将新节点连接至末端
        tail=node;//更新末端引用
        size++;
    }

    @Override
    public Object dequeue() throws QueueEmptyException {
    
    
        Object ele;
        if(isEmpty()){
    
    
            throw new QueueEmptyException("Queue is empty!");
        }
        ele=head.getElem();
        head=head.getNext();
        size--;
        if(size==0) tail=null;//若队列已空，需将tail指向null
        return ele;
    }

    @Override
    public void Traversal() {
    
    
        Node p=head;
        while (null!=p){
    
    
            System.out.println(p.getElem()+" ");
            p=p.getNext();
        }
    }
}