LeetCode 1-10

已于 2022-12-25 21:58:15 修改
阅读量381 收藏
点赞数
分类专栏： LeetCode 文章标签： leetcode 算法
于 2022-12-17 00:36:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53401568/article/details/128348988
版权

两数之和

原题：https://leetcode.cn/problems/two-sum/ 

题目描述 

给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15]，target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9，返回 [0,1] 。


示例 2：

输入：nums = [3,2,4]，target = 6
输出：[1,2]


示例 3：

输入：nums = [3,3]，target = 6
输出：[0,1]

题解 

哈希遍历

遍历哈希表并寻找是否含有等于target-nums[i]的key；若有则返回现在的数组下标i和该key对应的value 

​

C++ 

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> hash;
        for(int i=0;i<nums.size();i++){
            if(hash.count(target-nums[i])){
                return {hash[target-nums[i]],i};
            }
            hash[nums[i]]=i;
        }
        return {};
    }
};

count (InputIterator first, InputIterator last, const T& val) 

统计某一值在一定范围内出现的次数

first：将迭代器输入到搜索序列的初始位置

last：将迭代器输入到搜索序列的最终位置

val：要在范围内搜索的值

C#

public class Solution {
    public int[] TwoSum(int[] nums, int target) {
        Dictionary<int,int> hash=new Dictionary<int,int>();
        for(int i=0;i<nums.Length;i++){
            if(hash.ContainsKey(target-nums[i])){
                return new int[]{hash[target-nums[i]],i};
            }
            hash[nums[i]]=i;
        }
        return new int[]{};
    }
}

ContainsKey (TKey key) 

用于检查Dictionary中是否存在键，若存在则返回true，否则返回false

两数相加

原题： https://leetcode.cn/problems/add-two-numbers/ 

题目描述 

给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

示例 1： 

​

输入：l1 = [2,4,3]，l2 = [5,6,4]

输出：[7,0,8]

解释：342 + 465 = 807

示例 2：

输入：l1 = [0]，l2 = [0]
输出：[0]


示例 3：

输入：l1 = [9,9,9,9,9,9,9]，l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

题解

迭代 

迭代法本质上是模拟求和运算时的步骤，即逐位求和，记录进位 

​

C++  

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* res=new ListNode();
        ListNode* curr=res;
        int carry=0;
        while(l1||l2){
            int x=l1?l1->val:0;
            int y=l2?l2->val:0;
            int sum=x+y+carry;

            curr->next=new ListNode(sum%10);
            curr=curr->next;
            carry=sum/10;

            if(l1) l1=l1->next;
            if(l2) l2=l2->next;
        }
        if(carry!=0) curr->next=new ListNode(carry);
        return res->next;
    }
};

C#

public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
        ListNode res=new ListNode();
        ListNode curr=res;
        int carry=0;
        while(l1!=null||l2!=null){
            int x=l1!=null?l1.val:0;
            int y=l2!=null?l2.val:0;
            int sum=x+y+carry;

            curr.next=new ListNode(sum%10);
            curr=curr.next;
            carry=sum/10;

            if(l1!=null) l1=l1.next;
            if(l2!=null) l2=l2.next;
        }
        if(carry!=0) curr.next=new ListNode(carry);
        return res.next;
    }
}

递归

递归法本质是将迭代中的循环变为自调用，将迭代中循环条件变为递归的边界条件 

C++ 

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode* res=new ListNode();
        ListNode* curr=res;
        int carry=0;
        while(l1||l2){
            int x=l1?l1->val:0;
            int y=l2?l2->val:0;
            int sum=x+y+carry;

            curr->next=new ListNode(sum%10);
            curr=curr->next;
            carry=sum/10;

            if(l1) l1=l1->next;
            if(l2) l2=l2->next;
        }
        if(carry!=0) curr->next=new ListNode(carry);
        return res->next;
    }
};

C#

public class Solution {
    public ListNode AddTwoNumbers(ListNode l1, ListNode l2) {
        if(l1==null) return l2;
        if(l2==null) return l1;
        int sum=l1.val+l2.val;
        ListNode res=new ListNode(sum % 10);
        res.next=AddTwoNumbers(l1.next, l2.next);
        if(sum > 9) res.next=AddTwoNumbers(res.next, new ListNode(1));
        return res;
    }
}

无重复字符的最长子串

原题：https://leetcode.cn/problems/longest-substring-without-repeating-characters/  

题目描述 

给定一个字符串s，请你找出其中不含有重复字符的最长子串的长度。

示例 1：

输入：s = "abcabcbb"
输出：3 
解释：因为无重复字符的最长子串是 "abc"，所以其长度为 3。


示例 2：

输入：s = "bbbbb"
输出：1
解释：因为无重复字符的最长子串是 "b"，所以其长度为 1。


示例 3：

输入：s = "pwwkew"
输出：3
解释：因为无重复字符的最长子串是 "wke"，所以其长度为 3。
           请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

题解

滑动窗口

基本原理是保证窗口（子串）中的字母均唯一。为此需要两个指针来分别构成窗口的左边界与右边界，当未遇到重复字母时，调整右边界；当遇到重复字母时，调整左边界，以输入s="aca"为例

​

C++ 

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> c(128,0);
        int res=0;
        int l=0;
        for (int r=0;r<s.size();r++) {
            l=max(l,c[s[r]]);
            c[s[r]]=r+1;
            res=max(res,r-l+1);
        }
        return res;
    }
};

C# 

public class Solution {
    public int LengthOfLongestSubstring(string s) {
        int[] c=new int[128];
        int res=0;
        int l=0;
        for(int r=0;r<s.Length;r++){
            l=Math.Max(l,c[s[r]]);
            c[s[r]]=r+1;
            res=Math.Max(res,r-l+1);
        }
        return res;
    }
}

Array.Clear(Array,startIndex,endIndex) 

对于数值类型的数组，重置为0

>>> int[] a={1,2,3,4,5};
>>> Array.Clear(a,1,a.Length);
{1,0,0,0,0}

对于引用类型的数组，重置为null

>>> string[] a={"a","bc","defg"};
>>> Array.Clear(a,0,a.Length-1);
{null,null,"defg"}

参考博客：http://t.csdn.cn/9bD3A

寻找两个正序数组的中位数

原题：https://leetcode.cn/problems/median-of-two-sorted-arrays/ 

给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3]，nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3]，中位数 2


示例 2： 

输入：nums1 = [1,2]，nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4]，中位数 (2 + 3) / 2 = 2.5

题解

归并

C++

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m=nums1.size(),n=nums2.size(),k=0,i=0,j=0;
        vector<int> sub(m+n,0);
        while(i<m&&j<n)
            sub[k++]=nums1[i]<nums2[j]?nums1[i++]:nums2[j++];
        while(i<m) sub[k++]=nums1[i++];
        while(j<n) sub[k++]=nums2[j++];
        return k%2?sub[k/2]:(sub[k/2]+sub[k/2-1])/2.0;
    }
};

C#

public class Solution {
    public double FindMedianSortedArrays(int[] nums1, int[] nums2) {
        int m=nums1.Length,n=nums2.Length,k=0,i=0,j=0;
        int[] sub=new int[m+n];
        while(i<m&&j<n)
            sub[k++]=nums1[i]<nums2[j]?nums1[i++]:nums2[j++];
        while(i<m) sub[k++]=nums1[i++];
        while(j<n) sub[k++]=nums2[j++];
        return k%2!=0?sub[k/2]:(sub[k/2]+sub[k/2-1])/2.0;
    }
}

 

双指针 

C++ 

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int m=nums1.size(), n=nums2.size(),i=0,j=0,l=0,r=0;
        for(int x=0;x<=(m+n)/2;x++){
            l=r;
            r=(i<m&&(j>=n||nums1[i]<nums2[j]))?nums1[i++]:nums2[j++];
        }
        return (m+n)&1?r:(l+r)/2.0;
    }
};

C#

public class Solution {
    public double FindMedianSortedArrays(int[] nums1, int[] nums2) {
        int m=nums1.Length,n=nums2.Length,i=0,j=0,l=0,r=0;
        for(int x=0;x<=(m+n)/2;x++){
            l=r;
            r=(i<m&&(j>=n||nums1[i]<nums2[j]))?nums1[i++]:nums2[j++];
        }
        return (m+n)%2!=0?r:(l+r)/2.0;
    }
}

斯卡文计算机术士
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode答案-leetcode:leetcode
06-30
leetcode 答案leetcode(未完成) LeetCode 的解决方案。 每个文档都包含由 cpp 和 python ...1 容易 2 正常 3 中 4 硬 5 更难 如果您找到任何优化这些解决方案的方法，请随时通过以下方式与我们联系
leetcode下载-leetcode-1:leetcode-1
06-29
leetcode下载 LeetCode 简体中文 | 介绍 leetcode 题解，记录自己的 leetcode 解题之路。 本仓库目前分为四个部分： 第一个部分是 leetcode 经典题目的解析，包括思路，关键点和具体的代码实现。 第二部分是对于数据...
力扣 算法面试题汇总 Python
荷碧TongZJ 的水文
02-08 3403
近期在刷力扣官网的这份题，因为我是因为报名了蓝桥杯才刷算法题的，所以我会选择性地写一些题解 (不包括太简单的、太难的、不在我考试范围的) 以下都是我觉得比较有思考价值的题 热身： 1. 只出现一次的数字 读题之后可以找到两个重点：只有一个元素只出现了一次、其余每个元素均出现两次 “相同为0，相异为1”，马上想到异或运算。所有元素都异或在一起，最终的数值就是只出现一次的元素 class Solution(object): def singleNumber(self, n.
力扣----经典题（python实现）
一夜奈何梁山
03-11 2736
经典题一：两数之和：二：三数之和：三：两数相加：四： 买股票的最佳时机： 一：两数之和： 二：三数之和： 1：首先我们要对数组进行排序， 排序的原因是因为不允许出现重复的。 2：第一层循环，我们可以循环遍历数组，枚举a，而且我们要判断当前枚举的和上次枚举的是否值是相同的，如果相同的，则直接跳过。 3：第二层中，我们可以计算出，剩余两个相加需要的和。我们可以让第三个指针，指向末尾，然后循环遍历第二个指针， 4：第三层中，每次第二个指针到达一个位置，我们计算这两个指针的相加和是多少，如果大于需要的和，说明加多
力扣-算法练习(Python)
yt_xy的博客
07-01 378
1.两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 示例： 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] + nums[1] = 2 + 7 = 9 所以 返回 [0, 1] 思路：A+B=target => target-A=B 第一次尝试 class Solution(object
LeetCode：2两数相加
cxcf_wsy的博客
06-18 183
力扣算法：2两数相加
Python实现力扣经典面试题——移除元素
最新发布
m0_57021623的博客
01-23 1326
例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。根据题目要求，我们需要原地移除数组中所有值等于给定值的元素，并返回移除后数组的新长度。给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。输入：nums = [0,1,2,2,3,0,4,2], val = 2。
leetcode dp-1
02-09
leetcode 动态规划算法-1
leetcode1-python
04-19
leetcode刷题解析，有时间就上传，随缘更新
leetcode答案-LeetCode:LeetCode答题代码
06-30
leetcode 答案 LeetCode LeetCode答题代码 1. 两数之和 给定一个整数数列，找出其中和为特定值的那两个数。 你可以假设每个输入都只会有一种答案，同样的元素不能被重用。 示例: 给定 nums = [2, 7, 11, 15], target...
python【力扣LeetCode算法题库】19-删除链表的倒数第N个节点
01-21
删除链表的倒数第N个节点 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例： 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明： 给定的 n 保证是有效的。 进阶： 你能尝试使用一趟扫描实现吗？ # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution:
【力扣每日一题】每日一题Python代码详解【持续更新】
QAQjiaru233的博客
12-07 737
861.翻转后矩阵的得分（12.7日） 代码详解如下： class Solution(object): def matrixScore(self, A): """ :type A: List[List[int]] :rtype: int """ m = len(A) #行数 n = len(A[0]) #列数 # 第一步，先将二维列表第一列数值不是1的行进行行变化，将第
LeetCode第六十二题—Python实现
StriveZs'Blog
03-22 280
title: LeetCode No.62 categories: OJ LeetCode tags: Programing LeetCode OJ LeetCode第六十二题 自己代码的开源仓库:click here 欢迎Star和Fork ???? 题目描述 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 问总共有多少条不同的路径？
力扣基础题库（Python）
qq_41517856的博客
05-09 563
'''遇到重复的字符就把list长度存进index，然后更新list'''
python解力扣1106题
m0_62223570的博客
11-06 265
简单讲解力扣1106题，然后顺便介绍python3.10新增的match,case
leetcode（力扣）单调栈题目解析记录（python版本）
maggieyiyi的博客
02-24 487
其次，根据单调栈的特点，不难发现height[idx]小于height[stack[-1]]和height[i]，通俗来讲就是出现一个坑，可以接雨水。上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2。while stack and nums[i]
力扣 week1（Python题解）
momo的博客
05-09 569
不知道现在刷题还来不来得及，看到有人说一个月认真刷就行，所以就想试试，万一呢 准备从今天开始，按顺序认真刷题并记录过程中的一些小点 python列表操作： nums.remove(3) “3”表示数值，并且只能删除nums中第一个3 nums.pop(3) "3"表示索引，pop表示删除nums中第四个位置上的数据（python序列索引从0开始） nums.index(3) nums.sort() index表示数值“3”在num...
力扣简单题刷题笔记（python实现）
sinounuo的博客
03-29 527
力扣简单题刷题笔记
《力扣题库（C）：第2题 （两数相加）》
yexiangCSDN的专栏
04-27 349
第二题：两数相加 给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字 请你将两个数相加，并以相同形式返回一个表示和的链表 你可以假设除了数字 0 之外，这两个数都不会以 0开头 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l1 = [9,9,9,9,9,.
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们可以尝试以下几种解决方法： 1. 检查文件编码格式：首先，我们可以检查所编辑的文件的编码格式。通常来说，常用的编码格式有UTF-8和ASCII等。我们可以将编码格式更改为正确的格式。在LeetCode-Editor中，可以通过界面设置或编辑器设置来更改编码格式。 2. 使用正确的字符集：如果乱码是由于使用了不同的字符集导致的，我们可以尝试更改使用正确的字符集。常见的字符集如Unicode或者UTF-8等。在LeetCode-Editor中，可以在编辑器中选择正确的字符集。 3. 使用合适的编辑器：有时候，乱码问题可能与LeetCode-Editor自身相关。我们可以尝试使用其他编码工具，如Text Editor、Sublime Text或者IDE，看是否能够解决乱码问题。 4. 查找特殊字符：如果乱码问题只出现在某些特殊字符上，我们可以尝试找到并替换这些字符。通过仔细检查代码，我们可以找到导致乱码的特定字符，并进行修正或替换。 总之，解决LeetCode-Editor乱码问题的方法有很多。根据具体情况，我们可以尝试更改文件编码格式、使用正确的字符集、更换编辑器或者查找并替换特殊字符等方法来解决这个问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值