Leetcode 题库解答

原创 已于 2025-09-21 23:49:46 修改 · 215 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2025-06-28 22:47:13 首次发布
1. 两数之和

解法1：暴力解法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int size = nums.size();
        vector<int> result;
        for (int i = 0; i < size ; i++) {
            for (int j = i + 1; j < size ; j++){
                if (nums[i] + nums[j] == target) {
                    result.push_back(i);
                    result.push_back(j);
                    return result;
                }
            }
        }
        return result;
    }
};

解法2：unordered_map

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        unordered_map<int,int> map;
        for (int i = 0;i < n;i++){
            if (map.count(nums[i]) == 0) map[nums[i]] = i;
            if (map.count(target-nums[i]) != 0 && map[target-nums[i]] != i) 
                return{map[target-nums[i]],i};
        }
        return {};
    }
};
2. 两数相加

（暴力解法：倒转+倒转）

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int num1 = 0, num2 = 0;
        ListNode* temp = l1;
        int idx = 0;
        while(temp) {
            num1 += (temp->val) * pow (10, idx);
            idx += 1;
            temp = temp->next;
        }
        temp = l2;
        idx = 0;
        while(temp) {
            num2 += (temp->val) * pow (10, idx);
            idx += 1;
            temp = temp->next;
        }
        int result = num1 + num2;
        ListNode *ans = new ListNode(result % 10);
        ListNode* ptr = ans;
        result /=10;
        while(result){
            ans->next = new ListNode(result % 10);
            ans = ans->next;
            result /=10;
        }
        return ptr;
    }
};

逐位相加：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carry = 0;
        ListNode* result = nullptr;
        ListNode* ptr;
        while(l1 || l2) {
            int num1 = l1 ? l1->val : 0;
            int num2 = l2 ? l2->val : 0;
            int sum = num1 + num2 + carry;
            if (!result) {
                ptr = result = new ListNode(sum % 10);
            }
            else {
                result->next = new ListNode(sum % 10);
                result = result->next;
            }
            carry = sum / 10;
            if (l1) l1 = l1->next;
            if (l2) l2 = l2->next;
        }
        if (carry > 0) {
            result->next = new ListNode(carry);
        }
        return ptr;
    }
};
3. 无重复字符的最长子串

解法1（set）：滑动窗口

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int start = 0, end = 0;
        int max_size = 0;
        set<char> group; 
        while (start < s.length()) {
            while (end < s.length() && group.count(s[end]) == 0) {
                group.insert(s[end]);
                end += 1;
            }
            max_size = std::max(max_size, int(group.size()));
            while (s[start] != s[end]) {
                group.erase(s[start]);
                start += 1;
            }   
            group.erase(s[start]);
            start += 1;
        }
        return max_size;
    }
};

解法2（unordered_map）：滑动窗口

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> charIndexMap;
        int maxLength = 0;
        int start = 0;

        for (int end = 0; end < s.length(); ++end) {
            char currentChar = s[end];
            if (charIndexMap.find(currentChar) != charIndexMap.end()) {
                start = max(start, charIndexMap[currentChar] + 1);
            }
            charIndexMap[currentChar] = end;
            maxLength = max(maxLength, end - start + 1);
        }
        return maxLength;
    }
};

解法3（int flag[128]）：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int n = s.size();
        if (n == 0)
            return 0;
        int ans = 0;
        int flag[128] = { 0 };
        int left = 0, right = 0;
        int count = 0;
        while (right < n) {
            if (++flag[s[right]] == 2)
                count++;
            right++;
            while (count > 0) {
                if (--flag[s[left]] == 1)
                    count--;
                left++;
            }
            ans = max(ans, right - left);
        }
        return ans;
    }
};
5. 最长回文字串
class Solution {
public:
    string longestPalindrome(string s) {
        int length = 0;
        int start = 0;
        int flag = 0;
        for(int i = 0; i < s.length() - 1; i++){
            //奇数情况
            int count = 0;
            while( i - count >= 0 && i + count < s.length() && s[i - count] == s[i + count]){
                count++;
            }
            count--;
            if(count > length){
                start = i - count;
                length = count;
                flag = 0;
            }
            //偶数情况
            if(i + 1 < s.length() && s[i] == s[i + 1]){
                count = 0;
                while (i - count >= 0 && i + count + 1 < s.length() && s[i - count] == s[i + 1 + count])
                    count ++;
                count --;
                if(2 * count + 2 > 2 * length + 1){
                    flag = 1;
                    start = i - count;
                    length = count;
                }
            }
            
        }
        if (flag) return s.substr(start, 2 * length + 2);
        return s.substr(start, 2 * length + 1);
    }
};
6. Z字形变换
class Solution {
public:
    string convert(string s, int numRows) {
        vector<vector<string>> container;
        int flag = 0;
        int line = 0;
        for(int i = 0; i < s.length(); i++) {
            container[line].push_back(s[i]);
            if(!flag) line ++;
            else line --;
            if( line == numRows || line == 0 ) flag = (flag + 1) % 2;
        }
        int idx = 0;
        while(idx < container.size()){
            vector<string> temp = container[idx];
            int index = 0;
            while(index < temp.size()){
                cout << temp[index];
            }
            idx++;
        }
    }
};
20. 有效的括号
class Solution {
public:
    bool isValid(string s) {
        stack<char> ops;
        for (int i = 0;i < s.length(); i++) {
            if (s[i] == '(' || s[i] == '[' || s[i] == '{') ops.push(s[i]);
            else {
                if (ops.empty()) return false;
                char op = ops.top();
                ops.pop();
                if (s[i] == ')' && op != '(') return false;
                if (s[i] == ']' && op != '[') return false;
                if (s[i] == '}' && op != '{') return false;
            }
        }
        if (!ops.empty()) return false;
        return true;
    }
};
26. 删除有序数组中的重复项
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        set<int> once;
        for(int i = 0; i < nums.size(); i++) {
            if(once.find(nums[i]) != once.end()) {
                nums.erase(nums.begin() + i);
                i--;
            }
            else {
                once.insert(nums[i]);
            }
        }
        return nums.size();
    }
};
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
};
27. 移除元素
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int k = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] != val) {
                nums[k] = nums[i];
                k++;
            }
        }
        return k;
    }
};
94. 二叉树的中序遍历

解法1: 递归

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        if (!root) return result;
        vector<int> left = inorderTraversal(root->left);
        result.insert(result.end(), left.begin(), left.end());
        result.push_back(root->val);
        vector<int> right = inorderTraversal(root->right);
        result.insert(result.end(), right.begin(), right.end());
        return result;
    }
};

 解法2:迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        while (root != nullptr || !stk.empty()) {
            while (root != nullptr) {
                stk.push(root);
                root = root->left;
            }
            root = stk.top();
            stk.pop();
            res.push_back(root->val);
            root = root->right;
        }
        return res;
    }
};

125. 验证回文串
class Solution {
public:
    bool isPalindrome(string s) {
        int start = 0, end = s.length() - 1;
        while (start < end) {
            while (start < end && !isalpha(s[start]) && !isdigit(s[start])) start += 1;
            while (start < end && !isalpha(s[end]) && !isdigit(s[end])) end -= 1;
            if (tolower(s[start]) != tolower(s[end])) {
                return false;
            }
            start += 1 ;
            end -= 1;
        }
        return true;
    }
};
485. 最大连续1的个数
class Solution {
public:
    int findMaxConsecutiveOnes(vector<int>& nums) {
        int max = 0;
        int temp = 0;
        for(int i = 0; i < nums.size(); i++) {
            if(nums[i] == 1) {
                temp++;
            }
            else {
                max = (temp > max) ? temp : max;
                temp = 0;
            }
        }
        max = (temp > max) ? temp : max;
        return max;
    }
};
704. 二分查找
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int start = 0, end = nums.size() - 1;
        int pivot;
        while(start <= end) {
            pivot = (start + end)/2;
            if(nums[pivot] == target) return pivot;
            else if(nums[pivot] < target) start = pivot + 1;
            else end = pivot - 1;
        }
        return -1;
    }
};
1935. 可以输入的最大单词数

解法一：标记数组

class Solution {
public:
    int canBeTypedWords(string text, string brokenLetters) {
        int sum = 0;
        int mask[26] = {0};
        for (int i = 0; i < brokenLetters.length(); i++) {
            mask[brokenLetters[i]-'a'] = 1;
        }
        for (int index = 0; index < text.length(); index++) {
            bool flag = true;
            while(index < text.length() && text[index]!=' '){
                if (!flag) {
                    index++;
                    continue;
                }
                if (mask[text[index]-'a'] == 1){
                    flag = false;
                }
                index++;
            }
            if(flag) sum += 1;
        }
        return sum;
    }
};

解法二：哈希数组

class Solution {
public:
    int canBeTypedWords(string text, string brokenLetters) {
        unordered_set<char> broken;
        for (char ch: brokenLetters){
            broken.insert(ch);
        }
        int res = 0;
        bool flag = true;
        for (char ch: text){
            if (ch == ' '){
                if (flag){
                    ++res;
                }
                flag = true;
            }
            else if (broken.count(ch)){
                flag = false;
            }
        }
        if (flag){
            ++res;
        }
        return res;
    }
};

/*
作者：力扣官方题解
链接：https://leetcode.cn/problems/maximum-number-of-words-you-can-type/solutions/883398/ke-yi-shu-ru-de-zui-da-dan-ci-shu-by-lee-5dpc/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
*/
2197. 替换数组中的非互质数

解法一：暴力查找

class Solution {
public:
    vector<int> replaceNonCoprimes(vector<int>& nums) {
        for(int i = 0; i < nums.size() - 1; i++) {
            int j = gcd(nums[i],nums[i + 1]);
            if (j>1) {
                nums[i] = nums[i] / j * nums[i + 1];
                nums.erase(nums.begin() + i + 1);
                if (i >= 1) {
                    i -= 2;
                }
                else i = -1;
            }

        }
        return nums;
    }
};

解法二：局部存储，栈

class Solution {
public:
    vector<int> replaceNonCoprimes(vector<int>& nums) {
        vector<int> ans;
        for (int num: nums) {
            while (!ans.empty()) {
                int g = gcd(ans.back(), num);
                if (g > 1) {
                    num = ans.back() / g * num;
                    ans.pop_back();
                }
                else {
                    break;
                }
            }
            ans.push_back(num);
        }
        return ans;
    }
};

其中gcd实现算法为辗转相除法：

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
3408. 设计任务管理器
class TaskManager {
public:
    TaskManager(vector<vector<int>>& tasks) {
        for (int i = 0; i < tasks.size(); i++) {
            order.emplace(tasks[i][2],tasks[i][1]);
            myTasks[tasks[i][1]] = {tasks[i][2], tasks[i][0]};
        }
    }
    
    void add(int userId, int taskId, int priority) {
        myTasks[taskId] = {priority, userId};
        order.emplace(priority, taskId);
    }
    
    void edit(int taskId, int newPriority) {
        if (myTasks.find(taskId)!= myTasks.end()){
            myTasks[taskId].first = newPriority;
            order.emplace(newPriority,taskId);
        }
    }
    
    void rmv(int taskId) {
        myTasks.erase(taskId);
    }
    
    int execTop() {
        while (!order.empty()) {
            auto [priority, taskId] = order.top();
            auto it = myTasks.find(taskId);
            if (it == myTasks.end() || it->second.first != priority) {
                order.pop();
            } else {
                int userId = it->second.second;
                myTasks.erase(it);
                order.pop();
                return userId;
            }
        }
        return -1;
    }
private:
    priority_queue<pair<int,int>> order;
    unordered_map<int, pair<int,int>> myTasks;
};

标签
#leetcode #算法 #数据结构
silkworm_23
关注
深入理解JavaScript中的this关键字
03-17
NULL 博文链接：https://wv1124.iteye.com/blog/505236
JS中的this关键字详解
前端菜菜DayDayUp的博客
09-08 1265
this是Javascript语言的一个关键字它代表函数运行时，自动生成的一个内部对象，只能在函数内部使用,下面分四种情况，详细讨论this的用法，感兴趣的朋友可以了解下 this是Javascript语言的一个关键字。 它代表函数运行时，自动生成的一个内部对象，只能在函数内部使用。比如， function test(){ 　　this.x = 1; } 随着函数使用场合的不同，this的值会发生变化。但是有一个总的原则，那就是this指的是调用函数的那个对象。 一、下面分四种情况，详细..
JS中this关键字详解
firstcode666的博客
12-28 984
本文主要解释在JS里面this关键字的指向问题(在浏览器环境下)。 阅读此文章，还需要心平气和的阅读完，相信一定会有所收获，我也会不定期的发布，分享一些文章，共同学习 首先，必须搞清楚在JS里面，函数的几种调用方式: 普通函数调用 作为方法来调用 作为构造函数来调用 使用apply/call方法来调用 Function.prototype.bind方法 es6箭头函数 但是不管函数是按哪种方法来调用的，请记住一点：谁调用这个函数或方法,th..
JavaScript中的“this”关键字的保姆级详解！纯干货
m0_49931406的博客
09-26 2501
了解完上面的内容，你对JS中的this关键字就已经有了一个比较全面的了解。我们在工作或者学习过程中可以尝试经常去运用this关键字，这样可以加深我们的记忆和理解，以便于之后更好的使用到这个工具，帮助我们提高工作效率。
如何理解js中的this
weixin_69830171的博客
07-13 2011
this的值取决于它所在的函数如何被调用。下面是this可以获得新值的6种不同方式：下面我们一起来看看this是如何在每个环境中被改变的。当this在任何函数外面被调用时，也就是说在全局环境中被调用，在浏览器中。它默认指向window对象。 一般在全局环境中，我们很少用this关键字 ，所以我们对它也没有那么在意，继续看下一个环境。当我们使用new关键字创建一个对象的新的实例时，this关键字指向这个实例。 通过上面的代码，我们会发现，greg是Human的一个实例，现在无论何时调用greg，thi
Java中this和super关键字的使用方法(形似/不同，有史以来最详细)
zpf1813763637的博客
09-17 562
this和super关键字 this关键字 1、this的含义 this代表当前对象 2、this使用位置 this在实例初始化相关的代码块和构造器中：表示正在创建的那个实例对象，即正在new谁，this就代表谁 this在非静态实例方法中：表示调用该方法的对象，即谁在调用，this就代表谁。 this不能出现在静态代码块和静态方法中 3、this使用格式 （1）this.成员变量名 当方法的局部变量与当前对象的成员变量重名时，就可以在成员变量前面加thi.
JS学习笔记三
liuqinhou的博客
02-09 573
js基础
解析JavaScript--关键字this
郊眠寺
10-13 787
它将VUE的各个知识点进行了总结，整理成了《Vue 开发必须知道的36个技巧》。内容比较详实，对各个知识点的讲解也十分到位
JavaScript中this的理解
sdasadasds的博客
05-11 1126
JavaScript中this的理解 在 JavaScript 编程中，this 关键字非常重要，也比较难理解，经常让初学者比较迷惑，所有今天我们一起来聊一下this关键字。 一.this的概述 this是Javascript语言的一个关键字，它代表函数运行时,自动生成的一个内部对象，只能在函数内部使用，随着函数使用场合的不同，this的值会发生变化，但是有一个总的原则，那就是this指的是调用函数的那个对象。 总结：谁调用了这个函数，this指向谁(对象) 二.this的指向 因为this存在于函数内部，
js中关键字this的理解
m0_54510474的博客
06-03 436
js内部函数的调用，this关键字的理解
JavaScript this关键字的理解
后端开发，记录学习心得
04-06 1304
JavaScript this 关键字的理解 仅供个人学习做笔记使用，大佬轻喷 直接输出this指向全局对象 console.log(this) 全局函数其实是window(全局对象)的方法 function fun { console.log(this); } fun();//等价 window.fun() 3.this放在方法中，this 指向调用这个方法的对象 let cat = { name="喵喵"， sayName(){ console.log("我是"+this.nam
关于js里的this关键字的理解
灵云山的博客
06-30 717
this关键字在c++，java中都提供了这个关键字，在刚开始学习时觉得有难度，但是只要理解了，用起来就方便多了，下面通过本篇文章给大家详解js里this关键字的理解。 关于this，是很多前端面试必考的题目，有时候在网上看到这些题目，自己试了一下，额，还真的错了！在实际开发中，也会遇到 this 的问题（虽然一些类库会帮我们处理），例如在使用一些框架的时候，例如:knockout，有时候不明白
js中对this关键字的理解
SprintMan的博客
11-09 4892
this是Javascript语言的一个关键字。它代表函数运行时，自动生成的一个内部对象，只能在**函数内部使用**。 比如， 理解this指代什么的关键点在与： 看这个this指的是局部对象还是全局对象（global）默认在"script"标签中写的成员变量和方法都属于全局对象（global）所有，global对象其实是不存在的，当js在浏览器上应用的时候，**window对象是浏览器引擎对global对象的封装，
Js中的this关键字解析
Andrew_Lii的博客
11-20 308
学习this关键字的第一步是理解： this并不指向函数本身 this也不指向函数的词法作用域 this是在运行时进行绑定的，并不是在编写代码时绑定的，它的上下文取决于函数调用的各种条件，而和函数的声明位置没有任何关系，只取决于函数的调用方式 当一个函数调用时，会创建一个活动记录（有时候也称之为执行上下文），这个记录会包含函数： 调用位置 调用方式 传入的参数信息 等等… this就是这个...
正确理解javascript的this关键字
精彩人生
04-13 566
来源：http://js8.in/851.html javascript有this关键字，this跟javascript的执行上下文密切相关，很多前端开发工程师至今对this关键字还是模棱两可，本文将结合代码讲解下javascript的this关键字。 this和对象的关系 首先来看下面的代码： var person = { name:'Theo Wong', gender
深入理解JavaScript-this关键字
军火库
11-16 420
在讲Function、作用域时，我们都讲到了 this，因为 JavaScript 中的作用域是词法作用域，在哪里定义，就在哪里形成作用域。而与词法作用域相对应的还有一个作用域叫动态作用域，调用时去寻找它所处的位置。那个时候笔者就说 this 机制和动态作用域很像构造函数就是个模板，this 未来会指向 new 出来的对象。创建 Person 的实例时，this.name 将引用新创建的对象，并将一个名为 name 的属性放入新对象中this 其实很好理解，它就是一个代词，表示“这个”
JS 中 this 关键字详解
weixin_33862041的博客
08-03 288
本文主要解释在JS里面this关键字的指向问题(在浏览器环境下)。 首先，必须搞清楚在JS里面，函数的几种调用方式: 普通函数调用 作为方法来调用 作为构造函数来调用 使用apply/call方法来调用 Function.prototype.bind方法 es6箭头函数 但是不管函数是按哪种方法来调用的，请记住一点：谁调用这个函数或方...
JavaScript中的this关键字如何理解？
IT_10的博客
07-16 1157
1.this是一个关键字，不是变量，也不是属性名，在JavaScript中不允许给this赋值。 2.关键字this没有作用域的限制，嵌套的函数不会从调用它的函数中继承this。 3.如果嵌套的函数作为方法调用，其this的值指向调用它的对象；如果嵌套的函数作为函数调用，其this值是全局变量（非严格模式下）或者是undefined（严格模式下）。一定不能误以为调用嵌套函数时this会指向调用...
如何理解 JS 中的this关键字
CKZCH的博客
10-24 370
如何理解 JS 中的this关键字 this的指向跟调用方式有关，如果函数使用"()"来调用，那看一下括号前面是不是函数名，如果是，看函数名前面有没有对象 有，this指向该对象 没有， Nodejs环境中 this --> global 对象 浏览器环境中 this --> window 对象 举例说明： var money = "想要变成有钱人" var obj1 = { money:"我有一个亿",
深入理解Javascript之this关键字
liqiangcfc的专栏
01-14 600
<br /><br />Javascript是一种很灵活的语言, 而This关键字又是灵活中的灵活, 但是因为它的灵活, 也注定了它的难用.<br />以前我用this的时候, 都会觉得不踏实, 老是担心它不知道怎么地就会指到另外的什么地方.<br />其实, 这都是因为, 我们对它的不了解.<br />刚好最近再给百度学院做《Javascript高级-作用域/原型链》的ppt, 而swit1983网友也刚好提这个问题, 索性就把这部分内容独立总结出来, 与大家分享.<br />首先, 我先抛出一个定论:”
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值