【LeetCode剑指offer 01】数组中重复的数字、两个栈实现队列

数组中重复的数字

数组中重复的数字

找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入：

[2, 3, 1, 0, 2, 5, 3]

输出：2 或 3

限制：

2 <= n <= 100000

思路

很容易想到使用哈希表来记录元素出现次数

且因为题目规定了n的范围，所以我们使用的哈希表类型应该是map

代码

第一版

直接定义一个unordered_map

然后遍历数组，在哈希表对应位置计数，最后再遍历哈希表，返回第一个遇到的出现次数大于等于2的元素

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        //定义一个map
        unordered_map<int, int> hash;
        for(int i = 0; i < nums.size(); ++i){
            hash[nums[i]]++;
        }
        //在哈希表中找出现次数大于等于2的元素
        for(unordered_map<int, int>::iterator it = hash.begin(); it != hash.end(); ++it){
            if(it->second >= 2) return it->first;
        }
        return -1;
    }
};

这么做其实有点冗余，其实完全可以只用一个循环解决问题的

意思就是，我们其实可以不用记录元素出现的具体次数，只要在遍历时又碰到了即可直接返回

于是有了第二版

第二版

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        //定义一个map
        unordered_map<int, int> hash;
        //遍历数组，将元素加入哈希表，同时判断某元素是否重复出现
        for(int num : nums){
            if(hash[num]) return num;//当前遍历值出现在哈希表，为重复值，返回
            hash[num]++;//未出现的，则在哈希表中记录
        }
        return -1;
    }
};

用两个栈实现队列

用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead","deleteHead"]
[[],[3],[],[],[]]
输出：[null,null,3,-1,-1]

示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]

提示：

1 <= values <= 10000

最多会对 appendTail、deleteHead 进行 10000 次调用

思路

一拿到题肯定会下意识联想到 232. 用栈实现队列

这题之前刷代码随想录的时候写过，于是很自然的照着以前的思路写

事实上，这两题的核心思路是一样的，即使用两个栈（stack_in和stack_out），分别模拟队列的进和出

模拟加入队列功能的栈stack_in就直接使用push功能就行；

模拟从队列拿数据时，要先判断 stack_out 是否为空，不为空可以直接取该数据作为当前队列的头部数据

如果为空，就把 stack_in 的所有数据弹出，然后压入 stack_out ，然后取 stack_out 栈顶数据作为当前队列的头部数据，最后弹出栈顶数据

代码与坑

如果真是这么顺利就ac了我也不会特地写个记录

最开始我是完全按照之前的思路去写的代码，如下：

class CQueue {
public:
    //定义两个栈
    stack<int>stack_in;
    stack<int>stack_out;

    CQueue() {

    }

    void appendTail(int value) {
        stack_in.push(value);
    }

    int deleteHead() {
        if (stack_in.empty()) return -1;
        if(!stack_out.empty()) {
            return stack_out.top();
        }else{
            while(!stack_in.empty()){
                stack_out.push(stack_in.top());//问题位置
                stack_in.pop();
            }
            int res = stack_out.top();
            return res;
        }
    }
};

看起来很好，但是第一个用例都过不去

后面经过定位发现问题出现在交换两个栈元素的过程中

如果像上面那样写，可能出现莫名其妙的错误（原因TBD）

所以后面我用一个变量来接收弹出数据，然后再入栈（老老实实的写）

至少不会错了，以下是ac代码

class CQueue {
public:
    //定义两个栈
    stack<int>stack_in;
    stack<int>stack_out;

    CQueue() {

    }

    void appendTail(int value) {
        stack_in.push(value);
    }

    int deleteHead() {
        int res;//用于保存弹出栈的数据
        if(!stack_out.empty()){//当stack_out不为空，先将该数获取为res,然后弹出
            res = stack_out.top();
            stack_out.pop();
            return res;
        }else if(!stack_in.empty()){//当stack_in不为空，循环将所有数加入stack_out中
            while(!stack_in.empty()){
                res = stack_in.top();
                stack_in.pop();
                stack_out.push(res);
                // stack_out.push(stack_in.top());//这种写法会出错
                // stack_in.pop();
            }
            // res = stack_out.top();
            stack_out.pop();//两个栈交换完数据后，直接将stack_out的栈顶弹出
            return res;//当前res记录的是最后一个压入stack_out的数据，即stack_out的栈顶数据，返回即可
        }else{//栈为空时，返回-1
            return -1;
        }
    }
};

以下写法在 232. 用栈实现队列仍使用

stack_out.push(stack_in.top());//这种写法会出错
stack_in.pop();

为了保证统一，均修改为本题中的这种写法

为什么会出错？

代码1
int res;
res = stack_in.top();
stack_in.pop();
stack_out.push(res);

代码2
stack_out.push(stack_in.top());
stack_in.pop();  

这两种写法有何区别？为什么代码2在某些情况下会出错？

这两种写法的功能是相同的，都是将 stack_in 的栈顶元素弹出并压入 stack_out 中。但是，它们之间存在一些细微的区别。

主要是顺序不同

代码1先将栈顶元素存储到 res 中，再将 res 压入 stack_out 栈中，而代码2直接将 stack_in 栈顶元素压入 stack_out 栈中。

如果 stack_in 为空栈，那么代码1和代码2都会出错，因为都会试图访问空栈的栈顶元素。

但是，如果 stack_out 栈非空，那么代码2在将 stack_in 栈顶元素压入 stack_out 栈之前，没有先检查 stack_out 栈是否为空，因此可能会导致将元素插入到错误的位置。

因此，如果 stack_out 栈非空，最好使用代码1的写法。事实上，如果没超时，都无脑用第一种方式就行。