Java数据结构与算法笔记_day02(栈的实现)

栈的实现

栈的定义：
栈是限定仅在表尾进行插入和删除操作的线性表
我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom）
不含任何数据元素的栈称为空栈
栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构
栈本身是一个线性表，其数据元素具有线性关系，只不过它是一种特殊的线性表而已
栈的插入操作，叫作进栈，也称压栈、入栈
栈的删除操作，叫作出栈，也称弹栈
Stack栈接口的定义：

public interface Stack<E> extends Iterable<E> {
    public int size();  //获取栈中元素的个数
    public abstract boolean isEmpty();  //判断栈是否为空
    public void push (E element);   //进栈一个元素 在线性表表尾添加元素
    public E pop(); //弹出一个元素 在线性表表尾删除一个元素
    public E peek();    //查看当前栈顶元素
    public void clear();    //清空栈
}

ArrayStack类的定义：

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

    //栈的内部其实是有一个线性表实现
    public ArrayList<E> list;

    //创建一个默认容量的栈（默认容量的线性表）
    public ArrayStack(){
        list = new ArrayList<E>();
    }

    //创建一个指定容量的栈（指定容量的线性表）
    public ArrayStack(int capacity){
        list = new ArrayList<>(capacity);
    }


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

    //获取栈中有限元素的个数
    @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 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();
    }

    public boolean equals(Object o){
        if (this == o){
            return true;
        }
        if (o == null){
            return false;
        }
        if (o instanceof ArrayStack){
            ArrayStack other = (ArrayStack) o;
            return this.list.equals(other.list);
        }
        return false;
    }
}

TestArrayStack类：

public class TestArrayStack {
    public static void main(String[] args) {
        ArrayStack<Integer> stack = new ArrayStack<>();
        ArrayStack<Integer> stack1 = new ArrayStack<>(15);
        System.out.println(stack);

        for (int i = 0; i < 12; i++) {
            stack.push(i);
            stack1.push(i);
        }
        System.out.println(stack.equals(stack1));
        System.out.println(stack);
        System.out.println(stack1);

        for (int i = 0; i < 7; i++) {
            System.out.println(stack.pop());
        }
        System.out.println(stack);

        for (int num:stack){
            System.out.println(num);
        }
    }

}