動態數組-----棧的實現

棧的定義

棧是限定僅在表尾進行插入和刪除操作的線性表

• 我們把允許插入和刪除的一端稱爲棧頂（top），另一端稱爲棧底（bottom）
• 不含任何數據元素的棧稱爲空棧
• 棧又稱爲後進先出（Last In First Out）的線性表，簡稱LIFO結構
• 棧本身是一個線性表，其數據元素具有線性關係，只不過它是一種特殊的線性表而已
• 棧的插入操作，叫做進棧，也稱壓棧、入棧
• 棧的刪除操作，叫做出棧，也稱彈棧

Stack棧接口的定義

同樣棧可以順序存儲實現也可以鏈表存儲實現
所以將共性抽取定義出Stack接口

public interface Stack<E> extends Iterable<E> {
    public int size();
    public boolean isEmpty();
    public void push(E element);
    public E pop();
    public E peek();
    public void clear();
}

ArrayStack類

該類爲棧的順序存儲具體實現
因爲棧本身就是一種特殊的線性表
所以我們可以藉助之前完成的ArrarList來實現我們的ArrayStack

import shujujiegou_interface.Stack;

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E> {

    //棧內部就是由一個線性表來實現
    private ArrayList<E> list;

    //創建一個默認容量的棧（默認容量的線性表）
    public ArrayStack(){
        list=new ArrayList<>();
    }

    //創建一個指定容量的棧（指定容量的線性表）
    public ArrayStack(int capacity){
        list=new ArrayList<>(capacity);
    }

    //獲取棧中有效元素個數
    @Override
    public int size() {
        return list.size();
    }

    //判斷棧是否爲空
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    //入棧一個元素
    @Override
    public void push(E element) {
        list.add(element);
    }

    //出棧一個元素並返回
    @Override
    public E pop() {
        return list.remove(list.size()-1);
    }

    //查看棧頂元素 不刪除
    @Override
    public E peek() {
        return list.get(list.size()-1);
    }

    //清空棧
    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder(String.format("ArrayStack:%d/%d[",size(),list.getCapacity()));
        if (isEmpty()){
            sb.append("]");//ArrayStack:0/10[]
        }else {//ArrayStack:5/10[1,2,3,4,5]
            for (int i=0;i<size();i++){
                sb.append(list.get(i));
                if(i!=size()-1){
                    sb.append(",");
                }else{
                    sb.append("]");
                }
            }
        }
        return sb.toString();
    }
}

測試類

import shixianClass.ArrayStack;
import shujujiegou_interface.Stack;

public class TestArrayStack {
    public static void main(String[] args) {
        ArrayStack<Integer> stack=new ArrayStack<Integer>();
        System.out.println(stack);
        for(int i=1;i<=12;i++){
            stack.push(i);
        }
        System.out.println(stack);
        for(int i=1;i<=12;i++){
            System.out.print(stack.pop()+" ");
        }
        System.out.println(stack);
        for(int num:stack){
            System.out.println(num);
        }
    }
}

執行結果

ArrayStack:0/10[]
ArrayStack:12/20[1,2,3,4,5,6,7,8,9,10,11,12]
12 11 10 9 8 7 6 5 4 3 2 1 ArrayStack:0/5[]