泛型链表实现、用链表实现栈——Java

链表

使用size记录数据量，方便编程

public class Linklist<E>{

    private class Node<E>{
        public  E e;
        public Node<E> next;

        /*
        构造函数
        */
        Node(E e,Node next){
            this.e=e;
            this.next=next;
        }
        Node(E e){
            this(e,null);
        }
        Node(){
            this(null,null);
        }
    }

    private Node<E> head;
    private int size;
    /*
    构造函数
    */
    public Linklist(){
        head=new Node<E>();
        size=0;
    }
    public int getSize(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    /*
    添加数据
    */
    public void add(int index,E e){
        if(index<0||index>size){
            throw new IllegalArgumentException("添加失败，下标不合法");
        }
        Node pre=head;
        while(index>0){
            pre=pre.next;
            index--;
        }
        //Node node=new Node(e);
        //node.next=pre.next;;
        //pre.next=node;
        pre.next=new Node(e,pre.next);
        size++;
    }//新数据索引为index
    public void addFirst(E e){
        add(0,e);
    }
    public void addLast(E e){
        add(size,e);//添加后下标为 当前size
    }
    /*
    获取数据
    */
    public E get(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("查看失败，下标不合法");
        }
        Node node=head.next;
        for(int i=0;i<index;i++){
            node=node.next;
        }
        return (E)node.e;
    }
    public E getFirst(){
        return get(0);
    }
    public E getLast(){
        return get(size-1);
    }
    /*
    更新数据
    */
    public void set(int index,E e){
        if(index<0||index>=size){
            throw new IllegalArgumentException("更新失败，下表不合法");
        }
        Node node=head.next;
        for(int i=0;i<index;i++){
            node=node.next;
        }
        node.e=e;
    }
    public void setFirst(E e){
        set(0,e);
    }
    public void setLast(E e){
        set(size-1,e);
    }
    /*
    查看是否包含某数据
    */
    public boolean contains(E e){
        Node node=head.next;
        for(int i=0;i<size;i++){
            if(node.e==e)
                return true;
            node=node.next;
        }
        return false;
    }
    /*
    删除元素
     */
    public E remove(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("删除失败，下标不合法");
        }
        Node pre=head;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        Node ret=pre.next;
        pre.next=ret.next;
        ret.next=null;//此节点用不到了 断开前后链接
        size--;
        return (E)ret.e;
    }
    public E removeFirst(){
        return remove(0);
    }
    public E removeLast(){
        return remove(size-1);
    }
    /*
    toString
    */
    public String toString(){
        StringBuilder res=new StringBuilder();
        res.append("head->");
        Node node=head.next;
        // while(node!=null){
        //     res.append(node.e+"->");
        //     node=node.next;
        // }
        for(int i=0;node!=null;i++){
            res.append(node.e+"->");
            node=node.next;
        }
        res.append("null");
        return res.toString();
    }
}

栈

接口：

public interface Stack<E> {
    void push(E e);
    E pop();
    E peek();
    int getSize();
    boolean isEmpty();
}

实现：

public class LinklistStack<E> implements Stack<E> {

    Linklist<E> linklist=new Linklist<>();

    @Override
    public void push(E e){
        linklist.addFirst(e);
    }
    @Override
    public E pop(){
        return linklist.removeFirst();
    }
    @Override
    public E peek(){
        return  linklist.getFirst();
    }
    @Override
    public int getSize(){
        return linklist.getSize();
    }
    @Override
    public boolean isEmpty(){
        return linklist.isEmpty();
    }
}