用栈实现队列，用队列实现栈-----（JS实现）

仅用栈实现队列结构

解题思想：

• 准备一个dataIn栈执行入队操作，一个dataOut栈执行出队操作；
• 入队操作时：将数据正常压入dataIn栈即可
• 出队操作时：将dataIn栈的数据倒入dataOut栈，然后将dataOut栈中的数据出栈即可
• 注意：dataIn操作向dataOut栈倒入数据需要遵循两个原则：
  1. dataIn必须一次性全部将栈中所有数据都给dataOut栈
  2. 执行倒入操作前必须保证dataOut栈中没有数据

let stcQueue = {
    dataIn: [], // 负责入队
    dataOut: [], // 负责出队
    enqueue: function(a) { // 入队操作
        this.dataIn.push(a);
    },
    dequeue: function() { // 出队操作
        // 先用dao()将dataIn数据给dataOut
        dao(this.dataIn, this.dataOut);
        // 然后返回dataOut栈顶给用户
        return this.dataOut.pop();
    }
};
//  dataIn向dataOut倒数据函数
let dao = function(dataIn, dataOut) {
    // 1. 判断dataOut是否为空，为空则可以倒数据，不为空报错
    if (dataOut.length !== 0) {
        return "error";
    } else {
        // dataOut为空可以倒数据，必须保证dataIn一次性全部将数据倒完
        while (dataIn.length !== 0) {
            // 只要dataIn中还有数据，就一直把栈顶给dataOut
            dataOut.push(dataIn.pop());
        }
    }
};

仅用队列实现栈结构

解题思想：

• 准备两个队列data1，data2；spePush(入栈)操作时：哪个队列不为空就放入哪个队列
• spePop(出栈)操作时：若两个队列都为空，则报错；
• 若有队列不空，则将不空的队列除最后一个元素的其余元素都给空队列
• 然后返回该队列剩余的最后一个元素给用户
• 只能用pop(队列尾部加元素)和shift(队列头部出队)操作

let queStack = {
    data1: [],
    data2: [],
    pushQ: function(a) { // 入栈操作
        if (this.data1.length === 0 && this.data2.length === 0) {
            this.data1.push(a);
        } else if (this.data1.length !== 0 && this.data2.length === 0) {
            this.data1.push(a);
        } else if (this.data1.length === 0 && this.data2.length !== 0) {
            this.data2.push(a);
        }
    },
    popQ: function() { // 出栈操作
        if (this.data1.length === 0 && this.data2.length === 0) {
            return "error";
        } else if (this.data1.length === 0) { // data1 为空
            // data2中除了最后一个元素的数据都复制进data1
            while (this.data2.length - 1 !== 0) {
                this.data1.push(this.data2.shift());
            }
            return this.data2.shift(); // data2返回最后剩余的元素给用户
        } else { // data2为空
            // data1中除了最后一个元素的数据都复制进data2
            while (this.data1.length - 1 !== 0) {
                this.data2.push(this.data1.shift());
            }
            return this.data1.shift(); // data1返回最后剩余的元素给用户
        }
    }
};

实现一个特殊的栈：

• 在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作

• 要求:
  1. spePop()、spePush()、getMin()操作的时间复杂度都是O(1)
  2. 可以使用现成的栈

解题思想：

• 最容易想的思路是每次遍历栈中元素找出最小的元素，但题目要求时间复杂度为O(1)；遍历的时间复杂度是O(n)，故不可行
• 用两个栈，一个data栈做正常的spePop()、spePush()操作，另一个为min栈，用于存放data栈中的最小值
• 往min栈中放入元素的原则为：
• 当data栈spePush元素时，如果min为空则直接将相同的元素也spePush到min栈；
• 如果min不为空，则比较min栈顶和data要spePush的元素，谁小就spePush谁入min栈
• 当data栈spePop元素时，min栈也spePop；
• 调用getMin操作则返回min栈栈顶即可

let speStcak = {
    data: [],
    min: [],
    spePush: function(a) { // 入栈操作
        // 把元素入data栈
        this.data.push(a);
        if (this.min.length === 0) {
            // 如果min栈为空，则直接把元素入min栈
            this.min.push(a);
        } else {
            // 比较a和min栈顶谁小，把小的值给m
            let m = a < this.min[this.min.length - 1] ? a : this.min[this.min.length - 1];
            // min栈spePush两者之中的最小值
            this.min.push(m);
        }
    },
    spePop: function() { // 出栈操作
        if (this.data.length === 0 || this.min.length === 0) {
            return "error";
        } else {
            //  min执行出栈操作，为了和data栈同步更新
            this.min.pop();
            // 返回data栈栈顶给用户
            return this.data.pop();
        }
    },
    getMin: function() { // 得到data栈中最小元素的操作
        if (this.min.length === 0) {
            return "error";
        } else {
            // 返回min栈栈顶即可，min栈栈顶即为data栈中的最小元素
            return this.min[this.min.length - 1];
        }
    }
};