链栈实现（java）

对于栈，有两种实现方式，一种是用数组来实现顺序栈，另外一种就是用链表的形式来实现；

链栈的好处就是，不用事先规定栈的大小，不用考虑栈满的情况；

链栈的定义方式大概是和单链表的定义是一样的；

我的想法是，还是先定义一个头节点，在创建好了这个头节点的基础上进行出栈或者入栈的操作；

另外一个就是需要一个top指针，让top一直都指向栈顶元素

对于单链表而言，每次都需要从单链表的头节点开始遍历，一直到链表的最后；

而栈的特点是：后进先出，也就是后面插入的元素，是先出栈的；

所以用单链表来构造链栈，入栈操作，就可以使用头插法，每一次插入元素都是在头节点后面第一个位置插入，这样每次遍历的时候，后面插入的元素都在链表的头部，也就是达到了后面插入的元素，都是先出栈的，满足了栈的要求；

栈的代码实现：

(包括出栈、入栈、判空、计算栈的元素总和、访问栈顶元素等基本操作)

class LinkedStack {

    private StackNode head = new StackNode(0);
    private StackNode top = head.next;

    //入栈
    public void push(StackNode node) {
        node.next = head.next;
        head.next = node;
        top = node;
        System.out.println("入栈成功");
    }
    //出栈
    public void pop() {
        if (top == null) {
            System.out.println("栈空，不能出栈");
            return;
        }
      //  int value = top.no;
        System.out.printf("出栈成功，栈顶元素为 %d\n",top.no);
        head.next = top.next;
        top = top.next;


    }
    //遍历栈
    public void list() {
        if (top == null) {
            System.out.println("栈空，无法进行遍历");
        } else {
            StackNode temp = head.next;
            System.out.println("出栈的顺序为：");
            while (temp != null) {
                System.out.printf("%d\t", temp.no);
                temp = temp.next;
            }
            System.out.println();
            System.out.println("遍历完毕");
        }

    }
    //判断栈空
    public void isEmpty() {
        if (top == null) {
            System.out.println("栈空");
        }
        else {
            System.out.println("栈不为空");
        }
    }
    //计算栈中的元素个数
    public void sumNode() {
        StackNode temp = head.next;
        int sum = 0;
        while (temp != null) {
            sum++;
            temp = temp.next;
        }
        System.out.printf("栈中的元素个数为：%d\n",sum);
    }
    //访问栈顶元素，但不出栈
    public void peek(){
        if (top == null) {
            System.out.println("栈空，不能访问栈顶元素");
            return;
        }
        System.out.printf("访问的当前栈顶元素为：%d\n",top.no);
    }

}



class StackNode {
    public int no;
    public StackNode next;

    //构造器
    public StackNode(int no) {
        this.no = no;
    }
}

测试类：

import java.util.Scanner;

public class LinkedListStack {
    public static void main(String[] args) {
        //测试一下链栈是否正确
        //先创建一个LinkedStack对象
        LinkedStack linkedStack = new LinkedStack();
        String key = "";
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);
        while (loop) {
            System.out.println("show: 表示显示栈");
            System.out.println("push: 表示入栈");
            System.out.println("pop: 表示出栈");
            System.out.println("peek: 表示显示栈顶元素");
            System.out.println("exit: 退出程序");
            System.out.println("isEmpty: 判断栈满");
            System.out.println("sum: 计算栈中个数");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    linkedStack.list();
                    break;
                case "push":
                    System.out.println("请输入需要入栈的元素：");
                    int value = scanner.nextInt();
                    StackNode node = new StackNode(value);
                    linkedStack.push(node);
                    break;
                case "pop":
                    linkedStack.pop();
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                case "peek":
                    linkedStack.peek();
                    break;
                case "isEmpty":
                    linkedStack.isEmpty();
                    break;
                case "sum":
                    linkedStack.sumNode();
                    break;
                default:
                    System.out.println("输入有误，请重新输入");
                    break;
            }
        }
        System.out.println("程序退出");

    }
}