玩转数据结构之链表实现栈和队列

前言

前面我们了解了链表的数据结构并实现了增删改查操作；玩转数据结构之JAVA实现链表，这里我们使用链表结构来实现栈和队列

栈

• 定义栈对应接口

/**
 * 自定义栈接口
 * on 2022/7/19
 */
public interface Stack<E> {

    /**
     * 获取栈中元素的个数
     *
     * @return
     */
    int getSize();

    /**
     * 当前栈中元素是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 向栈中新增元素
     *
     * @param e
     */
    void push(E e);

    /**
     * 移除栈顶元素
     *
     * @return
     */
    E pop();

    /**
     * 查看栈顶元素
     *
     * @return
     */
    E peek();
}

• 使用链表实现栈

/**
 * @author 使用链表实现栈结构
 * on 2023/2/1
 */
public class LinkedListStack<E> implements Stack<E> {
    private LinkedList<E> linkedList;

    public LinkedListStack() {
        linkedList = new LinkedList<>();
    }

    @Override
    public int getSize() {
        return linkedList.getSize();
    }

    @Override
    public boolean isEmpty() {
        return linkedList.isEmpty();
    }

    @Override
    public void push(E e) {
        linkedList.addFirst(e);
    }

    @Override
    public E pop() {
        return linkedList.removeFirst();
    }

    @Override
    public E peek() {
        return linkedList.getFirst();
    }

    @NonNull
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Stack: top ");
        sb.append(linkedList);
        return sb.toString();
    }
}

队列

• 定义队列接口

/**
 * 自定义队列所实现的接口
 * on 2022/7/19
 */
public interface Queue<E> {

    /**
     * 获取队列中元素的个数
     *
     * @return
     */
    int getSize();

    /**
     * 判断当前队列是否为空
     *
     * @return
     */
    boolean isEmpty();

    /**
     * 元素入队
     *
     * @param e
     */
    void enqueue(E e);

    /**
     * 元素出队
     *
     * @return
     */
    E dequeue();

    /**
     * 获取对首元素
     *
     * @return
     */
    E getFront();

}

• 使用链表结构实现队列

/**
 * 使用链表结构实现队列
 * on 2023/2/1
 */
public class LinkedListQueue<E> implements Queue<E> {

    private class Node {
        private E e;
        private Node next;

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        public Node(E e) {
            this.e = e;
        }
    }

    /**
     * head表示链表头部元素，tail表示链表尾部元素
     */
    private Node head, tail;
    private int size;

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

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

    @Override
    public void enqueue(E e) {
        //入队操作，应入队尾入队，这样时间复杂度为O(1)
        if (tail == null) {
            //表示当前队列中没有元素
            tail = new Node(e);
            head = tail;
        } else {
            //当前队列中有元素，则直接往tail后面添加元素
            tail.next = new Node(e);
            tail = tail.next;
        }
        size++;

    }

    @Override
    public E dequeue() {
        if (isEmpty()) {
            throw new IllegalArgumentException("The Queue is Empty!");
        }
        //出队操作，应该从队首出队，这样时间复杂度为O(1)
        Node result = head;
        head = head.next;
        result.next = null;
        if (head == null) {
            //如果队列中只有一个元素的时候
            tail = null;
        }
        size--;
        return result.e;
    }

    @Override
    public E getFront() {
        if (isEmpty()) {
            throw new IllegalArgumentException("The Queue is Empty!");
        }
        return head.e;
    }

    @NonNull
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Queue Front:");
        Node current = head;
        while (current != null) {
            sb.append(current.e);
            sb.append("->");
            current = current.next;
        }
        sb.append("NULL");
        return sb.toString();
    }
}

小结

以上方式实现栈和队列，巧妙的利用了链表首部和尾部的特性，时间复杂度均为O(1)；