lc 0226

目录

• ✅ 232. 用栈实现队列
• 描述
• 解答
  • c
  • py
• ✅ 496. 下一个更大元素 I
• 描述
• 解答
  • java
  • another java

✅ 232. 用栈实现队列

https://leetcode-cn.com/problems/implement-queue-using-stacks

描述

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。
pop() -- 从队列首部移除元素。
peek() -- 返回队列首部的元素。
empty() -- 返回队列是否为空。
示例:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);
queue.peek();  // 返回 1
queue.pop();   // 返回 1
queue.empty(); // 返回 false
说明:

你只能使用标准的栈操作 -- 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/implement-queue-using-stacks
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

class MyQueue {
private:
    stack<int> s1; // 输入栈
    stack<int> s2;  // 输出栈
public:
    /** Initialize your data structure here. */
    MyQueue() {
    }

    /** Push element x to the back of queue. */
    void push(int x) {
        s1.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        if(s2.empty())
        {
            while(!s1.empty())
            {
                int tmp = s1.top();
                s1.pop();
                s2.push(tmp);
            }
        }
        int ret = s2.top();
        s2.pop();
        return ret;
    }

    /** Get the front element. */
    int peek() {
        int ret = this->pop();
        s2.push(ret);
        return ret;
    }// tt 上述这个 peek 是非常nice 的，他reuse 了pop。

    /** Returns whether the queue is empty. */
    bool empty() {
        return s1.empty()&& s2.empty();
    }
};

c

//C语言：线性表处理
//tt 但是这个没有使用stack 操作，仅仅是数组操作。

typedef struct {
    int front;
    int rear;
    int val[1000];
} MyQueue;
/*
tt queue looks like:

[-----front********rear------]
*/
/** Initialize your data structure here. */

MyQueue* myQueueCreate() {
    MyQueue *ret = (MyQueue*) malloc (sizeof(MyQueue));
    ret->front = 0;
    ret->rear = 0;
    memset(ret->val, 0, sizeof(int) * 1000);
    return ret;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
    obj->val[obj->rear++] = x;
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
    int ret = obj->val[obj->front];
    obj->val[obj->front] = 0;
    (obj->front)++;
    return ret;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
    return obj->val[obj->front];
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
    return obj->front == obj->rear;
}

void myQueueFree(MyQueue* obj) {
    memset(obj, 0, sizeof(MyQueue));
}

/**
执行用时 :
4 ms
, 在所有 C 提交中击败了
59.42%
的用户
内存消耗 :
7.2 MB
, 在所有 C 提交中击败了
44.34%
的用户
*/

py

python 双栈

class MyQueue(object):

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.instack = []
        self.outstack = []

    def push(self, x):
        """
        Push element x to the back of queue.
        :type x: int
        :rtype: None
        """
        self.instack.append(x)

    def pop(self):
        """
        Removes the element from in front of queue and returns that element.
        :rtype: int
        """
        if len(self.outstack) == 0:
            while self.instack:
                self.outstack.append(self.instack.pop())
        return self.outstack.pop()

    def peek(self):
        """
        Get the front element.
        :rtype: int
        """
        if len(self.outstack) == 0:
            while self.instack:
                self.outstack.append(self.instack.pop())
        return self.outstack[-1]
    def empty(self):
        """
        Returns whether the queue is empty.
        :rtype: bool
        """
        return len(self.instack) == 0 and len(self.outstack) == 0

# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

✅ 496. 下一个更大元素 I

https://leetcode-cn.com/problems/next-greater-element-i

描述

给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。

示例 1:

输入: nums1 = [4,1,2], nums2 = [1,3,4,2].
输出: [-1,3,-1]
解释:
    对于num1中的数字4，你无法在第二个数组中找到下一个更大的数字，因此输出 -1。
    对于num1中的数字1，第二个数组中数字1右边的下一个较大数字是 3。
    对于num1中的数字2，第二个数组中没有下一个更大的数字，因此输出 -1。
示例 2:

输入: nums1 = [2,4], nums2 = [1,2,3,4].
输出: [3,-1]
解释:
    对于num1中的数字2，第二个数组中的下一个较大数字是3。
    对于num1中的数字4，第二个数组中没有下一个更大的数字，因此输出 -1。
注意:

nums1和nums2中所有元素是唯一的。
nums1和nums2 的数组大小都不超过1000。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-i
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答

思路：

s1： 定位 nums1 中各个元素在 nums 2 中的位置 pos
s2： 从这个pos 往后遍历找max，（这里可以优化）

实际思路如下：使用 stack ， map

java

方法一：单调栈

我们可以忽略数组 nums1，先对将 nums2 中的每一个元素，求出其下一个更大的元素。随后对于将这些答案放入哈希映射（HashMap）中，再遍历数组 nums1，并直接找出答案。对于 nums2，我们可以使用单调栈来解决这个问题。

我们首先把第一个元素 nums2[1] 放入栈，随后对于第二个元素 nums2[2]，如果 nums2[2] > nums2[1]，那么我们就找到了 nums2[1] 的下一个更大元素 nums2[2]，此时就可以把 nums2[1] 出栈并把 nums2[2] 入栈；如果 nums2[2] <= nums2[1]，我们就仅把 nums2[2] 入栈。对于第三个元素 nums2[3]，此时栈中有若干个元素，那么所有比 nums2[3] 小的元素都找到了下一个更大元素（即 nums2[3]），因此可以出栈，在这之后，我们将 nums2[3] 入栈，以此类推。

可以发现，我们维护了一个单调栈，栈中的元素从栈顶到栈底是单调不降的。当我们遇到一个新的元素 nums2[i] 时，我们判断栈顶元素是否小于 nums2[i]，如果是，那么栈顶元素的下一个更大元素即为 nums2[i]，我们将栈顶元素出栈。重复这一操作，直到栈为空或者栈顶元素大于 nums2[i]。此时我们将 nums2[i] 入栈，保持栈的单调性，并对接下来的 nums2[i + 1], nums2[i + 2] ... 执行同样的操作。

作者：LeetCode

链接：https://leetcode-cn.com/problems/next-greater-element-i/solution/xia-yi-ge-geng-da-yuan-su-i-by-leetcode/

来源：力扣（LeetCode）

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> stack = new Stack<>();
        //map<aNumLeft, aNumBiggerThanaNumLeft>
        Map<Integer, Integer> map = new HashMap<>();
        int[] ret = new int[nums1.length];
        // tt 每个nums 里的元素，依次将会放入一个单调下降stack
        // tt 每次准备放入nums[x] 的时候，检查stack top 的元素，如果
        // tt 小于即将进入的nums[x] 那么就会pop stack top，并放入map
        for (int num : nums2) {
            while(!stack.isEmpty() && stack.peek() < num) {
                map.put(stack.pop(), num);
            }
            stack.push(num);
        }
        // tt deal with all the big ones left in our stack
        while(!stack.isEmpty()) {
            map.put(stack.pop(), -1);
        }
        for (int i = 0; i < nums1.length; i++) {
            ret[i] = map.get(nums1[i]);
        }
        return ret;
    }
}
/*
执行用时 :
6 ms
, 在所有 Java 提交中击败了
41.98%
的用户
内存消耗 :
39.7 MB
, 在所有 Java 提交中击败了
5.04%
的用户
*/

another java

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Stack<Integer> stack = new Stack<Integer>();
        HashMap<Integer, Integer> hasMap = new HashMap<Integer, Integer>();

        int[] result = new int[nums1.length];

        for(int num : nums2) {
            while(!stack.isEmpty() && stack.peek()<num){
                hasMap.put(stack.pop(), num);
            }
            stack.push(num);
        }

        for(int i = 0; i < nums1.length; i++) result[i] = hasMap.getOrDefault(nums1[i], -1);

        return result;
    }
}