leetcode经典题目（9）--栈、队列与哈希表

1. 用栈实现队列（NO.232）

题目描述：使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。
pop() – 从队列首部移除元素。
peek() – 返回队列首部的元素。
empty() – 返回队列是否为空。
解题思路：是用两个栈，一个用于入队操作，一个用于出队操作。一个元素需要经过两个栈才能出队列，在经过第一个栈时元素顺序被反转，经过第二个栈时再次被反转，此时就是先进先出顺序。

class MyQueue {
public:
    /** Initialize your data structure here. */
    MyQueue() {
        stack<int> st1;
        stack<int> st2;
    }    
    /** Push element x to the back of queue. */
    void push(int x) {
        st1.push(x);
    }    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if (st2.empty()){
            while (!st1.empty()){
                st2.push(st1.top());
                st1.pop();
            }
        }
        int res = st2.top();
        st2.pop();
        return res;
    }
    
    /** Get the front element. */
    int peek() {
        if (st2.empty()){
            while (!st1.empty()){
                st2.push(st1.top());
                st1.pop();
            }
        }
        int res = st2.top();
        return res;
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return st1.empty() && st2.empty();
    }
private:
    stack<int> st1;
    stack<int> st2;
};

2. 用队列实现栈（NO.225）

题目描述：使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
解题思路：出栈：将非空队列中的除队尾元素外的所有元素转移至另一个队列中，然后将最后一个元素出队；入栈：将元素压入到非空队列的队尾。

class MyStack {
public:
    /** Initialize your data structure here. */
    MyStack() {
        queue<int> qu1;
        queue<int> qu2;
    }   
    /** Push element x onto stack. */
    void push(int x) {
        if (qu1.empty())
            qu2.push(x);
        else
            qu1.push(x);
    }    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
        int res;
        if (qu1.empty()){
            while (qu2.size() > 1){
                qu1.push(qu2.front());
                qu2.pop();
            }
            res = qu2.front();
            qu2.pop();
        }
        else if (qu2.empty()){
            while (qu1.size() > 1){
                qu2.push(qu1.front());
                qu1.pop();
            }
            res = qu1.front();
            qu1.pop();
        }
        return res;
    }    
    /** Get the top element. */
    int top() {
        int res;
        if (qu1.empty()){
            while (qu2.size() > 1){
                qu1.push(qu2.front());
                qu2.pop();
            }
            res = qu2.front();
            qu1.push(res);
            qu2.pop();
        }
        else if (qu2.empty()){
            while (qu1.size() > 1){
                qu2.push(qu1.front());
                qu1.pop();
            }
            res = qu1.front();
            qu2.push(res);
            qu1.pop();
        }
        return res;
    }  
    /** Returns whether the stack is empty. */
    bool empty() {
        return qu1.empty() && qu2.empty();
    }
private:
    queue<int> qu1;
    queue<int> qu2;
};

3. 最小值栈（NO.155）

题目描述：设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
push(x) —— 将元素 x 推入栈中。
pop() —— 删除栈顶的元素。
top() —— 获取栈顶元素。
getMin() —— 检索栈中的最小元素。
解题思路：使用一个栈minValue记录数据栈的最小值，数据栈添加或者删除元素时，minValue栈也做相应的操作，使用变量min记录栈的最小值。

class MinStack {
private:
    stack<int> data;
    stack<int> minValue;
    int min = 0x7FFFFFFF;
public:
    /** initialize your data structure here. */
    MinStack() {
    }    
    void push(int x) {
        data.push(x);
        min = min < x ? min : x;
        minValue.push(min);      
    }  
    void pop() {
        data.pop();
        minValue.pop();  
        min = minValue.empty() ? 0x7FFFFFFF : minValue.top();     
    }
    int top() {
        return data.top();       
    }
    int getMin() {
        return min;       
    }
};

4. 用栈实现括号匹配（NO.20）

题目描述：给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。
解题思路：创建一个栈。遍历字符串，如果遇到的是左括号，则将其压入栈中，如果遇到的是右括号，分以下几种情况：（1）栈为空，肯定不匹配，返回false；（2）栈非空，且该右括号也栈顶的左括号匹配，则将栈顶元素弹出，继续遍历；（3）栈非空，但该右括号也栈顶左括号不匹配，则字符串无效，返回false。

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for (int i = 0; i < s.size(); i++){
            if (s[i] == '(' || s[i] == '{' || s[i] == '[')
                st.push(s[i]);
            else{
                if (st.empty())
                    return false;
                 else if ((s[i] == ')' && st.top() == '(') || (s[i] == ']' && st.top() == '[') ||                        (s[i] == '}' && st.top() == '{'))
                    st.pop();
                else
                    return false;
            }
        }
        return st.empty();       
    }
};

5. 数组中元素与下一个比它大的元素之间的距离（NO.739）

题目描述：请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。
例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。
解题思路一：从后往前遍历，便不用一个一个的比较，只考虑一个递增的子列，从而找到比当前值大的值的位置。最后一个元素对应的结果为0。要求出第i天对应的结果，只需要知道第i+1天对应的结果就可以：（1）若T[i] < T[i+1]，那么res[i]=1；（2）若T[i] > T[i+1]：若res[i+1]=0，那么res[i]=0；若res[i+1]!=0，那就比较T[i]和T[i+1+res[i+1]]（即将第i天的温度与比第i+1天大的那天的温度进行比较）

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        vector<int> res(T.size(),0);
        for (int i = T.size() - 2; i >= 0; i--){
            for (int j = i + 1; j < T.size(); j += res[j]){
                if (T[i] < T[j]){
                    res[i] = j - i;
                    break;
                }
                else if (res[j] == 0){
                    res[i] = 0;
                    break;
                }
            }
        }
        return res;
    }
};

解题思路二：使用一个栈存储尚未找到较大值的下标。遍历数组，如果当前数字大于栈顶数字，则可求得栈顶数字与比其大的值的距离，然后将栈顶元素弹出，继续比较栈中下一个元素。如果当前数字小于栈顶元素，则将其入栈。可以发现栈中元素是递减的。

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& T) {
        vector<int> res(T.size(),0);
        stack<int> st;
        for (int i = 0; i < T.size(); i++){
            while (!st.empty() && T[i] > T[st.top()]){
                res[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return res;
    }
};

6. 循环数组中比当前元素大的下一个元素（NO.503）

题目描述：给定一个循环数组（最后一个元素的下一个元素是数组的第一个元素），输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1。
解题思路：与上一题相似，只不过是循环数组，且找的是元素值而不是位置。令i的取值为0到2n，取其对应于循环数组中的值与栈顶元素比较，如果大于，弹出栈顶元素，如果小于且i小于n，入栈。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n,-1);
        stack<int> st;
        for (int i = 0; i < n * 2; i++){
            int num = nums[i % n];
            while (!st.empty() && num > nums[st.top()]){
                res[st.top()] = num;
                st.pop();
            }
            if (i < n)
                st.push(i);
        }
        return res;
    }
};

7. 最长和谐子序列（NO.594）

题目描述：和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。
输入: [1,3,2,2,5,2,3,7]； 输出: 5； 原因: 最长的和谐数组是：[3,2,2,2,3].
解题思路：使用一个哈希表，记录每个元素出现的次数，求相邻元素出现次数的和。这里使用unordered_map创建哈希表。

class Solution {
public:
    int findLHS(vector<int>& nums) {
        unordered_map<int,int> mymap;
        int res = 0;
        for (int num : nums){
            mymap[num]++;
            if (mymap[num-1] > 0)
                res = max(res,mymap[num-1]+mymap[num]);
            if (mymap[num+1] > 0)
                res = max(res,mymap[num+1]+mymap[num]);
        }
        return res;
    }
};

8. 最长连续序列（NO.128）

题目描述：给定一个未排序的整数数组，找出最长连续序列的长度。要求算法的时间复杂度为 O(n)。
输入: [100, 4, 200, 1, 3, 2]；输出: 4；解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。
解题思路一：使用动态规划，令dp[i]表示以第i个元素结尾的连续序列长度。首先对数组排序，遍历数组，如果nums[i]=nums[i-1]，则dp[i]=dp[i-1]；如果nums[i]=nums[i-1]+1，则dp[i]=dp[i-1]+1，否则，dp[i]=1.但是时间复杂度为$O(nlogn)$.

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int n = nums.size();
        if (n <= 1)
            return n;
        sort(nums.begin(),nums.end());
        vector<int> dp(n,1);
        int max = 1;
        for (int i = 1; i < n; i++){
            if (nums[i] == nums[i-1])
                dp[i] = dp[i-1];
            else if (nums[i] == nums[i-1] + 1)
                dp[i] = dp[i-1] + 1;
            if (dp[i] > max)
                max = dp[i];
        }
        return max;
    }
};

解题思路二：题目要求 O(n) 复杂度。
用哈希表存储每个端点值对应连续区间的长度。遍历数组：
（1）若数已在哈希表中：跳过不做处理
（2）若是新数加入：判断其左右相邻数是否在哈希表中，如果在，计算当前数的区间长度curLength，并更新最大长度和区间两边端点的长度值。

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_map<int,int> mymap;
        int maxLength = 0;
        for (int num : nums){
            if (mymap.find(num) == mymap.end()){//新数
                int curLength = 0;
                if (mymap.find(num-1) == mymap.end() && mymap.find(num+1) == mymap.end())
                    curLength = 1;
                else if (mymap.find(num-1) == mymap.end()){//右相邻数在哈希表中
                    curLength = mymap[num+1] + 1;
                    mymap[num+mymap[num+1]] = curLength;//更新右区间端点的长度值
                }
                else if (mymap.find(num+1) == mymap.end()){//左相邻数在哈希表中
                    curLength = mymap[num-1] + 1;
                    mymap[num-mymap[num-1]] = curLength;//更新左区间端点的长度值
                }
                else{//左右相邻数都在哈希表中
                    curLength = mymap[num-1] + mymap[num+1] + 1;
                    mymap[num-mymap[num-1]] = curLength;
                    mymap[num+mymap[num+1]] = curLength;
                }
                mymap[num] = curLength;
                if (curLength > maxLength)
                    maxLength = curLength;
            }
        }
        return maxLength;
    }
};