题目：两个栈实现一个队列

• 请调用两个栈，实现一个队列
• 功能add delete length

队列

• 先进先出
• api：add、delete、length

const queue = []
queue.push(100) / 入队
queue.push(200)
queue.push(300)
const n = queue.shift() //出队

逻辑结构vs物理结构

• 队列是逻辑结构，抽象模型
• 简单的，可以用数组，链表实现
• 复杂的队列服务，需单独设计

class MyQueue {
    private stack1 = []
    private stack2 = []
    // 入队
    add(n){
       this.stack1.push(n) 
    },
    delete(){
        let res
        const stack1 = this.stack1
        const stack2 = this.stack2
        // 将stack1 所有的元素移动到 stack2中
        while(stack1.length) {
            const n = stack1.pop()
            if(n!=null) {
                stack2.push(n)
            }
        }
        // stack2 pop
        res = stack2.pop()
        //将 stack2 所有元素还给 stack1
        while(stack2.length) {
            const n = stack2.pop()
            if(n!=null) {
                stack1.push(n)
            }
        }
        return res || null
    },
    get length() {
        return this.stack1.length
    }
}

单元测试

describe('两个栈，一个队列'， ()=>{
    it('add and lendth', () => {
        const q = new MyQueue()
        expext(q.length).toBe(0)
        q.add(100)
        q.add(200)
        q.add(300)
        expect(q.length).toBe(3)
    })
    it('delete', () => {
        const q = new MyQueue()
        expext(q.delete()).toBeNull()
        q.add(100)
        q.add(200)
        q.add(300)
        expext(q.delete()).toBe(100)
        expect(q.length).toBe(2)
        expext(q.delete()).toBe(200)
         expect(q.length).toBe(1)
    })

})

性能分析

• 时间复杂度：add() O(1) delete O(n)
• 空间复杂度，整体是O(n)