栈

栈（stack）

一个先入后出的有序列表

允许插入删除的一端为栈顶，固定的另一端为栈底

应用场景：

子程序的调用

处理递归调用

表达式的转换（中缀表达式转后缀表达式）与求值

二叉树的遍历

图形的深度优先搜索法

数组实现栈的思路：

1） 定义一个top表示栈顶，初始化为-1

2） 入栈：top++; stack[top] = data

3） 出栈：int value = stack[top]; top–; return value;

用单链表来实现栈的模拟：

package com.dataStructure;

import java.util.Scanner;

public class stack {
    public static void main(String[] args){
        ListStack listStack = new ListStack();
        listStack.setMaxSize(3);

        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while(loop){
            System.out.println("push为入栈");
            System.out.println("pop为出栈");
            System.out.println("show为展示栈内容");
            System.out.println("exit为退出程序");
            System.out.println("输入你的选择！");
            String key = scanner.next();
            switch(key){
                case "push":
                    System.out.println("输入一个数");
                    int value = scanner.nextInt();
                    NodeStack inputNode = new NodeStack(value);
                    listStack.push(inputNode);
                    break;
                case "pop":
                    listStack.pop();
                    break;
                case "show":
                    listStack.show();
                    break;
                case "exit":
                    loop = false;
                    scanner.close();
                    break;
            }

        }

    }
}

class NodeStack{
    int value;
    NodeStack next;

    public NodeStack(int i){
        this.value = i;
    }

    @Override
    public String toString(){
        return "Node's value is "+value;
    }
}

class ListStack{
    NodeStack head = new NodeStack(0);
    int MaxSize;

    void setMaxSize(int i){
        this.MaxSize = i;
    }

    boolean isMax(){
        NodeStack temp = head;
        int count = 0;
        while(true){
            if (temp.next == null){break;}
            temp = temp.next;       //找到要加入的位置
            count++;
        }
        if (MaxSize>count){
            return false;
        }
        else {
            return true;
        }
    }

    boolean isEmpty(){
        if(head.next == null){
            return true;
        }else{
            return false;
        }
    }

    void push(NodeStack input) {
        NodeStack temp = head;
        if (isMax()) {
            System.out.println("栈满，请爬！");
            return;
        } else {
            while (true) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            temp.next = input;
        }
    }



    void pop(){
        //出栈只能从最尾部出
        NodeStack temp = head;
        if(isEmpty()){return;}
        while(true){
            if(temp.next.next == null){break;}
            temp = temp.next;       //找到要加入的位置

        }
        System.out.println("出栈的元素是"+ temp.next.value);
        temp.next = null;
    }

    void show(){
        NodeStack temp = head.next;
        while(true){
            System.out.println("栈中的值为"+temp.value);
            if(temp.next == null){
                break;
            }
            temp = temp.next;

        }
    }

}