Python 每日一记237>>>Java栈的实现

利用单向链表实现栈结构，注意栈是先进后出。

package mypackage;

import java.util.Iterator;
//栈类
class Stack<T> implements Iterable<T> {

    //节点类
    private static class Node<T> {
        T data;
        Node next;

        //构造方法
        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
//    成员变量,头节点，节点个数
    Node head;
    int  N;
//    构造方法
    public Stack(){
//        初始head不指向任何节点，元素个数为零
        this.head=new Node(null,null);
        this.N=0;
    }

//    节点个数
    public int size(){
        return N;
    }

    //  是否为空
    public boolean isempty (){
        return N==0;
    }

    //    压栈，即向链表中添加元素,注意因为栈是先进后出，每次添加节点应该都是添加在首节点后，再让新节点指向之前的第一个节点
//    第一次添加元素是让首节点指向新节点，接着再添加节点，就要让首节点指向新节点，新节点指向之前的第一个节点，依次类推
    public void push(T data){
        if (N==0){
            Node newnode=new Node(data,null);
            head.next=newnode;
            N++;
        }
        else {
            Node oldfirst=head.next;
            Node newnode=new Node(data,null);
            head.next=newnode;
            newnode.next=oldfirst;
            N++;
        }
    }

//    出栈
//    如果为空，则弹出null,
//    如果不为空，弹出head后的第一个元素，让head指向第二个元素
    public T pop() {
        Node oldfirst = head.next;
        if (oldfirst==null) {
            return null;
        }
        else {
            head.next = oldfirst.next;
            N--;
            return (T) oldfirst.data;
        }
    }

//    重写，用于遍历
    @Override
    public Iterator<T> iterator() {
        // 返回的Iterator对象，创建一个内部类实现这个接口
        return new SIterator();
    }

    //    创建一个内部类实现Iterator接口
    public class SIterator implements Iterator {
        //        定义一个遍历的节点
        private Node n;
        public SIterator(){
//            初始化为0索引位置
            this.n=head;
        }
        //重写两个方法
        @Override
        public boolean hasNext() {
//            这个方法判断是否超出最大索引，如果超出会停止遍历
            return n.next!=null;
        }

        @Override
        public Object next() {
//            这个方法会遍历得每个节点
            n=n.next;
            return n.data;
        }
    }
}

//测试
public class MyJava {

    public static void main(String[] args) {
        Stack<Integer> stack=new Stack<>();
//        压栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);

//        遍历
        System.out.println("压栈后元素如下：");
        for (Integer stack1:stack){
            System.out.println(stack1);
        }

//        元素个数
        System.out.println("元素个数为"+stack.size());

//        出栈
        System.out.println("弹出元素依次为：");
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());
        System.out.println(stack.pop());//没有元素还弹出，返回null

//        判断是否为空
        System.out.println("是否为空"+stack.isempty());
    }
}

结果：