链式存储结构，试着完成1-9九个数字的进栈和出栈的操作。

链式存储结构，试着完成1-9九个数字的进栈和出栈的操作。

方法比较无脑，懒得想了

import java.util.EmptyStackException;

public class LinkedStackTest {
    public static void main(String[] args) throws Exception {


        LinkedStack stack = new LinkedStack<>();
        
        //压入9个数字
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        stack.push(7);
        stack.push(8);
        stack.push(9);

        System.out.println("检测peek()方法 应该是最后压入栈中的9");
        System.out.println("---->"+stack.peek());
        System.out.println();

        //打印 查看栈
        System.out.println("===下面是最初状态===");
        System.out.println(stack);
        System.out.println();
        
        // 弹出5个
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();

        //查看栈
        System.out.println("===弹出5个元素===");
        System.out.println(stack);
        System.out.println();
        
        //弹出3个 
        stack.pop();
        stack.pop();
        stack.pop();
        
        //查看栈
        System.out.println("===弹出3个元素，剩下一个元素是最初压入栈中的1===");
        System.out.println(stack);


    }
}


class LinkedStack<E>{

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


        public E getE() {
            return e;
        }

        public void setE(E e) {
            this.e = e;
        }

        public Node getNext() {
            return next;
        }

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



        public Node(E e, Node next) {

            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this(e, null);
        }

        public Node() {
            this(null, null);
        }

        @Override
        public String toString() {
            return e.toString();
        }


    }
    //栈元素个数
    private int size;
    //头结点
    private Node dummyHead;
    //栈帧
    private Node top;


    public LinkedStack() {
        dummyHead = new Node(null,null);
        size = 0;
        top = dummyHead;
    }



    public boolean isEmpty() {
        return this.size == 0;
    }

        /**
        *@Description 参数是一个元素 方法体内新建一个node 添加在top指针之后 top指针移动
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 20:20
        */
    public void push(E e){

        Node node = new Node(e,null);
        top.next = node;

        top = top.next;
        size++;


    }

        /**
        *@Description 获得栈顶元素
        *@Return Object
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 20:21
        */
    public Object peek() throws Exception {
        if(isEmpty())
            new EmptyStackException();
        Object temp = top.getE();
        return temp;
    }

        /**
        *@Description 弹出元素，重新循环到top前一个node 令此节点为top 然后此top的next为null
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 20:22
        */
    public Object pop() throws Exception {
        if(isEmpty())
            new EmptyStackException();
        //获得此时的栈顶元素 保存
        Object temp = top.getE();
        //找一个新的node 来找到top前一个节点
        Node last = dummyHead.next;
        //循环的次数为size-2
        for (int i = 0 ; i < size-2 ; i++){
            last = last.next;
        }
        //令top为此节点
        top = last;
        //top的next为null 释放空间
        top.next = null;

        size--;

        return temp;
    }
    
        /**
        *@Description 从栈底循环到栈顶 打印元素
        *@Param
        *@Return 
        *@Author Mr.Lu
        *@Date 2021/5/17
        *@Time 20:30
        */
    @Override
    public String toString() {
        //创建一个sb
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node temp = dummyHead.next;
        while (temp != null){
            //如果是最后一个 就不需要|
            if (temp.next == null){
                sb.append(temp.getE());
            }
            else {
                sb.append(temp.getE());
                sb.append("|");
            }
            //指针移动
            temp = temp.next;

        }
        sb.append("]");
        return sb.toString();
    }
}