【Lintcode】224. Implement Three Stacks by Single Array

题目地址：

https://www.lintcode.com/problem/implement-three-stacks-by-single-array/description

要求只用一个数组实现三个栈。

思路是用动态链表。新开一个类作为链表节点，每个节点存储其逻辑前驱和后继的指针，再开一个数组作为栈，每个位置就存放链表节点。另外再开一个数组存储三个栈的栈顶的节点的下标。详细代码如下：

public class ThreeStacks {
    
    class Node {
    	// 其逻辑前驱和后继的指针
        Node prev, next;
        // idx指这个节点位于数组的下标，val存数值
        int idx, val;
        public Node(int val, int idx) {
            this.val = val;
            this.idx = idx;
        }
    }
    // 存放节点的数组
    private Node[] stack;
    // 记录每个stack的栈顶位置
    private int[] tops;
    // 记录已经用到的空间个数
    private int used;
    
    /*
     * @param size: An integer
     */
    public ThreeStacks(int size) {
        // do intialization if necessary
        // 可以适当开的大一些
        stack = new Node[size * 4];
        // 一开始栈顶都处于-1，意味着三个栈都空
        tops = new int[]{-1, -1, -1};
    }
    
    /*
     * @param stackNum: An integer
     * @param value: An integer
     * @return: nothing
     */
    public void push(int stackNum, int value) {
        // Push value into stackNum stack
        // 先取出这个编号的栈顶的下标
        int top = tops[stackNum];
        if (top == -1) {
        	// 此时意味栈空，先看一下stack数组用到了哪儿，在那里new一个节点出来
            stack[used] = new Node(value, used);
            // 此时这个栈的栈顶就应该赋值为used
            tops[stackNum] = used;
            // 记录已经用过的空间数量加1
            used++;
        } else {
        	// 此时意味栈不空，将其栈顶的node取出来
            Node topNode = stack[top];
            if (topNode.next == null) {
            	// 这个node的后继是null，则新开一个node出来接上去
                stack[used] = new Node(value, used);
                topNode.next = stack[used];
                topNode.next.prev = topNode;
                // 更新一下栈顶下标
                tops[stackNum] = used;
                // 记录已经用过的空间数量加1
                used++;
            } else {
            	// 这个node的后继不是null，说明在那个地方new出过节点，直接覆盖掉val即可
                topNode.next.val = value;
                tops[stackNum] = topNode.next.idx;
            }
        }
        
    }
    
    /*
     * @param stackNum: An integer
     * @return: the top element
     */
    public int pop(int stackNum) {
        // Pop and return the top element from stackNum stack
        // 取出栈顶的node
        int top = tops[stackNum];
        Node topNode = stack[top];
        int res = topNode.val;
        // 前驱为null说明pop完栈就空了，所以直接将栈顶下标置为-1；
        // 否则将栈顶下标赋值为其前驱所在下标
        if (topNode.prev == null) {
            tops[stackNum] = -1;
        } else {
            tops[stackNum] = topNode.prev.idx;
        }
        
        return res;
    }
    
    /*
     * @param stackNum: An integer
     * @return: the top element
     */
    public int peek(int stackNum) {
        // Return the top element
        return stack[tops[stackNum]].val;
    }
    
    /*
     * @param stackNum: An integer
     * @return: true if the stack is empty else false
     */
    public boolean isEmpty(int stackNum) {
        // write your code here
        return tops[stackNum] == -1;
    }
}

所有操作时空复杂度$O(1)$（不包括栈本身耗用的空间）。