datastructure：链表模拟栈

import java.util.Scanner;

public class LinkedStackTest {
    public static void main(String[] args) {
        LinkedStack linkedStack = new LinkedStack(4);
        String key = "";
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);
        while (loop) {
            System.out.println("display:显示栈");
            System.out.println("push:入栈数据");
            System.out.println("pop:出栈数据");
            System.out.println("exit:退出程序");

            System.out.println("请输入对应的指令：");
            key = scanner.next();

            switch (key) {
                case "display":
                    linkedStack.display();
                    break;
                case "push":
                    System.out.println("输入要入栈的数据：");
                    int value = scanner.nextInt();
                    linkedStack.push(value);
                    break;
                case "pop":
                    try {
                        System.out.println("出栈的数据是：" + linkedStack.pop());
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    // 关闭文件流
                    scanner.close();
                    loop = false;
                    break;
                default:
                    System.out.println("输入的指令有误！");
                    break;
            }
        }
        System.out.println("程序退出了。");
    }
}

// 定义一个LinkedStack表示栈
class LinkedStack {
    // 定义栈的大小
    private int maxSize;
    // 用数组模拟栈，数据放在数组中
    private LinkedNode head;
    // top表示栈顶，初始化为-1
    private int top = -1;

    public LinkedStack(int maxSize) {
        this.maxSize = maxSize;
    }

    // 栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //入栈
    public void push(int value) {
        if (isFull()) {
            System.out.println("栈已满，不能入栈！");
            return;
        }
        // 根据数据创建一个结点
        LinkedNode node = new LinkedNode(value);
        // 链表中元素新增了一个
        top++;
        // 如果头元素是null，让新元素当作第一个元素
        if (head == null) {
            head = node;
            return;
        }
        // 头元素不是null，表明链表中已有元素，添加新元素
        LinkedNode temp = head;
        // 获取链条的尾部
        while (temp.getNext() != null) {
            temp = temp.getNext();
        }
        // 将结点添加到链条尾部
        temp.setNext(node);
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            // 有返回栈，建议抛出异常
            throw new RuntimeException("栈已空，不能出栈！");
        }
        top--;

        LinkedNode temp = head;
        // 链条中只有一个元素
        if (head.getNext() == null) {
            head = null;
            return temp.getValue();
        }
        // 链表中有不止一个元素
        while (temp.getNext().getNext() != null) {
            temp = temp.getNext();
        }
        //退出循环时说明已经找到top结点的前一个结点
        //删除top结点
        int res = temp.getNext().getValue();
        temp.setNext(null);
        return res;
    }

    //显示栈
    public void display() {
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表为空!");
            return;
        }
        // 思路：判断出链表不为空，遍历链表，将每个元素放在新链表的第一个位置上
        // 新的链表头结点
        LinkedNode newHead = null;
        LinkedNode oldHead = head;

        while (oldHead != null) {
            // 把原链表头结点上的数据放在新的结点上
            LinkedNode node = new LinkedNode(oldHead.getValue());

            // 代码合并，头插法。执行效果是：如果新链表的头结点是空，把新的结点作为头结点；否则加在头结点前面
            if (newHead != null) {
                node.setNext(newHead);
            }
            // 把newHead放在新链表的最前面
            newHead = node;

            // 移动原链表的头结点到后面的位置上
            oldHead = oldHead.getNext();
        }

        // 遍历新链表，依次输出每一个数据
        while (newHead != null) {
            System.out.println(newHead.getValue());
            newHead = newHead.getNext();
        }
    }
}

//定义LinkedNode，每个LinkedNode对象就是一个结点
class LinkedNode {
    private int value;
    private LinkedNode next;

    public LinkedNode(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

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

    public LinkedNode getNext() {
        return next;
    }

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