栈的简单实现--Java

​ 线性表_栈

定义：栈是一种基于先进后出(FILO)的数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。

我们称数据进入到栈的动作为压栈，数据从栈中出去的动作为弹栈。

栈的实现

import java.util.Iterator;

public class Stack<T> implements Iterable<T>{
    //记录首结点
    private Node<T> head;
    //记录栈中的元素个数
    private int N;


    //定义结点类
    private class Node<T>{
        private T item;
        private Node<T> next;

        public Node(T item, Node<T> next) {
            this.item = item;
            this.next = next;
        }
    }

    public Stack(){
        this.head=new Node<>(null,null);
    }

    //判断当前栈是否为空
    public boolean isEmpty(){
        return N==0;
    }

    //获取栈中元素的个数
    public int size(){
        return N;
    }

    //将元素压栈
    public void push(T t){
        Node<T> newNode=new Node<>(t,null);
        //栈中第一个
        Node<T> firstNode=head.next;
        //让head指向新结点newNode
        head.next=newNode;
        //让新节点指向第一个结点
        newNode.next=firstNode;
        //元素个数加一
        N++;
    }

    //将元素弹栈
    public T pop(){
        //找到栈的第一个元素
        Node<T> firstNode=head.next;
        if (firstNode==null){
            return null;
        }
        //找到栈的第二个元素
        //将head下一个指向secondNode
        head.next= firstNode.next;
        N--;
        return firstNode.item;
    }


    @Override
    public Iterator<T> iterator() {
        return new StackIterator();
    }

    private class StackIterator implements Iterator<T>{

        Node<T> first=head;

        @Override
        public boolean hasNext() {
            return first.next!=null;
        }

        @Override
        public T next() {
            first=first.next;
            return first.item;
        }
    }
}