数据结构--栈

一、什么是栈？
在古代栈是牲口棚的意思，在计算机中栈是一种机制；
栈机制：后进先出（LIFO：last in first out）

栈要素：栈底 和 栈顶，先入栈的为 栈底 和后入栈的为 栈顶 ；

建立栈：初始化栈空间，给定一个栈的容量，即栈顶
删除栈：回收栈空间内存
判断栈是否为空：根据栈中已有元素的个数，判断栈是否为空，为空返回true，不为空返回false
判断栈是否已满：根据 栈的容量 和 当前栈的长度 判断栈是否已经满员，为满返回true，不满返回false
清空栈元素：直接将栈顶置为0,
获取栈长度：由于栈顶会随着栈的长度改变而改变因此，能够直接使用栈顶获取栈的长度　　
入栈：首先对栈进行判满，而后将入参赋值给处于栈顶的那个元素（由于栈顶所指向的内存是一直为空的，因此能够直接赋值给栈顶），以后栈顶自增
出栈：首先对栈进行判空，而后将栈顶自减。

注：此处的出栈其实并不是删除元素所在内存，只是栈的最后一个元素（栈的长度）再也不指向那个元素，当再次添加元素的时候会覆盖掉以前出栈的元素

若是要返回入出栈的值，又不用入参，能够使用object类型，而后若是栈是空的，则进行throw操做，抛出异常，不过在调用的时候就要用try{}cache{}进行捕获异常了
遍历栈元素：可从栈底向栈顶遍历，也可从栈顶向栈底遍历，

下方为建立栈结构的代码：

package util;

public class MyStack {

    // 栈的容量大小
    private int myStackSize;
    // 栈顶，即栈的长度
    private int myStackTop;
    // 栈自己
    public Object[] myStack;

    public MyStack() {
        super();
    }

    /**
     * 初始化栈空间
     * @param size 栈的 容量大小
     */
    public MyStack(int size)
    {
        myStackSize = size;
        // 申请内存
        myStack = new Object[size];
        myStackTop = 0;
    }
    
    public void delStack()
    {
        myStack = null;
    }

    /**
     * 栈是否为空
     * @return
     */
    public boolean isNullStack()
    {
        return 0 == myStackTop ? true : false;
    }

    /**
     * 栈是否为满
     * @return
     */
    public boolean isFullStack()
    {
        return myStackSize == myStackTop ? true : false;
    }

    /**
     * 清空栈
     */
    public void clearStack()
    {
        myStackTop = 0;
    }

    /**
     * 返回栈长度
     * @return
     */
    public int stackLen()
    {
        return myStackTop;
    }

    /**
     * 元素入栈
     * @param element
     * @return
     */
    public boolean push(Object element){
        if (isFullStack())
        {
            return false;
        }
        else
        {
            myStack[myStackTop] = element;
            myStackTop ++;
            return true;
        }
    }

    /**
     * 出栈
     * @return 返回出栈的元素
     * @throws Exception
     */
    public Object pop() throws Exception
    {
        if (isNullStack())
        {
            throw new Exception("栈为空，没法删除元素");
        }
        else
        {
            myStackTop --;
            return myStack[myStackTop];
        }
    }

    /**
     * 遍历栈
     * @param isFromButtom 为真 顺序遍历，为假倒序遍历
     */
    public void StackTraverse(boolean isFromButtom)
    {
        if (isFromButtom)
        {
            for (int i = 0; i < myStackTop; i++)
            {
                System.out.println(myStack[i].toString());
            }
        }
        else
        {
            for (int i = myStackTop - 1; i >= 0; i--)
            {
                System.out.println(myStack[i].toString());
            }
        }
    }
}

　　

下方是测试上方的代码：

package use.test;

import test.entity.Person;
import util.MyStack;

public class TestMyStack {
    public static void main(String[] args) {
        MyStack myStack = new MyStack(3);
        
        Person person1 = new Person();
        person1.setAddress("合肥市蜀山区");
        person1.setName("张三");
        person1.setAge(22);
        
        Person person2 = new Person();
        person2.setAddress("南京市江宁区");
        person2.setName("李四");
        person2.setAge(44);
        
        //入栈
        myStack.push(person1);//栈底
        myStack.push(person2);
        
        myStack.push(1);//栈顶
        
        System.out.println("栈的长度为：" + myStack.stackLen());
        myStack.StackTraverse(true);
        
        //出栈
        try {
            Object element = myStack.pop();
            System.out.println("\n当前出栈的元素为：" + element);
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        System.out.println("栈的长度为：" + myStack.stackLen());
        myStack.StackTraverse(false);
        
        //清空栈
//        myStack.clearStack();
        if (myStack.isNullStack())
        {
            System.out.println("栈为空");
        }
        
        if (myStack.isFullStack())
        {
            System.out.println("栈为满");
        }
        
    }
}