Leetcode刷题笔记--Hot11-20

已于 2023-08-27 00:18:49 修改
阅读量289 收藏
点赞数
分类专栏： 数据结构&LeetCode 文章标签： leetcode
于 2023-07-05 21:09:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/131563965
版权

目录

1--有效的括号（20）

2--合并两个有序链表（21）

3--括号生成（22）

4--合并K个升序链表（23）

5--下一个排列（31）

6--最长有效括号（32）

7--搜索旋转排序数组（33）

8--在排序数组中查找元素的第一个​​​​​​​和最后一个位置（34）

9--组合总和（39）

10--接雨水（42）

1--有效的括号（20）

主要思路：

        利用栈，遍历字符串，遇到左括号则入栈，遇到右括号则出栈，并判断出栈元素是否与右括号匹配；

        当字符串有效时，栈为空（所有左括号都匹配出栈）；当字符串无效时，则栈不为空（仍有未匹配的左括号）；

#include <iostream>
#include <string>
#include <stack>

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

int main(int argc, char *argv[]){

    std::string test = "()[]{}";
    Solution S1;
    bool res = S1.isValid(test);
    if(res) std::cout << "true" << std::endl;
    else std::cout << "false" << std::endl;
    return 0;
}

2--合并两个有序链表（21）

主要思路：

        归并排序，分别遍历比较两个链表的结点，数值小的结点归并到新链表中；

#include <iostream>
#include <string>
#include <stack>

struct ListNode {
     int val;
     ListNode *next;
     ListNode() : val(0), next(nullptr) {}
     ListNode(int x) : val(x), next(nullptr) {}
     ListNode(int x, ListNode *next) : val(x), next(next) {}
};

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == NULL && list2 == NULL) return NULL;
        ListNode* head = new ListNode();
        ListNode* l_back = head; // 指向新链表最后一个结点
        ListNode* l1 = list1;
        ListNode* l2 = list2;
        while(l1 != NULL && l2 != NULL){
            if(l1->val < l2->val){
                l_back->next = l1;
                l1 = l1->next;
                l_back = l_back->next;
            }
            else{
                l_back->next = l2;
                l2 = l2->next;
                l_back = l_back->next;
            }
        }
        if(l1 == NULL) l_back->next = l2;
        if(l2 == NULL) l_back->next = l1;
        return head->next;
    }
};

int main(int argc, char *argv[]){
    ListNode* Node1 = new ListNode(1);
    ListNode* Node2 = new ListNode(2);
    ListNode* Node3 = new ListNode(4);

    Node1->next = Node2;
    Node2->next = Node3;

    ListNode* Node4 = new ListNode(1);
    ListNode* Node5 = new ListNode(3);
    ListNode* Node6 = new ListNode(4);
    Node4->next = Node5;
    Node5->next = Node6;

    Solution S1;
    ListNode* l = S1.mergeTwoLists(Node1, Node4);
    while(l != NULL){
        std::cout << l->val << " ";
        l = l->next;
    } 
    return 0;
}

3--括号生成（22）

主要思路：视频讲解

        递归遍历第 num 个字符是属于左括号还是右括号，递归终止条件是剩下的左括号和右括号数为 0；

        有效的括号组合必须是当前剩下的右括号数必须大于剩下的左括号数；

#include <iostream>
#include <string>
#include <vector>

class Solution {
public:
    std::vector<std::string> generateParenthesis(int n) {
        recur(n, n, 0);
        return Res;
    }

    // 还剩下 left 个和 right 个左括号和右括号，当前要填第 num 个字符
    void recur(int left, int right, int num){
        if(left == 0 && right == 0){
            c[num] = 0;
            Res.push_back(c);
            return;
        }
        
        if(left){ // 剩下的左括号不为 0
            c[num] = '(';
            recur(left - 1, right, num + 1);
        }
        if(left < right){ // 剩下的右括号必须大于剩下的左括号
            c[num] = ')';
            recur(left, right - 1, num + 1);
        }
    }
private:
    std::vector<std::string> Res;
    char c[20];
};

int main(int argc, char *argv[]){
    int n = 3;
    Solution S1;
    std::vector<std::string> Res = S1.generateParenthesis(n);
    for(std::string value : Res){
        std::cout << value << std::endl;
    }
    return 0;
}

4--合并K个升序链表（23）

主要思路：视频讲解参考

        与归并排序两个有序链表的思想类似，可以用 k 个结点指针指向 k 个链表的结点，每次归并值最小的结点到链表中，同时结点下移；

        为了方便比较 k 个链表结点的值大小，可以用一个集合来存储和维护 k 个链表结点，其中这个集合默认以升序排列；则每次只需要取集合的头元素出来即可，并将该元素的下一个结点重新存储在 k 个链表结点中； 

#include <iostream>
#include <queue>

struct ListNode {
     int val;
     ListNode *next;
     ListNode() : val(0), next(nullptr) {}
     ListNode(int x) : val(x), next(nullptr) {}
     ListNode(int x, ListNode *next) : val(x), next(next) {}
};

class Solution {
public:
    ListNode* mergeKLists(std::vector<ListNode*>& lists) {
        using Elem = std::pair<int, ListNode*>;
        // 定义一个堆，用于存储 k 个头结点（升序排列）
        std::priority_queue<Elem, std::vector<Elem>, std::greater<Elem>> Stack;
        // 用 k 个链表的头结点初始化堆
        for(ListNode* item : lists) if(item){
            Stack.push({item->val, item});
        }
        // 定义归并后的链表
        ListNode *head = nullptr;
        ListNode *tail = nullptr;
        while(!Stack.empty()){
            Elem tmp = Stack.top();
            Stack.pop();
            if(head == nullptr){
                head = tail = tmp.second; // 空链表时第一个结点作为头节点
            }
            else{
                tail->next = tmp.second; // 链表非空，将新结点加入到链表尾部
                tail = tail->next; // 更新尾指针
            }
            if(tmp.second->next != nullptr){ // 将下一个结点放到堆中，用于下一轮的比较
                Stack.push({tmp.second->next->val, tmp.second->next});
            }
        }
        return head;
    }

};

int main(int argc, char *argv[]){
    ListNode *Node1 = new ListNode(1);
    ListNode *Node2 = new ListNode(4);
    ListNode *Node3 = new ListNode(5);
    Node1->next = Node2;
    Node2->next = Node3;

    ListNode *Node4 = new ListNode(1);
    ListNode *Node5 = new ListNode(3);
    ListNode *Node6 = new ListNode(4);
    Node4->next = Node5;
    Node5->next = Node6;

    ListNode *Node7 = new ListNode(2);
    ListNode *Node8 = new ListNode(6);
    Node7->next = Node8;

    std::vector<ListNode*> Lists = {Node1, Node4, Node7};
    Solution S1;
    ListNode *NewList = S1.mergeKLists(Lists);
    while(NewList != nullptr){
        std::cout << NewList->val << " ";
        NewList = NewList->next;
    }
    return 0;
}

5--下一个排列（31）

主要思路：

         先判断当前排列是否是最大的排列；

        不是最大的排列，记录第一个不满足 a[i] > a[i+1] 的位置；

        从尾开始遍历，找到第一个 a[j] > a[i] 的位置，交换 a[j] 和 a[i]，并将 a[i] 之后的数据反转，使其变成升序；（结合实例比较容易理解：实例讲解）

#include <iostream>
#include <vector>   
#include <algorithm>

class Solution {
public:
    void nextPermutation(std::vector<int>& nums) {
        int len = nums.size();
        int i;
        for(i = len - 2; i >= 0; i--){
            if(nums[i+1] > nums[i]) break;
        }
        if(i == -1){ // 最大的排列
            std::reverse(nums.begin(), nums.end());
            return;
        }
        int j;
        for(j = len - 1; j > i; j--){
            if(nums[j] > nums[i]) break;
        }
        std::swap(nums[i], nums[j]);
        std::reverse(nums.begin()+i+1, nums.end());
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> input = {0, 3, 5, 4, 2, 1};
    S1.nextPermutation(input);
    for(int item : input){
        std::cout << item << " ";
    }
    return 0;
}

6--最长有效括号（32）

主要思路：

        左括号入栈，每遇到一个右括号弹出一个栈顶元素；当栈空时，表明某一段合法的字符串已经完全匹配成功，这时可以重新计算下一段合法的字符串；

        为了正确计算合法字符串的长度，需要记录一个左边界元素，初始化为-1；有效字符串长度等于最后一个合法字符串的索引值减去左边界元素；

        视频讲解参考：最长有效括号

#include <iostream>
#include <string>
#include <stack>

class Solution {
public:
    int longestValidParentheses(std::string s) {
        int n = s.length();
        std::stack<int> stk;
        stk.push(-1); // 左边界
        int ret = 0;
        for(int i = 0; i < n; i++){
            if(s[i] == '(') stk.push(i); // 左括号压栈
            else{ // 右括号
                if(stk.top() == -1 || s[stk.top()] == ')'){ // 无法匹配的情况
                    stk.push(i); // 更新左边界
                }else{
                    stk.pop();
                    int b = stk.top();
                    ret = std::max(ret, i - b); // 计算有效长度
                }
            }
        }
        return ret;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    std::string test = "()";
    int res = S1.longestValidParentheses(test);
    std::cout << res << std::endl;
    return 0;
}

7--搜索旋转排序数组（33）

主要思路：

        基于二分法，二分后肯定有一边是有序的，因此首先判断哪一边是有序，接着继续判断target是否在有序部分，如果不在则下一次二分的范围是无序部分；

        本题一个细节是边界=号的取法需要细心；

#include <iostream>
#include <vector>

class Solution {
public:
    int search(std::vector<int>& nums, int target) {
        if(nums.size() == 0) return -1;
        if (nums.size() == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int l = 0;
        int r = nums.size() - 1;
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(nums[mid] == target) return mid;
            
            if(nums[l] <= nums[mid]){ // [l, mid-1]有序
                if(nums[l] <= target && target < nums[mid]){
                    r = mid - 1;
                }
                else{
                    l = mid + 1;
                }

            }
            else{ // [mid, r]有序
                if(nums[mid] < target && target <= nums[r]){
                    l = mid + 1;
                }
                else{
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> test = {4,5,6,7,0,1,2};
    int target = 0;
    int res= S1.search(test, target);
    std::cout << res << std::endl;
}

8--在排序数组中查找元素的第一个​​​​​​​和最后一个位置（34）

主要思路：

        基于二分法，实现两个二分函数，分别查找第一个位置和最后一个位置；

#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<int> searchRange(std::vector<int>& nums, int target) {
        int left = find_left(nums, target);
        int right = find_right(nums, target);
        std::vector<int> res = {left, right};
        return res;
    }

    // 查找第一个等于target的位置
    int find_left(std::vector<int>& nums, int target){
        int l = 0, r = nums.size() - 1, res = -1;
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(nums[mid] < target){
                l = mid + 1;
            }
            // nums[mid] >= target: 当 nums[mid] == mid 时，左移(因为要找到第一个)，当 nums[mid] > target 时，也应该左移
            else{
                res = mid; // 记录可能的位置
                r = mid - 1;
            }
        }
        if(res == -1 || nums[res] != target) return -1; //未找到target
        return res;
    }

    // 查找最后一个等于target的位置
    int find_right(std::vector<int>& nums, int target){
        int l = 0, r = nums.size() - 1, res = -1;
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(nums[mid] <= target){ // 分析同理
                res = mid; // 记录可能的值
                l = mid + 1;
            }
            else{ // nums[mid] > target 
                r = mid - 1;
            }
        }
        if(res == -1 || nums[res] != target) return -1;
        return res;
    }
};

int main(int argc, char *argv[]){
    // nums = [5,7,7,8,8,10], target = 8
    std::vector<int> test = {1};
    int target = 0;
    Solution S1;
    std::vector<int> res = S1.searchRange(test, target);
    std::cout << "[" << res[0] << "," << res[1] << "]" << std::endl;
    return 0;
}

9--组合总和（39）

主要思路：

        递归暴力枚举是否选一个数，并更新对应的加和；

        回溯时应把当前数从容器中剔除；

#include <iostream>
#include <vector>

class Solution {
public:
    std::vector<std::vector<int>> combinationSum(std::vector<int>& candidates, int target) {
        dfs(candidates, target, 0, 0, tmp);
        return res;
    }

    void dfs(std::vector<int>& candidates, int target, int sum, int cur, std::vector<int> &tmp){
        if(cur == candidates.size()){
            if(sum == target) res.push_back(tmp);
            return;
        }

        // 不选择candidates[cur]
        dfs(candidates, target, sum, cur+1, tmp);
        // 选择candidates[cur]
        for(int i = 1; sum+i*candidates[cur] <= target; i++){ // 选取i个
            tmp.push_back(candidates[cur]);
            dfs(candidates, target, sum + candidates[cur] * i, cur+1, tmp);
        }

        // 回溯弹出
        while(!tmp.empty() && tmp.back() == candidates[cur]){
            tmp.pop_back();
        }
    }

private:
    std::vector<std::vector<int>> res;
    std::vector<int> tmp;
};

int main(int argc, char *argv[]){
    // candidates = [2,3,6,7], target = 7
    std::vector<int> test = {2, 3, 6, 7};
    int target = 7;
    Solution S1;
    std::vector<std::vector<int>> res = S1.combinationSum(test, target);
    for(auto v : res){
        for(auto item : v){
            std::cout << item << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

10--接雨水（42）

主要思路：

        维护一个单调栈，存储索引，栈顶到栈底元素对应的高度逐渐递增；

视频讲解参考

#include <iostream>
#include <vector>
#include <stack>

class Solution {
public:
    int trap(std::vector<int>& height) {
        std::stack<int> stk;
        int res = 0;
        for(int i = 0; i < height.size(); i++){
            while(!stk.empty() && height[i] > height[stk.top()]){
                int mid = stk.top();
                stk.pop();
                if(stk.empty()){
                    break;
                }
                int h = std::min(height[i], height[stk.top()]) - height[mid];
                int w = i - stk.top() - 1;
                res += h * w;
            }
            stk.push(i);
        }
        return res;
    }
};

int main(int argc, char *argv[]){
    // height = [0,1,0,2,1,0,1,3,2,1,2,1]
    std::vector<int> test = {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1};
    Solution S1;
    int res = S1.trap(test);
    std::cout << res << std::endl;
    return 0;
}

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode刷题笔记-堆
08-19
Leetcode刷题笔记—堆相关题型，刷透一道题顶10盲刷10道题，还在苦苦纠结于打开力扣直奔题解的苦恼吗? 赶快来看一看吧
Leetcode刷题笔记--Hot01-10
牵一只蜗牛去散步
05-31 344
基于滑动窗口和哈希表，用一个滑动窗口遍历字符串的字符，确保滑动窗口内的所有字符都是不重复的，当滑动字符不断扩大遇到重复字符时，将左指针右移，直到没有重复字符，这时比较滑动窗口的长度和最大长度的值，更新最大长度；使用双指针法，左指针指向左边的容器，右指针指向右边的容器，左容器容量低则左指针自增，右容器容量低则右指针自减，直到两个指针相遇，记录并更新最大容量值，具体原理证明见上面的讲解视频；遍历字符串的每个字符，用两个指针 l 和 r 分别指向其左字符和右字符，判断左字符和右字符是否相等，不断贪心向外扩展；
Leetcode刷题笔记--Hot61-70
牵一只蜗牛去散步
10-14 233
状态转移方程: dp[i][j] = std::min(dp[i-1][j-1], std::min(dp[i-1][j], dp[i][j-1])) + 1;不断将剩余先修课程数为0的课程加入到队列q中，当队列为空时，若修的课程数等于总课程数，则返回true，否则返回false；遍历两遍，第一遍求解L[i]，L[i]表示第i位左边所有数的乘积；基于动态规划，dp[i][j]表示以(i, j)为右下角，所构成正方形的最大边长。每修队列q中的课程，以该课程作为先修课程的所有课程，其剩余先修课程个数减1；
Leetcode刷题笔记--Hot51-60
牵一只蜗牛去散步
09-24 294
当一个桶不为空时，当准备放入一个新的元素时，如果新的元素与桶内的元素不相同，则不放入这个新元素且将桶内的一个元素拿出来；状态转移方程 dp[i][0] = dp[i-1][1] + nums[i]，dp[i][1] = dp[i-1][0];之所以使用 dp_min[i]，是由于会出现负数的情况，当负负得正时会出现更大的连续和，因此要考虑 dp_min[i]；访问到第i间房屋时，设dp[i][0]表示打劫第i间房屋，dp[i][1]表示不打劫第i间房屋，能够获得的最高金额；非常有哲学意义的一道题！
Leetcode刷题笔记--Hot91--100
牵一只蜗牛去散步
10-31 151
状态转移方程：dp[j] += dp[j - nums[i]]，其实质是：当背包已经装了nums[i]时，剩余容量为 j - nums[i]，此时装满剩余容量的方法数为 dp[j - nums[i]]，遍历不同的 nums[i] 将方法数相加即可；的总结点数，例如上图中[4, 2, 1, 3]可以理解为以 1 为根节点，其左子树路径的最大结点数为[4, 2]，右子树路径的最大结点数为[3]；递归二叉树，对于每一个节点，递归求解左子树的结点数，右子树的结点数，向上返回最大的节点树；7--合并二叉树（617）
谷歌师兄的leetcode刷题笔记-blog:博客
06-30
谷歌师兄的leetcode刷题笔记完美无瑕 一个基于 Tufte CSS 的漂亮、快速、兼容 AMP 的 Jekyll 主题。 Immaculate 真的很快，这要归功于 Google AMP。 当通过 Google 的 CDN 提供服务时，您会看到典型的...
谷歌师兄的leetcode刷题笔记-momentum:势头
06-30
谷歌师兄的leetcode刷题笔记动力是给男人的 我们的重点是男人的工作，并成为我们能做到的最好的男人。 我们支持男人拥有真正的友谊 当然，我们喜欢一起玩乐，但我们正在寻找更多的东西：与我们信任的伟人建立真正的...
Leetcode刷题笔记-大厂面试突破集
08-15
莘莘学子，苦逼码农，皓首穷经，只为进厂。今拾得Leetcode打谱集一部，不敢独享，特献给广大程序员。
谷歌师兄的leetcode刷题笔记-saltride:盐渍
06-30
谷歌师兄的leetcode刷题笔记离子盐之旅 IonSaltRide 是一个实验项目，旨在提供一个易于使用的移动应用程序，以帮助我们丰盛生命教会的访客和工作人员。 这是一个绿色项目，将专注于它的可用性，以帮助新用户和有经验...
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环）
<font color="Pink">Tisfy的博客</font>
05-18 856
LeetCode 2644.找出可整除性得分最大的整数：暴力模拟（两层循环） 给你两个下标从 0 开始的整数数组 nums 和 divisors 。 divisors[i] 的 可整除性得分 等于满足 nums[j] 能被 divisors[i] 整除的下标 j 的数量。 返回 可整除性得分 最大的整数 divisors[i] 。如果有多个整数具有最大得分，则返回数值最小的一个。
LeetCode 235. 二叉搜索树的最近公共祖先
2301_80211119的博客
05-16 686
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
贪心 -力扣860.柠檬水找零力扣2208.将数组和减半的最少操作次数力扣179.最大数力扣376.摆动序列
weixin_72953218的博客
05-14 456
贪心 -力扣860.柠檬水找零力扣2208.将数组和减半的最少操作次数力扣179.最大数力扣376.摆动序列
LeetCode 108.将有序数组转换为二叉搜索树
2301_80211119的博客
05-18 815
给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 平衡 二叉搜索树。
力扣204.计数质数（线性筛）
ouliten的博客
05-17 168
假设不中断，对于i*primes[j+1]这个合数，它被primes[j+1]这个质数标记.但实际上，它的最小质数因该是primes[j],因为当i' =(i/primes[j])*primes[j+1]时，i' *primes[j]==i*primes[j+1],可知它因该被primes[j]这个质数标记。线性筛我之前的题解已经涉及到，但是讲的实在太差了我自己回看都看不懂，于是通过这道题重新回顾线性筛。（p,q等都是质因数，n,m是指数），其中一定会有一个最小的质数，我们的目的是要标记一个合数。
Golang | Leetcode Golang题解之第91题解码方法
weixin_66442839的博客
05-16 278
Golang | Leetcode Golang题解之第91题解码方法
代码随想录Day40：Leetcode343、96
maybeyaluokenai的博客
05-15 449
Leetcode343、96
【缺失的第一个正数】leetcode,python
m0_73629042的博客
05-18 231
总结：我觉得一个关键点是将[1,n]外的点全部赋值为0，这样的话，我们就能将问题转换为[1,n]上，就能使用先前的哈希表方法了。直接上石山代码：（过不了一点）。真是越做越觉得自己所学尚浅，，
力扣-219. 存在重复元素 II
最新发布
ls3614140的博客
05-19 94
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k。如果存在，返回 true；否则，返回 false。输入：nums = [1,2,3,1,2,3], k = 2。输入：nums = [1,2,3,1], k = 3。输入：nums = [1,0,1,1], k = 1。
leetcode刷题手册c++版
09-07
LeetCode刷题手册C版是一本针对程序员刷题的教材，旨在帮助他们提高编程能力、学习算法和数据结构。C语言作为一门广泛应用于系统编程和嵌入式开发的语言，在LeetCode刷题中也是非常重要的一种编程语言。 这本手册...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值