精华内容
下载资源
问答
  • LeetCode中的常用知识总结
    2020-03-31 01:13:24

    1、在本地调试的时候,通常需要将二维数组当作形参传入函数中。

    void findCircleNum(int** M, int MSize, int* MColSize){

        /* 函数主体 */
    }

    int main()
    {
        int arr[3][3] = {{1,1,0}, {1,1,1}, {0,1,1}}; /* 定义一个二维数组 */
        int *p[3]; /* 定义一个指针数组,该数组里面含有3个int类型的指针 */

        int MSize = 3; 
        int a = 3;
        int* MColSize = &a;;
        p[0] = &arr[0][0]; /* 每个指针指向一个一维数组 */
        p[1] = arr[1];
        p[2] = arr[2];
        
        findCircleNum(p, MSize , MColSize )); /* 调用函数 */

        return 0;
    }

    2、函数返回值是个一维数组,需要手动申请内存

    int* findCircleNum(int** M, int MSize, int* MColSize){

        int *p = NULL;

        p = (int *)malloc(sizeof(int) * MSize);

        /* 给p指向的内存进行ch *初始化为0, 两种方式,一种安全,一种不安全 */

        memset(p, 0, sizeof(p));

        (void)memset_s(p, sizeof(p), 0, size); /* 其中size小于sizeof(p) */

         /* 函数主体 */
    }

    3、函数返回值是个二维数组,需要手动申请内存

    int* findCircleNum(int** M, int MSize, int* MColSize){

        int **p = NULL;

        int m = 2;

        p = (int **)malloc(sizeof(int *) * MSize);

        for (int i = 0; i < MSize; i++) {

            p[i] = (int *)malloc(sizeof(int) * m);

            p[i][0] = 0;

            p[i][1] = 0;

        }

         /* 函数主体 */
    }

    4、使用memset函数,给数组赋值为0

    void *memset(void *s, int ch, size_t n); /* 将已开辟内存空间 s 的首 n 个字节的值设为值 c */

    通常用于内存初始化,也可以用来将一段内存空间设置为某个字符

    5、使用memset_s函数,给数组赋值为0

    /*

      dest:指向要填充的对象的指针

      destsz:目标数组的大小

      ch:填充的字节

      coun:t要填充的字节数

      返回值:dest 副本,成功时为零,错误时为非零

    */

    errno_t memset_s(void * dest,size_t destsz,int ch,size_t count);

    与memset相同,只是在运行时检测到以下错误,并且如果dest和destsz本身有效,则在将ch存储到目标范围[dest,dest + destsz)的每个位置之后调用当前安装的约束处理函数:

    dest是一个空指针
    destsz或count大于SIZE_MAX
    count大于destsz(会发生缓冲区溢出)

    如果由dest <count <= destsz指向的字符数组的大小,行为是未定义的; 换句话说,destsz的错误值不会暴露即将发生的缓冲区溢出。

    更多相关内容
  • 股票买卖最佳时机leetcode 术语表见文档末尾 灵感/问题 在经典的做市商模型(例如 Uniswap 中使用的恒定产品模型)中,交易 A->B 的滑点与交易所为该交易对预留的 A 和 B 资产的数量成正比。 不幸的是,当前的 DEX ...
  • 1.术语说明 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面; 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面; 内排序:所有排序操作都在内存中完成; 外排序:由于数据太大,因此把...
  • 颜色分类leetcode 机器学习词典 该文件包含机器学习爱好者难以理解的机器学习术语的精选列表。 条款是 1. 监督学习 它是这样的, 你会得到一堆照片,其中包含有关照片内容的信息,然后训练一个模型来识别新照片。 你...
  • LeetCode原题Count and Say

    2019-04-09 14:51:18
    Leetcode原题Count and Say count-and-say序列是整数序列,前五个术语如下: 1. 1 2. 11 3. 21 1211 5. 111221 1被读作“1”或11。 11被读作“两个1”或21。 21被读作“一个2,然后一个1”或1211。 给定整数n,...
  • 谷歌师兄的leetcode刷题笔记Berkeley Pi Sigma Epsilon API 加州大学伯克利分校营销和商业联谊会 Pi Sigma Epsilon,Zeta Chi Chapter 的应用程序编程接口 (API)。 API 位于 . 请访问我们。 目录 发展 克隆此 api ...
  • leetcode被墙ML1024 “这些墙有点像那样有趣。 首先你讨厌他们,然后你习惯了他们。足够的时间过去了,变得如此你依赖他们。 这就是制度化。” 机器学习框架 一些工具、论文和关于机器学习框架的一切。 如火炬、张量...
  • 最大公共字符串leetcode 二叉树 二叉树是一种抽象的数据结构,由根节点和左右子树组成。 一个节点可以有零个、一个或两个子节点。 二叉树的类型 目标 能够熟悉二叉树上的各种术语。 能够实现二叉树节点。 能够使用...
  • leetcode 部分排序类 在数学和计算机科学中,算法是如何解决一类问题的明确规范。 算法可以执行计算、数据处理和自动推理任务。 作为一种有效的方法,算法可以在有限的空间和时间内用定义明确的形式语言来表达,用于...
  • leetcode 分类尽可能多地记录我到数据相关领域的方式,包括...是一个预处理术语,用于不均匀的数据集,以便成为一个统一的数据集 load_multiple_csv.ipynb 一次读取一个文件夹中的多个数据集并随机拆分成train &test
  • leetcode 答案CIC Discord 机器人 ...能够对科技行业术语给出简单的定义:前端、后端、CI/CD 等 俱乐部信息 - 去谁进行模拟面试/简历评论/等 在设定的时间发布公告,也许是通过爬虫? 关于这个必要
  • leetcode 150 java 面试准备 - 算法 为前端工作面试的算法部分做准备的资源。 寻找解决方案的方法 把面试当作一个协作会议,把整个过程当作解决工作中的问题。 最重要的是说出来,让面试官知道你的思考过程。 使用...
  • leetcode赛车并发 好读/看 竞争条件 当多个线程执行临界区的结果可能因线程执行的顺序而异时,则称临界区包含竞争条件。 术语竞态条件源于线程正在通过临界区竞争的比喻,并且该竞争的结果影响执行临界区的结果。 ...
  • leetcode#排序#相对名词

    2020-11-17 11:02:21
    506. 相对名次 Difficulty: 简单 给出 N 名运动员的成绩,找出他们的相对名次并授予前三名对应的奖牌。前三名运动员将会被分别授予 “金牌”,“银牌” 和“ 铜牌”(“Gold Medal”, “Silver Medal”, ...

    506. 相对名次

    Difficulty: 简单

    给出 N 名运动员的成绩,找出他们的相对名次并授予前三名对应的奖牌。前三名运动员将会被分别授予 “金牌”,“银牌” 和“ 铜牌”(“Gold Medal”, “Silver Medal”, “Bronze Medal”)。

    (注:分数越高的选手,排名越靠前。)

    示例 1:

    输入: [5, 4, 3, 2, 1]
    输出: ["Gold Medal", "Silver Medal", "Bronze Medal", "4", "5"]
    解释: 前三名运动员的成绩为前三高的,因此将会分别被授予 “金牌”,“银牌”和“铜牌” ("Gold Medal", "Silver Medal" and "Bronze Medal").
    余下的两名运动员,我们只需要通过他们的成绩计算将其相对名次即可。
    

    提示:

    1. N 是一个正整数并且不会超过 10000。
    2. 所有运动员的成绩都不相同。

    Solution

    Language: 全部题目

    
    class Solution {
        public String[] findRelativeRanks(int[] nums) {
            Map<Integer,Integer> map = new HashMap<>(); 
            for(int i=0;i<nums.length;++i) {
                map.put(nums[i],i);
            }
            Arrays.sort(nums);
            String[] res = new String[nums.length];
            for(int i=res.length-1;i>=0;--i) {
                if(i==res.length-1) {
                    res[map.get(nums[i])] = "Gold Medal";
                }else if(i == nums.length-2) {
                    res[map.get(nums[i])] = "Silver Medal";
                }else if(i==nums.length-3) {
                    res[map.get(nums[i])] = "Bronze Medal";
                }else{
                    res[map.get(nums[i])] = String.valueOf( (nums.length-i));
                }
            }
            return res;
        }
    }
    
    展开全文
  • 股票买卖最佳时机leetcode 柯比 团队成员:Aditya Acharya、Eric Ong、Ji Hwan Kim、John Shin、Neal Goyal 目录 概述 欢迎来到股票溢出。 Stock Overflow 是一个全栈 Web 应用程序,它使用新闻数据来预测股票价格的...
  • 力码上海力码解决方案 解决方案是用Java和Python编写的 那我们怎么做 ...你有多喜欢 珍妮 丽莎 玫瑰 智秀 ...术语:定义 上海:世界前一城 删除线 世界是平的。 任务列表 撰写新闻稿 更新网站 联系媒体
  • leetcode中文版真棒明星 我的 GitHub 星星的精选列表! 生成者 内容 C - 发现唐诗中的幻方 - Git 源代码镜像 - 这是一个仅发布的存储库,所有拉取请求都将被忽略。 请按照文档/提交补丁程序进行任何改进。 C# - 该...
  • leetcode 答案 :graduation_cap: 初级开发者模拟面试题 我有时会为初级开发人员进行模拟面试,以下是我提出的一些问题。 其中一些问题比初级水平更高级,但我认为接触未知的术语和概念总是好的,即使只是简单地说...
  • leetcode备忘录系统算法-数据结构 两个不错的排序算法及其 Big-O(完成) 归并排序 快速排序 冒泡排序 基本数据结构实现及其 Big-O 复杂性 哈希图 堆 队列 双端队列双端队列 链表 反转链表 合并两个排序列表 回文...
  • leetcode打不开写代码 系统的要求和目标 功能需求 当用户输入他们的查询时,我们的服务应该建议从用户输入的任何内容开始的前 10 个术语。 结果中只应显示一小时窗口内出现频率超过 1000 的搜索词 结果中只应显示...
  • 股票买卖最佳时机leetcode 赔率分布分析 这是一个 Python 脚本,用于分析给定时间段内给定股票的回报。 基本术语 什么是股市? 股票市场或股票市场主要以交易股票或股票、其他金融证券如交易所交易基金 (ETF)、公司...
  • 谷歌师兄的leetcode刷题笔记Delta Sigma PI UCI 网站 这个版本的 Delta Sigma Pi 的 Pi Sigma 章节的网站是使用 . Google Sheets API 被用于为兄弟 bios 和职业提取数据。 有关插件源的更多信息。 如何在本地运行 ...
  • 股票买卖最佳时机leetcode 家畜 LiveStock 是一个基本的股票交易网站,作为 CSE 305:2016 年Spring在石溪大学采取的数据库系统原理课程项目而构建。该项目由我们的三人团队构建。 以下是我们教授的一些项目规范。 ...
  • 我一直说自己的 Python 编码是入门水平,一来是自己摸索着学、并没有接触很深层的专业练习,二来是接触的多是入门级别的问题或练习、对于很多术语及算法都是一头雾水的。这种情况如果我就是业余来学 Python 玩完全...

    今天迎来了个简单难度的题目,在经历一番中等难度题目的洗礼后,情不自禁露出吊打小朋友的微笑,感觉今天可以多做几道。

    我一直说自己的 Python 编码是入门水平,一来是自己摸索着学、并没有接触很深层的专业练习,二来是接触的多是入门级别的问题或练习、对于很多术语及算法都是一头雾水的。这种情况如果我就是业余来学 Python 玩完全够用了,但如果想进一步提升,就不得不经历些辛苦的进阶过程,这也是我打算坚持刷题练习的原因。

    话不多说,看题~

    题目

    中文题目

    第 7 题 整数反转:

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

    示例:

    输入: 123

    输出: 321

    输入: -123

    输出: -321

    输入: 120

    输出: 21

    来源:力扣(LeetCode)

    链接:https://leetcode-cn.com/problems/reverse-integer

    注意:

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

    英文题目

    Question 7 Reverse Integer:

    Given a 32-bit signed integer, reverse digits of an integer.

    Example:

    Input: 123

    Output: 321

    Input: -123

    Output: -321

    Input: 120

    Output: 21

    Note:

    Assume we are dealing with an environment which could only store integers within the 32-bit signed integer range: [−2^31,  2^31 − 1]. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

    思路

    Python 入门阶段,会频繁接触类型转换,将整数转化成字符串来进行翻转,这就是最直接的思路。但要对负数、超出 32 位范围的数做个单独处理。吸取昨天那题的经验,我们尽量对整个处理过程精简化。比如如果负数,我们也用个负数标志来做记录,然后将其转化为正数,这样所有的正负数都可以走同一个处理过程,结束时再对有负数标志的单独返回即可。

    代码

    class Solution:

    def reverse(self, x: int) -> int:

    # 为负数做个标志

    negative = False

    # 负数情况,标志记录,同时把负数转正方便后续统一处理

    if x<0:

    negative =True

    x = -x

    # 将数字转化为字符串

    s = str(x)

    # 通过字符串的 s[::-1]来进行翻转 “123” 会被转为 “321”

    s_reverse = s[::-1]

    # 将翻转的字符串转化为整数

    x_reverse = int(s_reverse)

    # 负数标志来还原负数

    if negative:

    x_reverse = - x_reverse

    # 根据题目要求,超出范围的返回 0

    if x_reverse 2**31-1:

    return 0

    else:

    return x_reverse

    提交答案

    这次运行结果上,用时表现不错,但内存消耗表现挺差:

    中文区结果:

    执行用时 : 36 ms, 在所有 Python3 提交中击败了 82.58% 的用户

    内存消耗 :13.5 MB, 在所有 Python3 提交中击败了 6.67% 的用户

    英文版结果:

    Runtime: 24 ms, faster than 94.49% of Python3 online submissions for Reverse Integer.

    Memory Usage: 14 MB, less than 5.26% of Python3 online submissions for Reverse Integer.

    优化

    翻看别人的解法,有两个挺有意思。第一个就是和我相同的思路,但是有点酷炫地将代码压缩,有些一行代码的味道:

    class Solution:

    def reverse(self, x: int) -> int:

    y=int(str(x)[::-1]) if x>=0 else -int(str(x)[:0:-1])

    return y if -2**31

    #作者:jutraman

    #链接:https://leetcode-cn.com/problems/reverse-integer/solution/pythonzheng-shu-fan-zhuan-by-jutraman/

    表现结果:

    Runtime: 24 ms, faster than 94.49% of Python3 online submissions for Reverse Integer.

    Memory Usage: 13.7 MB, less than 5.26% of Python3 online submissions for Reverse Integer.

    处理过程基本一致,少了些中间变量的定义赋值等。这里面有个用法,被称为 Python 的三元表达式:y = true_value if condition else false_value ,即将 if-else 写入一行中,很多一行代码都会用到这个。包括最后这个 return 语句也是这个用法。

    第二个值得思考的点也不少,首先刚我们因为整数和字符串间的转换、以及对字符串的翻转处理等导致内存消耗较高。这份代码则完全运用数字计算来完成任务:

    class Solution:

    def reverse(self, x: int) -> int:

    y, res = abs(x), 0

    # 则其数值范围为 [−2^31,  2^31 − 1]

    boundry = (1<<31) -1 if x>0 else 1<<31

    while y != 0:

    res = res*10 +y%10

    if res > boundry :

    return 0

    y //=10

    return res if x >0 else -res

    #作者:boywithacoin_cn

    #链接:https://leetcode-cn.com/problems/reverse-integer/solution/pythondan-chu-he-tui-ru-shu-zi-yi-chu-qian-jin-xin/

    这份代码在作者贴出的表现中表现超好,但我实际提交后效果竟然和用字符串处理的差不多,有点奇怪:

    Runtime: 32 ms, faster than 52.34% of Python3 online submissions for Reverse Integer.

    Memory Usage: 13.6 MB, less than 5.26% of Python3 online submissions for Reverse Integer.

    不纠结表现了,这代码里对 2^31 的处理使用的 1<<31 的方式,采用了 << 位运算符:

    a << 2

    左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补0。

    输出结果 240 ,二进制解释:1111 0000

    之后对数字的翻转是靠除以 10 的取余或取整的操作,还是挺有耐心的。

    结论

    第七题,简单难度,也给了自己多些时间领略别人的代码和思路。感觉今天开始有意识地练习昨天看到的那种对特殊情况做个标记,然后统一来处理。对用位运算符来实现 2 的指数运算也有个了概念,虽然之后可能还是不会去用,但有这么个认知了。再就是 if-else 的三元表达式 true-value if condition else false-value 这个以后可以练起来,刚开始用感觉老会不自觉加上引号。

    一周养成一个习惯,哈哈,现在对这种刷题的记录也开始着重记录心得和学到的知识点,不再是单纯代码和注释就完事了,还挺不错的体验。

    另外由于这题不难,引发了自己对入门的一些关于入门学习的碎碎念。前几天有朋友转发我一个 Python 入门课程、问值不值得入手买。对于这类课程,作为自学过来的老菜鸟,我是完全不会买的。但这个也要看个人,这种入门课程只能是个开始学习的引子,课程内容不去体验是完全没法评判的。同时,我们所能接触到的大多数 Python 学习推广,无论多么酷炫高大上,大多数的推广者是没有体验过这个课程内容的,更准确地说:多数的推广者并不是通过这类课程学出来的,所以看看就好、结合自己的情况来考虑。如果不想买,那么选些入门级别的书、刷刷题也是很快入门的路子。

    至于选什么书、怎么去练习,我觉得要有自己的一个选择标准,结合着你要学来做什么,有针对地筛选和决定,别学了几个月、大半年甚至一两年了还晃荡着沉不下来,那样真的是挺浪费自己的时间。个人感悟,与大家共勉~

    展开全文
  • 股票买卖最佳时机leetcode 投资组合回测器 我制作的命令行脚本可帮助我做出有关在股市中选择股票的决定。 简单来说,它是一个投资组合回测器; 即给定一个投资组合,它会告诉你该投资组合过去的表现。 注意:我在...
  • 颜色分类leetcode 外行术语中的算法: 机器学习中的水果图像识别过程与婴儿开始识别水果的过程非常相似。 例如,父母试图让婴儿学习颜色。 他们向宝宝展示颜色,并用它告诉宝宝颜色的名称。 而且他们只是不做一次,...
  • 两两认识leetcode 我使用的学习资源 目录 如何学习 HTML 和 CSS 使用 BEM 编写更好的 CSS 命令行 学习 Git 和 GitHub 降价 JavaScript 前端 ES6 及以后 网络编程 Python ReactJS 节点 蜜蜂 学习数据库 验证 全栈教程...
  • leetcode 部分排序类编码面试笔记 编码面试可能是程序员压力最大的面试之一。 这个 repo 的灵感来自于面试准备。 凯文的建议有四个步骤来按顺序学习: - 排序算法、基于图的算法、其他经典教科书算法 问题解决 - ...
  • 这种现状导致了一个后果:现在的开发者往往需要花费数周时间在 LeetCode 等网站上了解综合数百个问题。 这里将列出最常见的 14 种模式,它们可被用于解决任何常见编程面试问题。另外还会说明如何识别每种模式,并会...

    来源:Fahim ul Haq

    机器之心编译  | 参与:Panda


    对很多开发者来说,编程工作的面试准备很容易让人焦虑。面试要涉及的东西实在太多,其中很多还往往与开发者的日常工作无关。这种现状导致了一个后果:现在的开发者往往需要花费数周时间在 LeetCode 等网站上了解综合数百个问题。

    这里将列出最常见的 14 种模式,它们可被用于解决任何常见编程面试问题。另外还会说明如何识别每种模式,并会为每种模式提供一些问题示例。这些内容都只是蜻蜓点水——我强烈建议你看看课程《Grokking the Coding Interview: Patterns for Coding Questions》,里面提供了全面的解释、示例和编程实践。

    今天将说明以下 14 种常见的解题模式:

    1.滑动窗口
    2.二指针或迭代器
    3.快速和慢速指针或迭代器
    4.合并区间
    5.循环排序
    6.原地反转链表
    7.树的宽度优先搜索(Tree BFS)
    8.树的深度优先搜索(Tree DFS)
    9.Two Heaps
    10.子集
    11.经过修改的二叉搜索
    12. 前 K 个元素
    13. K 路合并
    14.拓扑排序

    开始!

    1.滑动窗口

    滑动窗口模式是用于在给定数组或链表的特定窗口大小上执行所需的操作,比如寻找包含所有 1 的最长子数组。从第一个元素开始滑动窗口并逐个元素地向右滑,并根据你所求解的问题调整窗口的长度。在某些情况下窗口大小会保持恒定,在其它情况下窗口大小会增大或减小。

    下面是一些你可以用来确定给定问题可能需要滑动窗口的方法:

    • 问题的输入是一种线性数据结构,比如链表、数组或字符串

    • 你被要求查找最长/最短的子字符串、子数组或所需的值

    你可以使用滑动窗口模式处理的常见问题:

    • 大小为 K 的子数组的最大和(简单)

    • 带有 K 个不同字符的最长子字符串(中等)

    • 寻找字符相同但排序不一样的字符串(困难)

    2.二指针或迭代器

    二指针(Two Pointers)是这样一种模式:两个指针以一前一后的模式在数据结构中迭代,直到一个或两个指针达到某种特定条件。二指针通常在排序数组或链表中搜索配对时很有用;比如当你必须将一个数组的每个元素与其它元素做比较时。

    二指针是很有用的,因为如果只有一个指针,你必须继续在数组中循环回来才能找到答案。这种使用单个迭代器进行来回在时间和空间复杂度上都很低效——这个概念被称为「渐进分析(asymptotic analysis)」。尽管使用 1 个指针进行暴力搜索或简单普通的解决方案也有效果,但这会沿 O(n²) 线得到一些东西。在很多情况中,二指针有助于你寻找有更好空间或运行时间复杂度的解决方案。

    用于识别使用二指针的时机的方法:

    • 可用于你要处理排序数组(或链接列表)并需要查找满足某些约束的一组元素的问题

    • 数组中的元素集是配对、三元组甚至子数组

    下面是一些满足二指针模式的问题:

    • 求一个排序数组的平方(简单)

    • 求总和为零的三元组(中等)

    • 比较包含回退(backspace)的字符串(中等)

    3.快速和慢速指针

    快速和慢速指针方法也被称为 Hare & Tortoise 算法,该算法会使用两个在数组(或序列/链表)中以不同速度移动的指针。该方法在处理循环链表或数组时非常有用。

    通过以不同的速度进行移动(比如在一个循环链表中),该算法证明这两个指针注定会相遇。只要这两个指针在同一个循环中,快速指针就会追赶上慢速指针。

    如何判别使用快速和慢速模式的时机?

    • 处理链表或数组中的循环的问题

    • 当你需要知道特定元素的位置或链表的总长度时

    何时应该优先选择这种方法,而不是上面提到的二指针方法?

    • 有些情况不适合使用二指针方法,比如在不能反向移动的单链接链表中。使用快速和慢速模式的一个案例是当你想要确定一个链表是否为回文(palindrome)时。

    下面是一些满足快速和慢速指针模式的问题:

    • 链表循环(简单)

    • 回文链表(中等)

    • 环形数组中的循环(困难)

    4.合并区间

    合并区间模式是一种处理重叠区间的有效技术。在很多涉及区间的问题中,你既需要找到重叠的区间,也需要在这些区间重叠时合并它们。该模式的工作方式为:

    给定两个区间(a 和 b),这两个区间有 6 种不同的互相关联的方式:

    理解并识别这六种情况有助于你求解范围广泛的问题,从插入区间到优化区间合并等。

    那么如何确定何时该使用合并区间模式呢?

    • 如果你被要求得到一个仅含互斥区间的列表

    • 如果你听到了术语「重叠区间(overlapping intervals)」

    合并区间模式的问题:

    • 区间交叉(中等)

    • 最大 CPU 负载(困难)

    5. 循环排序

    这一模式描述了一种有趣的方法,处理的是涉及包含给定范围内数值的数组的问题。循环排序模式一次会在数组上迭代一个数值,如果所迭代的当前数值不在正确的索引处,就将其与其正确索引处的数值交换。你可以尝试替换其正确索引处的数值,但这会带来 O(n^2) 的复杂度,这不是最优的,因此要用循环排序模式。

    如何识别这种模式?

    • 涉及数值在给定范围内的排序数组的问题

    • 如果问题要求你在一个排序/旋转的数组中找到缺失值/重复值/最小值

    循环排序模式的问题:

    • 找到缺失值(简单)

    • 找到最小的缺失的正数值(中等)

    6.原地反转链表

    在很多问题中,你可能会被要求反转一个链表中一组节点之间的链接。通常而言,你需要原地完成这一任务,即使用已有的节点对象且不占用额外的内存。这就是这个模式的用武之地。该模式会从一个指向链表头的变量(current)开始一次反转一个节点,然后一个变量(previous)将指向已经处理过的前一个节点。以锁步的方式,在移动到下一个节点之前将其指向前一个节点,可实现对当前节点的反转。另外,也将更新变量「previous」,使其总是指向已经处理过的前一个节点。

    如何识别使用该模式的时机:

    • 如果你被要求在不使用额外内存的前提下反转一个链表

    原地反转链表模式的问题:

    • 反转一个子列表(中等)

    • 反转每个 K 个元素的子列表(中等)

    7.树的宽度优先搜索(Tree BFS)

    该模式基于宽度优先搜索(BFS)技术,可遍历一个树并使用一个队列来跟踪一个层级的所有节点,之后再跳转到下一个层级。任何涉及到以逐层级方式遍历树的问题都可以使用这种方法有效解决。

    Tree BFS 模式的工作方式是:将根节点推至队列,然后连续迭代知道队列为空。在每次迭代中,我们移除队列头部的节点并「访问」该节点。在移除了队列中的每个节点之后,我们还将其所有子节点插入到队列中。

    如何识别 Tree BFS 模式:

    • 如果你被要求以逐层级方式遍历(或按层级顺序遍历)一个树

    Tree BFS 模式的问题:

    • 二叉树层级顺序遍历(简单)

    • 之字型遍历(Zigzag Traversal)(中等)

    8.树的深度优先搜索(Tree DFS)

    Tree DFS 是基于深度优先搜索(DFS)技术来遍历树。

    你可以使用递归(或该迭代方法的技术栈)来在遍历期间保持对所有之前的(父)节点的跟踪。

    Tree DFS 模式的工作方式是从树的根部开始,如果这个节点不是一个叶节点,则需要做三件事:

    1.决定现在是处理当前的节点(pre-order),或是在处理两个子节点之间(in-order),还是在处理两个子节点之后(post-order)

    1. 为当前节点的两个子节点执行两次递归调用以处理它们

    如何识别 Tree DFS 模式:

    • 如果你被要求用 in-order、pre-order 或 post-order DFS 来遍历一个树

    • 如果问题需要搜索其中节点更接近叶节点的东西

    Tree DFS 模式的问题:

    • 路径数量之和(中等)

    • 一个和的所有路径(中等)

    9. Two Heaps

    在很多问题中,我们要将给定的一组元素分为两部分。为了求解这个问题,我们感兴趣的是了解一部分的最小元素以及另一部分的最大元素。这一模式是求解这类问题的一种有效方法。该模式要使用两个堆(heap):一个用于寻找最小元素的 Min Heap 和一个用于寻找最大元素的 Max Heap。该模式的工作方式是:先将前一半的数值存储到 Max Heap,这是由于你要寻找前一半中的最大数值。然后再将另一半存储到 Min Heap,因为你要寻找第二半的最小数值。在任何时候,当前数值列表的中间值都可以根据这两个 heap 的顶部元素计算得到。

    识别 Two Heaps 模式的方法:

    • 在优先级队列、调度等场景中有用

    • 如果问题说你需要找到一个集合的最小/最大/中间元素

    • 有时候可用于具有二叉树数据结构的问题

    Two Heaps 模式的问题:

    • 查找一个数值流的中间值(中等)

    10. 子集

    很多编程面试问题都涉及到处理给定元素集合的排列和组合。子集(Subsets)模式描述了一种用于有效处理所有这些问题的宽度优先搜索(BFS)方法。

    该模式看起来是这样:

    给定一个集合 [1, 5, 3]

    1. 从一个空集开始:[[]]
    2.向所有已有子集添加第一个数 (1),从而创造新的子集:[[], [1]]
    3.向所有已有子集添加第二个数 (5):[[], [1], [5], [1,5]]
    4.向所有已有子集添加第三个数 (3):[[], [1], [5], [1,5], [3], [1,3], [5,3], [1,5,3]]

    下面是这种子集模式的一种视觉表示:

    如何识别子集模式:

    • 你需要找到给定集合的组合或排列的问题

    子集模式的问题:

    • 带有重复项的子集(简单)

    • 通过改变大小写的字符串排列(中等)

    11. 经过修改的二叉搜索

    只要给定了排序数组、链表或矩阵,并要求寻找一个特定元素,你可以使用的最佳算法就是二叉搜索。这一模式描述了一种用于处理所有涉及二叉搜索的问题的有效方法。

    对于一个升序的集合,该模式看起来是这样的:

    1.首先,找到起点和终点的中间位置。寻找中间位置的一种简单方法是:middle = (start + end) / 2。但这很有可能造成整数溢出,所以推荐你这样表示中间位置:middle = start + (end — start) / 2。
    2.如果键值(key)等于中间索引处的值,那么返回这个中间位置。
    3.如果键值不等于中间索引处的值:
    4.检查 key < arr[middle] 是否成立。如果成立,将搜索约简到 end = middle — 15.检查 key > arr[middle] 是否成立。如果成立,将搜索约简到 end = middle + 1

    下面给出了这种经过修改的二叉搜索模式的视觉表示:

    经过修改的二叉搜索模式的问题:

    • 与顺序无关的二叉搜索(简单)

    • 在经过排序的无限数组中搜索(中等)

    12. 前 K 个元素

    任何要求我们找到一个给定集合中前面的/最小的/最常出现的 K 的元素的问题都在这一模式的范围内。

    跟踪 K 个元素的最佳的数据结构是 Heap。这一模式会使用 Heap 来求解多个一次性处理一个给定元素集中 K 个元素的问题。该模式是这样工作的:

    1. 根据问题的不同,将 K 个元素插入到 min-heap 或 max-heap 中
    2.迭代处理剩余的数,如果你找到一个比 heap 中数更大的数,那么就移除那个数并插入这个更大的数

    这里无需排序算法,因为 heap 将为你跟踪这些元素。

    如何识别前 K 个元素模式:

    • 如果你被要求寻找一个给定集合中前面的/最小的/最常出现的 K 的元素

    • 如果你被要求对一个数值进行排序以找到一个确定元素

    前 K 个元素模式的问题:

    • 前面的 K 个数(简单)

    • 最常出现的 K 个数(中等)

    13. K 路合并

    K 路合并能帮助你求解涉及一组经过排序的数组的问题。

    当你被给出了 K 个经过排序的数组时,你可以使用 Heap 来有效地执行所有数组的所有元素的排序遍历。你可以将每个数组的最小元素推送至 Min Heap 以获得整体最小值。在获得了整体最小值后,将来自同一个数组的下一个元素推送至 heap。然后,重复这一过程以得到所有元素的排序遍历结果。

    该模式看起来像这样:

    1.将每个数组的第一个元素插入 Min Heap
    2.之后,从该 Heap 取出最小(顶部的)元素,将其加入到合并的列表。
    3.在从 Heap 移除了最小的元素之后,将同一列表的下一个元素插入该 Heap
    4.重复步骤 2 和 3,以排序的顺序填充合并的列表

    如何识别 K 路合并模式:

    • 具有排序数组、列表或矩阵的问题

    • 如果问题要求你合并排序的列表,找到一个排序列表中的最小元素

    K 路合并模式的问题:

    • 合并 K 个排序的列表(中等)

    • 找到和最大的 K 个配对(困难)

    14. 拓扑排序

    拓扑排序可用于寻找互相依赖的元素的线性顺序。比如,如果事件 B 依赖于事件 A,那么 A 在拓扑排序时位于 B 之前。

    这个模式定义了一种简单方法来理解执行一组元素的拓扑排序的技术。

    该模式看起来是这样的:

    1.初始化。a)使用 HashMap 将图(graph)存储到邻接的列表中;b)为了查找所有源,使用 HashMap 记录 in-degree 的数量
    2.构建图并找到所有顶点的 in-degree。a)根据输入构建图并填充 in-degree HashMap
    3.寻找所有的源。a)所有 in-degree 为 0 的顶点都是源,并会被存入一个队列
    4.排序。a)对于每个源,执行以下操作:i)将其加入到排序的列表;ii)根据图获取其所有子节点;iii)将每个子节点的 in-degree 减少 1;iv)如果一个子节点的 in-degree 变为 0,将其加入到源队列。b)重复 (a),直到源队列为空。

    如何识别拓扑排序模式:

    • 处理无向有环图的问题

    • 如果你被要求以排序顺序更新所有对象

    • 如果你有一类遵循特定顺序的对象

    拓扑排序模式的问题:

    • 任务调度(中等)

    • 一个树的最小高度


    以上。

    
    
    - END -看完一键三连在看,转发,点赞是对文章最大的赞赏,极客重生感谢你
    推荐阅读
    
    经典算法刷题笔记pdf
    
    深入理解数据结构和算法
    
    个人学习方法分享
    
    
    
    展开全文
  • leetcode做不出来Running through problems on LeetCode trying to solve complex algorithms and have no clue what approach to take in solving them? Or maybe you succeeded in solving the algorithm without ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,178
精华内容 471
关键字:

leetcode术语