LeetCode刷题笔记

最新推荐文章于 2024-08-04 16:25:50 发布
最新推荐文章于 2024-08-04 16:25:50 发布
阅读量250 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43349479/article/details/115878258
版权

LeetCode刷题笔记

目录

常见算法

KMP

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
                j = next[j]; // 向前回溯
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

每日一题

2021.04.19 27.移除元素「简单」

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

通过次数367,732，提交次数615,835

解法一：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int countVal=count(nums.begin(),nums.end(),val);
        remove(nums.begin(),nums.end(),val);
        return nums.size()-countVal;
    }
};

在这里插入图片描述

解法二：

#include <algorithm>

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size=nums.size();
        int countVal=count(nums.begin(),nums.end(),val);; //val出现的次数
        sort(nums.begin(),nums.end()); //排序
        vector<int>::iterator iter=find(nums.begin(),nums.end(),val);
        nums.erase(iter,iter+countVal);
        return size-countVal;
    }
};

在这里插入图片描述

2021.04.20 28.实现strStr()「简单」

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回  -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：

输入：haystack = "hello", needle = "ll"
输出：2

示例 2：

输入：haystack = "aaaaa", needle = "bba"
输出：-1

示例 3：

输入：haystack = "", needle = ""
输出：0

提示：

0 <= haystack.length, needle.length <= 5 * 104
haystack 和 needle 仅由小写英文字符组成

通过次数354,811，提交次数880,279

class Solution {
public:
    void getNext(int* next, const string& s) {
        int j = -1;
        next[0] = j;
        for(int i = 1; i < s.size(); i++) { // 注意i从1开始
            while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
                j = next[j]; // 向前回溯
            }
            if (s[i] == s[j + 1]) { // 找到相同的前后缀
                j++;
            }
            next[i] = j; // 将j（前缀的长度）赋给next[i]
        }
    }
    int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

在这里插入图片描述

2021.04.27 938. 二叉搜索树的范围和「简单」

给定二叉搜索树的根结点 root，返回值位于范围 [low, high] 之间的所有结点的值的和。

示例 1：
在这里插入图片描述

输入：root = [10,5,15,3,7,null,18], low = 7, high = 15
输出：32

示例 2：
在这里插入图片描述

输入：root = [10,5,15,3,7,13,18,1,null,6], low = 6, high = 10
输出：23

提示：

树中节点数目在范围 [1, 2 * 104] 内
1 <= Node.val <= 105
1 <= low <= high <= 105
所有 Node.val 互不相同

通过次数71,632，提交次数88,202

/**
 * 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:
    int rangeSumBST(TreeNode *root, int low, int high) {
        if (root == nullptr) {
            return 0;
        }
        if (root->val > high) {
            return rangeSumBST(root->left, low, high);
        }
        if (root->val < low) {
            return rangeSumBST(root->right, low, high);
        }
        return root->val + rangeSumBST(root->left, low, high) + rangeSumBST(root->right, low, high);
    }
};

在这里插入图片描述

2021.04.28 633. 平方数之和「中等」

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a 2 + b 2 = c a^2+b^2=c a2+b2=c。

示例 1：

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

示例 2：

输入：c = 3
输出：false

示例 3：

输入：c = 4
输出：true

示例 4：

输入：c = 2
输出：true

示例 5：

输入：c = 1
输出：true

提示：

0 <= c <= 231 - 1

通过次数67,913，提交次数174,405

class Solution {
public:
    bool judgeSquareSum(int c) {
        long int total=0;
        long int j = sqrt(c);
        int i = 0;
        while (i <= j){
            total = i * i + j * j;
            if (total > c) --j;
            else if (total < c) ++i;
            else return true;
        }
        return false;
    }
};

在这里插入图片描述

2021.04.30 137. 只出现一次的数字 II「中等」

给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。

示例 1：

输入：nums = [2,2,3,2]
输出：3

示例 2：

输入：nums = [0,1,0,1,0,1,99]
输出：99

提示：

1 <= nums.length <= 3 * 10^4
-2^31 <= nums[i] <= 2^31 - 1
nums 中，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次

进阶：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

通过次数67,051，提交次数95,350

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        for(int i=0;i<nums.size();++i){
            if(count(nums.begin(),nums.end(),nums[i])==1){
                return nums[i];
            }
        }
        return 0;
    }
};

在这里插入图片描述

2021.05.03 7. 整数反转「简单」

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [ − 2 31 , 2 31 − 1 −2^{31}, 2^{31} − 1 −231,231−1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

示例 4：

输入：x = 0
输出：0

提示：

-2^31 <= x <= 2^31 - 1

通过次数682,277，提交次数1,935,736

class Solution {
public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            if (rev < INT_MIN / 10 || rev > INT_MAX / 10) {
                return 0;
            }
            int digit = x % 10;
            x /= 10;
            rev = rev * 10 + digit;
        }
        return rev;
    }
};

在这里插入图片描述

树

104. 二叉树的最大深度「简单」

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明:

叶子节点是指没有子节点的节点。

在这里插入图片描述

通过次数401,113，提交次数527,316

/**
 * 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:
    int maxDepth(TreeNode* root) {
        if(root==NULL) return 0;
        return 1+max(maxDepth(root->left),maxDepth(root->right)); // 递归
    }
};

在这里插入图片描述

559.N叉树的最大深度「简单」

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

在这里插入图片描述

输入：root = [1,null,3,2,4,null,5,6]
输出：3

示例 2：
在这里插入图片描述

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：5

提示：

树的深度不会超过 1000 。
树的节点数目位于 [0, 104] 之间。

通过次数49,073，提交次数68,192

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

// 递归
class Solution {
public:
    int maxDepth(Node* root) {
        int maxi = 0;
        if(!root) return 0;
        //找出所有子树中最高的那个的长度
        for(Node* it:root->children){
            if(it) maxi = max(maxi,maxDepth(it));
        }
        //树的长度等于最高的子树的长度+1
        return maxi+1;
    }
};

在这里插入图片描述

后记

「每日一题」模块暂时就更新到这里啦，以后准备把leetCode刷题记录写在blink里边，辣就先酱紫啦！

你这个代码我看不懂
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Python基础练习 待更~
qq_40250786的博客
09-09 2574
''' #Leecode答案全解https://www.cnblogs.com/grandyang/p/4606334.html def moveZeroes(nums): """ :type nums: List[int] :rtype: None Do not return anything, modify nums in-place instead. """ a = 0 k = 0 while k < len(nums):
leetcode刷题
liuhehe的博客
04-27 176
https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E7%9B%AE%E5%BD%95.md
LeetCode(力扣）数组篇 JAVA刷题详解
最新发布
weixin_61779644的博客
08-04 1001
是不是有许多小伙伴在刷力扣的时候感觉无从下手？从头按顺序开始刷的童鞋们可能会比较有感触，为什么才第四题就感觉很难了?没关系，本文将对力扣的 1-500 题中不需要会员的数据结构与算法题目(数据库与 shell 除外)进行分类，并推荐一个刷题的顺序。完全零基础可以刷题吗？不能，至少要基本掌握一门计算机语言的语法。但现在在网上随便搜一下就能搜到许多关于计算机语言的教程。当然，最好还是上一下正规的课程。刷题顺序很重要吗？重要。按照题目类别结构化地刷题的速度不仅更快，而且可以在刷完一类题之后进行总结。
leetcode 刷题
qq_37815136的博客
07-10 465
题目一：leetcode200Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically....
Leetcode刷题
weixin_41070993的博客
04-02 726
刷题 leetcode 1.两数之和 #哈希表 class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: hashtable = dict() for i, item in enumerate(nums): if target-item in hashtable: return [hashtable[target
LeetCode 刷题笔记 with Java.zip
11-23
《LeetCode刷题笔记withJava》是一份专为Java开发者准备的算法实战指南，涵盖了LeetCode网站上前一百道编程挑战题目。这份资料旨在帮助程序员提升算法能力，掌握数据结构和问题解决技巧，对于准备面试或者想要提升...
谷歌高畅Leetcode刷题笔记.pdf
08-04
这本书名为《LeetCode101：和你一起你轻松刷题（C++）》的电子书，作者高畅ChangGao，旨在帮助有C++基础但缺乏刷题经验的读者。本文将详细阐述该电子书中提及的IT知识点，覆盖算法与数据结构两大板块，以及十五个...
LeetCode刷题笔记.rar
07-05
《LeetCode刷题笔记》是针对LeetCode这个在线编程挑战平台的个人学习心得与总结，主要涵盖数据结构和算法两大核心领域。LeetCode是一个全球知名的编程训练网站，它提供了丰富的编程题目，帮助开发者提升编程技能，...
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
LeetCode刷题笔记 ＃ 标题 标签 1个 两次总和 哈希表 2个 加两个数字 链表 3 最长子串，无重复字符 细绳 4 两个排序数组的中位数 大批 5 最长回文子串 细绳 6 之字形转换 细绳 7 反整数 数学 8 字符串到整数 ...
LeetCode刷题
Us006124的博客
04-09 169
LeetCode刷题记录数据结构算法简介示例1、两数之和分析代码示例2、两数相加分析代码示例3、无重复字符的最长子串分析代码示例 记录一下练习的过程，也算是对自己的激励 数据结构 算法简介 示例 1、两数之和 分析 代码示例 2、两数相加 分析 代码示例 class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode head = new ListNode(0);
leetcode 刷题篇
qq_39790992的博客
04-29 378
1.https://leetcode-cn.com/problems/01-matrix/ 第一题0-1矩阵 解法1：BFS 解法2：DP。dp的做法思路较巧妙，关键点在于二次遍历。 2.https://leetcode-cn.com/problems/132-pattern 解法：最小栈。 以2,4,2,3,5为例。 从后往前遍历，构建最小栈。 5入栈 3入栈 2入栈 然后...
LeetCode刷题：1025. Divisor Game （JAVA动态规划算法）
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
05-12 675
LeetCode刷题：1025. Divisor Game 原题链接：https://leetcode.com/problems/divisor-game/ Alice and Bob take turns playing a game, with Alice starting first. Initially, there is a number N on the chalkboard. ...
【LeetCode】LeetCode刷题--简单题（1）
Pam的博客
07-17 484
为了记录已经做过的leetcode题目，因此简单的记录了代码及解释 我的做题顺序是先简单后难，先面试热门题目后一般 1. 两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。 思路： 遍历数组中的元素 定义num2为 target - nums[i]，即另外一个整数 判断num2是否在nums中，并输出其索引值 判断num2索引值与另外一个元素是否相同，
leetcode(从1~400题)刷题
以码平川的博客
07-13 217
leetcode刷题汇总 1.链表部分 2.树部分 1.0链表部分 2.0树部分
LeetCode 刷题攻略
起个名字真难的博客
05-20 2303
很多刚开始刷题的同学都有一个困惑：面对leetcode上近两千道题目，从何刷起。 大家平时刷题感觉效率低，浪费的时间主要在三点： 1.找题 2.找到了不应该现阶段做的题 3.没有全套的优质题解可以参考 其实我之前在知乎上回答过这个问题，回答内容大概是按照如下类型来刷 数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->图论->高级数据结构， 再从简单刷起，做了几个类型题目之后，再慢慢做中等题目、困难题目。 但我能设
leetcode 刷题（算法入门）
西西与贝贝
11-02 281
一、有序数组的平方 997题 给你一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序 示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100] 排序后，数组变为 [0,1,9,16,100] 示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121] 来源：力扣（LeetCode...
LeetCode刷题攻略
Redemption___的博客
06-13 7185
应届生面试算法就考个数组 链表 二叉树 矩阵 数组变着法子考你排序 查询 指针 位运算 链表变着法子考你指针 最多再考个哈希 二叉树变着法子考用递归和栈前中后遍历 最多加上回溯 矩阵的话就是知道起点的路径查询和不知道起点的路径查询 掌握了这些 面大厂就比较轻松了 其实和学历技术关系也不大 大部分人先死到想都不敢想上了。 据了解，LeetCode 是一个非常棒的 OJ（Online Judge）平台，收集了许多公司的面试题目。相对其他 OJ 平台而言，有着下面的几个优点： 题目全部来自业内大公司的真.
Java版LeetCode刷题笔记：51-100题解析
这本Java版的LeetCode刷题笔记不仅提供了N皇后问题的解法，还涵盖了其他49个问题的详细解答，对于提升Java编程能力和算法理解具有很大帮助。读者可以通过提供的链接访问在线题解和项目源码，以便深入学习和实践。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你这个代码我看不懂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值