数据结构-通过数组和单链表实现栈

1.栈的介绍

：
1）栈的英文名称（stack）
2) 栈是一个先进后出的有序列表
3) 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性结构。允许操作的一端称为栈顶，固定的一端称为栈底。
4）图解说明出栈和入栈的概念

2.栈的一些应用场景

1）子程序的调用：在跳往子程序之前，会先将下个指令的地址存放在堆栈中，直到子程序执行完后在将地址取出，已回到原来的程序中
2）处理递归调用：和子程序调用类似，只是除了存储下一个指令的地址外，也将参数，区域变量等数据存入到堆栈中。
3）表达式的转换（中缀表达式转后缀表达式）与求值
4）二叉树的遍历
5）图形的深度优先搜索法。

3.用数组实现栈
图解思路：

实际上在Jdk 中栈的底层实现使用的Vector数组

代码部分：

//数组实现栈--jdk 使用 vector实现的栈
public class ArrayImplStack {

    //栈空间大小
    public int maxSize;
    //栈顶
    public int top;
    //数组
    public Object[] arr;

    //初始化
    public ArrayImplStack(int maxSize) {
        this.maxSize = maxSize;
        this.arr = new Object[maxSize];
        this.top = -1;
    }

    //判断栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }

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

    //入栈
    public void push(Object obj){
        //判断是否满
        if(isFull()){
            throw new RuntimeException("栈存储已满");
        }
        //添加数据
        top++;
        arr[top] = obj;
    }

    //出栈
    public Object pop(){
        //判断栈是否为空
        if(isEmpty()){
            throw new EmptyStackException();
        }
        //出栈
        Object value = arr[top];
        top--;
        return value;
    }
    //展示栈
    public void list(){
        if(isEmpty()) {
            System.out.println("栈空，没有数据~~");
            return;
        }
        //循环遍历
        for (int i = top; i >-1 ; i--) {
            System.out.printf("stack[%d]=%d\n", i, arr[i]);
        }
    }
}

4用链表的方式实现栈

//链表节点
public class Node<E> {

    //数据
    public E e;
    //下个节点
    public Node<E> next;

    public Node() {
    }

    public Node(E e) {
        this.e = e;
    }
}

//使用单链表实现栈
public class SingleLinkedImplStack<E> {
    //创建头结点
    private Node<E> head = new Node<E>();
    //单链表长度
    private int size;

    //判断节点是否为空
    public boolean isEmpty() {
        return head.next == null;
    }

    //入栈
    public void push(E e) {
        //创建节点
        Node<E> eNode = new Node<>(e);
        //辅助指针
        Node<E> temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = eNode;
        size++;
    }

    //出栈
    public Object pop() {
        //判断链表是否为空
        if (isEmpty()) {
            throw new EmptyStackException();
        }
        //出栈,直接获取链表最后一个节点
        Node<E> eNode = getLastNode();
        //将最后一个节点的前一节点next 设置null
        getLastPreNode().next = null;
        size--;
        return eNode.e;
    }

    //获取栈长度
    public int size() {
        return size;
    }

    //获取最后一个节点
    public Node<E> getLastNode() {
        Node<E> temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        return temp;
    }
    //获取最后一个节点的前一个节点
    public Node<E> getLastPreNode() {
        Node<E> temp = head;
        while (true) {
            if (temp.next.next == null) {
                break;
            }
            temp = temp.next;
        }
        return temp;
    }
    //展示链表
    public void list() {
        //指向第一个节点
        Node<E> temp = head.next;
        if (isEmpty()) {
            System.out.println("栈空，没有数据~~");
            return;
        }
        while (true) {
            System.out.println(temp);
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
    }
}