栈的实现

栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作。
栈的特性：后进先出

栈主要分为两类：

• 静态栈
• 动态栈

【静态栈】

静态栈的核心是数组，类似于一个连续内存的数组，我们只能操作其栈顶元素。

【动态栈】

动态栈的核心是链表，在内存中可以不连续，我们只能操作其栈顶结点。

以下代码是用链表实现的动态栈：

1.双向链表类

public class DoubleLinkedList<T> implements MyList<T>{
    protected ListNode<T> first=new ListNode<T>();
    protected ListNode<T> last=new ListNode<T>();
    private int size=0;
    
    public DoubleLinkedList()
    {
        first.next=last;
        last.pre=first;
    }
    
    @Override
    public void add(T element) {
        ListNode<T> newNode=new ListNode<T>(element);
        last.pre.next=newNode;
        newNode.pre=last.pre;
        newNode.next=last;
        last.pre=newNode;
        size++;
    }

    @Override
    public void delete(T element) {
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(p.data.equals(element))
            {
                p.pre.next=p.next;
                p.next.pre=p.pre;
                size--;
                return ;
            }
            p=p.next;
        }
        
    }

    @Override
    public void delete(int index) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=last)
        {
            if(i==index)
            {
                p.pre.next=p.next;
                p.next.pre=p.pre;
                p.pre=null;
                p.next=null;
                size--;
                return ;
            }
            p=p.next;
            i++;
        }
        
    }

    @Override
    public void update(int index, T newelement) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(i==index)
            {
                p.data=newelement;
            }
            p=p.next;
            i++;
        }
        
        
    }

    @Override
    public boolean contains(T element) {
        return indexOf(element)>=0;
    }

    @Override
    public T at(int index) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(i==index)
            {
                return (T) p.data;
            }
            p=p.next;
            i++;
        }
        return null;
    }

    @Override
    public int indexOf(T element) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(p.data.equals(element))
            {
                return i;
            }
            p=p.next;
            i++;
        }
        return -1;
    }
    
    @Override
    public String toString()
    {
        StringBuilder sb=new StringBuilder("[");
        ListNode<T> p=first.next;
        while(p!=last)
        {
            sb.append(p.data+(p.next!=last?",":""));
            
            p=p.next;
        }
        sb.append("]");
        return sb.toString();
    }

    public int getSize()
    {
        return this.size;
    }
    
    public void setSize(int size) {
        this.size=size;
    }
}

2.双向链表的接口：

public interface MyList<T>{
    //新增一个元素
    void add(T element);
    //删除与输入元素相同的元素
    void delete(T element);
    //根据索引删除元素
    void delete(int index);
    //更新元素
    void update(int index,T newelement);
    //查询1
    boolean contains(T element);
    
    T at(int index);
    
    int indexOf(T element);
}

3.结点类：

public class ListNode<T> {
      T data;
      ListNode<T> pre; //前驱结点
      ListNode<T> next; //后驱结点
    
    public ListNode()
    {
        
    }
    public ListNode(T element)
    {
        this.data=element;
    }
    
    
}

4.栈的接口

public interface IStack<T>{

    //元素入栈
    void push(T e);
    
    //弹出栈顶
    T pop();
    
    //是否为空
    boolean isEmpty();
    
    //查看栈顶元素
    T peek();
    
    //栈内元素个数 
    int getSize();
    
}

5.栈类

import java.util.EmptyStackException;

public class MyStack<T> extends DoubleLinkedList<T> implements IStack<T>{

    @Override
    public void push(T e) {
        super.add(e);
        
    }

    @Override
    public T pop() {
        if(getSize()<=0) throw new EmptyStackException();
        ListNode<T> the=last.pre;
        T value=(T) the.data;
        super.delete(getSize()-1);
        return value;
        
    }

    @Override
    public boolean isEmpty() {
        
        return getSize()>0;
    }
    
    @Override
    public T peek() {
        if(getSize()<=0) throw new EmptyStackException();
        return (T) last.pre.data;
    }

    public int getSize()
    {
        return super.getSize();
    }

    
}