栈和队列的Java实现

---

一、栈

1. 数组实现

public class ArrayStack<T> implements MyStack<T>{

    private T[] arr;
    private int size = 0;
    private int max = 0;

    public ArrayStack(int max) {
        this.max = max;
        arr = new Object[max];
    }

    // 插入元素至栈顶
    @Override
    public boolean push(T element) {
        if(this.getSize() < max) {
            arr[size++] = element;
            return true;
        } else {
            return false;
        }
    }

    // 返回栈顶元素并出栈
    @Override
    public T pop() {
        T t = null;
        if(size > 0) {
            t = (T) arr[size--];
        }
        arr[size] = null;
        return t;
    }

    // 返回栈顶元素，但不出栈
    @Override
    public T peek() {
        T t = null;
        if(size > 0) {
            t = (T) arr[size--];
        }
        return t;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public int getSize() {
        return size;
    }
    
}

2. 链表实现

public class ListStack<T> implements MyStack<T>{
    
    private Node<T> head = null;
    private int size = 0;

    // 插入元素至栈顶
    public boolean push (T t) {
        if(head == null) {
            head = new Node<T>();
            head.t = t;
            head.next = null;
            size++;
        } else { // 把头节点的值往后移一位，将新增加的值添加到头节点的位置
            Node<T> temp = head;
            head = new Node<T>();
            head.t = t;
            head.next = temp;
            size++;
        }
        return false;
    }

    // 返回栈顶元素并出栈
    public T pop() {
        T t = null;
        if(!isEmpty()) {
            t = head.t;
            head = head.next;
            size--;
        }
        return t;
    }

    // 返回栈顶元素，但不出栈
    public T peek() {
        T t = null;
        if(!isEmpty()) {
            t = head.t;
        }
        return t;
    }

    public boolean isEmpty() {
        if(head == null) {
            return true;
        } else {
            return false;
        }
    }

    public int getSize() {
        return size;
    }
}

二、队列

public class ListQueue<T> {
    
    private Node<T> front;
    private Node<T> rear;
    private int size;

    public ListQueue() {
        this.front = null;
        this.rear = null;
        this.size = 0;
    }

    public void push(T t) {
        Node<T> node = new Node<T>();
        node.t = t;
        if(isEmpty()) {
            front = node;
            rear = node;
        } else {
            rear.next = node;
            rear = node;
        }
        size++;
    }

    public T pop() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        Node<T> node = new Node<T>();
        node = front;
        front = node.next;
        node.next = null;
        if(isEmpty()) {
            // 当队列为空，即最后一个元素被删除时，front会指向null，但是rear仍指向最后一个元素，此时需要将rear指向为null
            rear = front;
        }
        return node.t;
    }
    
    public T peek() {
        if(isEmpty()) {
            throw new RuntimeException("队列为空");
        }
        return front.t;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int getSize() {
        return size;
    }
}