使用带头结点的单向链表模拟栈

package com.zzb.stack;

import java.io.Serializable;
import java.util.Scanner;

/**
 * @Auther: Administrator
 * @Date: 2020/1/21 12:50
 * @Description: 使用 带头结点的单向链表 模拟 栈 数据结构
 * （1）栈是一个先入后出(FILO-First In Last Out)的有序列表
 * （2）栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的
 *  一端，为变化的一端，称为栈顶(Top)另一端为固定的一端，称为栈底(Bottom)
 *  （3）根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元
 *  素最先删除，最先放入的元素最后删除
 *
 *  技巧：
 *  压栈时采用头插法
 */
public class SingleLinkedListStackTest {
    public static void main(String[] args) {
        // 创建栈
        SingleLinkedListStack stack = new SingleLinkedListStack();
        // 接受用户输入
        String order = "";
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        while(loop) {
            System.out.println("---------------push：添加数据到栈----------------");
            System.out.println("---------------pop：从栈中获取数据---------------");
            System.out.println("---------------show：遍历栈---------------------");
            System.out.println("---------------top：查看栈顶数据-------------");
            System.out.println("---------------exit：退出程序----------------------");
            // 接收一个字符
            order = scanner.next();
            switch(order) {
                case "push":
                    System.out.println("输入一个数据");
                    int data = scanner.nextInt();
                    stack.push(new Node(data));
                    break;
                case "pop":
                    Node pop = stack.pop();
                    System.out.println("获取的数据为  " + pop);
                    break;
                case "show":
                    stack.show();
                    break;
                case "top":
                    Node top = stack.top();
                    System.out.println("队列的头部数据为  " + top);
                    break;
                case "exit":
                    loop = false;
                    scanner.close();
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

// 带头结点的单向链表模拟栈
class SingleLinkedListStack{
    private SingleLinkedList singleLinkedList = new SingleLinkedList();

    // 压栈 push
    // 头插法
    public void push(Node node) {
        this.singleLinkedList.add(node);
    }

    // 弹栈 pop
    public Node pop() {
        return this.singleLinkedList.get();
    }

    // 遍历栈
    public void show() {
        this.singleLinkedList.show();
    }

    // 获取栈顶元素
    public Node top() {
        return this.singleLinkedList.top();
    }
}

// 带头结点的单向链表类
class SingleLinkedList{
    // 头结点，初始化时不代表真实节点对象
    // 弹栈 之后 head属性变量会指向真实节点对象
    // head 属性变量 总是 指向 要被获取元素 的 前一个位置
    private Node head = new Node(-1);

    // 压栈 push
    // 头插法
    public void add(Node node) {
        Node temp = this.head.getNext();
        this.head.setNext(node);
        node.setNext(temp);
    }

    // 弹栈
    public Node get() {
        if(this.head.getNext() == null) {
            return null;
        }
        this.head = this.head.getNext();
        if(head != null) {
            return head;
        }
        return null;
    }

    // 遍历栈
    public void show() {
        // 判断栈是否为空
        if(this.head.getNext() == null) {
            System.out.println("空栈！");
            return;
        }
        Node temp = this.head.getNext();
        while(true) {
            if(temp == null) {
                break;
            }
            System.out.println(temp);
            temp = temp.getNext();
        }
    }

    // 获取栈顶元素
    public Node top() {
        return this.head.getNext();
    }

    public Node getHead() {
        return head;
    }

    public void setHead(Node head) {
        this.head = head;
    }
}

// 节点类
class Node implements Serializable{
    private static final long serialVersionUID = 6336166902396505533L;
    private int id;
    private Node next;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Node getNext() {
        return next;
    }

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

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