數據結構--棧

一、什麼是棧？
在古代棧是牲口棚的意思，在計算機中棧是一種機制；
棧機制：後進先出（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("棧爲滿");
        }
        
    }
}