java单链表实现栈的功能(push、pop、peak)

package com.bigdata.datastructure.stack;

import java.util.Scanner;

/**
 * @ description: 单链表实现栈的功能
 * @ author: spencer
 * @ date: 2020/10/28 16:28
 */
public class LinkedStackDemo {

    public static void main(String[] args) {

        LinkedStack stack = new LinkedStack(5);
        String key = "";
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop){
            System.out.println("show:显示栈");
            System.out.println("exit:退出程序");
            System.out.println("push:添加数据到栈");
            System.out.println("pop:从栈中取出数据");
            System.out.println("peak:显示栈顶的数据");

            System.out.println("请输入你的选择：");
            key = scanner.next();

            switch (key){
                case "show":
                    System.out.println("================================");
                    stack.list();
                    System.out.println("================================");
                    break;
                case "push":
                    int value = scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        try {
                            int result = stack.pop();
                            System.out.println("出栈的数据是：" + result);
                        } catch (Exception e) {
                            System.out.println(e.getMessage());
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case "peak":
                    try {
                        int result = stack.peak();
                        System.out.println("栈顶数据是：" + result);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

    }
}

class LinkedStack{
    private int maxSize; // 栈大小
    private int numCount; // 栈内元素个数
    private Node top; // 栈顶元素

    public LinkedStack(int maxSize) {
        this.maxSize = maxSize;
        numCount = 0;
        top = null;
    }

    public void setTop(Node top) {
        this.top = top;
    }

    // 栈满
    public boolean isFull(){
        return maxSize == numCount;
    }

    // 栈空
    public boolean isEmpty(){
        return numCount == 0;
    }

    /**
     * 入栈
     * @param value
     */
    public void push(int value){
        if (isFull()){
            System.out.println("栈满，无法入栈");
            return;
        }
//        Node temp = top;
//        while (true){
//            if (temp.next == null){
//                break;
//            }
//            temp = temp.next; // 遍历链表，直到遍历完成退出
//            numCount++;
//        }
//        // 退出循环后，指针指向链表的最后
//        temp.next = node;
        top = new Node(value, top);
        numCount++;
    }

    /**
     * 出栈
     * @return
     */
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空，无法出栈");
        }

        int value = top.getNum(); // 获取栈顶元素
        top = top.next; // 指针后移
        numCount--;
        return value;
    }

    /**
     * 显示栈顶元素
     * @return
     */
    public int peak(){
        if (isEmpty()){
            throw new RuntimeException("栈为空，无法显示栈顶元素");
        }

        int value = top.getNum();
        return value;
    }

    /**
     * 显示栈中元素
     */
    public void list(){
        if (isEmpty()){
            System.out.println("栈空，无法显示数据");
            return;
        }

        Node temp = top; // 辅助变量，用来遍历链表
        while (temp.next != null){
            if (temp.next == null){
                break;
            }
            System.out.println(temp);
            temp = temp.next; // 指针后移
        }
        // 当链表中只有一个元素时，不需要循环，直接输出
        System.out.println(temp);

    }
}

class Node{
    public int num;
    public Node next;

    public Node(int num) {
        this.num = num;
    }

    public Node(int num, Node next) {
        this.num = num;
        this.next = next;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Node getNext() {
        return next;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "num=" + num +
                '}';
    }
}