栈原理及实现

栈(stack) 必须遵守元素先进后出的规定，如果不遵守就不是栈了！栈也称为后进先出表。

栈作为数据结构，是一种只能在一端进行插入和删除操作的特殊线性表 。

先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。
允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。

栈的具体实现

栈是一种 "特殊" 的线性存储结构，因此栈的具体实现有以下两种方式：

顺序栈:  采用顺序存储结构可 以模拟栈存储数据的特点，从而实现栈存储结构；(数组实现)

链栈: 采用链式存储结构实现栈结构；(链表实现)

栈的应用

回退，括号匹配，进制转换

顺序栈的基本实现

java代码实现(可运行)

/**
 * @author 阿康
 * @ClassName: Stack
 */
public class Stack1 {

    /**
     * 测试
     */
    public static void main(String[] args) {
        StackOrder stackLower = new StackOrder(5);
        for (int i = 0; i < 6; i++) {
            boolean push = stackLower.push(i);
            System.out.println(push);
        }
        for (int i = 0; i < 6; i++) {
            int pop = stackLower.pop();
            System.out.println(pop);
        }
        stackLower.disPlay();
    }

}

/**
 * 顺序结构栈
 */
class StackOrder {

    int maxSize;
    int top;
    int[] arr;

    public StackOrder(int size) {
        this.maxSize = size;
        this.top = -1;
        arr = new int[size];
    }

    public boolean push(int data) {
        if (top == maxSize - 1) {
            System.out.println("满栈!");
            return false;
        }
        arr[++top] = data;
        return true;
    }

    public int pop() {
        if (top == -1) {
            System.out.println("空栈!");
            return -1;
        }
        return arr[top--];
    }

    public void disPlay () {
        for (int value : arr) {
            System.out.println(value);
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public boolean isFull() {
        return top == maxSize-1;
    }

}

链栈的基本实现

Java代码(可运行)

/**
 * @author 阿康
 * @ClassName: 链栈的实现
 */
public class Stack<T> {

    /**
     * 定义Node节点
     * @param <T> 泛型
     */
    static class Node<T> {
        public T data;
        public Node<T> next;
    }

    /** 栈底指针 */
    private  Node<T> bottom;
    /** 栈顶指针 */
    private  Node<T> top;
    /** 栈当前大小 */
    private static Integer size;

    /**
     * 初始化
     */
    public Stack() {
        bottom = top = new Node<>();
        top.next = bottom;
        size = 0;
    }

    /**
     * 是否空
     */
    public boolean isEmpty() {
        return top.next == bottom;
    }

    /**
     * 入栈
     */
    public void pushStack(T element) {
        Node<T> temp = new Node<>();
        temp.data = element;
        //第一次入栈操作
        if (top.next == bottom) {
            temp.next = bottom;
        } else {
            temp.next = top.next;
        }
        top.next = temp;
        size++;
    }

    /**
     * 出栈
     */
    public void popStack() {
        if (isEmpty()) {
            System.out.println("栈中没有元素！");
        } else {
            System.out.println("出栈操作：" + top.next.data + " ");
            top.next = top.next.next;
        }
        size--;
    }

    /**
     * 元素个数
     */
    public int sizeStack() {
        return size;
    }

    /**
     * 查看顶部值
     */
    public void getTop() {
        System.out.println("顶部值：" + top.next.data);
    }

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        System.out.println(stack.isEmpty()+"");
        stack.pushStack(2);
        stack.pushStack(4);
        stack.pushStack(6);
        stack.popStack();
        stack.popStack();
        stack.popStack();
        stack.popStack();

    }
}