Java栈的实现

栈的定义

栈是限定仅在表的一端进行操作的线性表。 允许进行插入和删除元素操作的这一端称为栈顶，固定不变的另一端称为栈底。由于只能在栈顶进行插入和删除操作，所以栈中元素的最大特点就是 “先进后出”，即先入栈的元素在后面出栈。
栈分为顺序栈与链式栈。

栈的基本操作

1. 栈初始化：生成一个空栈；
2. 判断栈空与栈满：判断栈中元素是否为空或者满；
3. 入栈：向栈中添加元素；
4. 出栈：删除栈中元素；
5. 读取栈顶元素：获取栈顶元素。

利用Java泛型实现顺序栈

//顺序栈
public class Mystack<T> {
    private T[] stack;//存放元素
    private int size;//记录栈的元素个数
    private final int DEFAULT_SIZE=10;//初始化默认大小为10

    public Mystack() {
        size = 0;
        stack = (T[]) new Object[DEFAULT_SIZE];
    }

    //判断栈是否为空
    public boolean isEmpty() {
        if (size <= 0)
            return true;
        else
            return false;
    }

    //判断栈是否已满
    public boolean isFull() {
        if (size >= stack.length)
            return true;
        else
            return false;
    }
    //入栈
    public void push(T value) {
        if (isFull())
            return;
        stack[size++] = value;
    }

    //出栈
    public void pop() {
        if (isEmpty())
            return;
        stack[size - 1] = null;
        size--;
    }

    //获取栈顶元素
    public T getTop() {
        return stack[size - 1];
    }

}

以下为测试代码：

 public static void main(String[] args){

        Mystack<Integer> mystack = new Mystack<>();
        System.out.println("栈是否为空" + mystack.isEmpty());
        mystack.push(1);
        mystack.push(2);
        mystack.push(3);
        System.out.println("栈顶元素为" + mystack.getTop());
        mystack.pop();
        System.out.println("出栈后栈顶元素为" + mystack.getTop());
        
    }

测试结果为：

链栈的实现

public class LinkStack<T> {
    //节点类
    static class Entry {
        private Object value;
        private Entry next;

        public Entry() {

        }

        public Entry(Object value) {
            this.value = value;
            next = null;
        }

        public Object getValue() {
            return value;
        }

        public void setValue(Object value) {
            this.value = value;
        }

        public Entry getNext() {
            return next;
        }

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

    private Entry head;//头节点
    private Entry tailflag;//尾节点

    public LinkStack() {
        head = new Entry();
        tailflag = head;
    }

    //尾部入栈
    public void pushtail(T value) {
        Entry newEntry = new Entry(value);
        tailflag.setNext(newEntry);
        tailflag = newEntry;
    }

    //尾部出栈
    public void poptail() {
        tailflag.setValue(null);
        Entry p = head;
        while (p.getNext() != tailflag) {
            p = p.getNext();
        }
        tailflag = p;
        p.setNext(null);
    }

    //头部入栈
    public void pushhead(T value) {
        Entry newEntry = new Entry(value);
        if (head.getNext() == null)
            head.setNext(newEntry);
        else {
            newEntry.setNext(head.getNext());
            head.setNext(newEntry);
        }
    }

    //头部出栈
    public void pophead() {
        if (head.getNext() == null)
            return;
        else {
            head.getNext().setValue(null);
            head.setNext(head.getNext().getNext());
        }
    }

    //获取头部元素
    public T getHead() {
        return (T) head.getNext().value;
    }

    //获取尾部元素
    public T getTail() {
        return (T) tailflag.value;
    }
}

以下为测试代码：

public static void main(String[] args) {
        LinkStack<Integer> mystack = new LinkStack<>();
        mystack.pushtail(1);
        mystack.pushtail(2);
        mystack.pushtail(3);
        System.out.println("尾部元素为"+mystack.getTail());
        System.out.println("头部元素为"+mystack.getHead());
        mystack.pushhead(4);
        mystack.pushhead(5);
        mystack.pushhead(6);
        System.out.println("尾部元素为"+mystack.getTail());
        System.out.println("头部元素为"+mystack.getHead());
    }

测试结果：