剑指 Offer 09. 用两个栈实现队列

LinkedList

import java.util.Stack;
class CQueue {
    private LinkedList<Integer> inList; // 插入栈
    private LinkedList<Integer> outList; // 删除栈

    public CQueue() {
        inList = new LinkedList<>();
        outList = new LinkedList<>();
    }

    public void appendTail(int value) {
        inList.offer(value); // 将元素压入插入栈
    }

    public int deleteHead() {
        if (outList.isEmpty()) { // 如果删除栈为空
            while (!inList.isEmpty()) {
                outList.push(inList.pop()); // 将插入栈中的元素全部压入临时栈中
            }
            
            while (!outList.isEmpty()) {
                inList.push(outList.pop()); // 将临时栈中的元素逐个弹出并压入删除栈中
            }
        }

        if (inList.isEmpty()) { // 如果删除栈还是为空，则返回 -1
            return -1;
        } else { // 否则返回删除栈的栈顶元素
            return inList.pop();
        }
    }
}

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue obj = new CQueue();
 * obj.appendTail(value);
 * int param_2 = obj.deleteHead();
 */

Stack

import java.util.Stack;
class CQueue {
    private Stack<Integer> inStack;
    private Stack<Integer> outStack;

    public CQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }

    public void appendTail(int value) {
        inStack.push(value);
    }

    public int deleteHead() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop());
            }
        }

        if (outStack.isEmpty()) {
            return -1;
        } else {
            return outStack.pop();
        }
    }
}

Deque

import java.util.Stack;
class CQueue {
    
    Deque<Integer> inStack = new ArrayDeque<>();
    Deque<Integer> outStack = new ArrayDeque<>();

    public void appendTail(int value) {
        inStack.push(value);
    }

    public int deleteHead() {
        if (!outStack.isEmpty()) {
            return outStack.pop();
        }
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
        if (!outStack.isEmpty()) {
            return outStack.pop();
        }
        return -1;
    }
}

Stack
Stack 是一个基于 Vector 的后进先出（LIFO）的栈类，它继承了 Vector 类并实现了栈接口。Stack 中的元素可以使用 push() 方法压入栈中，使用 pop() 方法弹出栈顶元素，使用 peek() 方法返回栈顶元素的值但不弹出栈顶元素。Stack 的缺点是它不是一个线程安全的类，但是由于 Vector 的实现方式，在多线程环境下执行多个操作会导致性能下降。

LinkedList
LinkedList 是 Java 中的一个双向链表类，它实现了 List 接口和 Deque 接口。LinkedList 支持在链表两端进行插入和删除操作，可以用作 LIFO 栈或 FIFO 队列。LinkedList 的优点是它具有良好的性能和灵活的操作，可以快速地在链表两端进行插入和删除操作，支持双向遍历，同时也可以用作普通的动态数组。LinkedList 的缺点是它不是一个线程安全的类，因此在多线程环境下需要进行同步处理。

Deque
Deque（双端队列）是一种同时具有栈和队列性质的数据结构，它支持在两端进行插入和删除元素的操作。Java 中提供了 Deque 接口，它继承了 Queue 接口和 Iterable 接口，因此可以使用 Queue 接口定义的方法和 foreach 循环。Deque 支持在队列两端插入和删除元素，可以用作 LIFO 栈或 FIFO 队列。Deque 的优点是它具有良好的性能和灵活的操作，支持双向遍历，同时也可以用作普通的动态数组。Deque 的实现类包括 ArrayDeque 和 LinkedList，其中 ArrayDeque 是一个数组实现的双端队列，具有更好的性能和更小的空间开销。

综上所述，Stack、LinkedList 和 Deque 都是常用的数据结构，它们都可以用来实现栈或队列等数据结构，但是它们各自具有一些特点和缺点。Stack 是一个基于 Vector 的后进先出 (LIFO) 的栈类，具有线程安全的特点，但是性能较差；LinkedList 是 Java 中的一个双向链表类，不具有线程安全的特点，但是具有良好的性能和灵活的操作；Deque 是一种同时具有栈和队列性质的数据结构，具有双向遍历和灵活的操作特点，可以用作 LIFO 栈或 FIFO 队列，其中 ArrayDeque 具有更好的性能和更小的空间开销。因此，在选择数据结构时需要根据具体的需求和场景来选择适合的数据结构，以获得更好的性能和更好的代码质量。