用数组模拟栈结构

栈的特点

(Stack)是一种线性存储结构，它具有如下特点：

栈中的数据元素遵守”后进先出”(First In Last Out)的原则，简称FILO结构。限定只能在栈顶进行插入和删除操作。

数组实现

package stack;

/**
 * 使用数组模拟栈
 * top ：表示栈顶，初始化默认为-1
 * 入栈：top++ ，stack[top] = data
 * 出栈：val = stack[top --] ,return val
 */
public class ArrayStack {
    private int maxSize;//栈的大小
    private int[] stack;//数组模拟栈
    private int top = -1;//栈底，初始化为-1

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.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;
        }
        top++;
        stack[top] = value;
    }

    public int pop() {
        //判空？
        if (isEmpty()) {
            throw new RuntimeException("无数据！！");
        }
        int val = stack[top];
        top--;
        return val;
    }

    //遍历栈
    public void list() {
        //判空？
        if (isEmpty()) {
            System.out.println("无数据！！");
            return;
        }
        for (int i = top; i > -1; i--) {
            System.out.println("stack[" + i + "]=" + stack[i]);
        }
    }
        //返回当前栈顶的值，不是pop
    public int peek(){
        return stack[top];
    }
}

链表实现

节点信息：

class Node {
    //存放数值
    private int val;
    private Node next;

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

    public int getVal() {
        return val;
    }

    public void setVal(int val) {
        this.val = val;
    }

    public Node getNext() {
        return next;
    }

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

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

实现：

package stack;

import java.util.Stack;

/**
 * @author ASUS
 * @Date 2020/5/29 17:16
 * @Version 1.0.0
 */
//使用单链表实现栈
public class LinkedListStack {
    Node first = new Node(-1);
    Node top = first;

    //栈空
    public boolean isEmpty() {
        return first.getNext() == null;
    }

    //入栈
    public void push(int value) {
        Node newNode = new Node(value);
        top.setNext(newNode);
        top = top.getNext();
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("无数据！！");
        }
        Node cur = first;
        //循环跳出，cur位于top之前
        while (true) {
            if (cur.getNext() == top) {
                break;
            }
            cur = cur.getNext();
        }
        int value = top.getVal();
        cur.setNext(null);
        top = cur;
        return value;
    }

    //遍历栈
    public void list() {
        //判空？
        if (isEmpty()) {
            System.out.println("无数据！！");
            return;
        }
        Stack<Node> stack = new Stack<>();
        Node cur = first.getNext();
        while (cur != null) {
            stack.push(cur);
            cur = cur.getNext();//cur后移，遍历链表
        }
        while (stack.size() > 0) {
            //顺序出栈，依次打印
            System.out.println(stack.pop());
        }
    }
}