【手把手教你刷力扣5】栈Stack（含力扣真题）

栈Stack

基本介绍

特点：先进后出

四个操作的时间复杂度：

操作	时间复杂度	–
访问Access	O(1)	栈顶元素
搜索Search	O(N)
插入Insert	O(1)
删除Delete	O(1)	栈顶元素

常用操作

创建栈

std::stack<int> s;

添加栈

    s.push(10);
    s.push(20);
    s.push(30);

查找栈顶元素——即将出栈的元素

    if (!s.empty()) {
        int topElement = s.top();
        std::cout << "栈顶元素: " << topElement << std::endl;
    } else {
        std::cout << "栈为空，无法获取栈顶元素" << std::endl;
    }

删除栈顶元素——即将出栈的元素

    if (!s.empty()) {
        s.pop();
        std::cout << "已删除栈顶元素" << std::endl;
    }

栈的长度

    std::cout << "栈的长度（通过辅助方法计算）: ";
    int length = 0;
    std::stack<int> tempStack = s; // 复制栈以保留原始栈状态
    while (!tempStack.empty()) {
        tempStack.pop();
        length++;
    }
    std::cout << length << std::endl;

栈是否为空

    if (s.empty()) {
        std::cout << "栈为空" << std::endl;
    } else {
        std::cout << "栈不为空" << std::endl;
    }

遍历栈（边删除栈顶元素边遍历）

    while (!s.empty()) {
        int currentElement = s.top();
        std::cout << currentElement << " ";
        s.pop();
    }
    std::cout << std::endl;

20. 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
3.每个右括号都有一个对应的相同类型的左括号

示例 1：

输入：s = “()”
输出：true

示例 2：

输入：s = “()[]{}”
输出：true

示例 3：

输入：s = “(]”
输出：false

示例 4：

输入：s = “([])”
输出：true

class Solution {
public:
    bool isValid(string s) {
        std::stack<char> S;
        for (char c : s) {	//遍历字符串 s 中的每个字符，并在每次迭代中将当前字符赋值给变量 c。
            if (c == '(' || c == '[' || c == '{') {
                S.push(c);
            } else if (c == ']' && S.top() == '[' ||
                     c == ')' && S.top() == '(' ||
                       c == '}' && S.top() == '{'){
                S.pop();
            }else{
                return false;
            }
        }
        if (S.empty()) {
            return true;
        } else {
            return false;
        }
    }
};

把遍历字符串的字符，若是左括号则放到栈中去，若是右括号则与栈顶元素比较，最后判断栈是否为空

496.下一个更大元素 I

nums1 中数字 x 的 下一个更大元素 是指 x 在nums2中对应位置 右侧 的 第一个 比 x 大的元素。

给你两个 没有重复元素 的数组 nums1 和 nums2 ，下标从 0 开始计数，其中nums1 是 nums2 的子集。

对于每个 0 <= i < nums1.length ，找出满足nums1[i] == nums2[j]的下标 j ，并且在 nums2 确定nums2[j]的 下一个更大元素 。如果不存在下一个更大元素，那么本次查询的答案是-1。

返回一个长度为nums1.length的数组ans作为答案，满足 ans[i] 是如上所述的 下一个更大元素 。

示例 1：

输入：nums1 = [4,1,2], nums2 = [1,3,4,2].
输出：[-1,3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。
nums2 = [1,3,4,2]。下一个更大元素是 3 。
nums2 = [1,3,4,2]。不存在下一个更大元素，所以答案是 -1 。

示例 2：

输入：nums1 = [2,4], nums2 = [1,2,3,4].
输出：[3,-1]
解释：nums1 中每个值的下一个更大元素如下所述：
nums2 = [1,2,3,4]。下一个更大元素是 3 。
nums2 = [1,2,3,4]。不存在下一个更大元素，所以答案是 -1

这是错的，还要更改

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        std::queue<int> q;
        std::queue<int> q2;

        //把nums2放到栈q里面
        for(int i=0;i<nums2.size();i++){
            q.push(nums2[i]);
        }

        int max=-1;
        //对nums1遍历
        for(int i=0;i<nums1.size();i++){
            int num=nums2[i];   //获取num2

            while(num==q.front()){

                if(q.top()>num){    //遇到一次比num大的就保留
                    max=q.top();
                }
                int temp=q.pop();   //接收被pop掉的数据
                q2.push(temp)
            }
            while(q2.size==0){      //补全q1
                q.push(q2.pop());
            }
        }
        return q2;
        
    }
};