1.什么是栈

　　　　[1]. 栈是一种只能在一端进行插入和删除操作的线性表；插入：入栈（push）；删除：出栈（pop）；

　　　　[2]. 栈是按照“先进后出”（Last In First Out, LIFO）的原则存储数据；

　　　　　　　　 栈顶（Top）：允许删除和插入；

　　　　　　　　栈底（Botton） ；

　　　　[3]. 栈的分类：

静态栈：其核心是数组，类似于一个连续内存的数组，需要提前确定好栈的大小；

动态栈：其核心是链表，内存够用的前提下，可以无穷大，不连续；

　　　　[4]. 栈的表示：

1.1 栈的表示

2. 栈的基本操作

　　　　[1]. 栈的存储结构

　　　　[2]. 进栈

　　　　[3]. 出栈

　　　　[4]. 判断空，判断满

　　　　[5]. 栈的遍历

　　　　[6]. 清空栈

　　　　备注：静态栈参考【2.线性表——数组】

动态栈参考【2.线性表——链表】

3. 静态栈的代码实现

　　　　[1]. 静态栈的存储结构

public class MyStack {
    final int STACKSIZE = 5; // 声明栈的容量
    // 注意：final 的用法；
    public int bottom;
    public int top;
    public int[] arr;

    public MyStack() {
        bottom = top = -1;
        arr = new int[STACKSIZE];
    }
}

　　　　[2]. 静态栈的基本操作实现

package com.Stack;

/*
* 静态栈的基本操作：
*       1. 初始化，创建
*       2. 入栈
*       3. 出栈
*       4. 判断空;判断满；
*       5. 遍历
*       6. 清空
*
* */

public class DemoStack {
    // 判断满
    public static boolean isFull(MyStack stack){
        if(stack.top >= stack.STACKSIZE-1) // 利用数组构建的静态栈的下标是从0开始的
            return true;
        else
            return false;
        // 判断满，简写代码：return stack.top >= stack.STACKSIZE-1；
    }

    // 判断空
    public static boolean isEmpty(MyStack stack){
        if(stack.top == stack.bottom)
            return true;
        else
            return false;
        // 简写：return stack.top == stack.bottom；
    }

    // 进栈
    public static boolean poshStack(MyStack stack,int data){
        if(isFull(stack)){
            System.out.println("当前栈已满！");
            return false;
        }else{
            stack.arr[++stack.top] = data;
            return true;
        }
    }

    // 出栈
    public static boolean popStack(MyStack stack){
        if(isEmpty(stack)){
            System.out.println("当前栈为空！");
            return false;
        }else{
            System.out.println("栈顶元素出栈："+stack.arr[stack.top--]);
            return true;
        }
    }

    // 遍历输出
    public static boolean printOutStack(MyStack stack) {
        if(isEmpty(stack)){
            System.out.println("当前栈为空！无法输出");
            return false;
        }else{
            int length = stack.top - stack.bottom;
            System.out.print("栈遍历输出：");
            for(int i=length-1 ; i>=0; i--){
                System.out.print(stack.arr[i]+" ");
            }
            System.out.println("\n"+"==============分隔符===================");
            return true;
        }
    }

    // 清空栈
    public static boolean clearStack(MyStack stack){
        if(isEmpty(stack)){
            System.out.println("当前栈为空！");
            return false;
        }else{
/*           int length = stack.top - stack.bottom;
             for(int i=length-1 ; i>=0; i--){
                 stack.arr[i] = 0;
                 stack.top--;
            }*/
            stack.arr = null;// java内部会不定时的启动【垃圾回收机制】，对堆内存空间进行回收
            stack.top = stack.bottom = -1;
            return true;
        }
    }

    public static void main(String[] args) {
        MyStack stack = new MyStack();

        poshStack(stack,1);
        poshStack(stack,2);
        poshStack(stack,3);
        poshStack(stack,4);
        poshStack(stack,5);
        System.out.println("入栈后");
        printOutStack(stack);

        popStack(stack);
        popStack(stack);
        System.out.println("出栈后");
        printOutStack(stack);

        clearStack(stack);
        if(isEmpty(stack)){
            System.out.println("栈已清空 ！");
        }
        printOutStack(stack);
    }
}

　　　　[3]. 运行结果

4. 动态栈的代码实现（待更）

　　　　[1]. 动态栈的存储结构

　　　　[2]. 动态栈的基本操作实现

　　　　[3]. 运行结果

备注：学习过程中难免会出现很多错误，请大家指教！有问题可以直接评论我，谢谢！

原文地址：https://www.cnblogs.com/ZHOUsya/p/12642058.html