动态数组-----栈的实现

栈的定义

栈是限定仅在表尾进行插入和删除操作的线性表

• 我们把允许插入和删除的一端称为栈顶（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[]