LeetCode

最新推荐文章于 2024-08-10 16:13:14 发布
原创 最新推荐文章于 2024-08-10 16:13:14 发布 · 276 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Leetcode

本文精选LeetCode上的经典算法题目，包括两数之和、两数相加、无重复字符的最长子串等，详细解析了每道题目的解题思路与代码实现，旨在帮助读者深入理解算法设计与优化。

1、两数之和:
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
方法一：暴力
方法二：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        if(nums.empty()){
            return res;
        }
        int n=nums.size();
        unordered_map<int,int> maps;
        for(int i=0;i<n;i++){
            maps[nums[i]]=i;
        }
        for(int i=0;i<n;i++){
            auto item=maps.find(target-nums[i]);
            if(item!=maps.end() && item->second!=i){
                res.push_back(i);
                res.push_back(item->second);
                break;
            }
        }
        return res;
    }
};

方法三：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        if(nums.empty()){
            return res;
        }
        int n=nums.size();
        unordered_map<int,int> maps;
        
        for(int i=0;i<n;i++){
            auto item=maps.find(target-nums[i]);
            if(item!=maps.end() && item->second!=i){
                res.push_back(item->second);
                res.push_back(i);
                break;
            }
            maps[nums[i]]=i;
        }
        return res;
    }
};

2、两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1==NULL && l2==NULL) return NULL;
        if(l1==NULL) return l2;
        if(l2==NULL) return l1;
        ListNode * newHead=new ListNode(-1);
        ListNode * p=newHead;
        int add=0;
        while(l1!=NULL && l2!=NULL){
            int sum=l1->val+l2->val+add;
            add=sum/10;
            ListNode * temp=new ListNode(sum%10);
            p->next=temp;
            p=p->next;
            l1=l1->next;
            l2=l2->next;
        }
        while(l1!=NULL){
            int sum=l1->val+add;
            add=sum/10;
            ListNode * temp=new ListNode(sum%10);
            p->next=temp;
            p=p->next;
            l1=l1->next;
        }
        while(l2!=NULL){
            int sum=l2->val+add;
            add=sum/10;
            ListNode * temp=new ListNode(sum%10);
            p->next=temp;
            p=p->next;
            l2=l2->next;
        }
        //重点别忘了最后的进位
        if(add==0)
            return newHead->next;
        ListNode * temp=new ListNode(add);
        p->next=temp;
        return newHead->next;
    }
};

缩减代码：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        if(l1==NULL && l2==NULL) return NULL;
        if(l1==NULL) return l2;
        if(l2==NULL) return l1;
        ListNode * newHead=new ListNode(-1);
        ListNode * p=newHead;
        int add=0;
        while(l1!=NULL || l2!=NULL){
            int sum=l1!=NULL?l1->val:0;
            sum+=l2!=NULL?l2->val:0;
            sum+=add;
            add=sum/10;
            ListNode * temp=new ListNode(sum%10);
            p->next=temp;
            p=p->next;
            if(l1!=NULL)  l1=l1->next;
            if(l2!=NULL)  l2=l2->next;
        }
        if(add>0)
            p->next=new ListNode(add);
        return newHead->next;
    }
};

3. 无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.empty()){
            return 0;
        }
        int n=s.size();
        if(n==1){
            return 1;
        }
        vector<int> count(256,0);
        int left=0,right=0;
        int maxLen=-1;
        while(right<n){
            int index=s[right];
            while(count[index]==1){
                count[s[left]]--;
                left++;
            }
            count[index]++;
            right++;
            maxLen=max(maxLen,right-left);
        }
        return maxLen;
    }
};

方法二：

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if(s.empty()){
            return 0;
        }
        int n=s.size(),ans=0;
        vector<int> index(128);//current index of char
        for(int j=0,i=0;j<n;j++){
            i=max(index[s[j]],i);
            ans=max(ans,j-i+1);
            index[s[j]]=j+1;
        }
        return ans;
    }
};

5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”
方法一：暴力
方法二：

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty()){
            return "";
        }
        int n=s.size();
        int start=0,maxLen=0;
        for(int i=0;i<n;i++){
            int len1=patter(s,i,i);
            int len2=patter(s,i,i+1);
            if(len1>maxLen && len1>len2){
                start=i-len1/2;
                maxLen=len1;
            }
            if(len2>maxLen && len2>len1){
                start=i-len2/2+1;
                maxLen=len2;
            }
        }
        return s.substr(start,maxLen);
    }
    int patter(string s,int i,int j){
        while(i>=0 && j<s.size() && s[i]==s[j]){
            i--;
            j++;
        }
        return j-i-1;
    }
};

方法三：动态规划

class Solution {
public:
    string longestPalindrome(string s) {
        if(s.empty()){
            return "";
        }
        int n=s.size();
        vector<vector<bool> > dp(n,vector<bool>(n,false));
        int start=0,maxLen=0;
        for(int i=0;i<n;i++){
            for(int j=i;j>=0;j--){
                dp[j][i]=(s[i]==s[j] && (i-j<2 || dp[j+1][i-1]));
                if(dp[j][i] && i-j+1>maxLen){
                    start=j;
                    maxLen=i-j+1;
                }
            }
        }
        return s.substr(start,maxLen);
    }
    
};

6. Z 字形变换
将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：

L C I R
E T O E S I I G
E D H N
之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);
示例 1:

输入: s = “LEETCODEISHIRING”, numRows = 3
输出: “LCIRETOESIIGEDHN”

class Solution {
public:
    string convert(string s, int numRows) {
        if(s.empty() || numRows==1){
            return s;
        }
        
        int len=numRows+numRows-2;
        vector<string> res(numRows,"");
        for(int i=0;i<s.size();i++){
            int yu=i%len;
            if(yu<numRows){
                res[yu]+=s[i];
            }else{
                int index=numRows-(yu-numRows+2);
                res[index]+=s[i];
            }
        }
        string result;
        for(int i=0;i<res.size();i++){
            result+=res[i];
        }
        return result;
    }
};

7. 整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:

输入: 123
输出: 321
示例 2:

输入: -123
输出: -321
示例 3:

输入: 120
输出: 21
注意:

假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

class Solution {
public:
    int reverse(int x) {
        
        long res=0;
        while(x!=0){
            res=res*10+x%10;
            x=x/10;
        }
        long left=pow(-2,31),right=pow(2,31)-1;
        if(res<INT_MIN || res>INT_MAX){
            return 0;
        }
        return res;
    }
};

9. 回文数

class Solution {
public:
    bool isPalindrome(int x) {
   		// 特殊情况：
        // 如上所述，当 x < 0 时，x 不是回文数。
        // 同样地，如果数字的最后一位是 0，为了使该数字为回文，
        // 则其第一位数字也应该是 0
        // 只有 0 满足这一属性
        if(x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }
        long long res=0;
        int y=x;
        while(x>res){
            res=res*10+x%10;
            x=x/10;
        }
        // 当数字长度为奇数时，我们可以通过 revertedNumber/10 去除处于中位的数字。
        // 例如，当输入为 12321 时，在 while 循环的末尾我们可以得到 x = 12，
        //revertedNumber = 123，
        // 由于处于中位的数字不影响回文（它总是与自己相等），所以我们可以简单地将其去除。
        return x==res || x==res/10;
    }
};

11. 盛最多水的容器
在这里插入图片描述

class Solution {
public:
    int maxArea(vector<int>& height) {
        if(height.empty()){
            return 0;
        }
        int maxArea=-1;
        int left=0,right=height.size()-1;
        while(left<right){
            maxArea=max(min(height[left],height[right])*(right-left),maxArea);
            if(height[right]>height[left]){
                left++;
            }else{
                right--;
            }            
        }
        return maxArea;
    }
};

12. 整数转罗马数字

在这里插入图片描述

class Solution {
public:
    string intToRoman(int num) {
        int values[]={1000,900,500,400,100,90,50,40,10,9,5,4,1};
        string reps[]={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
        string res;
        for(int i=0;i<13;i++){
            while(num>=values[i]){
                num-=values[i];
                res+=reps[i];
            }
        }
        return res;
    }
};

15. 三数之和
给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int> > res;
        if(nums.empty() || nums.size()<3){
            return res;
        }
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size()-2;i++){
            if(nums[i]>0){
                break;
            }
            if(i>0 && nums[i]==nums[i-1]) continue;
            int left=i+1,right=(int)nums.size()-1;
            while(left<right){
                if(nums[left]+nums[right]==0-nums[i]){
                    res.push_back({nums[i],nums[left],nums[right]});
                    while(left<right && nums[left] == nums[left+1]) left++;
                    while(left<right && nums[right]==nums[right-1]) right--;
                    left++;
                    right--;
                }else if(nums[left]+nums[right]<0-nums[i]){
                    left++;
                }else{
                    right--;
                }
            }
        }
        return res;
    }
};

18. 四数之和
在这里插入图片描述

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int> > res;
        if(nums.empty() || nums.size()<4){
            return res;
        }
        sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size()-3;i++){
            if(i>0 && nums[i]==nums[i-1]) continue;
            for(int j=i+1;j<nums.size()-2;j++){
                if(j>i+1 && nums[j]==nums[j-1]) continue;
                int left=j+1,right=nums.size()-1;
                while(left<right){
                    int sum=nums[i]+nums[j]+nums[left]+nums[right];
                    if(sum==target){
                        res.push_back({nums[i],nums[j],nums[left],nums[right]});
                        while(left<right && nums[left]==nums[left+1]) left++;
                        while(left<right && nums[right]==nums[right-1]) right--;
                        left++;
                        right--;
                    }else if(sum<target){
                        left++;
                    }else{
                        right--;
                    }
                }
            }
        }
        return res;
    }
};

19. 删除链表的倒数第N个节点
注意边界问题
在这里插入图片描述

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==NULL){
            return head;
        }
        ListNode * fast=head,* slow=head;
        int k=1;
        while(fast!=NULL){
            if(k<=n+1){
                fast=fast->next;
                k++;
            }else{
                slow=slow->next;
                fast=fast->next;
            }
        }
        if(k<=n+1)
            return head->next;
        slow->next=slow->next->next;
        return head;
    }
};

22. 括号生成
在这里插入图片描述

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        help(res,"",0,0,n);
        return res;
    }
    void help(vector<string> &res,string cur,int open,int close,int max){
        if(cur.size()==max*2){
            res.push_back(cur);
            return ;
        }
        if(open<max)
            help(res,cur+"(",open+1,close,max);
        if(close<open)
            help(res,cur+")",open,close+1,max);
    }
};
自用leetcode IDEA插件配置
weixin_43303286的博客
08-21 458
然后temp文件夹保存在/leetcode-java/src（要不重新配置JDK特别麻烦）
给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置,你的算法时间复杂度必须是 O(log n) 级别。
qq_43328798的博客
08-19 1379
#include<iostream> #include<vector> #include<string> using namespace std; int main() { string str; while (getline(cin,str)) { int target; cin >> target; vector<int> num; int count = 0; for (int i = 0; i <=str.s
LeetCode解题汇总目录
热门推荐
Michael是个半路程序员
09-06 8万+
此篇为学习完《数据结构与算法之美》后，在LeetCode刷题的汇总目录，方便大家查找（Ctrl+Find），一起刷题，一起PK交流！如果本文对你有帮助，可以给我点赞加油！ Updated on 2022.6.12刷题可以按照不同的专题进行，便于加强某个知识点的理解。另有《剑指Offer》面试题（更新完毕）、《程序员面试金典》面试题（更新完毕）、LintCode代码能力测试CAT。LeetCode MySQL 数据库解题目录点击访问 我的 LeetCode 主页我的 GitHub 主页注：本文超过字数限制，
Leetcode
weixin_44576047的博客
04-23 330
Leetcode头文件
记录个人学习、笔记
10-08 716
方便做leetcode的工具类头文件
LeetCode刷题攻略
最新发布
Jak的博客
08-10 1521
分析错误：如果遇到错题，仔细分析错误原因并查找资料进行补充学习。回顾解法：总结解法背后的算法思路及其适用场景，确保知识内化。通过系统性刷题、定期复习、充分利用讨论区和总结错题，可以更有效地提高自己的算法能力和面试准备程度。最重要的是保持持续学习的态度和耐心，不断挑战自我。祝你在 LeetCode 刷题和面试中取得优秀的成绩！如果你还有其他具体问题或需要进一步的帮助，请告诉我！
LeetCode的使用方法
科学的N次方
04-01 1015
通过解题和学习，你可以不断提高自己的算法和数据结构水平，从而更好地应对编程挑战和面试考核。LeetCode 提供了一些常见的面试题目，并且你可以在面试模式下进行练习，模拟真实的面试环境。：除了题库外，LeetCode 还提供了一些算法和数据结构的学习资源，如精选题解、官方题解、讨论区等。LeetCode 是一个在线的编程题库平台，旨在帮助程序员提高编程技能，特别是在算法和数据结构方面。：在提交解答后，你可以查看自己的解答在不同测试用例下的运行结果，以及其他用户的解答和讨论。
Leetcode周赛
weixin_47156261的博客
02-20 953
Leetcode周赛一、???? 第 281 场力扣周赛 一、???? 第 281 场力扣周赛 第 281 场力扣周赛 6012. 统计各位数字之和为偶数的整数个数 第一步：编写一个将数字千分位、百分位、十分位数字相加的函数 第二步：使用for循环遍历从1~num的数字，如果数字和为偶数，count++,最后return count. 注：c++中/是求商，%是求余，比如数985，商为98，余数为5,依次… class Solution { public: int countEven(int n
LeetCode的坑
m0_65280246的博客
08-25 513
这里是一个关于LeetCode编辑器的一个坑，leetcode的判定规则：每次提交后所用的测试用例共享全局变量和类变量。 测试的时候用例只有一个，而提交相当于测试很多个用例，这些用例共享所有的静态变量，某个变量使用到的静态变量可能被上一个测试用例修改过了，就会出现问题。 总之，LeetCode做题不要用静态变量。 ...
leetcode浇花-Leetcode:我的Leetcode解决方案
07-01
leetcode 浇花力码 我已经完成了 Leetcode 中的 119 / 1162 题。 一步步。 逐个。 # 标题 Python C 困难 标签 001 去 简单的 002 去 中等的 003 去 中等的 007 去 简单的 009 简单的 011 去 中等的 013 去 简单的 ...
leetcode最大连通域-leetcode:leetcode
06-30
leetcode 最大连通域leetcode zigzag.py - 字符串“PAYPALISHIRING”在给定的行数上以锯齿形图案书写 delete_dup_nodes.py - 删除所有具有重复编号的节点 topn_toy.py - 来自推文的 Yopn 玩具 僵尸人类.py - 2D 网格...
leetcode答案-leetcode-practice:leetcode-练习
06-30
《LeetCode练习与解答解析》 LeetCode是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法和数据结构问题，旨在帮助程序员提升技能，为面试和实际工作做好准备。本资源"leetcode答案-leetcode-practice:leetcode...
leetcode打不开-leetcode:leetcode
06-30
leetcode打不开Leetcode Note Tips Tip1: Two pointer for sorted array (#Array 1. Two Sum) Tip2: Sum[i:j] = Sum[0:j] - Sum[0:i] for continuous array (# Array 560. Subarray Sum Equals K) Tip3: Knapsack ...
leetcode题库-leetcode-java:LeetcodeJava代码
06-29
leetcode题库 leetcode solutions in java 本仓库内包含了java实现的leetcode解法，代码规范，可读性良好，其中的解法思想并不受语言限制。 BFS(Breath First Search) bfs能解决什么样的问题 图遍历中是否可达、最短...
LeetCode:Largest Rectangle in Histogram(直方图中最大矩形面积)
但行好事，莫问前程
12-01 898
84. Largest Rectangle in Histogram Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.   Ab...
LeetCode ：Given a binary tree, find its maximum depth. （二叉树的最大深度）
但行好事，莫问前程
07-22 843
题目描述： Given a binary tree, find its maximum depth. The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node. 解题思路： 第一种是递归方法：每个二叉树的最大深度=左子树的...
LeetCode:Given a singly linked list L: L 0→L 1→…→L n-1→L n, reorder it to: L 0→L n →L 1→L n-1→L 2...
但行好事，莫问前程
07-29 813
题目描述： 链表： 变换成为： 两种思路： 1、第一种比较容易想到，也比较简单，但是就是复杂度比较高，即使能在牛客网的LeetCode上能通过。就是把所有的元素都存储起来呗，然后新建一个链表，循环取第一个，最后一个，第一个，最后一个直到结束为止，并将这写元素插入到新的链表中，程序如下： import java.util.LinkedList; public class Solution...
EditDistance,求两个字符串最小编辑距离，动态规划
但行好事，莫问前程
01-06 533
问题描述： 题目描述 Edit Distance Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.) You have the following 3 operatio...
LeetCode题目解答技巧分享
在深入分析标题“LeetCode题目解答”和描述“LeetCode题目解答”，以及标签“LeetCode”与压缩包子文件列表“Leetcode”后，我们可以推断出相关知识点主要围绕着LeetCode这个在线编程实践平台。LeetCode 是一个汇集...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值