1. 如何从大量的 URL 中找出相同的 URL？ 给定 a、b 两个文件，各存放 50 亿个 URL，每个 URL 各占 64B，内存限制是 4G。请找出 a、b 两个文件共同的 URL。 每个 URL 占 64B，那么 50 亿个 URL占用的空间大小约为 320GB。 由…

一千个读者眼中有一千个哈姆雷特，一千名 大数据 程序员心目中就有一千套 大数据面试题。本文就是笔者认为可以用来面试大数据 程序员的面试题。 这套题的题目跟公司和业务都没有关系，而且也并不代表笔者本人可以把这些题回答得非常好，笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来…

1、集群的最主要瓶颈 磁盘IO 2、Hadoop运行模式 单机版、伪分布式模式、完全分布式模式 3、HDFS写流程 1）client 客户端发送上传请求，通过 RPC 与 namenode 建立通信，

大数据工程师是近几年异常火爆的职位，市场需求旺盛，众多互联网公司都打出了高薪招聘的广告，本文整理了网络上部分技术人员分享的各大互联网公司大数据类(Hadoop、Spark等)面试题以及面试时需要注意的一些问题，希望对各位技术人员有所帮助。 分享之前我还是要推荐下我自己创建的大数…

前言 随着 5G 时代的到来，大数据人工智能产业链又一次迎来了井喷式的爆发，随着岗位需求的不断增加，越来越多的人选择大数据课程，但是没有真正从事大数据工作的人面对企业面试有种无从下手的感觉，面对面试说

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 题目来源 作者：是锅粥 链接：https://www.nowcoder.com/discuss/745950

1、HAnamenode 是如何工作的? ZKFailoverController主要职责 1）健康监测：周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机

本文整理了互联网大厂数据开发、数据分析、数仓等数据相关岗位面试过程中经常出现的SQL面试题，并给出了参考答案。涉及了炸裂函数、开窗函数、聚合函数开窗、在线直播人数等 以及这两年各大厂面疯了各种连续问题

1. hadoop 架构 Hadoop2.0版本，引入了Yarn。核心：HDFS+Yarn+Mapreduce Yarn是资源调度框架。能够细粒度的管理和调度任务。此外，还能够支持其他的计算框架，比如spark等。 Namenode：也叫名称节点，是HDFS的守护程序（一个核心…

六、描述HBase 中scan 和get 的功能以及实现的异同？七、hbase如何导入数据？八、hbase 的存储结构？九、解释下 hbase 实时查询的原理十、详细描述 HBase 中一个 cell 的结构？十一、简述 HBase 中 compact 用途是什么，什么时候触发，...

1. 通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？ spark是借鉴了Mapreduce,并在其基础上发展起来的，继承了其分布式

1、Flink怎么做压力测试和监控？ 参考答案：我们一般碰到的压力来自以下几个方面： （1）产生数据流的速度如果过快，而下游的算子消费不过来的话，会产生背压。背压的监控可以使用FlinkWebUI(l

Redis熟不熟，介绍下它有几种数据类型？我回答了8种，面试官说只有5种，后来在网上搜了搜，版本也很多。 手撕代码第一道是力扣原题：169. 多数元素 手撕代码第二道如何实现最小栈（也是力扣原题155. 最小栈），可能时间有限，没有让手写，说一下思路。 自我介绍之后，就全程几乎…

local 本地，通常是测试的时候用。 standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。 SparkonYarn 交给Yarn来进行资源调度，有 yarn-clu

​ 目录 HDFS文件写入和读取流程 HDFS组成架构 介绍下HDFS，说下HDFS优缺点，以及使用场景 HDFS作用 HDFS的容错机制 HDFS的存储机制 HDFS的副本机制 HDFS的常见数据格

什么是数据湖 数据湖（Data Lake）是一个大型数据存储和处理系统， 它能够存储各种类型和格式的数据，包括结构化数据、半结构化数据和非结构化数据。以下是关于数据湖的详细解释： 定义与特点 数据存储

​ 1、介绍下YARN 2、YARN有几个模块 3、YARN工作机制 4、YARN有什么优势，能解决什么问题? 5、YARN容错机制 6、YARN高可用 7、YARN调度器 8、YARN中Contai

分享大数据常见的面试题 一、mr的shuffle流程 说到mr的Shuffle，那么首先要明确shuffle属于哪个阶段。shuffle就是从Map端输出到Reduce输入的整个过程，这个过程广义上称

介绍下Flume  Flume架构  Flume有哪些Source  说下Flume事务机制  介绍下Flume采集数据的原理？底层实现？  Flume如何保证数据的可靠性  Flume传输数据时如何

介绍一下Mysql和Hivesql的区别？ 一方面，可以从底层原理出发回答，例如： 查询语言不同： Hive是hql语言，Mysql是sql语句； 存储位置不同： Hive是建立在 Hadoop 之上

Spark解决什么问题 二 Spark为什么会有自己的资源调度器 三 Spark运行模式 四 Spark常用端口号 五 Spark提交作业参数 六 Spark的transformation算子

Spark Streaming第一次运行不丢失数据 kafka参数 auto.offset.reset 参数设置成earliest 从最初始偏移量开始消费数据

Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架，Spark提供了一个全面、统一的框架用于管理各种有着不同性质(文本数据、图表数据等)的数据集和数据源(批量数据或实时的流数据)的大数据处理的需求。成为大数据核心技术之一，自然也成为了众多企业面试的核心专业问题，小编…

Spark系列面试题 Spark面试题（一） Spark面试题（二） Spark面试题（三） Spark面试题（四） Spark面试题（五）——数据倾斜调优 Spark面试题（六）——Spark资源调

微信搜索公众号：知了小巷公众号后台回复“资料”两个字，有大数据神秘学习大礼包！1.Spark的几种部署模式及其特点SparkSubmit#prepareSubmitEnvironment本地模式Spa

## Spark系列面试题 - [Spark面试题（一）](https://www.ikeguang.com/?p=1922) - [Spark面试题（二）](https://www.ikeguang

Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎。Spark Core中提供了Spark最基础与最核心

1）本地模式   Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类   local：只启动一个executor   local[k]:启动k个executor   lo...

Spark的任务执行流程 https://wenku.baidu.com/view/9bf37bd07f1cfad6195f312b3169a4517723e513.html Spark总体架构和运行

简单介绍一下 Flink   Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽

概述2019年是大数据实时计算领域最不平凡的一年，2019年1月阿里巴巴Blink（内部的Flink分支版本）开源，大数据领域一夜间从Spark独步天下走向了两强争霸的时代。Flink因为其天然的流式

有没有去面试的时候被问到Flink的面试题你答不上来，为什么那？，菜吗？ 不是。原因是你接触的面试题太少了，那我今天就根据不同的群体来给大家你分享。 好今天的Flink的题目就分享到这里，背过上面的那些题目害怕面试官提问？信自己，努力和汗水总会能得到回报的。我是大数据老哥，我们…

相信小伙伴们对于Flink一定不会感到陌生，作为连续三年蝉联第一，荣膺全球最活跃的 Apache 开源项目，Flink在中国的热度也一直是居高不下。近几年，在社区的推动下，Flink 技术栈在越来越多的公司开始得到应用，因此在大数据的求职招聘中，对于Flink的着重考察也变得越…

简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象层的

1，简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象

Flink中的执行图一般是可以分为四类，按照生成顺序分别为：StreamGraph-> JobGraph-> ExecutionGraph->物理执行图。顾名思义，这里代表的是我们编写的流程序图。通过Stream API生成，这是执行图的最原始拓扑数据结构。StreamGraph...

16. Flink中有哪些窗口？ Flink 支持两种划分窗口的方式，按照time和count。如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个coun

1 Flink的并行度了解吗？Flink的并行度设置是怎样的？ Flink中的任务被分为多个并行任务来执行，其中每个并行的实例处理一部分数据。这些并行实例的数量被称为并行度。我们在实际生产环境中可以从

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...结果被一道算法题坑了，"有效的括号"使用栈来解，会非常简单.

终于来了，算法相关的。 其实个人理解，前端岗位对于算法的要求与其他IT岗位相比，是低得多的。 但是小白我经历了如蚂蚁金服、网易这样的大厂教做人之后，还是觉得，对于一些基本算法、思想的掌握还是必须的。 然后，就把自己遇到的、学到的算法相关的再总结一下，方便自己随时备战面试。 JS…

看到一篇算法文章，觉得着实有趣，但不知为何我看到题后首先想到的是田忌赛马。今天我也试着解释下这题，当做是一个学习的过程。 64 匹马分 8 次在全部比完一次，然后我们可以把目标缩小到 32 匹马。 1、八次比完后，我们可以将每一匹马的速度按下表排好。 剩下的 8 组 32 匹马…

链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n …

回想以前遇到过的面试官，甚至包括自己作为面试官的时候，大都是停留在问【是什么】的问题上，而很少去追问【为什么】。。。

1. 概述 排序算法分为内部排序和外部排序，内部排序把数据记录放在内存中进行排序，而外部排序因排序的数据量大，内存不能一次容纳全部的排序记录，所以在排序过程中需要访问外存。 经常提及的八大排序算法指的就是内部排序的八种算法，分别是冒泡排序、快速排序、直接插入排序、希尔排序、简单…

持续更新，持续更新...

【前端面试复习系列文章】 2024前端高频面试题-- html篇 2024前端高频面试题-- CSS篇 2024前端高频面试题-- JS篇 2024前端高频面试题-- VUE篇 2024前端高频面试题

1. KMP 算法 谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致…

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置（找不到返回 -1）。 有一个祖先树状 json 对象，当一个人有一个儿子的时候，其 child …

0. 几个概念 完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~ 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子…

前言 本文题目选自 LeetCode 精选 TOP 面试题，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所

前几天有个朋友去面试字节跳动，面试官问了他一道链表相关的算法题，不过他一时之间没做出来，就来问了我一下，感觉这道题还不错，拿来讲一讲。 给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一…

数据结构是对实际问题中的数据元素及相互间的联系的抽象。一般用线性表来表示常用数据结构，线性表分为顺序存储的顺序表和连式存储的链表。 在学习算法之前，必须要了解一些常用数据结构的概念。 栈：一种特殊串联形式的抽象数据类型，可由链表或数组实现，通过链表或数组的栈顶（Top）指针对数…

2019年马上就要结束了，相信很多童鞋都开始蠢蠢欲动了，寻找新的机会了，但是工作太忙没有时间刷算法题，面试的时候好心虚。这里双手奉上40道LeetCode上经典面试算法题，整理的内容有点长，建议先收藏，慢慢消化，在来年顺利拿到满意的offer。 内容较多，整理不易，希望大家关注…

腾讯年终奖 什么是真正的好公司？ 一年到头，出不了几次裁员等劳务纠纷的吃瓜新闻。 只有到年底了，才因为年终奖远高于行业水平，实在没法低调了，"被迫"上热搜。 最近网友爆料了腾讯头牌部门的年终奖： WX

限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣…

接触 Android 开发也有一段时间了，前段时间便开始想抽空整理一些知识点，通过笔记整理的方式减少自己重复学习的时间成本和提高自身的效率。 本文总结的部分是常见面试算法题，算法题解均有 java 实现。目录可以在右边侧边栏查看跳转。 之后会整理的知识点还会有 java、And…

本文题目选自 LeetCode 精选 TOP 面试题，这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。 上版本部分请参考# 简单题上 二叉树（DFS） 二叉树前

众所周知，与后台开发人员相比，算法是我们前端开发人员的一个弱项。 而近两年随着互联网行业竞争愈发激烈，市场上对前端岗位的算法要求也有一定的提升。 我记得大三参加腾讯的校招面试时只准备了几种常见的排序算法就足以应对了，然而今年包括今日头条在内的多家大厂的前端笔试题目中都出现了"贪…

大家好，我是薇薇，一名沪漂女程序员，年前惨遭被裁，正值在家悲伤抠脚之际，突然看到两位朋友在合谋开发一款刷leetcode的小工具——leetcode-practice…… 下面重点稍微来介绍一下 在神

大家好，今早在B站看到up主的vscode里藏了leetcode插件，这才知道原来还有这款神器。但是没想到在用的时候遇到了一些麻烦，花了一点时间才解决。所以写这篇文章除了给大家安利这个好用的插件之外，也是为了帮助更多的同学避免踩坑。 vscode在工业界鼎鼎大名，被誉为微软少有…

花了十几天，把《算法》看了一遍。然后重新 AC 了一遍 LeetCode 的题并记录下心得。

算法一直是大厂前端面试常问的一块，而大家往往准备这方面的面试都是通过leetcode刷题。 我特地整理了几道leetcode中「很有意思」而且非常「高频」的算法题目，分别给出了思路分析（带图解）和代码实现。 给定一个整数数组 nums 和一个目标值 target，请你在该数组中…

题目分类及刷题顺序推荐 一. 数组 二. 字符串 三. 数与位 四. 栈与递归 五. 链表 六. 哈希表 七. 贪心算法 八. 双指针法 九. 树 十. 图与搜索 十一. 二分查找 十二. 二进制运算

虽然很多人都觉得前端算法弱，但其实 JavaScript 也可以刷题啊！最近两个月断断续续刷完了 leetcode 前 200 的 middle + hard ，总结了一些刷题常用的模板代码。走过路过发现 bug 请指出，拯救一个辣鸡（但很帅）的少年就靠您啦！ 包括打印函数和一…

众所周知，现在的互联网公司面试，只要是写代码的岗位，都会来一套算法题组合拳伺候。 所以大家在准备校招、社招，或者闲暇的时候，都可以刷刷题，保持良好的手感。

我就是那个 @量子位 答案里面提到的“lucifer 小哥哥”。 我本人从开始准备算法以来，大概经过了几个月的时间，这期间自己成长了很多，从刷题菜鸡，到现在对刷题套路，题型有了自己的理解，感受还是蛮多的。我本人不是算法高手，算是勤能补拙类型。不过经过几个月的学习和练习，不仅面试…

1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串

leetcode网站中的编程环境，代码提示，快捷键并不友好，我们在刷题的时候往往不高效，且过后也不能快速，随时随地的进行方便的复盘。所以在这篇文章中我将介绍如何在 VsCode 中通过插件来高效的刷题

老司机带你刷 LeetCode

LeetCode热题100道-Day02 136. 只出现一次的数字 在stream流中的reduce方法使用异或运算。

作为一个前端同学，为什么不用JavaScript刷LeetCode，而是使用TypeScript来刷题呢？ 当然，你也可以选择c++、java来刷题，但我认为还是用自己研究方向的语言比较好

作为一个多年的老菜鸟，有感于大部分的公司面试 “面试造航母，工作螺丝钉” 的作风，特整理了这个数据结构和算法面试题系列。对于校招而言，如果没有太多实践/实习经验，大公司往往喜欢考察数据结构和算法，如微软就特别喜欢在校招时手写算法题，而且难度还不小，当年我毕业找工作时也是颇受折磨…

数学是科学之基础，数字题往往也是被面试玩出花来。数学本身是有趣味的一门学科，前段时间有点不务正业，对数学产生了浓厚的兴趣，于是看了几本数学史论的书，也买了《几何原本》和《陶哲轩的实分析》，看了部分章节，受益良多，有兴趣的朋友可以看看。特别是几何原本，欧几里得上千年前的著作，里面…

500 Data structures and algorithms interview questions and their solutions

背包问题包括0-1背包问题、完全背包问题、部分背包问题等多种变种。其中，最简单的是部分背包问题，它可以采用贪心法来解决，而其他几种背包问题往往需要动态规划来求解。本文主要来源于《背包问题九讲》，我选择了比较简单的0-1背包问题和完全背包问题进行汇总。同时给出实现代码，如有错误，…

继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。本文所有代码在 这里 。 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 题： 给定一棵…

HashMap 是我们熟悉的散列表实现，也是 “面试八股文” 的标准题库之一。今天，我给出一份 HashMap 高频面试题口述简答答案，希望对你刷题有帮助。

前面总结了随机算法，这次再把以前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，希望这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，如有错误，也恳请各路大牛指正。二叉树的递归示例代码请参…

在用C语言实现一些常见的数据结构和算法时，C语言的基础不能少，特别是指针和结构体等知识。 linux中的C编译得到的目标文件和可执行文件都是ELF格式的，可执行文件中以segment来划分，目标文件中，我们是以section划分。一个segment包含一个或多个section，…

随机算法涉及大量概率论知识，有时候难得去仔细看推导过程，当然能够完全了解推导的过程自然是有好处的，如果不了解推导过程，至少记住结论也是必要的。本文总结最常见的一些随机算法的题目，是几年前找工作的时候写的。需要说明的是，这里用到的随机函数 randInt(a, b) 假定它能随机…

栈作为一种基本的数据结构，在很多地方有运用，比如函数递归，前后缀表达式转换等。本文会用C数组来实现栈结构(使用链表实现可以参见链表那一节，使用头插法构建链表即可)，并对常见的几个跟栈相关的面试题进行分析，本文代码在 这里。 我们使用结构体来定义栈，使用柔性数组来存储元素。几个宏…

链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的…

快速排序也是基于分治模式，类似归并排序那样，不同的是快速排序划分最后不需要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤： 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每个元…

字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。本文相关代码见 这里。 首先来看一些字符串的基本函数的实现，以下代码取自MIT6.828课程。 题： 给定一个字符串，找出该…

排序算法也是面试中常常提及的内容，问的最多的应该是快速排序、堆排序。这些排序算法很基础，但是如果平时不怎么写代码的话，面试的时候总会出现各种bug。虽然思想都知道，但是就是写不出来。本文打算对各种排序算法进行一个汇总，包括插入排序、冒泡排序、选择排序、计数排序、归并排序，基数排…

在说二叉树前，先来看看什么是树。树中基本单位是结点，结点之间的链接，称为分支。一棵树最上面的结点称之为根节点，而下面的结点为子结点。一个结点可以有0个或多个子结点，没有子结点的结点我们称之为叶结点。 二叉树是指子结点数目不超过2个的树，它是一种很经典的数据结构。而二叉搜索树(B…

二分查找本身是个简单的算法，但是正是因为其简单，更容易写错。甚至于在二分查找算法刚出现的时候，也是存在bug的（溢出的bug），这个bug直到几十年后才修复（见《编程珠玑》）。本文打算对二分查找算法进行总结，并对由二分查找引申出来的问题进行分析和汇总。若有错误，请指正。本文完整…

本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(…

存储过程就像我们编程语言中的函数一样，封装了我们的代码(PLSQL、T-SQL)。 上面的文字我们肯定是看不懂的，也不愿意看下去的。接下来我就总结一下： 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的 第二范式：满足第一范式,表…

例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话…

使用group by的sql语句，select后的字段只能是group by后的字段，如果需要展示其他字段数据，需要给该列使用聚合函数，否则默认展示分组后的第一行数据。 左连接：左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录。右表记录不足的地方均为NULL（用户信…

SQL（结构化查询语言）是一种设计用于检索和操作数据的数据库。它属于美国国家标准协会（ANSI）的一种标准，可用于执行Select（选择）、Update（更新）、Delete（删除）和Insert（插入）等数据任务。 表是在具有列和行的模型中设计的数据集合。在表中，指定了列数称…

😊：“读题，入职时候的薪水，加上提示一个员工有多次涨薪的情况，所以本质上是求解每个员工的最低薪水，还要按照emp_no降序排列。阿，求每个员工的薪水最小值，用group by就可以实现，要输出的字段在salaries这张表中都有，所以别看他给了2张表，只需要1张表就能算出结果。1...

Sql常用语法下列语句部分是Mssql语句，不可以在access中使用。 SQL分类： DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) DML—数据操纵语言(SELECT，

1/连续最长登陆天数 2/下一次登陆时间距离上一次登陆时间大于30天时，从1开始计数 3/一张包含全国各城市用户的观看记录表view_info（表中一条数据代表一次观看记录），包含city_name、

MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引。 MySQL官方对索引的定义为：索引（In…

面试官：要不你来讲讲你们对MySQL是怎么调优的？ 候选者：哇，这命题很大阿…我认为，对于开发者而言，对MySQL的调优重点一般是在「开发规范」、「数据库索引」又或者说解决线上慢查询上。 候选者：而对

这天我正在午休呢，公司DBA就把我喊醒了，说某库出现大量慢SQL，很快啊，很快，我还没反应过来，库就挂了，我心想现在的用户不讲武德啊，怎么在我睡觉的时候大量请求呢。 这是很常见的一个场景哈，因为很多业务开始数据量级不大，所以写sql的时候就没注意性能，等量级上去，很多业务就需要…

敖丙：加索引。 敖丙：没了。 哈哈开头这个场景是我臆想的一个面试场景，但是大家是不是觉得很真实，每个人的简历上但凡写到了数据库，都会在后面顺便写一句，会数据库调优。 我觉得调优能回答的点还是很多很多的，我自己看了《MySQL实战》、《高性能MySQL》、《丁奇MySQL47讲》…

一、前言 上一篇我们说了 腾讯一面：说一说 MySQL 中索引的底层原理，相信你对索引有个很清晰的认识了，这一篇我们来说一说慢 SQL 的排查以及调优。为啥面试官要问这个问题，其实跟上一篇的索引底层原

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

大家好，我是 V 哥。SQL调优对于提升数据库查询性能至关重要，特别是当数据量大时。以下是20个详细的SQL调优指南和高级技巧，结合案例说明，帮助优化SQL查询的性能。 1. 选择合适的索引 技巧: 

一次线上慢SQL调优分享 一周前，客户反馈做题页面经常卡顿，加载慢；我们监控比较少，所以根据直觉去MySQL慢查询日志一看，果然是一条慢SQL。废话不多，开整！！！ 业务背景 一个在线做题的代码评测系

作为开发人员，我们免不了与sql打交道。有些sql可能在业务的最开始，执行是毫无问题的。但是随着业务量的提升以及业务复杂度的加深，可能之前的sql就会逐渐展现出疲惫之势了。这时就会面临sql调优。 那么调优到底如何调？不同的人有不同的姿势。可能大部分人首先想到的就是加索引。 没…

order by字段尽量走索引... 其中有些手段也许跟随者MySQL版本的升级过时了。我们真的需要背这些调优手段吗？我觉得是没有必要的，在掌握MySQL存储架构和SQL执行原理的情况下，我们就很自然的明白，为什么要提议这么优化了，甚至能够发现别人提的不太合理的优化手段。 在 …

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情 1.写在前面 在昨天的时候，我们就谈到了数据库连接池优化 详情可参考这里：点击查看 经过昨天的分析，我们已

面试官：MySQL如何进行性能调优？ 具体操作我这里整理了慢查询、explain、@@profiling关键字 慢查询 DBA有时候会发现有些语句比较慢，他们怎么发现的呢？ 编辑配置文件打开慢查询 然

在系统运行过程中，总会与数据库的交互，通过数据库端的日志查询执行时间最长与执行次数最多的sql语句，就可以有针对性的进行调优处理。 取执行时间最长的前50条sql语句。

引言 数据库性能优化是每个后端程序猿必备的基础技能之一，而Mysql中的explain堪称Mysql的性能优化分析神器，我们可以通过它来分析SQL语句的对应的执行计划在Mysql底层到底是如何执行的，

这几周系统访问量也是居高不下，不出意外系统又出现瓶颈了，大量用户反馈判题结果响应太慢；经排查，又是关于SQL的问题 业务背景 一个类似于力扣在线做题的代码评测模块，用户提交判题任务后，后台会进行异步判

什么是 SQL 调优？是不是觉得自己知道但又很模糊说不清楚，面试被问没有真实的案例，并不具备说服力。本文以为详细案例给大家解读。

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

Spark SQL是Spark生态系统中非常重要的组件， 能够利用 Spark 进行结构化的存储和操作。本文将围绕Spark内存泄露问题进行排查，并且给出具体的Spark调优方法。

@[TOC](OracleSQL调优系列之SQLMonitorReport)1、SQLMonitor简介SQL调优系列博客链接：SQL调优专栏sqlmonitor是oracle官方提供的自动监控符合特

Hive的架构 Hive元数据默认存储在derby数据库，不支持多客户端访问，所以将元数据存储在MySQl，支持多客户端访问。 2 Hive和e和数据库比较，Hive 和数据库除了拥有类似的查询语言，

1. hive 内部表和外部表的区别？ 未被external修饰的是内部表（managed table），被external修饰的为外部表（external table）； 内部表数据由Hive自身管

Hive SQL基本上适用大数据领域离线数据处理的大部分场景。Hive SQL的优化也是我们必须掌握的技能，而且，面试一定会问。那么，我希望面试者能答出其中的80%优化点，在这个问题上才算过关。 JVM重利用可以使得JOB长时间保留slot,直到作业结束，这在对于有较多任务和较…

第一题 需求 实现 数据准备 查询SQL 第二题 需求 实现 数据准备 查询SQL实现 第三题 需求 实现 数据准备 查询SQL 第四题 需求 实现 数据准备 查询SQL 第五题 需求 实现 数据准备

有用户点击日志记录表 t_click_log_025，包含user_id(用户ID),click_time(点击时间)，请查询出连续点击三次的用户数。

1.Hive的架构 2 Hive和数据库比较 Hive 和数据库除了拥有类似的查询语言，再无类似之处。 1）数据存储位置 Hive 存储在 HDFS 。数据库将数据保存在块设备或者本地文件系统中。 2

📋 数据表：user_orders
+----+---------+---------------------------+
| id | user_id | products                  |
+----+---------+---------------------------+
| 1  | 1001    | ["P01","P02","P03"]       |
| 2  | 1002    | ["P02","P04"]             |
| 3  | 1003    | ["P01","P05","P06","P02"]  |
+----+---------+---------------------------+

🔍 问题
使用 json_each() 将 products 中的JSON数组"炸裂"成多行，每个商品一行。

💡 参考
SELECT u.user_id, je.value AS product_id
FROM user_orders u, json_each(u.products) AS je;

📖 解析
- json_each() 是SQLite的JSON函数，功能类似Hive的explode()
- 返回两列：key(下标) 和 value(元素值)
- FROM 后用逗号连接（隐式JOIN），相当于 LATERAL VIEW
- 这是JSON数组→多行的基础操作

📋 数据表：page_visits
+----+---------+---------------------------------------------+
| id | user_id | pages                                       |
+----+---------+---------------------------------------------+
| 1  | 1001    | ["home","search","detail","cart"]           |
| 2  | 1002    | ["home","detail"]                           |
| 3  | 1003    | ["login","home","profile","settings","logout"] |
+----+---------+---------------------------------------------+

🔍 问题
使用 json_each() 炸裂 pages，保留数组中每个元素的下标(key)和值(value)。

💡 参考
SELECT p.user_id, je.key AS page_idx, je.value AS page_name
FROM page_visits p, json_each(p.pages) AS je;

📖 解析
- json_each() 返回 key(下标) 和 value(值)，下标从0开始
- 相当于Hive的 posexplode() → 同时拿到下标和值
- 适用场景：需要知道元素在数组中的位置

📋 数据表：user_tags_json
+----+---------+---------------------------------------------+
| id | user_id | tags                                        |
+----+---------+---------------------------------------------+
| 1  | 1001    | {"age":"25","city":"SZ","vip":"true"}        |
| 2  | 1002    | {"age":"30","city":"GZ"}                       |
| 3  | 1003    | {"age":"22","city":"BJ","level":"gold"}         |
+----+---------+---------------------------------------------+

🔍 问题
用 json_each() 将JSON对象的 key-value 炸裂成多行。

💡 参考
SELECT u.user_id, je.key AS tag_key, je.value AS tag_value
FROM user_tags_json u, json_each(u.tags) AS je;

📖 解析
- json_each() 对JSON对象同样返回(key, value)两列
- Hive中Map类型用 explode() 效果相同
- 常用场景：标签、配置等属性对→结构化分析

📋 数据表：articles_json
+----+------------+---------------------------+-------------------+
| id | article_id | tags                      | categories        |
+----+------------+---------------------------+-------------------+
| 1  | A01        | ["sql","hive","spark"]     | ["tech","database"] |
| 2  | A02        | ["python"]                 | ["tech"]         |
+----+------------+---------------------------+-------------------+

🔍 问题
同时炸裂 tags 和 categories，得到所有标签×分类的笛卡尔积组合。

💡 参考
SELECT a.article_id, t.value AS tag, c.value AS category
FROM articles_json a
JOIN json_each(a.tags) AS t
JOIN json_each(a.categories) AS c;

📖 解析
- 多个 json_each() 会造成笛卡尔积，数据量 = N1 × N2
- 如不需要笛卡尔积，分别查询再 UNION ALL
- 注意数据量膨胀对性能的影响

📋 数据表：user_orders（同入门1）
products字段含重复值：1001有两个P01，1003有两个P02

🔍 问题
炸裂后统计每个用户购买商品的去重数量和总数。

💡 参考
-- 去重数量
SELECT u.user_id, COUNT(DISTINCT je.value) AS unique_items
FROM user_orders u, json_each(u.products) je
GROUP BY u.user_id;

-- 总数量
SELECT u.user_id, COUNT(je.value) AS total_items
FROM user_orders u, json_each(u.products) je
GROUP BY u.user_id;

📖 解析
- 炸裂后一行变多行 → GROUP BY 原表字段做聚合
- COUNT(DISTINCT) 实现去重计数
- 这是json_each最常用场景：打平→聚合分析

📋 数据表：event_logs
+----+---------+-------------------------------------------------------------+
| id | user_id | events                                                      |
+----+---------+-------------------------------------------------------------+
| 1  | 1001    | [{"type":"pv","ts":"10:00"},{"type":"cart","ts":"10:05"},{"type":"pay","ts":"10:10"}] |
| 2  | 1002    | [{"type":"pv","ts":"11:00"}]                                 |
+----+---------+-------------------------------------------------------------+

🔍 问题
用 json_each() 炸裂对象数组，用 json_extract() 取出每个对象的字段。

💡 参考
SELECT e.user_id,
       json_extract(je.value, '$.type') AS event_type,
       json_extract(je.value, '$.ts') AS event_time
FROM event_logs e, json_each(e.events) AS je;

📖 解析
- json_each() 的value是整个JSON对象
- 再用 json_extract(value, '$.字段') 取出对象内部的字段
- 这相当于Hive中 inline(Array<Struct>) 的功能
- json_extract 使用 JSON path 语法：$.字段名

📋 数据表：user_tags_json + tag_recommendations
user_tags_json: tags是JSON对象 {"sports":"1","music":"1"}
tag_recommendations: 标签→推荐商品映射表

🔍 问题
炸裂用户标签的key，JOIN推荐表，为每个用户推荐商品。

💡 参考
SELECT DISTINCT u.user_id, r.recommend
FROM user_tags_json u
JOIN json_each(u.tags) je  -- 炸裂标签的key
JOIN tag_recommendations r ON je.key = r.tag;

📖 解析
- 先 json_each() 打平JSON → 再 JOIN → 去重
- 这是实际场景中的经典操作
- 注意JOIN顺序：炸裂产生多行后再与其他表关联
- 如果不先炸裂，JSON字段无法直接做等值JOIN

📋 数据表：user_tags_json (tags是JSON对象)

🔍 问题
炸裂JSON对象后用CASE WHEN做行转列，得到每个用户的各属性宽表。

💡 参考
WITH exploded AS (
  SELECT u.user_id, je.key AS attr_key, je.value AS attr_val
  FROM user_tags_json u, json_each(u.tags) je
)
SELECT user_id,
  MAX(CASE WHEN attr_key='age'   THEN attr_val END) AS age,
  MAX(CASE WHEN attr_key='city'  THEN attr_val END) AS city,
  MAX(CASE WHEN attr_key='vip'   THEN attr_val END) AS vip,
  MAX(CASE WHEN attr_key='level' THEN attr_val END) AS level
FROM exploded GROUP BY user_id;

📖 解析
- 经典二步走：json_each打平 → CASE WHEN/MAX行列转换
- 类似Hive的 explode + Pivot 组合
- 适用于：JSON标签/配置 → 结构化宽表，方便后续分析

📋 数据表：user_orders
products字段是JSON数组，含重复值

🔍 问题
1. 先 json_each 炸裂去重
2. 再用 json_group_array(DISTINCT) 重新聚合为去重数组

💡 参考
SELECT user_id,
  json_group_array(DISTINCT je.value) AS unique_products
FROM user_orders, json_each(products) je
GROUP BY user_id;

📖 解析
- json_group_array()：将多行聚合成JSON数组（类似Hive collect_list）
- DISTINCT 在聚合函数内去重（类似Hive collect_set）
- 完整套路：json_each → 处理 → json_group_array 重塑
- 其他聚合：json_group_object(key,value) 生成JSON对象
- 注意：大量数据聚合时注意性能

📋 综合题：分析 user_orders 的用户购买行为

🔍 问题（多个子问题）
1. 统计每个商品被多少用户购买（商品热度）
2. 找出购买商品数最多的用户
3. 计算用户之间的商品共现次数

💡 参考
-- 1. 商品热度
SELECT je.value AS product, COUNT(DISTINCT user_id) AS buyer_cnt
FROM user_orders, json_each(products) je
GROUP BY je.value ORDER BY buyer_cnt DESC;

-- 2. 最多商品用户
SELECT user_id, COUNT(je.value) AS item_cnt
FROM user_orders, json_each(products) je
GROUP BY user_id ORDER BY item_cnt DESC LIMIT 1;

-- 3. 共现分析（自连接）
SELECT a.value AS p1, b.value AS p2, COUNT(*) AS co_cnt
FROM user_orders u,
     json_each(u.products) a,
     json_each(u.products) b
WHERE a.value < b.value
GROUP BY p1, p2;

📖 解析
- 子问题3用了两个json_each做自连接，数据膨胀=Σ(Ni²)
- 大数据量时建议加LIMIT或先过滤再炸裂
- 性能优化原则：减少炸裂前数据量 > 控制炸裂膨胀倍数 > 增加索引

1. 如何从大量的 URL 中找出相同的 URL？ 给定 a、b 两个文件，各存放 50 亿个 URL，每个 URL 各占 64B，内存限制是 4G。请找出 a、b 两个文件共同的 URL。 每个 URL 占 64B，那么 50 亿个 URL占用的空间大小约为 320GB。 由…

一千个读者眼中有一千个哈姆雷特，一千名 大数据 程序员心目中就有一千套 大数据面试题。本文就是笔者认为可以用来面试大数据 程序员的面试题。 这套题的题目跟公司和业务都没有关系，而且也并不代表笔者本人可以把这些题回答得非常好，笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来…

1、集群的最主要瓶颈 磁盘IO 2、Hadoop运行模式 单机版、伪分布式模式、完全分布式模式 3、HDFS写流程 1）client 客户端发送上传请求，通过 RPC 与 namenode 建立通信，

大数据工程师是近几年异常火爆的职位，市场需求旺盛，众多互联网公司都打出了高薪招聘的广告，本文整理了网络上部分技术人员分享的各大互联网公司大数据类(Hadoop、Spark等)面试题以及面试时需要注意的一些问题，希望对各位技术人员有所帮助。 分享之前我还是要推荐下我自己创建的大数…

前言 随着 5G 时代的到来，大数据人工智能产业链又一次迎来了井喷式的爆发，随着岗位需求的不断增加，越来越多的人选择大数据课程，但是没有真正从事大数据工作的人面对企业面试有种无从下手的感觉，面对面试说

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 题目来源 作者：是锅粥 链接：https://www.nowcoder.com/discuss/745950

1、HAnamenode 是如何工作的? ZKFailoverController主要职责 1）健康监测：周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机

本文整理了互联网大厂数据开发、数据分析、数仓等数据相关岗位面试过程中经常出现的SQL面试题，并给出了参考答案。涉及了炸裂函数、开窗函数、聚合函数开窗、在线直播人数等 以及这两年各大厂面疯了各种连续问题

1. hadoop 架构 Hadoop2.0版本，引入了Yarn。核心：HDFS+Yarn+Mapreduce Yarn是资源调度框架。能够细粒度的管理和调度任务。此外，还能够支持其他的计算框架，比如spark等。 Namenode：也叫名称节点，是HDFS的守护程序（一个核心…

六、描述HBase 中scan 和get 的功能以及实现的异同？七、hbase如何导入数据？八、hbase 的存储结构？九、解释下 hbase 实时查询的原理十、详细描述 HBase 中一个 cell 的结构？十一、简述 HBase 中 compact 用途是什么，什么时候触发，...

1. 通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？ spark是借鉴了Mapreduce,并在其基础上发展起来的，继承了其分布式

1、Flink怎么做压力测试和监控？ 参考答案：我们一般碰到的压力来自以下几个方面： （1）产生数据流的速度如果过快，而下游的算子消费不过来的话，会产生背压。背压的监控可以使用FlinkWebUI(l

Redis熟不熟，介绍下它有几种数据类型？我回答了8种，面试官说只有5种，后来在网上搜了搜，版本也很多。 手撕代码第一道是力扣原题：169. 多数元素 手撕代码第二道如何实现最小栈（也是力扣原题155. 最小栈），可能时间有限，没有让手写，说一下思路。 自我介绍之后，就全程几乎…

local 本地，通常是测试的时候用。 standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。 SparkonYarn 交给Yarn来进行资源调度，有 yarn-clu

​ 目录 HDFS文件写入和读取流程 HDFS组成架构 介绍下HDFS，说下HDFS优缺点，以及使用场景 HDFS作用 HDFS的容错机制 HDFS的存储机制 HDFS的副本机制 HDFS的常见数据格

什么是数据湖 数据湖（Data Lake）是一个大型数据存储和处理系统， 它能够存储各种类型和格式的数据，包括结构化数据、半结构化数据和非结构化数据。以下是关于数据湖的详细解释： 定义与特点 数据存储

​ 1、介绍下YARN 2、YARN有几个模块 3、YARN工作机制 4、YARN有什么优势，能解决什么问题? 5、YARN容错机制 6、YARN高可用 7、YARN调度器 8、YARN中Contai

分享大数据常见的面试题 一、mr的shuffle流程 说到mr的Shuffle，那么首先要明确shuffle属于哪个阶段。shuffle就是从Map端输出到Reduce输入的整个过程，这个过程广义上称

介绍下Flume  Flume架构  Flume有哪些Source  说下Flume事务机制  介绍下Flume采集数据的原理？底层实现？  Flume如何保证数据的可靠性  Flume传输数据时如何

介绍一下Mysql和Hivesql的区别？ 一方面，可以从底层原理出发回答，例如： 查询语言不同： Hive是hql语言，Mysql是sql语句； 存储位置不同： Hive是建立在 Hadoop 之上

Spark解决什么问题 二 Spark为什么会有自己的资源调度器 三 Spark运行模式 四 Spark常用端口号 五 Spark提交作业参数 六 Spark的transformation算子

Spark Streaming第一次运行不丢失数据 kafka参数 auto.offset.reset 参数设置成earliest 从最初始偏移量开始消费数据

Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架，Spark提供了一个全面、统一的框架用于管理各种有着不同性质(文本数据、图表数据等)的数据集和数据源(批量数据或实时的流数据)的大数据处理的需求。成为大数据核心技术之一，自然也成为了众多企业面试的核心专业问题，小编…

Spark系列面试题 Spark面试题（一） Spark面试题（二） Spark面试题（三） Spark面试题（四） Spark面试题（五）——数据倾斜调优 Spark面试题（六）——Spark资源调

微信搜索公众号：知了小巷公众号后台回复“资料”两个字，有大数据神秘学习大礼包！1.Spark的几种部署模式及其特点SparkSubmit#prepareSubmitEnvironment本地模式Spa

## Spark系列面试题 - [Spark面试题（一）](https://www.ikeguang.com/?p=1922) - [Spark面试题（二）](https://www.ikeguang

Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎。Spark Core中提供了Spark最基础与最核心

1）本地模式   Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类   local：只启动一个executor   local[k]:启动k个executor   lo...

Spark的任务执行流程 https://wenku.baidu.com/view/9bf37bd07f1cfad6195f312b3169a4517723e513.html Spark总体架构和运行

简单介绍一下 Flink   Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽

概述2019年是大数据实时计算领域最不平凡的一年，2019年1月阿里巴巴Blink（内部的Flink分支版本）开源，大数据领域一夜间从Spark独步天下走向了两强争霸的时代。Flink因为其天然的流式

有没有去面试的时候被问到Flink的面试题你答不上来，为什么那？，菜吗？ 不是。原因是你接触的面试题太少了，那我今天就根据不同的群体来给大家你分享。 好今天的Flink的题目就分享到这里，背过上面的那些题目害怕面试官提问？信自己，努力和汗水总会能得到回报的。我是大数据老哥，我们…

相信小伙伴们对于Flink一定不会感到陌生，作为连续三年蝉联第一，荣膺全球最活跃的 Apache 开源项目，Flink在中国的热度也一直是居高不下。近几年，在社区的推动下，Flink 技术栈在越来越多的公司开始得到应用，因此在大数据的求职招聘中，对于Flink的着重考察也变得越…

简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象层的

1，简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象

Flink中的执行图一般是可以分为四类，按照生成顺序分别为：StreamGraph-> JobGraph-> ExecutionGraph->物理执行图。顾名思义，这里代表的是我们编写的流程序图。通过Stream API生成，这是执行图的最原始拓扑数据结构。StreamGraph...

16. Flink中有哪些窗口？ Flink 支持两种划分窗口的方式，按照time和count。如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个coun

1 Flink的并行度了解吗？Flink的并行度设置是怎样的？ Flink中的任务被分为多个并行任务来执行，其中每个并行的实例处理一部分数据。这些并行实例的数量被称为并行度。我们在实际生产环境中可以从

题目：小红书大数据开发面试 - 你对大数据有什么理解？

原文要点：大数据主要用于处理海量数据的技术工具。2012年开始火起来，Pig/Storm当时流行。政府对大数据大力支持上升到国家战略。目前步入后红海时代，对实时性要求更高，Spark/Flink很火。未来SQL化是趋势，物联网兴起带来更多数据。

---

🤖 AI解析：
答案/思路：大数据 = 海量数据处理技术体系。从离线批处理（Hadoop时代）到实时流处理（Spark/Flink时代），再到SQL化+湖仓一体的趋势。

📌 关键知识点：大数据发展历程（Hadoop→Spark→Flink）、实时计算趋势、SQL化发展方向、物联网数据增长

⚠️ 易错点：1) 不要只说数据量大，要讲技术栈演进；2) 需要区分离线/实时场景；3) 要结合业务场景说，不要纯理论

题目：小红书大数据面试 - Hadoop有哪些了解？优势和劣势？

原文要点：Hadoop是大数据基石，分为HDFS（存储）、MapReduce（计算）、Yarn（调度）。优势：海量离线存储、MR稳定容错、数据安全（NN HA）。劣势：处理慢（比Spark差20倍）、不支持多任务同时执行、基于磁盘而非内存。

---

🤖 AI解析：
答案/思路：Hadoop三核心组件分工明确。优势在于存储可靠+计算容错；劣势在于速度（磁盘IO瓶颈）和并发能力弱。NameNode HA通过双NN策略实现高可用。

📌 关键知识点：HDFS存储机制、MapReduce计算模型、YARN资源调度、NameNode HA、Hadoop3纠删码优化

⚠️ 易错点：1) Hadoop3的纠删码将3倍存储压缩到1.5倍，这是较新特性；2) 不要混淆YARN和ZooKeeper的角色；3) MapReduce稳定性好但速度差是核心矛盾

题目：小红书大数据面试 - 不同database的应用场景和特点？

原文要点：Hive-离线海量数仓、HBase-实时海量数仓、ClickHouse-实时海量数仓支持SQL、ES-全文检索引擎、MySQL-传统RDBMS。

---

🤖 AI解析：
答案/思路：按场景选数据库：离线分析用Hive，实时查询用ClickHouse，全文检索用ES，海量随机读写用HBase，业务事务用MySQL。

📌 关键知识点：OLAP vs OLTP、列式存储（ClickHouse/HBase）vs 行式存储（MySQL）、倒排索引（ES）、数仓分层（Hive离线/ClickHouse实时）

⚠️ 易错点：1) HBase和ClickHouse都做实时但场景不同：HBase适合随机读写，CK适合聚合分析；2) Hive底层可切换Tez/Spark引擎不是只有MR；3) ES不只做搜索也能做分析

题目：小红书大数据面试 - Spark Shuffle原理，Hash Shuffle和Sort Shuffle的区别？

---

🤖 AI解析：
答案/思路：Hash Shuffle（1.2前）：每个Mapper为每个Reducer生成一个文件，小文件数=M*R，海量文件导致IO压力。Sort Shuffle（1.2+）：Mapper端先排序再写，引入Index文件，文件数=2*M，大幅减少。Tungsten Sort进一步优化为序列化排序。

📌 关键知识点：宽依赖vs窄依赖、Shuffle划分Stage边界、Hash Shuffle小文件问题、Sort Shuffle排序+索引机制、UnsafeShuffle/Tungsten优化

⚠️ 易错点：1) Hash Shuffle的Consolidated版本将文件数降为Core*R而非M*R；2) Sort Shuffle在数据量小于spark.shuffle.sort.bypassMergeThreshold时走Bypass机制不排序；3) 不要只说Spark比Hadoop快因为内存计算，Shuffle优化也是关键

题目：小红书大数据面试 - Hadoop和Spark的区别和优劣？

---

🤖 AI解析：
答案/思路：核心区别是计算模型：Hadoop MR每步写磁盘（Map→Shuffle→Reduce），Spark DAG内存管道减少IO。Spark快但需要更多内存资源，MR慢但稳定容错好。

📌 关键知识点：DAG执行模型vs MR线性模型、内存计算vs磁盘计算、迭代计算优势（ML/图计算）、RDD血缘线容错、资源需求差异

⚠️ 易错点：1) Spark并非全内存，Shuffle仍会写磁盘；2) MR的稳定性优势在小集群不明显；3) Spark Streaming是微批次不是真正流处理，Flink才是

题目：小红书大数据面试 - Spark分Stage的原则是什么？

---

🤖 AI解析：
答案/思路：Spark按宽依赖切分Stage。从后往前遍历DAG，遇到宽依赖就断开形成新Stage，窄依赖的算子Pipeline在同一个Stage内执行。

📌 关键知识点：宽依赖（Shuffle Dependency）vs窄依赖（Narrow Dependency）、Stage划分算法、Pipeline执行、groupByKey/map/filter的依赖类型

⚠️ 易错点：1) map/filter是窄依赖但coalesce(numPartitions, shuffle=true)会强制Shuffle变宽依赖；2) 宽依赖不是不好，是Stage边界的自然划分；3) 分Stage是从最后RDD逆向遍历

题目：小红书/拼多多等大厂Flink面试 - Flink架构是怎样的？集群有哪些角色？

原文要点：Flink架构以分布式流处理为核心，核心组件包括JobManager、TaskManager和Client。JobManager是Master角色，负责接收Job、协调Checkpoint、Failover恢复。TaskManager是Worker角色，执行Task。Client提交Flink程序。

---

🤖 AI解析：
答案/思路：Flink主从架构：JobManager（调度+容错+协调）、TaskManager（执行+心跳+资源汇报）、Client（预处理+提交）。YARN模式下Client提交后可断开，Standalone模式需ZK做HA。

📌 关键知识点：主从模型、Checkpoint协调、Failover机制、TaskSlot资源隔离、YARN/Standalone/K8s部署模式

⚠️ 易错点：1) YARN模式下JobManager故障由YARN自动重启，不需要额外HA配置；2) TaskSlot和Parallelism不是一回事，一个Slot可运行多个TaskChain；3) Client不是集群运行时组件

题目：小红书大数据面试 - Flink如何实现Exactly-Once语义？

---

🤖 AI解析：
答案/思路：Flink Exactly-Once依赖两层保障：1) 内部：Checkpoint机制（Chandy-Lamport分布式快照算法），定期对全部算子状态做快照，故障时从最近Checkpoint恢复；2) 外部：Sink端支持两阶段提交（2PC）或幂等写入，确保外部系统数据一致。Kafka Source端配合Checkpoint提交offset。

📌 关键知识点：Chandy-Lamport算法、Checkpoint Barrier对齐、两阶段提交（2PC）、Kafka offset管理、幂等写入

⚠️ 易错点：1) Exactly-Once需要Source+内部+Sink三层配合，缺一不可；2) Checkpoint间隔太短影响吞吐，太长恢复慢；3) Barrier对齐模式 vs 未对齐模式的取舍

题目：小红书大数据面试 - Flink和Spark Streaming有什么区别？

---

🤖 AI解析：
答案/思路：核心区别是处理模型：Flink是真正的流处理（事件驱动，逐条处理），Spark Streaming是微批次流处理（DStream=RDD序列，按batch间隔切批）。Flink延迟更低（毫秒级），Spark Streaming延迟取决于batch间隔（秒级）。Flink支持事件时间+Watermark处理乱序数据，Spark Streaming主要用处理时间。

📌 关键知识点：流处理vs微批次、事件时间vs处理时间、Watermark机制、State管理差异、Checkpoint机制对比

⚠️ 易错点：1) Spark Structured Streaming已引入事件时间和Watermark，不要只说Spark不支持事件时间；2) Flink的批处理模式（BATCH execution mode）也支持了；3) 两者的容错机制本质不同：Flink是分布式快照，Spark是RDD血缘追踪+Checkpoint

题目：大厂Flink面试 - Flink的Checkpoint存在哪里？

原文要点：Checkpoint可存储在内存、文件系统（HDFS/NFS）或RocksDB中。Checkpoint定期记录应用状态用于故障恢复。

---

🤖 AI解析：
答案/思路：三种存储后端：1) MemoryStateBackend（状态在JM内存，快照在JM内存，适合测试小状态）；2) FsStateBackend（状态在TM内存，快照写到文件系统，适合中等状态生产）；3) RocksDBStateBackend（状态在RocksDB本地磁盘，快照到文件系统，适合大状态生产场景）。

📌 关键知识点：StateBackend三种实现、RocksDB增量Checkpoint、State大小限制、异步快照vs同步快照

⚠️ 易错点：1) MemoryStateBackend默认单状态最大5MB且只存JM内存，生产禁用；2) RocksDB支持增量Checkpoint大幅减少IO；3) 开启增量Checkpoint需设置state.backend.incremental=true

题目：数据开发面试题 - Flink反压（Backpressure）问题的诊断与处理。生产环境中Flink实时ETL任务出现明显延迟，下游Kafka消费lag持续上涨。

---

🤖 AI解析：
答案/思路：反压诊断三步法：1) Flink Web UI看Backpressure指标（OK→LOW→HIGH）；2) 定位瓶颈算子（通常是Sink或重算子）；3) 分析根因（数据倾斜、GC、外部系统慢、并行度不足）。解决方案：增加并行度、优化数据倾斜（LocalAgg+GlobalAgg）、调整GC策略、异步IO写外部系统。

📌 关键知识点：反压传播机制、Web UI反压指标、数据倾斜处理（两阶段聚合）、异步IO、GC调优

⚠️ 易错点：1) 反压是Flink自保护机制不是bug，不要盲目调参；2) 数据倾斜时增加并行度无效，需先打散key；3) Sink端慢不要只加并行度，检查外部系统瓶颈

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...结果被一道算法题坑了，"有效的括号"使用栈来解，会非常简单.

终于来了，算法相关的。 其实个人理解，前端岗位对于算法的要求与其他IT岗位相比，是低得多的。 但是小白我经历了如蚂蚁金服、网易这样的大厂教做人之后，还是觉得，对于一些基本算法、思想的掌握还是必须的。 然后，就把自己遇到的、学到的算法相关的再总结一下，方便自己随时备战面试。 JS…

看到一篇算法文章，觉得着实有趣，但不知为何我看到题后首先想到的是田忌赛马。今天我也试着解释下这题，当做是一个学习的过程。 64 匹马分 8 次在全部比完一次，然后我们可以把目标缩小到 32 匹马。 1、八次比完后，我们可以将每一匹马的速度按下表排好。 剩下的 8 组 32 匹马…

链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n …

回想以前遇到过的面试官，甚至包括自己作为面试官的时候，大都是停留在问【是什么】的问题上，而很少去追问【为什么】。。。

1. 概述 排序算法分为内部排序和外部排序，内部排序把数据记录放在内存中进行排序，而外部排序因排序的数据量大，内存不能一次容纳全部的排序记录，所以在排序过程中需要访问外存。 经常提及的八大排序算法指的就是内部排序的八种算法，分别是冒泡排序、快速排序、直接插入排序、希尔排序、简单…

持续更新，持续更新...

【前端面试复习系列文章】 2024前端高频面试题-- html篇 2024前端高频面试题-- CSS篇 2024前端高频面试题-- JS篇 2024前端高频面试题-- VUE篇 2024前端高频面试题

1. KMP 算法 谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致…

众所周知，与后台开发人员相比，算法是我们前端开发人员的一个弱项。 而近两年随着互联网行业竞争愈发激烈，市场上对前端岗位的算法要求也有一定的提升。 我记得大三参加腾讯的校招面试时只准备了几种常见的排序算法就足以应对了，然而今年包括今日头条在内的多家大厂的前端笔试题目中都出现了"贪…

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置（找不到返回 -1）。 有一个祖先树状 json 对象，当一个人有一个儿子的时候，其 child …

0. 几个概念 完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~ 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子…

前言 本文题目选自 LeetCode 精选 TOP 面试题，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所

前几天有个朋友去面试字节跳动，面试官问了他一道链表相关的算法题，不过他一时之间没做出来，就来问了我一下，感觉这道题还不错，拿来讲一讲。 给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一…

数据结构是对实际问题中的数据元素及相互间的联系的抽象。一般用线性表来表示常用数据结构，线性表分为顺序存储的顺序表和连式存储的链表。 在学习算法之前，必须要了解一些常用数据结构的概念。 栈：一种特殊串联形式的抽象数据类型，可由链表或数组实现，通过链表或数组的栈顶（Top）指针对数…

2019年马上就要结束了，相信很多童鞋都开始蠢蠢欲动了，寻找新的机会了，但是工作太忙没有时间刷算法题，面试的时候好心虚。这里双手奉上40道LeetCode上经典面试算法题，整理的内容有点长，建议先收藏，慢慢消化，在来年顺利拿到满意的offer。 内容较多，整理不易，希望大家关注…

腾讯年终奖 什么是真正的好公司？ 一年到头，出不了几次裁员等劳务纠纷的吃瓜新闻。 只有到年底了，才因为年终奖远高于行业水平，实在没法低调了，"被迫"上热搜。 最近网友爆料了腾讯头牌部门的年终奖： WX

限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣…

接触 Android 开发也有一段时间了，前段时间便开始想抽空整理一些知识点，通过笔记整理的方式减少自己重复学习的时间成本和提高自身的效率。 本文总结的部分是常见面试算法题，算法题解均有 java 实现。目录可以在右边侧边栏查看跳转。 之后会整理的知识点还会有 java、And…

大家好，我是薇薇，一名沪漂女程序员，年前惨遭被裁，正值在家悲伤抠脚之际，突然看到两位朋友在合谋开发一款刷leetcode的小工具——leetcode-practice…… 下面重点稍微来介绍一下 在神

大家好，今早在B站看到up主的vscode里藏了leetcode插件，这才知道原来还有这款神器。但是没想到在用的时候遇到了一些麻烦，花了一点时间才解决。所以写这篇文章除了给大家安利这个好用的插件之外，也是为了帮助更多的同学避免踩坑。 vscode在工业界鼎鼎大名，被誉为微软少有…

花了十几天，把《算法》看了一遍。然后重新 AC 了一遍 LeetCode 的题并记录下心得。

算法一直是大厂前端面试常问的一块，而大家往往准备这方面的面试都是通过leetcode刷题。 我特地整理了几道leetcode中「很有意思」而且非常「高频」的算法题目，分别给出了思路分析（带图解）和代码实现。 给定一个整数数组 nums 和一个目标值 target，请你在该数组中…

题目分类及刷题顺序推荐 一. 数组 二. 字符串 三. 数与位 四. 栈与递归 五. 链表 六. 哈希表 七. 贪心算法 八. 双指针法 九. 树 十. 图与搜索 十一. 二分查找 十二. 二进制运算

虽然很多人都觉得前端算法弱，但其实 JavaScript 也可以刷题啊！最近两个月断断续续刷完了 leetcode 前 200 的 middle + hard ，总结了一些刷题常用的模板代码。走过路过发现 bug 请指出，拯救一个辣鸡（但很帅）的少年就靠您啦！ 包括打印函数和一…

众所周知，现在的互联网公司面试，只要是写代码的岗位，都会来一套算法题组合拳伺候。 所以大家在准备校招、社招，或者闲暇的时候，都可以刷刷题，保持良好的手感。

我就是那个 @量子位 答案里面提到的“lucifer 小哥哥”。 我本人从开始准备算法以来，大概经过了几个月的时间，这期间自己成长了很多，从刷题菜鸡，到现在对刷题套路，题型有了自己的理解，感受还是蛮多的。我本人不是算法高手，算是勤能补拙类型。不过经过几个月的学习和练习，不仅面试…

1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串

leetcode网站中的编程环境，代码提示，快捷键并不友好，我们在刷题的时候往往不高效，且过后也不能快速，随时随地的进行方便的复盘。所以在这篇文章中我将介绍如何在 VsCode 中通过插件来高效的刷题

老司机带你刷 LeetCode

LeetCode热题100道-Day02 136. 只出现一次的数字 在stream流中的reduce方法使用异或运算。

作为一个前端同学，为什么不用JavaScript刷LeetCode，而是使用TypeScript来刷题呢？ 当然，你也可以选择c++、java来刷题，但我认为还是用自己研究方向的语言比较好

作为一个多年的老菜鸟，有感于大部分的公司面试 “面试造航母，工作螺丝钉” 的作风，特整理了这个数据结构和算法面试题系列。对于校招而言，如果没有太多实践/实习经验，大公司往往喜欢考察数据结构和算法，如微软就特别喜欢在校招时手写算法题，而且难度还不小，当年我毕业找工作时也是颇受折磨…

数学是科学之基础，数字题往往也是被面试玩出花来。数学本身是有趣味的一门学科，前段时间有点不务正业，对数学产生了浓厚的兴趣，于是看了几本数学史论的书，也买了《几何原本》和《陶哲轩的实分析》，看了部分章节，受益良多，有兴趣的朋友可以看看。特别是几何原本，欧几里得上千年前的著作，里面…

500 Data structures and algorithms interview questions and their solutions

背包问题包括0-1背包问题、完全背包问题、部分背包问题等多种变种。其中，最简单的是部分背包问题，它可以采用贪心法来解决，而其他几种背包问题往往需要动态规划来求解。本文主要来源于《背包问题九讲》，我选择了比较简单的0-1背包问题和完全背包问题进行汇总。同时给出实现代码，如有错误，…

继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。本文所有代码在 这里 。 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 题： 给定一棵…

HashMap 是我们熟悉的散列表实现，也是 “面试八股文” 的标准题库之一。今天，我给出一份 HashMap 高频面试题口述简答答案，希望对你刷题有帮助。

前面总结了随机算法，这次再把以前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，希望这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，如有错误，也恳请各路大牛指正。二叉树的递归示例代码请参…

在用C语言实现一些常见的数据结构和算法时，C语言的基础不能少，特别是指针和结构体等知识。 linux中的C编译得到的目标文件和可执行文件都是ELF格式的，可执行文件中以segment来划分，目标文件中，我们是以section划分。一个segment包含一个或多个section，…

随机算法涉及大量概率论知识，有时候难得去仔细看推导过程，当然能够完全了解推导的过程自然是有好处的，如果不了解推导过程，至少记住结论也是必要的。本文总结最常见的一些随机算法的题目，是几年前找工作的时候写的。需要说明的是，这里用到的随机函数 randInt(a, b) 假定它能随机…

栈作为一种基本的数据结构，在很多地方有运用，比如函数递归，前后缀表达式转换等。本文会用C数组来实现栈结构(使用链表实现可以参见链表那一节，使用头插法构建链表即可)，并对常见的几个跟栈相关的面试题进行分析，本文代码在 这里。 我们使用结构体来定义栈，使用柔性数组来存储元素。几个宏…

链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的…

快速排序也是基于分治模式，类似归并排序那样，不同的是快速排序划分最后不需要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤： 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每个元…

字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。本文相关代码见 这里。 首先来看一些字符串的基本函数的实现，以下代码取自MIT6.828课程。 题： 给定一个字符串，找出该…

排序算法也是面试中常常提及的内容，问的最多的应该是快速排序、堆排序。这些排序算法很基础，但是如果平时不怎么写代码的话，面试的时候总会出现各种bug。虽然思想都知道，但是就是写不出来。本文打算对各种排序算法进行一个汇总，包括插入排序、冒泡排序、选择排序、计数排序、归并排序，基数排…

在说二叉树前，先来看看什么是树。树中基本单位是结点，结点之间的链接，称为分支。一棵树最上面的结点称之为根节点，而下面的结点为子结点。一个结点可以有0个或多个子结点，没有子结点的结点我们称之为叶结点。 二叉树是指子结点数目不超过2个的树，它是一种很经典的数据结构。而二叉搜索树(B…

二分查找本身是个简单的算法，但是正是因为其简单，更容易写错。甚至于在二分查找算法刚出现的时候，也是存在bug的（溢出的bug），这个bug直到几十年后才修复（见《编程珠玑》）。本文打算对二分查找算法进行总结，并对由二分查找引申出来的问题进行分析和汇总。若有错误，请指正。本文完整…

本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(…

存储过程就像我们编程语言中的函数一样，封装了我们的代码(PLSQL、T-SQL)。 上面的文字我们肯定是看不懂的，也不愿意看下去的。接下来我就总结一下： 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的 第二范式：满足第一范式,表…

例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话…

使用group by的sql语句，select后的字段只能是group by后的字段，如果需要展示其他字段数据，需要给该列使用聚合函数，否则默认展示分组后的第一行数据。 左连接：左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录。右表记录不足的地方均为NULL（用户信…

SQL（结构化查询语言）是一种设计用于检索和操作数据的数据库。它属于美国国家标准协会（ANSI）的一种标准，可用于执行Select（选择）、Update（更新）、Delete（删除）和Insert（插入）等数据任务。 表是在具有列和行的模型中设计的数据集合。在表中，指定了列数称…

😊：“读题，入职时候的薪水，加上提示一个员工有多次涨薪的情况，所以本质上是求解每个员工的最低薪水，还要按照emp_no降序排列。阿，求每个员工的薪水最小值，用group by就可以实现，要输出的字段在salaries这张表中都有，所以别看他给了2张表，只需要1张表就能算出结果。1...

Sql常用语法下列语句部分是Mssql语句，不可以在access中使用。 SQL分类： DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) DML—数据操纵语言(SELECT，

1/连续最长登陆天数 2/下一次登陆时间距离上一次登陆时间大于30天时，从1开始计数 3/一张包含全国各城市用户的观看记录表view_info（表中一条数据代表一次观看记录），包含city_name、

MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引。 MySQL官方对索引的定义为：索引（In…

面试官：要不你来讲讲你们对MySQL是怎么调优的？ 候选者：哇，这命题很大阿…我认为，对于开发者而言，对MySQL的调优重点一般是在「开发规范」、「数据库索引」又或者说解决线上慢查询上。 候选者：而对

这天我正在午休呢，公司DBA就把我喊醒了，说某库出现大量慢SQL，很快啊，很快，我还没反应过来，库就挂了，我心想现在的用户不讲武德啊，怎么在我睡觉的时候大量请求呢。 这是很常见的一个场景哈，因为很多业务开始数据量级不大，所以写sql的时候就没注意性能，等量级上去，很多业务就需要…

敖丙：加索引。 敖丙：没了。 哈哈开头这个场景是我臆想的一个面试场景，但是大家是不是觉得很真实，每个人的简历上但凡写到了数据库，都会在后面顺便写一句，会数据库调优。 我觉得调优能回答的点还是很多很多的，我自己看了《MySQL实战》、《高性能MySQL》、《丁奇MySQL47讲》…

一、前言 上一篇我们说了 腾讯一面：说一说 MySQL 中索引的底层原理，相信你对索引有个很清晰的认识了，这一篇我们来说一说慢 SQL 的排查以及调优。为啥面试官要问这个问题，其实跟上一篇的索引底层原

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

大家好，我是 V 哥。SQL调优对于提升数据库查询性能至关重要，特别是当数据量大时。以下是20个详细的SQL调优指南和高级技巧，结合案例说明，帮助优化SQL查询的性能。 1. 选择合适的索引 技巧: 

一次线上慢SQL调优分享 一周前，客户反馈做题页面经常卡顿，加载慢；我们监控比较少，所以根据直觉去MySQL慢查询日志一看，果然是一条慢SQL。废话不多，开整！！！ 业务背景 一个在线做题的代码评测系

作为开发人员，我们免不了与sql打交道。有些sql可能在业务的最开始，执行是毫无问题的。但是随着业务量的提升以及业务复杂度的加深，可能之前的sql就会逐渐展现出疲惫之势了。这时就会面临sql调优。 那么调优到底如何调？不同的人有不同的姿势。可能大部分人首先想到的就是加索引。 没…

order by字段尽量走索引... 其中有些手段也许跟随者MySQL版本的升级过时了。我们真的需要背这些调优手段吗？我觉得是没有必要的，在掌握MySQL存储架构和SQL执行原理的情况下，我们就很自然的明白，为什么要提议这么优化了，甚至能够发现别人提的不太合理的优化手段。 在 …

背景 基于TPCDS的100G，500G数据进行了99SQL综合调优测试 测试机为物理机5台，1台为管理节点，4台为计算节点 可用内存约1T，核心数（vCore）200大概 重要参数 执行器个数 --

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情 1.写在前面 在昨天的时候，我们就谈到了数据库连接池优化 详情可参考这里：点击查看 经过昨天的分析，我们已

面试官：MySQL如何进行性能调优？ 具体操作我这里整理了慢查询、explain、@@profiling关键字 慢查询 DBA有时候会发现有些语句比较慢，他们怎么发现的呢？ 编辑配置文件打开慢查询 然

在系统运行过程中，总会与数据库的交互，通过数据库端的日志查询执行时间最长与执行次数最多的sql语句，就可以有针对性的进行调优处理。 取执行时间最长的前50条sql语句。

引言 数据库性能优化是每个后端程序猿必备的基础技能之一，而Mysql中的explain堪称Mysql的性能优化分析神器，我们可以通过它来分析SQL语句的对应的执行计划在Mysql底层到底是如何执行的，

这几周系统访问量也是居高不下，不出意外系统又出现瓶颈了，大量用户反馈判题结果响应太慢；经排查，又是关于SQL的问题 业务背景 一个类似于力扣在线做题的代码评测模块，用户提交判题任务后，后台会进行异步判

什么是 SQL 调优？是不是觉得自己知道但又很模糊说不清楚，面试被问没有真实的案例，并不具备说服力。本文以为详细案例给大家解读。

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

Spark SQL是Spark生态系统中非常重要的组件， 能够利用 Spark 进行结构化的存储和操作。本文将围绕Spark内存泄露问题进行排查，并且给出具体的Spark调优方法。

Hive的架构 Hive元数据默认存储在derby数据库，不支持多客户端访问，所以将元数据存储在MySQl，支持多客户端访问。 2 Hive和e和数据库比较，Hive 和数据库除了拥有类似的查询语言，

1. hive 内部表和外部表的区别？ 未被external修饰的是内部表（managed table），被external修饰的为外部表（external table）； 内部表数据由Hive自身管

Hive SQL基本上适用大数据领域离线数据处理的大部分场景。Hive SQL的优化也是我们必须掌握的技能，而且，面试一定会问。那么，我希望面试者能答出其中的80%优化点，在这个问题上才算过关。 JVM重利用可以使得JOB长时间保留slot,直到作业结束，这在对于有较多任务和较…

第一题 需求 实现 数据准备 查询SQL 第二题 需求 实现 数据准备 查询SQL实现 第三题 需求 实现 数据准备 查询SQL 第四题 需求 实现 数据准备 查询SQL 第五题 需求 实现 数据准备

有用户点击日志记录表 t_click_log_025，包含user_id(用户ID),click_time(点击时间)，请查询出连续点击三次的用户数。

1.Hive的架构 2 Hive和数据库比较 Hive 和数据库除了拥有类似的查询语言，再无类似之处。 1）数据存储位置 Hive 存储在 HDFS 。数据库将数据保存在块设备或者本地文件系统中。 2

题目：有一张用户点击行为表 user_click_log（user_id, click_time, page_id, event_name），另有一张笔记品类表 note_category（page_id, category_name）。请用SQL找出每个用户点击次数最多的前3个笔记品类，输出用户ID、品类名称、点击次数、排名。

思路：窗口函数 + 多表联查。第一步关联两表按用户和品类聚合算点击次数；第二步用 ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY cnt DESC) 排序；第三步筛选 rk <= 3。

---

🤖 AI解析：
答案/思路：使用 CTE 分步处理，先聚合再排序最后过滤。关键SQL：ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY click_cnt DESC)

📌 关键知识点：窗口函数（ROW_NUMBER/RANK/DENSE_RANK）、CTE、多表JOIN聚合、分组TopN

⚠️ 易错点：1) 并列排名时ROW_NUMBER会随机分配序号，如需保留并列应改用RANK/DENSE_RANK；2) 大数据量下需要分区表或索引优化；3) 注意LEFT JOIN和INNER JOIN的区别影响结果

题目：有一张用户登录表 user_login（user_id, login_date）。请计算2025年1月的新用户次日留存率、7日留存率和30日留存率。新用户定义为该月首次登录的用户。

思路：先用MIN(login_date)找出1月首次登录用户，然后LEFT JOIN后续登录记录，用CASE WHEN判断是否在N天后再次登录。

---

🤖 AI解析：
答案/思路：留存率 = 仍在活跃的用户数 ÷ 同批次新用户总数。先提取首次登录日期作为基准日，再关联后续登录判断是否回访。

📌 关键知识点：留存率定义、DATE_ADD日期函数、LEFT JOIN保留未回访用户、CASE WHEN条件计数

⚠️ 易错点：1) 留存率的分子必须是同一批次用户，不能混批；2) 注意区分自然日和事件日留存；3) 大数据量下用Hive/Spark分布式计算；4) 老用户换设备重新注册需交叉验证

题目：现有一张订单表order（order_id, user_id, product_id, quantity, pay_time），请查询出每个用户的第一条记录和最后一条记录。

思路：用ROW_NUMBER()按user_id分组、pay_time排序，分别取ASC和DESC的rn=1记录，再UNION合并。

---

🤖 AI解析：
答案/思路：对每个user_id按pay_time升序排列取首条（ROW_NUMBER ASC rn=1），按pay_time降序排列取末条（ROW_NUMBER DESC rn=1），再合并结果。

📌 关键知识点：ROW_NUMBER窗口函数、PARTITION BY分组、ORDER BY排序方向、UNION ALL合并

⚠️ 易错点：1) 同一时间有多条订单时ROW_NUMBER只取一条，如需全部可用RANK；2) 注意pay_time可能为NULL需过滤；3) 大数据量建议用子查询而非全表扫描

题目：Hive面试高频题 - Hive内部表和外部表的区别？

原文要点：未被external修饰的是内部表，被external修饰的是外部表。内部表删除时会同时删除元数据和数据；外部表删除时只删除元数据不删除数据。

---

🤖 AI解析：
答案/思路：内部表（Managed Table）：Hive管理数据生命周期，DROP TABLE删除元数据+数据。外部表（External Table）：Hive只管理元数据，数据路径可外部指定，DROP TABLE只删元数据。生产建议用外部表防止误删数据。

📌 关键知识点：EXTERNAL关键字、数据存储位置控制、DROP行为差异、LOCATION指定路径、MSCK REPAIR TABLE恢复分区

⚠️ 易错点：1) 内部表数据默认在hive.metastore.warehouse.dir下，外部表需指定LOCATION；2) 外部表ALTER TABLE不会移动数据文件；3) 生产环境建议外部表+分区表组合

题目：Hive面试高频题 - Hive的排序方式有哪些？各有什么区别？

---

🤖 AI解析：
答案/思路：4种排序：ORDER BY全局排序（单Reducer，数据量大很慢）；SORT BY局部排序（每个Reducer内排序，不保证全局）；DISTRIBUTE BY按字段分发到Reducer（控制分区）；CLUSTER BY = DISTRIBUTE BY + SORT BY（同字段分发并排序）。

📌 关键知识点：全局排序vs局部排序、Reducer数量影响、DISTRIBUTE BY分区控制、CLUSTER BY等价组合、limit优化ORDER BY

⚠️ 易错点：1) ORDER BY只用一个Reducer，大数据量必须加limit；2) SORT BY不保证全局有序；3) CLUSTER BY的排序字段和分区字段必须相同；4) DISTRIBUTE BY后可接不同的SORT BY字段

题目：小红书大数据面试 - Hive两个大表Join的过程？

---

🤖 AI解析：
答案/思路：大表Join核心是Shuffle Join：Map阶段按Join key分发到Reducer，Reducer端做合并。优化方式：1) MapJoin（小表广播到每个Mapper内存）；2) Bucket MapJoin（分桶表只Join对应桶）；3) Sort Merge Bucket Join（分桶+排序后Merge Join无需Shuffle）。

📌 关键知识点：Common Join（Shuffle Join）、Map Join（广播小表）、SMB Join（分桶排序合并）、大小表策略、mapjoin.auto.convert参数

⚠️ 易错点：1) MapJoin要求小表能放进内存，否则OOM；2) SMB Join需要两表分桶数相同且按Join key排序；3) Hive默认优先尝试MapJoin，小表超阈值才降级为Common Join

1. 如何从大量的 URL 中找出相同的 URL？ 给定 a、b 两个文件，各存放 50 亿个 URL，每个 URL 各占 64B，内存限制是 4G。请找出 a、b 两个文件共同的 URL。 每个 URL 占 64B，那么 50 亿个 URL占用的空间大小约为 320GB。 由…

一千个读者眼中有一千个哈姆雷特，一千名 大数据 程序员心目中就有一千套 大数据面试题。本文就是笔者认为可以用来面试大数据 程序员的面试题。 这套题的题目跟公司和业务都没有关系，而且也并不代表笔者本人可以把这些题回答得非常好，笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来…

1、集群的最主要瓶颈 磁盘IO 2、Hadoop运行模式 单机版、伪分布式模式、完全分布式模式 3、HDFS写流程 1）client 客户端发送上传请求，通过 RPC 与 namenode 建立通信，

大数据工程师是近几年异常火爆的职位，市场需求旺盛，众多互联网公司都打出了高薪招聘的广告，本文整理了网络上部分技术人员分享的各大互联网公司大数据类(Hadoop、Spark等)面试题以及面试时需要注意的一些问题，希望对各位技术人员有所帮助。 分享之前我还是要推荐下我自己创建的大数…

前言 随着 5G 时代的到来，大数据人工智能产业链又一次迎来了井喷式的爆发，随着岗位需求的不断增加，越来越多的人选择大数据课程，但是没有真正从事大数据工作的人面对企业面试有种无从下手的感觉，面对面试说

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 题目来源 作者：是锅粥 链接：https://www.nowcoder.com/discuss/745950

1、HAnamenode 是如何工作的? ZKFailoverController主要职责 1）健康监测：周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机

本文整理了互联网大厂数据开发、数据分析、数仓等数据相关岗位面试过程中经常出现的SQL面试题，并给出了参考答案。涉及了炸裂函数、开窗函数、聚合函数开窗、在线直播人数等 以及这两年各大厂面疯了各种连续问题

1. hadoop 架构 Hadoop2.0版本，引入了Yarn。核心：HDFS+Yarn+Mapreduce Yarn是资源调度框架。能够细粒度的管理和调度任务。此外，还能够支持其他的计算框架，比如spark等。 Namenode：也叫名称节点，是HDFS的守护程序（一个核心…

六、描述HBase 中scan 和get 的功能以及实现的异同？七、hbase如何导入数据？八、hbase 的存储结构？九、解释下 hbase 实时查询的原理十、详细描述 HBase 中一个 cell 的结构？十一、简述 HBase 中 compact 用途是什么，什么时候触发，...

1. 通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？ spark是借鉴了Mapreduce,并在其基础上发展起来的，继承了其分布式

1、Flink怎么做压力测试和监控？ 参考答案：我们一般碰到的压力来自以下几个方面： （1）产生数据流的速度如果过快，而下游的算子消费不过来的话，会产生背压。背压的监控可以使用FlinkWebUI(l

Redis熟不熟，介绍下它有几种数据类型？我回答了8种，面试官说只有5种，后来在网上搜了搜，版本也很多。 手撕代码第一道是力扣原题：169. 多数元素 手撕代码第二道如何实现最小栈（也是力扣原题155. 最小栈），可能时间有限，没有让手写，说一下思路。 自我介绍之后，就全程几乎…

local 本地，通常是测试的时候用。 standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。 SparkonYarn 交给Yarn来进行资源调度，有 yarn-clu

​ 目录 HDFS文件写入和读取流程 HDFS组成架构 介绍下HDFS，说下HDFS优缺点，以及使用场景 HDFS作用 HDFS的容错机制 HDFS的存储机制 HDFS的副本机制 HDFS的常见数据格

什么是数据湖 数据湖（Data Lake）是一个大型数据存储和处理系统， 它能够存储各种类型和格式的数据，包括结构化数据、半结构化数据和非结构化数据。以下是关于数据湖的详细解释： 定义与特点 数据存储

​ 1、介绍下YARN 2、YARN有几个模块 3、YARN工作机制 4、YARN有什么优势，能解决什么问题? 5、YARN容错机制 6、YARN高可用 7、YARN调度器 8、YARN中Contai

分享大数据常见的面试题 一、mr的shuffle流程 说到mr的Shuffle，那么首先要明确shuffle属于哪个阶段。shuffle就是从Map端输出到Reduce输入的整个过程，这个过程广义上称

介绍下Flume  Flume架构  Flume有哪些Source  说下Flume事务机制  介绍下Flume采集数据的原理？底层实现？  Flume如何保证数据的可靠性  Flume传输数据时如何

介绍一下Mysql和Hivesql的区别？ 一方面，可以从底层原理出发回答，例如： 查询语言不同： Hive是hql语言，Mysql是sql语句； 存储位置不同： Hive是建立在 Hadoop 之上

Spark解决什么问题 二 Spark为什么会有自己的资源调度器 三 Spark运行模式 四 Spark常用端口号 五 Spark提交作业参数 六 Spark的transformation算子

Spark Streaming第一次运行不丢失数据 kafka参数 auto.offset.reset 参数设置成earliest 从最初始偏移量开始消费数据

Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架，Spark提供了一个全面、统一的框架用于管理各种有着不同性质(文本数据、图表数据等)的数据集和数据源(批量数据或实时的流数据)的大数据处理的需求。成为大数据核心技术之一，自然也成为了众多企业面试的核心专业问题，小编…

Spark系列面试题 Spark面试题（一） Spark面试题（二） Spark面试题（三） Spark面试题（四） Spark面试题（五）——数据倾斜调优 Spark面试题（六）——Spark资源调

微信搜索公众号：知了小巷公众号后台回复“资料”两个字，有大数据神秘学习大礼包！1.Spark的几种部署模式及其特点SparkSubmit#prepareSubmitEnvironment本地模式Spa

## Spark系列面试题 - [Spark面试题（一）](https://www.ikeguang.com/?p=1922) - [Spark面试题（二）](https://www.ikeguang

Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎。Spark Core中提供了Spark最基础与最核心

1）本地模式   Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类   local：只启动一个executor   local[k]:启动k个executor   lo...

Spark的任务执行流程 https://wenku.baidu.com/view/9bf37bd07f1cfad6195f312b3169a4517723e513.html Spark总体架构和运行

简单介绍一下 Flink   Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽

概述2019年是大数据实时计算领域最不平凡的一年，2019年1月阿里巴巴Blink（内部的Flink分支版本）开源，大数据领域一夜间从Spark独步天下走向了两强争霸的时代。Flink因为其天然的流式

有没有去面试的时候被问到Flink的面试题你答不上来，为什么那？，菜吗？ 不是。原因是你接触的面试题太少了，那我今天就根据不同的群体来给大家你分享。 好今天的Flink的题目就分享到这里，背过上面的那些题目害怕面试官提问？信自己，努力和汗水总会能得到回报的。我是大数据老哥，我们…

相信小伙伴们对于Flink一定不会感到陌生，作为连续三年蝉联第一，荣膺全球最活跃的 Apache 开源项目，Flink在中国的热度也一直是居高不下。近几年，在社区的推动下，Flink 技术栈在越来越多的公司开始得到应用，因此在大数据的求职招聘中，对于Flink的着重考察也变得越…

简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象层的

1，简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象

Flink中的执行图一般是可以分为四类，按照生成顺序分别为：StreamGraph-> JobGraph-> ExecutionGraph->物理执行图。顾名思义，这里代表的是我们编写的流程序图。通过Stream API生成，这是执行图的最原始拓扑数据结构。StreamGraph...

16. Flink中有哪些窗口？ Flink 支持两种划分窗口的方式，按照time和count。如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个coun

1 Flink的并行度了解吗？Flink的并行度设置是怎样的？ Flink中的任务被分为多个并行任务来执行，其中每个并行的实例处理一部分数据。这些并行实例的数量被称为并行度。我们在实际生产环境中可以从

Flink如何实现端到端Exactly-Once语义？请详细阐述源端、计算端、Sink端三方协同的完整机制。这是2026年Flink面试的重中之重。

---

🤖 AI解析：
三方协同机制：①计算端——异步屏障快照(ABS)：基于Chandy-Lamport算法，JobManager发送Checkpoint Barrier，Source算子持久化状态后广播Barrier，下游算子对齐Barrier后持久化，所有Sink完成后Checkpoint完成；②源端——可重放数据源：Kafka的offset作为状态保存到Checkpoint，故障恢复时从最近Checkpoint恢复offset重放数据；③Sink端——两阶段提交(2PC)：预提交阶段收到Barrier后开启事务写入但不提交，元数据存Checkpoint；正式提交阶段Checkpoint全局完成后提交事务；回滚阶段Checkpoint失败则回滚事务。

Exactly-Once的本质：不是'数据只处理一次'，而是'重复处理不影响最终结果'——通过幂等/事务保证。

📌 关键知识点：端到端Exactly-Once=源端可重放+计算端Checkpoint+Sink端2PC，三者缺一不可；ABS算法的Barrier对齐保证快照全局一致性；2PC的预提交-正式提交-回滚三阶段
⚠️ 易错点：只讲Checkpoint不够——那只是计算端的一致性，源端和Sink端必须配合；2PC的Sink如果在预提交后、正式提交前崩溃，恢复后需能正确提交或回滚；Kafka的exactly-once需要事务型Producer

在订单支付场景中，面对峰值10万TPS的乱序数据，Watermark生成策略与乱序容忍度如何设计？迟到数据的完整处理方案是什么？

---

🤖 AI解析：
Watermark生成策略：采用固定乱序容忍度策略，Watermark=最大事件时间-容忍时长。容忍度设置：取P99延迟时长作为容忍度，保证99%数据正常处理。

迟到数据四层兜底方案：①第一层Watermark容错——设置合理容忍度，绝大多数乱序数据窗口计算前到达；②第二层允许延迟重新计算——窗口不立即销毁，继续接收迟到数据，每来一条重新触发计算更新结果；③第三层侧输出流兜底——超允许延迟的数据输出到侧输出流，不丢弃保留原始数据；④第四层离线批处理修正——凌晨用离线批处理重算前一天全量数据，修正实时计算偏差。

📌 关键知识点：Watermark本质是给乱序数据设定容错边界而非简单的'处理乱序'；四层兜底是生产环境标准方案；容忍度设太小丢数据，设太大延迟高
⚠️ 易错点：容忍度不能拍脑袋设——必须基于历史数据P99延迟；只设Watermark不设允许延迟=丢弃大量迟到数据；侧输出流的数据必须有人工处理流程否则会堆积

Flink中Slot和并行度的关系是什么？一个Slot中能运行多个Task吗？一个作业的总并行度受什么限制？这是面试中最容易踩坑的考点。

---

🤖 AI解析：
核心区别：Slot是TaskManager的静态资源配额——每个Slot对应TM的一部分内存(目前CPU不做隔离)，决定TM最多能同时运行多少个Task线程。并行度是算子的动态任务并发数——决定一个算子被拆分成多少个并行的Task执行。

关键关系：①一个Slot中可以运行多个属于同一个作业的Task线程(算子链优化后)；②一个作业的总并行度不能超过集群中可用的Slot总数；③Slot Sharing允许同一作业的不同算子的SubTask共享同一个Slot，提高资源利用率。

Operator Chain：将上下游可链接的算子合并到同一个Task中执行，避免序列化/反序列化和网络传输，大幅提升吞吐。链接条件：并行度一致+Forward分区+链化策略允许。

📌 关键知识点：Slot=静态资源配额，并行度=动态任务并发数；算子链是Flink最核心的性能优化手段；Slot Sharing提高资源利用率避免浪费
⚠️ 易错点：Slot≠并行度——一个Slot可运行多个Task(算子链)；并行度超过Slot总数会资源不足导致任务无法调度；断开算子链(disableChaining)需谨慎——只在性能瓶颈需单独监控时才断

Spark Structured Streaming的流表二元性是什么？如何实现流-流Join、流-批Join和流-维表Join？各自的适用场景和限制是什么？

---

🤖 AI解析：
流表二元性：无界流数据=持续增长的动态表，每条新数据=对表的一次INSERT，用统一SQL实现批处理与流处理。持续查询：引擎监听新数据到达，每次数据变更触发查询重新计算。

三种流式Join：①流-流Join：必须基于事件时间+Watermark限定Join时间范围避免状态膨胀(如下单+支付限定30分钟内)；②流-批Join：实时数据流与离线维度表关联，实现维度补全，支持静态批表定时刷新；③流-维表Join(Lookup Join)：实时查询外部存储的维表，支持缓存+异步IO提升性能。

Trigger策略：微批处理(默认，吞吐高)、连续处理(毫秒延迟但仅支持简单算子)、一次性处理(增量批处理)。

📌 关键知识点：流表二元性是Structured Streaming的核心创新——批流SQL统一；流-流Join必须限定时间范围否则状态无限膨胀；Lookup Join+异步IO是大维表关联的最佳实践
⚠️ 易错点：Structured Streaming的Watermark只能单调递增不支持回退，对迟到数据处理能力弱于Flink；连续处理模式不支持聚合/Join等复杂操作；流-流Join的时间范围设置过大会导致状态膨胀OOM

Flink CDC如何实现全量+增量一体化数据同步？与Canal/Debezium相比有什么核心优势？无锁全量读取的原理是什么？

---

🤖 AI解析：
Flink CDC原理：底层基于Debezium，分两阶段——①全量同步阶段：对DB表无锁读取，全量同步历史数据同时记录当前日志位点，不锁表不影响线上；②增量同步阶段：全量完成后自动切换，持续监听增量日志(Binlog/WAL)捕获增删改。

核心优势：①全量+增量一体化无需额外中间件；②无锁全量读取不影响线上DB；③直接接入Flink SQL支持实时清洗转换关联；④支持Exactly-Once保证数据不丢不重；⑤支持多库多表同步和分库分表合并。

无锁读取原理：基于MVCC快照读——在REPEATABLE READ隔离级别下做一致性快照读，保证全量读取期间看到的数据是一致性的，同时Binlog位点记录保证增量衔接不丢数据。

📌 关键知识点：Flink CDC=无锁全量+增量一体化，是实时数仓数据接入的标准方案；无锁读取基于MVCC快照读实现；与Canal相比省了中间件简化架构
⚠️ 易错点：无锁读取不是'没有锁'——依赖数据库的MVCC机制，需确认DB支持REPEATABLE READ；全量同步大表耗时较长期间增量数据会堆积在Binlog中需关注磁盘空间；CDC不支持DDL变更自动同步需手动处理

Spark Streaming(DStream)和Structured Streaming有什么核心差异？为什么行业内全面转向Structured Streaming？Receiver模式与Direct模式的区别是什么？

---

🤖 AI解析：
核心差异：①编程模型：DStream=RDD序列(底层RDD操作)，Structured Streaming=DataFrame/DataSet(基于Catalyst优化器)；②执行模型：DStream仅微批，Structured Streaming支持微批+连续处理+一次性处理；③流批统一：DStream无法与批处理共享代码，Structured Streaming的SQL批流统一；④优化器：DStream无优化器，Structured Streaming有Catalyst+Tungsten。

Receiver vs Direct模式：Receiver=高阶消费者API+Receiver线程+WAL(At-least-once，单点瓶颈)；Direct=低阶消费者API直接读Kafka分区(Exactly-once，并行度与分区数对应)。

行业趋势：Structured Streaming已成主流，DStream仅存量项目使用。

📌 关键知识点：Structured Streaming的核心优势=Catalyst优化器+流批统一SQL；Direct模式全面替代Receiver模式；流表二元性是Structed Streaming的理论基础
⚠️ 易错点：不要说DStream已废弃——仍有大量存量项目在运行面试会问；连续处理模式虽然延迟低但支持的算子极其有限不能当万能方案；Receiver模式的WAL机制有性能开销且不能保证Exactly-Once

Spark性能调优不能零散调参数，请给出系统化的调优方法论，包括资源调优、数据倾斜调优、内存调优、算子调优和存储调优五大维度。

---

🤖 AI解析：
五大维度系统调优：①资源调优——Executor内存/堆外内存比例、CPU核数(2-5个)、并行度(2-3倍CPU核数)、动态资源分配；②数据倾斜调优——reduceByKey替代groupByKey、Salting加盐打散、两阶段聚合、Broadcast Join小表、AQE自动优化(Spark3.0+)；③内存调优——堆内存/堆外内存合理分配(spark.memory.fraction=0.6)、Kryo序列化替代Java序列化(10倍压缩)、persist(StorageLevel.MEMORY_ONLY_SER)；④算子调优——mapPartitions替代map(减少GC)、coalesce替代repartition(减少Shuffle)、filter后repartition(避免数据倾斜)；⑤存储调优——列式存储Parquet/ORC、合理分区和分桶、数据压缩snappy/lz4。

AQE关键配置：spark.sql.adaptive.enabled=true、spark.sql.adaptive.shuffle.targetPostShuffleInputSize=64MB、spark.sql.adaptive.skewJoin.enabled=true。

📌 关键知识点：调优不是调参数而是系统化定位瓶颈；AQE是Spark3.0自动优化的利器；资源调优是第一步，数据倾斜调优是重点
⚠️ 易错点：不要一上来就加Executor——先看是不是数据倾斜导致少数Task慢；coalesce只能减分区不能增(会丢数据)；Kryo需要注册类否则性能提升有限

Flink支持Session/Per-Job/Application/Serverless四种部署模式，对比它们的核心特点、资源隔离性和适用场景。云原生场景下如何选择？

---

🤖 AI解析：
四种模式对比：①Session模式——集群常驻，所有作业共享资源(低隔离性，适合测试/短作业)；②Per-Job模式——每个作业独立集群，完成后销毁(高隔离性，但启动慢，已被Application模式替代)；③Application模式——每个应用对应一个集群，main()在JobManager执行(高隔离性，目前主流)；④Serverless模式——按需付费，自动弹性扩缩容(极高隔离性，适合峰谷波动大的云原生场景)。

云原生选择：生产环境→Application模式(资源隔离+启动较快)；云原生/K8s→Application+Serverless混合(常态用Application，峰值用Serverless弹性扩容)。

K8s部署关键：Operator管理Flink集群生命周期、Pod模板自定义资源配置、Ingress暴露WebUI/REST接口。

📌 关键知识点：Application模式是当前主流生产部署方式；Serverless模式是云原生趋势但成本需管控；Per-Job已被Application模式替代但面试仍会问
⚠️ 易错点：Session模式不能用于生产——作业间会互相影响(OOM/资源争抢)；Per-Job模式虽然隔离好但启动慢+资源浪费；Serverless模式冷启动延迟需预热处理

Flink三种状态后端(Memory/FsState/RocksDB)的对比与选型？RocksDB的核心优势是什么？如何优化RocksDB在大状态场景下的性能？

---

🤖 AI解析：
三种后端对比：①MemoryStateBackend——状态在TM堆内存，Checkpoint在JM堆内存(极高性能，极低可靠性，仅本地测试)；②FsStateBackend——状态在TM堆内存，Checkpoint持久化到HDFS/S3(高性能+高可靠，适合小状态生产作业)；③RocksDBStateBackend——状态在本地磁盘RocksDB，Checkpoint持久化到HDFS/S3+支持增量Checkpoint(中性能+极高可靠性，支持TB级大状态)。

RocksDB核心优势：①不受TM堆内存限制，支持TB级大状态；②增量Checkpoint只持久化差异，大幅降低IO开销；③LSM-Tree结构写入性能优异。

优化策略：①开启增量Checkpoint(checkpointing.incremental=true)；②调整RocksDB的block cache和write buffer大小；③使用Bloom Filter加速点查；④定期Compaction减少读放大；⑤状态TTL自动清理过期数据。

📌 关键知识点：RocksDB是唯一支持大状态的状态后端；增量Checkpoint是大状态场景的必备优化；状态TTL避免状态无限膨胀
⚠️ 易错点：FsStateBackend状态在堆内存——大状态会OOM，生产环境超过几GB就必须用RocksDB；RocksDB的读写经过磁盘IO，性能低于堆内存但远好于OOM崩溃；增量Checkpoint不是万能的——首次Checkpoint仍是全量

生产环境Flink实时ETL任务出现延迟，下游Kafka消费lag持续上涨，如何系统化诊断和解决背压问题？面试高频场景题。

---

🤖 AI解析：
诊断四步法：①Flink Web UI看BackPressure指标(红色=高反压，绿色=正常)；②看TaskManager日志是否有buffer耗尽/内存不足；③分析哪个算子是瓶颈——通常是聚合/Join/外部IO；④看数据流量是否有突增(业务峰值)。

解决六方案：①增大并行度分散负载(最直接)；②优化算子逻辑——预过滤减少数据量、减少状态访问；③调整网络buffer配置(taskmanager.network.memory)；④异步IO替代同步查询——Lookup Join用async=TRUE；⑤分区重平衡(rebalance/rescale)解决数据分布不均；⑥外部系统瓶颈——DB加索引/Kafka增加分区。

背压本质：自稳机制——下游慢时自动减缓上游速率防止崩溃，但持续反压意味着性能瓶颈需人工干预。

📌 关键知识点：背压是自稳机制不是bug——但持续反压=性能瓶颈需定位；Kafka lag是反压的外在信号；先定位瓶颈算子再对症下药
⚠️ 易错点：背压≠数据丢失——Flink的Checkpoint保证一致性；单纯增大并行度不一定有效——可能是下游DB扛不住；异步IO需注意超时和重试策略否则会引入新问题

什么是向量数据库？RAG架构如何设计？如何优化RAG的检索效果？这是2026年大数据面试新增的热门考点，AI+数据融合方向。

---

🤖 AI解析：
向量数据库：专门存储和查询向量数据的数据库，核心能力是相似性搜索——在海量向量中快速找到与查询向量最相似的K个。核心技术：①向量索引(IVF/HNSW/Annoy)；②向量压缩(PQ/SQ)；③分布式存储(水平扩展)；④混合查询(向量+标量)。

RAG架构设计：①文档处理→将文档分割成小块(512-1024 token)；②向量生成→嵌入模型将文档块转为向量；③向量存储→存入向量数据库(Milvus/Chroma)；④检索→用户查询→嵌入→相似性搜索→TopK文档块；⑤生成→文档块+查询→LLM生成回答。

优化策略：文档分割策略(按语义段落而非固定长度)、检索策略(Hybrid Search=向量+关键词)、重排序(Cross-encoder精排)、Chunk overlap(块间重叠避免信息截断)。

📌 关键知识点：向量数据库的核心是相似性搜索而非精确匹配；RAG是解决大模型幻觉和知识更新的最有效方法；HNSW索引是当前性能最好的向量索引算法
⚠️ 易错点：文档分割不能简单按字数切——会切断语义上下文；纯向量检索不够——需结合关键词检索(Hybrid Search)；嵌入模型的选择直接影响检索质量，需针对业务场景微调

请对比Lambda架构、Kappa架构和流批一体架构的优缺点、适用场景。为什么流批一体是终极形态？Flink+Paimon如何实现流批一体？

---

🤖 AI解析：
三大架构对比：①Lambda架构——批处理层(准确性)+实时层(低延迟)，需维护两套代码，逻辑不一致，开发运维成本高，适合对准确性要求极高的金融场景；②Kappa架构——'流是批的超集'，一套代码处理批和流，简化架构，但历史数据重放需重算整个Kafka，适合实时性优先的场景；③流批一体——Kappa的进一步发展，不仅代码统一，存储层也统一(Flink+Paimon)，是终极形态。

Flink+Paimon实现：Flink提供流批统一计算引擎(同一SQL处理流和批)，Paimon提供流批统一存储(LSM-Tree支持秒级实时写入+高效批量查询)，ACID事务保证流批数据一致性。

选择建议：新项目一律流批一体；存量Lambda架构逐步迁移；金融等对准确性要求极高的场景可保留Lambda。

📌 关键知识点：Lambda最大问题=两套代码逻辑不一致；Kappa最大问题=历史数据重放成本高；流批一体=Flink+Paimon代码+存储双统一；不是所有场景都要流批一体
⚠️ 易错点：流批一体不是万能药——某些场景Lambda更合适(如金融对准确性要求极高)；Kappa架构重放历史数据时Kafka存储成本很高；流批一体的Paimon目前生态不如Iceberg成熟

如何设计一个大模型数据管道？大模型数据处理与传统数据处理有什么不同？数据清洗去重的最佳实践是什么？2026年新增AI+数据融合考点。

---

🤖 AI解析：
大模型数据管道五层架构：①数据接入层——支持多种数据源(Web爬虫/API/数据库/文档)；②数据处理层——Spark/Flink分布式处理(TB/PB级)；③数据存储层——对象存储存原始+处理后数据；④数据标注层——标注工具和平台(人工+AI辅助标注)；⑤数据服务层——为大模型训练提供数据服务(分批加载+断点续训)。

与传统的差异：①数据量巨大(TB-PB级)；②数据类型多(文本/图片/音视频)；③质量要求高(低质量数据直接降低模型能力)；④标注需求大(监督微调需大量标注)。

清洗去重最佳实践：MinHash+LSH近似去重(千万级文档)、规则过滤(长度/语言/质量分数)、Perplexity过滤(用小模型打分筛低质量)、数据增强(同义词替换/回译)。

📌 关键知识点：大模型数据管道的核心挑战是数据质量而非数据量；MinHash+LSH是大规模去重的标准方案；Perplexity过滤是筛低质量数据的有效方法
⚠️ 易错点：不要用精确去重——PB级数据精确去重不可行，必须用近似去重；数据增强不能过度——过度增强会导致模型过拟合增强模式而非学真实分布；标注数据质量比数量更重要

如何设计一个完整的数据质量监控体系？数据质量的五个维度是什么？如何实现自动化数据质量检查？数据契约如何与数据质量监控结合？

---

🤖 AI解析：
五维质量体系：①准确性(数据正确反映现实)、②完整性(数据无缺失)、③一致性(跨系统数据一致)、④及时性(数据及时提供)、⑤唯一性(数据无重复)。

监控体系设计：①接入层——数据格式/Schema校验、源端数据量波动监控；②处理层——ETL任务成功率/延迟监控、中间表行数/空值率/枚举值校验；③服务层——指标异常检测(3σ/Isolation Forest)、数据血缘追踪。

自动化检查：Great Expectations/Deequ框架写检查规则→CI/CD集成→异常告警→自动修复(重跑/回填)→数据契约校验(源端Schema/SLA是否符合契约)。

从事后到事前：数据契约=事前约束(定义+检查)，监控体系=事中发现(检测+告警)，两者结合才能实现全链路数据质量保障。

📌 关键知识点：数据质量不是单一维度而是五维体系；自动化检查框架(Great Expectations/Deequ)是工程化基础；数据契约是事前预防，监控是事中发现，两者互补
⚠️ 易错点：只有监控没有修复=无效——告警了没人处理等于没监控；数据质量指标体系不是越多越好——聚焦核心字段和核心表；数据血缘是根因分析的基础，没有血缘监控就是空中楼阁

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...结果被一道算法题坑了，"有效的括号"使用栈来解，会非常简单.

终于来了，算法相关的。 其实个人理解，前端岗位对于算法的要求与其他IT岗位相比，是低得多的。 但是小白我经历了如蚂蚁金服、网易这样的大厂教做人之后，还是觉得，对于一些基本算法、思想的掌握还是必须的。 然后，就把自己遇到的、学到的算法相关的再总结一下，方便自己随时备战面试。 JS…

看到一篇算法文章，觉得着实有趣，但不知为何我看到题后首先想到的是田忌赛马。今天我也试着解释下这题，当做是一个学习的过程。 64 匹马分 8 次在全部比完一次，然后我们可以把目标缩小到 32 匹马。 1、八次比完后，我们可以将每一匹马的速度按下表排好。 剩下的 8 组 32 匹马…

链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n …

回想以前遇到过的面试官，甚至包括自己作为面试官的时候，大都是停留在问【是什么】的问题上，而很少去追问【为什么】。。。

1. 概述 排序算法分为内部排序和外部排序，内部排序把数据记录放在内存中进行排序，而外部排序因排序的数据量大，内存不能一次容纳全部的排序记录，所以在排序过程中需要访问外存。 经常提及的八大排序算法指的就是内部排序的八种算法，分别是冒泡排序、快速排序、直接插入排序、希尔排序、简单…

持续更新，持续更新...

【前端面试复习系列文章】 2024前端高频面试题-- html篇 2024前端高频面试题-- CSS篇 2024前端高频面试题-- JS篇 2024前端高频面试题-- VUE篇 2024前端高频面试题

1. KMP 算法 谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致…

众所周知，与后台开发人员相比，算法是我们前端开发人员的一个弱项。 而近两年随着互联网行业竞争愈发激烈，市场上对前端岗位的算法要求也有一定的提升。 我记得大三参加腾讯的校招面试时只准备了几种常见的排序算法就足以应对了，然而今年包括今日头条在内的多家大厂的前端笔试题目中都出现了"贪…

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置（找不到返回 -1）。 有一个祖先树状 json 对象，当一个人有一个儿子的时候，其 child …

0. 几个概念 完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~ 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子…

前言 本文题目选自 LeetCode 精选 TOP 面试题，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所

前几天有个朋友去面试字节跳动，面试官问了他一道链表相关的算法题，不过他一时之间没做出来，就来问了我一下，感觉这道题还不错，拿来讲一讲。 给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一…

数据结构是对实际问题中的数据元素及相互间的联系的抽象。一般用线性表来表示常用数据结构，线性表分为顺序存储的顺序表和连式存储的链表。 在学习算法之前，必须要了解一些常用数据结构的概念。 栈：一种特殊串联形式的抽象数据类型，可由链表或数组实现，通过链表或数组的栈顶（Top）指针对数…

2019年马上就要结束了，相信很多童鞋都开始蠢蠢欲动了，寻找新的机会了，但是工作太忙没有时间刷算法题，面试的时候好心虚。这里双手奉上40道LeetCode上经典面试算法题，整理的内容有点长，建议先收藏，慢慢消化，在来年顺利拿到满意的offer。 内容较多，整理不易，希望大家关注…

腾讯年终奖 什么是真正的好公司？ 一年到头，出不了几次裁员等劳务纠纷的吃瓜新闻。 只有到年底了，才因为年终奖远高于行业水平，实在没法低调了，"被迫"上热搜。 最近网友爆料了腾讯头牌部门的年终奖： WX

限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣…

接触 Android 开发也有一段时间了，前段时间便开始想抽空整理一些知识点，通过笔记整理的方式减少自己重复学习的时间成本和提高自身的效率。 本文总结的部分是常见面试算法题，算法题解均有 java 实现。目录可以在右边侧边栏查看跳转。 之后会整理的知识点还会有 java、And…

大家好，我是薇薇，一名沪漂女程序员，年前惨遭被裁，正值在家悲伤抠脚之际，突然看到两位朋友在合谋开发一款刷leetcode的小工具——leetcode-practice…… 下面重点稍微来介绍一下 在神

大家好，今早在B站看到up主的vscode里藏了leetcode插件，这才知道原来还有这款神器。但是没想到在用的时候遇到了一些麻烦，花了一点时间才解决。所以写这篇文章除了给大家安利这个好用的插件之外，也是为了帮助更多的同学避免踩坑。 vscode在工业界鼎鼎大名，被誉为微软少有…

花了十几天，把《算法》看了一遍。然后重新 AC 了一遍 LeetCode 的题并记录下心得。

算法一直是大厂前端面试常问的一块，而大家往往准备这方面的面试都是通过leetcode刷题。 我特地整理了几道leetcode中「很有意思」而且非常「高频」的算法题目，分别给出了思路分析（带图解）和代码实现。 给定一个整数数组 nums 和一个目标值 target，请你在该数组中…

题目分类及刷题顺序推荐 一. 数组 二. 字符串 三. 数与位 四. 栈与递归 五. 链表 六. 哈希表 七. 贪心算法 八. 双指针法 九. 树 十. 图与搜索 十一. 二分查找 十二. 二进制运算

虽然很多人都觉得前端算法弱，但其实 JavaScript 也可以刷题啊！最近两个月断断续续刷完了 leetcode 前 200 的 middle + hard ，总结了一些刷题常用的模板代码。走过路过发现 bug 请指出，拯救一个辣鸡（但很帅）的少年就靠您啦！ 包括打印函数和一…

众所周知，现在的互联网公司面试，只要是写代码的岗位，都会来一套算法题组合拳伺候。 所以大家在准备校招、社招，或者闲暇的时候，都可以刷刷题，保持良好的手感。

我就是那个 @量子位 答案里面提到的“lucifer 小哥哥”。 我本人从开始准备算法以来，大概经过了几个月的时间，这期间自己成长了很多，从刷题菜鸡，到现在对刷题套路，题型有了自己的理解，感受还是蛮多的。我本人不是算法高手，算是勤能补拙类型。不过经过几个月的学习和练习，不仅面试…

1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串

leetcode网站中的编程环境，代码提示，快捷键并不友好，我们在刷题的时候往往不高效，且过后也不能快速，随时随地的进行方便的复盘。所以在这篇文章中我将介绍如何在 VsCode 中通过插件来高效的刷题

老司机带你刷 LeetCode

LeetCode热题100道-Day02 136. 只出现一次的数字 在stream流中的reduce方法使用异或运算。

作为一个前端同学，为什么不用JavaScript刷LeetCode，而是使用TypeScript来刷题呢？ 当然，你也可以选择c++、java来刷题，但我认为还是用自己研究方向的语言比较好

作为一个多年的老菜鸟，有感于大部分的公司面试 “面试造航母，工作螺丝钉” 的作风，特整理了这个数据结构和算法面试题系列。对于校招而言，如果没有太多实践/实习经验，大公司往往喜欢考察数据结构和算法，如微软就特别喜欢在校招时手写算法题，而且难度还不小，当年我毕业找工作时也是颇受折磨…

数学是科学之基础，数字题往往也是被面试玩出花来。数学本身是有趣味的一门学科，前段时间有点不务正业，对数学产生了浓厚的兴趣，于是看了几本数学史论的书，也买了《几何原本》和《陶哲轩的实分析》，看了部分章节，受益良多，有兴趣的朋友可以看看。特别是几何原本，欧几里得上千年前的著作，里面…

500 Data structures and algorithms interview questions and their solutions

背包问题包括0-1背包问题、完全背包问题、部分背包问题等多种变种。其中，最简单的是部分背包问题，它可以采用贪心法来解决，而其他几种背包问题往往需要动态规划来求解。本文主要来源于《背包问题九讲》，我选择了比较简单的0-1背包问题和完全背包问题进行汇总。同时给出实现代码，如有错误，…

继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。本文所有代码在 这里 。 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 题： 给定一棵…

HashMap 是我们熟悉的散列表实现，也是 “面试八股文” 的标准题库之一。今天，我给出一份 HashMap 高频面试题口述简答答案，希望对你刷题有帮助。

前面总结了随机算法，这次再把以前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，希望这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，如有错误，也恳请各路大牛指正。二叉树的递归示例代码请参…

在用C语言实现一些常见的数据结构和算法时，C语言的基础不能少，特别是指针和结构体等知识。 linux中的C编译得到的目标文件和可执行文件都是ELF格式的，可执行文件中以segment来划分，目标文件中，我们是以section划分。一个segment包含一个或多个section，…

随机算法涉及大量概率论知识，有时候难得去仔细看推导过程，当然能够完全了解推导的过程自然是有好处的，如果不了解推导过程，至少记住结论也是必要的。本文总结最常见的一些随机算法的题目，是几年前找工作的时候写的。需要说明的是，这里用到的随机函数 randInt(a, b) 假定它能随机…

栈作为一种基本的数据结构，在很多地方有运用，比如函数递归，前后缀表达式转换等。本文会用C数组来实现栈结构(使用链表实现可以参见链表那一节，使用头插法构建链表即可)，并对常见的几个跟栈相关的面试题进行分析，本文代码在 这里。 我们使用结构体来定义栈，使用柔性数组来存储元素。几个宏…

链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的…

快速排序也是基于分治模式，类似归并排序那样，不同的是快速排序划分最后不需要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤： 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每个元…

字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。本文相关代码见 这里。 首先来看一些字符串的基本函数的实现，以下代码取自MIT6.828课程。 题： 给定一个字符串，找出该…

排序算法也是面试中常常提及的内容，问的最多的应该是快速排序、堆排序。这些排序算法很基础，但是如果平时不怎么写代码的话，面试的时候总会出现各种bug。虽然思想都知道，但是就是写不出来。本文打算对各种排序算法进行一个汇总，包括插入排序、冒泡排序、选择排序、计数排序、归并排序，基数排…

在说二叉树前，先来看看什么是树。树中基本单位是结点，结点之间的链接，称为分支。一棵树最上面的结点称之为根节点，而下面的结点为子结点。一个结点可以有0个或多个子结点，没有子结点的结点我们称之为叶结点。 二叉树是指子结点数目不超过2个的树，它是一种很经典的数据结构。而二叉搜索树(B…

二分查找本身是个简单的算法，但是正是因为其简单，更容易写错。甚至于在二分查找算法刚出现的时候，也是存在bug的（溢出的bug），这个bug直到几十年后才修复（见《编程珠玑》）。本文打算对二分查找算法进行总结，并对由二分查找引申出来的问题进行分析和汇总。若有错误，请指正。本文完整…

本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(…

存储过程就像我们编程语言中的函数一样，封装了我们的代码(PLSQL、T-SQL)。 上面的文字我们肯定是看不懂的，也不愿意看下去的。接下来我就总结一下： 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的 第二范式：满足第一范式,表…

例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话…

使用group by的sql语句，select后的字段只能是group by后的字段，如果需要展示其他字段数据，需要给该列使用聚合函数，否则默认展示分组后的第一行数据。 左连接：左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录。右表记录不足的地方均为NULL（用户信…

SQL（结构化查询语言）是一种设计用于检索和操作数据的数据库。它属于美国国家标准协会（ANSI）的一种标准，可用于执行Select（选择）、Update（更新）、Delete（删除）和Insert（插入）等数据任务。 表是在具有列和行的模型中设计的数据集合。在表中，指定了列数称…

😊：“读题，入职时候的薪水，加上提示一个员工有多次涨薪的情况，所以本质上是求解每个员工的最低薪水，还要按照emp_no降序排列。阿，求每个员工的薪水最小值，用group by就可以实现，要输出的字段在salaries这张表中都有，所以别看他给了2张表，只需要1张表就能算出结果。1...

Sql常用语法下列语句部分是Mssql语句，不可以在access中使用。 SQL分类： DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) DML—数据操纵语言(SELECT，

1/连续最长登陆天数 2/下一次登陆时间距离上一次登陆时间大于30天时，从1开始计数 3/一张包含全国各城市用户的观看记录表view_info（表中一条数据代表一次观看记录），包含city_name、

MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引。 MySQL官方对索引的定义为：索引（In…

面试官：要不你来讲讲你们对MySQL是怎么调优的？ 候选者：哇，这命题很大阿…我认为，对于开发者而言，对MySQL的调优重点一般是在「开发规范」、「数据库索引」又或者说解决线上慢查询上。 候选者：而对

这天我正在午休呢，公司DBA就把我喊醒了，说某库出现大量慢SQL，很快啊，很快，我还没反应过来，库就挂了，我心想现在的用户不讲武德啊，怎么在我睡觉的时候大量请求呢。 这是很常见的一个场景哈，因为很多业务开始数据量级不大，所以写sql的时候就没注意性能，等量级上去，很多业务就需要…

敖丙：加索引。 敖丙：没了。 哈哈开头这个场景是我臆想的一个面试场景，但是大家是不是觉得很真实，每个人的简历上但凡写到了数据库，都会在后面顺便写一句，会数据库调优。 我觉得调优能回答的点还是很多很多的，我自己看了《MySQL实战》、《高性能MySQL》、《丁奇MySQL47讲》…

一、前言 上一篇我们说了 腾讯一面：说一说 MySQL 中索引的底层原理，相信你对索引有个很清晰的认识了，这一篇我们来说一说慢 SQL 的排查以及调优。为啥面试官要问这个问题，其实跟上一篇的索引底层原

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

大家好，我是 V 哥。SQL调优对于提升数据库查询性能至关重要，特别是当数据量大时。以下是20个详细的SQL调优指南和高级技巧，结合案例说明，帮助优化SQL查询的性能。 1. 选择合适的索引 技巧: 

一次线上慢SQL调优分享 一周前，客户反馈做题页面经常卡顿，加载慢；我们监控比较少，所以根据直觉去MySQL慢查询日志一看，果然是一条慢SQL。废话不多，开整！！！ 业务背景 一个在线做题的代码评测系

作为开发人员，我们免不了与sql打交道。有些sql可能在业务的最开始，执行是毫无问题的。但是随着业务量的提升以及业务复杂度的加深，可能之前的sql就会逐渐展现出疲惫之势了。这时就会面临sql调优。 那么调优到底如何调？不同的人有不同的姿势。可能大部分人首先想到的就是加索引。 没…

order by字段尽量走索引... 其中有些手段也许跟随者MySQL版本的升级过时了。我们真的需要背这些调优手段吗？我觉得是没有必要的，在掌握MySQL存储架构和SQL执行原理的情况下，我们就很自然的明白，为什么要提议这么优化了，甚至能够发现别人提的不太合理的优化手段。 在 …

背景 基于TPCDS的100G，500G数据进行了99SQL综合调优测试 测试机为物理机5台，1台为管理节点，4台为计算节点 可用内存约1T，核心数（vCore）200大概 重要参数 执行器个数 --

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情 1.写在前面 在昨天的时候，我们就谈到了数据库连接池优化 详情可参考这里：点击查看 经过昨天的分析，我们已

面试官：MySQL如何进行性能调优？ 具体操作我这里整理了慢查询、explain、@@profiling关键字 慢查询 DBA有时候会发现有些语句比较慢，他们怎么发现的呢？ 编辑配置文件打开慢查询 然

在系统运行过程中，总会与数据库的交互，通过数据库端的日志查询执行时间最长与执行次数最多的sql语句，就可以有针对性的进行调优处理。 取执行时间最长的前50条sql语句。

引言 数据库性能优化是每个后端程序猿必备的基础技能之一，而Mysql中的explain堪称Mysql的性能优化分析神器，我们可以通过它来分析SQL语句的对应的执行计划在Mysql底层到底是如何执行的，

这几周系统访问量也是居高不下，不出意外系统又出现瓶颈了，大量用户反馈判题结果响应太慢；经排查，又是关于SQL的问题 业务背景 一个类似于力扣在线做题的代码评测模块，用户提交判题任务后，后台会进行异步判

什么是 SQL 调优？是不是觉得自己知道但又很模糊说不清楚，面试被问没有真实的案例，并不具备说服力。本文以为详细案例给大家解读。

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

Spark SQL是Spark生态系统中非常重要的组件， 能够利用 Spark 进行结构化的存储和操作。本文将围绕Spark内存泄露问题进行排查，并且给出具体的Spark调优方法。

Hive的架构 Hive元数据默认存储在derby数据库，不支持多客户端访问，所以将元数据存储在MySQl，支持多客户端访问。 2 Hive和e和数据库比较，Hive 和数据库除了拥有类似的查询语言，

1. hive 内部表和外部表的区别？ 未被external修饰的是内部表（managed table），被external修饰的为外部表（external table）； 内部表数据由Hive自身管

Hive SQL基本上适用大数据领域离线数据处理的大部分场景。Hive SQL的优化也是我们必须掌握的技能，而且，面试一定会问。那么，我希望面试者能答出其中的80%优化点，在这个问题上才算过关。 JVM重利用可以使得JOB长时间保留slot,直到作业结束，这在对于有较多任务和较…

第一题 需求 实现 数据准备 查询SQL 第二题 需求 实现 数据准备 查询SQL实现 第三题 需求 实现 数据准备 查询SQL 第四题 需求 实现 数据准备 查询SQL 第五题 需求 实现 数据准备

有用户点击日志记录表 t_click_log_025，包含user_id(用户ID),click_time(点击时间)，请查询出连续点击三次的用户数。

1.Hive的架构 2 Hive和数据库比较 Hive 和数据库除了拥有类似的查询语言，再无类似之处。 1）数据存储位置 Hive 存储在 HDFS 。数据库将数据保存在块设备或者本地文件系统中。 2

如何设计一个支持秒级延迟的流批一体数仓架构？字节跳动2026年大数据架构师面试必考题，要求端到端数据延迟<10秒，同时支持T+0实时报表和T+1离线分析。

---

🤖 AI解析：
架构设计：四层架构——①数据接入层：Flink CDC同步业务DB，Filebeat采集日志；②统一消息层：Kafka多集群架构，原始Topic保留7天，清洗Topic保留3天；③统一计算层：Flink流批一体引擎，实时用DataStream/Batch Mode，离线用Flink Batch Mode；④统一存储层：Apache Paimon湖仓存储(ODS/DWD/DWS/DIM)。服务层用StarRocks做实时OLAP，Trino做离线OLAP。

关键技术点：Flink+Paimon是流批一体最佳实践——Flink提供流批统一计算引擎，Paimon的LSM-Tree结构适合高吞吐实时写入且支持秒级更新；增量Checkpoint间隔1-2秒保证秒级延迟；两阶段提交(2PC)保证数据一致性。

📌 关键知识点：Flink+Paimon流批一体架构；Paimon的LSM-Tree结构实现高吞吐写入+批量查询；2PC+Exactly-Once保证端到端一致性
⚠️ 易错点：不要以为Kappa架构就是流批一体——Kappa只是用一套代码，流批一体要求存储层也统一；Paimon小文件合并策略必须配置，否则查询性能急剧下降

对比Delta Lake、Iceberg、Hudi、Paimon四大开放表格式的原理差异和选型依据，什么业务场景选择哪种格式？2026年大数据面试最热门考点。

---

🤖 AI解析：
四大格式对比：①Delta Lake(Databricks)——与Spark深度集成，查询性能高，实时性分钟级，市场份额35%；②Iceberg(Netflix)——开放表格式标准，多引擎支持最好，实时性分钟级，份额30%；③Hudi(Uber)——面向更新优化，写入性能高，实时性分钟级，份额15%；④Paimon(阿里)——流批统一存储，与Flink深度集成，实时性秒级，份额20%。

选型依据：主用Spark→Delta Lake；主用Flink+需秒级实时→Paimon；多引擎兼容→Iceberg；大量更新删除→Hudi/Paimon。

📌 关键知识点：Paimon是唯一支持秒级实时的格式；Iceberg生态兼容性最强；Delta Lake与Spark绑定最深；选型需看计算引擎、实时性要求和生态需求
⚠️ 易错点：不要只看市场份额选型——实时性要求是决定性因素；Paimon虽然实时性最好但生态不如Iceberg成熟；Delta Lake不是'开源'的，社区版和商业版功能差异大

设计一个电商实时数仓架构，从数据接入到数据服务全链路设计。要求支持实时大屏、实时报表、实时风控、实时推荐四大应用场景。

---

🤖 AI解析：
全链路架构：①数据接入：Flink CDC同步MySQL/PostgreSQL，Filebeat采集用户日志，API同步第三方数据，统一写入Kafka；②ODS层：Kafka存储原始数据保留3-7天；③DWD层：Flink清洗去噪+维度退化+统一口径，写入Kafka和Paimon；④DWS层：Flink按主题轻度聚合，写入Paimon和ClickHouse；⑤DIM层：Flink CDC同步维度表存Paimon；⑥ADS层：StarRocks/ClickHouse提供高性能查询。

应用场景：实时大屏(GMV/订单/用户)、实时报表(多维分析)、实时风控(欺诈检测)、实时推荐(行为驱动)。

📌 关键知识点：实时数仓分层与离线数仓的核心差异——实时用Kafka+Paimon替代HDFS+Hive；DIM层必须实时同步否则维度关联延迟；ClickHouse/StarRocks做OLAP加速
⚠️ 易错点：实时数仓不是把离线数仓搬一遍到实时——ODS层用Kafka而非HDFS是关键差异；维度表如果用T+1同步，实时指标会因维度缺失而不准确

大数据处理中数据倾斜是最常见的问题，请给出完整的识别和解决方案。包括Spark和Flink两种引擎下的不同处理策略。

---

🤖 AI解析：
识别方法：①Spark UI/Flink UI查看Task执行时间，找特别长的；②查看数据分布，找数据量特别大的Key；③查看Shuffle数据量，找Reducer数据量特别大的。

六大解决方案：①过滤空值/异常值——倾斜由大量空值引起时直接过滤；②随机前缀法(Salting)——给倾斜Key加随机前缀分散到多Reducer，再全局聚合；③分阶段聚合——先局部聚合减数据量再全局聚合；④广播小表——Join倾斜时小表broadcast避免Shuffle；⑤动态分区——根据数据分布动态调整分区数；⑥引擎内置优化——Spark的skew join hint和AQE，Flink的倾斜Join优化。

Spark特有：reduceByKey替代groupByKey(Map端预聚合)；Flink特有：Local-Global聚合模式。

📌 关键知识点：先识别再解决——不同原因对应不同方案；Salting是最通用方案但需两步Join；AQE(Spark3.0+)可自动检测并拆分倾斜分区
⚠️ 易错点：不要一上来就说'加随机前缀'——要先定位是哪个Key倾斜、倾斜原因是什么；Salting后Join需两步(先加盐Join再去盐聚合)；AQE需spark.sql.adaptive.enabled=true

数据仓库为什么要分层？分层过多有什么问题？如何根据业务需求调整分层架构？2026年面试不再问'五层架构是什么'，而是问'你为什么这样分层'。

---

🤖 AI解析：
分层哲学：分层的本质是'关注点分离'——每层解决一个核心问题：ODS(原始数据保真)、DWD(明细数据清洗标准化)、DWS(汇总数据复用)、ADS(应用数据服务化)、DIM(公共维度统一)。过度分层的代价：①ETL链路变长延迟增大；②中间表暴增存储成本翻倍；③开发维护成本高、数据溯源难。

实时数仓分层差异：ODS→Kafka(而非HDFS)，DWD→Flink清洗+Paimon，DWS→Flink聚合+ClickHouse。什么情况可合并：DWD+DWS合并(数据量小、业务简单时)；ODS+DWD合并(数据源本身已清洗)。

📌 关键知识点：分层不是教条而是成本-收益权衡；实时数仓分层与离线的核心差异在存储层(Kafka vs HDFS)；过度分层比不分层更危险
⚠️ 易错点：不要背五层架构——面试官想知道的是你的分层决策逻辑；合并层级不等于偷懒——简单业务强套五层反而增加维护成本；实时数仓的ODS层不能省——原始数据是溯源的唯一保障

请详细阐述SCD1/SCD2/SCD3的定义、适用场景，以及在实时数仓中如何实现SCD2？SCD2的性能问题如何优化？

---

🤖 AI解析：
SCD类型：①SCD1(覆盖)——直接覆盖旧值，不保留历史，适用于数据修正、无需追溯变化的场景；②SCD2(新增行)——新增一行记录新值，用start_date/end_date标记有效期，保留完整历史，是最常用的方式；③SCD3(新增列)——增加一列存旧值，只保留前一次变化，适用于只需比较前后两次的场景。

实时数仓SCD2实现：Flink CDC捕获变更→双流JOIN+状态管理维护有效记录→写入Paimon的UPSERT表(主键+有效期)。性能优化：①Paimon的LSM-Tree天然支持高效UPSERT；②增量Checkpoint减少状态持久化开销；③分区剪枝按日期分区加速查询。

📌 关键知识点：SCD2是最常用但也是性能问题最多的方式；实时数仓用Paimon的UPSERT能力替代传统Hive的INSERT+OVERWRITE；end_date='9999-12-31'表示当前有效记录
⚠️ 易错点：SCD2在实时环境中的关键挑战是UPDATE性能——传统Hive不支持UPDATE必须全表覆盖；实时数仓中SCD2的版本链可能很长需定期归档历史版本

什么是数据契约？为什么说它是数据治理的新范式？数据契约包含哪些内容？如何在组织中推行数据契约？2026年大数据面试热点考点。

---

🤖 AI解析：
数据契约定义：数据生产者和消费者之间的正式协议，定义数据的结构、格式、质量标准和SLA。包含内容：①Schema定义(结构和字段类型)；②语义定义(业务含义和计算口径)；③质量标准(准确性/完整性/一致性要求)；④SLA(更新频率和延迟要求)；⑤所有权(生产者和负责人)。

实现方式：①代码生成——根据契约自动生成代码；②运行时检查——数据生产/消费时检查是否符合契约；③监控告警——违反契约自动告警；④版本管理——管理契约的版本变化。

推行策略：先从小范围试点→证明价值→管理层支持→全组织推广→建立激励机制。

📌 关键知识点：数据契约是数据治理从'事后补救'到'事前预防'的关键转变；契约的核心是'协议'而非'文档'——必须有自动化检查和告警；推行数据契约是组织问题而非纯技术问题
⚠️ 易错点：数据契约≠文档——没有自动化检查的契约只是纸上谈兵；推行不能一步到位——先从最痛的数据质量问题入手；契约版本管理经常被忽略但它是避免breaking change的关键

Flink SQL支持Append-only、Retract、Upsert三种流类型，它们的区别是什么？各自适用于什么场景？Retract流和Upsert流在实现聚合时有什么差异？

---

🤖 AI解析：
三种流类型：①Append-only流——只有INSERT操作，没有UPDATE/DELETE，适用于日志/事件等不可变数据，最简单性能最好；②Retract流——包含INSERT和撤回(DELETE+INSERT)，当聚合结果更新时先撤回旧结果再插入新结果，适用于无主键的聚合场景(如GROUP BY无唯一键)；③Upsert流——包含INSERT和UPDATE，基于主键判断：有则UPDATE，无则INSERT，适用于CDC数据/有主键维度表等场景，性能优于Retract(一条UPDATE vs 一条DELETE+INSERT)。

聚合实现差异：Retract流——聚合结果变化时发送[DELETE旧值, INSERT新值]两条消息；Upsert流——聚合结果变化时只发送一条UPDATE消息(基于主键)。Upsert性能更优但必须有主键。

📌 关键知识点：Upsert流是Flink SQL中最常用的流类型(有主键场景)；Retract流的撤回机制会导致下游收到两条消息需特殊处理；CDC数据天然是Upsert流
⚠️ 易错点：Retract流的撤回消息不能忽略——下游必须正确处理+I/-D消息对；Upsert流必须有主键否则退化为Retract流；聚合结果频繁更新时Retract流的消息量是Upsert的两倍

Flink的Checkpoint和Savepoint有什么核心区别？90%的候选人无法精准说清。它们在触发方式、用途、生命周期、格式和增量支持上有什么不同？

---

🤖 AI解析：
五大维度对比：①触发方式——Checkpoint=引擎自动按预设间隔触发，Savepoint=用户手动执行命令触发；②核心用途——Checkpoint=故障自动恢复保证运行可靠性，Savepoint=作业升级/版本迁移/集群重启/暂停恢复；③生命周期——Checkpoint=与作业绑定，作业停止后默认删除，Savepoint=用户管理，永久保存在分布式文件系统除非手动删除；④格式——Checkpoint=针对快速恢复优化，格式紧凑与状态后端绑定，Savepoint=标准化格式，不绑定状态后端，支持跨版本/跨集群恢复；⑤增量支持——Checkpoint=支持增量Checkpoint(只持久化差异)，Savepoint=仅支持全量持久化。

生产实践：Checkpoint间隔不宜太短(影响吞吐)也不宜太长(影响恢复速度)，通常30s-3min。版本升级必须先做Savepoint再停作业。

📌 关键知识点：Checkpoint=自动故障恢复(轻量+增量)，Savepoint=人工版本管理(全量+标准格式)；Savepoint是唯一支持跨版本恢复的机制；生产环境必须两者结合使用
⚠️ 易错点：作业停止后Checkpoint默认删除——重要状态变更前必须手动Savepoint；Savepoint是全量的做一次很慢不能频繁执行；从Savepoint恢复时如果改了算子拓扑可能不兼容需检查

数据仓库中三种事实表(事务型/周期型快照/累积型快照)的区别与适用场景？重点讲解累积型快照事实表的设计技巧和回退/异常处理。

---

🤖 AI解析：
三种事实表：①事务型事实表——记录每次业务事件(如下单/支付)，一行=一个事件，适用于业务过程分析、漏斗转化；②周期型快照事实表——按固定周期记录状态(如每日余额/每日库存)，一行=一个实体一个周期，适用于趋势分析、同环比；③累积型快照事实表——记录业务全生命周期的关键节点(如订单从创建→支付→发货→签收)，一行=一个完整流程，适用于流程分析、SLA监控、瓶颈定位。

累积型快照设计：字段包含所有关键节点时间(order_time/pay_time/ship_time/receive_time)，中间状态用NULL填充。回退/异常处理：①逆向流程(退货)用额外字段或独立事实表；②超时未完成的流程设置告警阈值；③事实表支持UPDATE(实时数仓用Paimon UPSERT)。

📌 关键知识点：累积型快照事实表是业务生命周期分析的核心——也是面试中最容易暴露薄弱环节的考点；实时数仓用Paimon的UPSERT能力替代传统Hive的全表覆盖
⚠️ 易错点：累积型快照事实表不适合高频变更场景——每次变更都需UPDATE全行；业务回退(退货/取消)不能简单删除记录——需保留历史轨迹；事实表粒度选择错误会导致分析结果完全错误

## 题目描述
记录直播平台主播上播及下播时间，计算出平台最高峰同时直播人数。

## 表结构
live_broadcast(anchor_id INT, start_time DATETIME, end_time DATETIME)

## 字段说明
- anchor_id: 主播ID
- start_time: 上播时间
- end_time: 下播时间

## 示例
anchor_id=1: 08:00-10:00, id=2: 09:00-12:00, id=3: 09:30-11:00
09:30-10:00 同时有3人直播，峰值为3

## 解题思路
1. 上播事件标记+1，下播事件标记-1
2. UNION ALL 展开为事件流
3. 按时间排序，SUM() OVER 累计在线人数
4. 取 MAX 即为峰值

## 参考答案
WITH events AS (
   SELECT start_time AS ts, 1 AS cnt FROM live_broadcast
   UNION ALL
   SELECT end_time, -1 FROM live_broadcast
),
ordered AS (
   SELECT ts, SUM(cnt) OVER (ORDER BY ts, cnt DESC) as online_cnt
   FROM events
)
SELECT MAX(online_cnt) as peak_concurrent FROM ordered;

1. 如何从大量的 URL 中找出相同的 URL？ 给定 a、b 两个文件，各存放 50 亿个 URL，每个 URL 各占 64B，内存限制是 4G。请找出 a、b 两个文件共同的 URL。 每个 URL 占 64B，那么 50 亿个 URL占用的空间大小约为 320GB。 由…

一千个读者眼中有一千个哈姆雷特，一千名 大数据 程序员心目中就有一千套 大数据面试题。本文就是笔者认为可以用来面试大数据 程序员的面试题。 这套题的题目跟公司和业务都没有关系，而且也并不代表笔者本人可以把这些题回答得非常好，笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来…

1、集群的最主要瓶颈 磁盘IO 2、Hadoop运行模式 单机版、伪分布式模式、完全分布式模式 3、HDFS写流程 1）client 客户端发送上传请求，通过 RPC 与 namenode 建立通信，

大数据工程师是近几年异常火爆的职位，市场需求旺盛，众多互联网公司都打出了高薪招聘的广告，本文整理了网络上部分技术人员分享的各大互联网公司大数据类(Hadoop、Spark等)面试题以及面试时需要注意的一些问题，希望对各位技术人员有所帮助。 分享之前我还是要推荐下我自己创建的大数…

前言 随着 5G 时代的到来，大数据人工智能产业链又一次迎来了井喷式的爆发，随着岗位需求的不断增加，越来越多的人选择大数据课程，但是没有真正从事大数据工作的人面对企业面试有种无从下手的感觉，面对面试说

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 题目来源 作者：是锅粥 链接：https://www.nowcoder.com/discuss/745950

1、HAnamenode 是如何工作的? ZKFailoverController主要职责 1）健康监测：周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机

本文整理了互联网大厂数据开发、数据分析、数仓等数据相关岗位面试过程中经常出现的SQL面试题，并给出了参考答案。涉及了炸裂函数、开窗函数、聚合函数开窗、在线直播人数等 以及这两年各大厂面疯了各种连续问题

1. hadoop 架构 Hadoop2.0版本，引入了Yarn。核心：HDFS+Yarn+Mapreduce Yarn是资源调度框架。能够细粒度的管理和调度任务。此外，还能够支持其他的计算框架，比如spark等。 Namenode：也叫名称节点，是HDFS的守护程序（一个核心…

六、描述HBase 中scan 和get 的功能以及实现的异同？七、hbase如何导入数据？八、hbase 的存储结构？九、解释下 hbase 实时查询的原理十、详细描述 HBase 中一个 cell 的结构？十一、简述 HBase 中 compact 用途是什么，什么时候触发，...

1. 通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？ spark是借鉴了Mapreduce,并在其基础上发展起来的，继承了其分布式

1、Flink怎么做压力测试和监控？ 参考答案：我们一般碰到的压力来自以下几个方面： （1）产生数据流的速度如果过快，而下游的算子消费不过来的话，会产生背压。背压的监控可以使用FlinkWebUI(l

Redis熟不熟，介绍下它有几种数据类型？我回答了8种，面试官说只有5种，后来在网上搜了搜，版本也很多。 手撕代码第一道是力扣原题：169. 多数元素 手撕代码第二道如何实现最小栈（也是力扣原题155. 最小栈），可能时间有限，没有让手写，说一下思路。 自我介绍之后，就全程几乎…

local 本地，通常是测试的时候用。 standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。 SparkonYarn 交给Yarn来进行资源调度，有 yarn-clu

​ 目录 HDFS文件写入和读取流程 HDFS组成架构 介绍下HDFS，说下HDFS优缺点，以及使用场景 HDFS作用 HDFS的容错机制 HDFS的存储机制 HDFS的副本机制 HDFS的常见数据格

什么是数据湖 数据湖（Data Lake）是一个大型数据存储和处理系统， 它能够存储各种类型和格式的数据，包括结构化数据、半结构化数据和非结构化数据。以下是关于数据湖的详细解释： 定义与特点 数据存储

​ 1、介绍下YARN 2、YARN有几个模块 3、YARN工作机制 4、YARN有什么优势，能解决什么问题? 5、YARN容错机制 6、YARN高可用 7、YARN调度器 8、YARN中Contai

分享大数据常见的面试题 一、mr的shuffle流程 说到mr的Shuffle，那么首先要明确shuffle属于哪个阶段。shuffle就是从Map端输出到Reduce输入的整个过程，这个过程广义上称

介绍下Flume  Flume架构  Flume有哪些Source  说下Flume事务机制  介绍下Flume采集数据的原理？底层实现？  Flume如何保证数据的可靠性  Flume传输数据时如何

介绍一下Mysql和Hivesql的区别？ 一方面，可以从底层原理出发回答，例如： 查询语言不同： Hive是hql语言，Mysql是sql语句； 存储位置不同： Hive是建立在 Hadoop 之上

Spark解决什么问题 二 Spark为什么会有自己的资源调度器 三 Spark运行模式 四 Spark常用端口号 五 Spark提交作业参数 六 Spark的transformation算子

Spark Streaming第一次运行不丢失数据 kafka参数 auto.offset.reset 参数设置成earliest 从最初始偏移量开始消费数据

Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架，Spark提供了一个全面、统一的框架用于管理各种有着不同性质(文本数据、图表数据等)的数据集和数据源(批量数据或实时的流数据)的大数据处理的需求。成为大数据核心技术之一，自然也成为了众多企业面试的核心专业问题，小编…

Spark系列面试题 Spark面试题（一） Spark面试题（二） Spark面试题（三） Spark面试题（四） Spark面试题（五）——数据倾斜调优 Spark面试题（六）——Spark资源调

微信搜索公众号：知了小巷公众号后台回复“资料”两个字，有大数据神秘学习大礼包！1.Spark的几种部署模式及其特点SparkSubmit#prepareSubmitEnvironment本地模式Spa

## Spark系列面试题 - [Spark面试题（一）](https://www.ikeguang.com/?p=1922) - [Spark面试题（二）](https://www.ikeguang

Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎。Spark Core中提供了Spark最基础与最核心

1）本地模式   Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类   local：只启动一个executor   local[k]:启动k个executor   lo...

Spark的任务执行流程 https://wenku.baidu.com/view/9bf37bd07f1cfad6195f312b3169a4517723e513.html Spark总体架构和运行

简单介绍一下 Flink   Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽

概述2019年是大数据实时计算领域最不平凡的一年，2019年1月阿里巴巴Blink（内部的Flink分支版本）开源，大数据领域一夜间从Spark独步天下走向了两强争霸的时代。Flink因为其天然的流式

有没有去面试的时候被问到Flink的面试题你答不上来，为什么那？，菜吗？ 不是。原因是你接触的面试题太少了，那我今天就根据不同的群体来给大家你分享。 好今天的Flink的题目就分享到这里，背过上面的那些题目害怕面试官提问？信自己，努力和汗水总会能得到回报的。我是大数据老哥，我们…

相信小伙伴们对于Flink一定不会感到陌生，作为连续三年蝉联第一，荣膺全球最活跃的 Apache 开源项目，Flink在中国的热度也一直是居高不下。近几年，在社区的推动下，Flink 技术栈在越来越多的公司开始得到应用，因此在大数据的求职招聘中，对于Flink的着重考察也变得越…

简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象层的

1，简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象

Flink中的执行图一般是可以分为四类，按照生成顺序分别为：StreamGraph-> JobGraph-> ExecutionGraph->物理执行图。顾名思义，这里代表的是我们编写的流程序图。通过Stream API生成，这是执行图的最原始拓扑数据结构。StreamGraph...

16. Flink中有哪些窗口？ Flink 支持两种划分窗口的方式，按照time和count。如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个coun

1 Flink的并行度了解吗？Flink的并行度设置是怎样的？ Flink中的任务被分为多个并行任务来执行，其中每个并行的实例处理一部分数据。这些并行实例的数量被称为并行度。我们在实际生产环境中可以从

窄依赖：一个父RDD分区对应一个子RDD分区（如map,filter），或多个父RDD分区对应一个子RDD分区（如co-partitioned join）。
宽依赖：一个父RDD分区对应非全部子RDD分区（如groupByKey,reduceByKey），或一个父RDD分区对应全部子RDD分区（如未经协同划分的join）。

---

🤖 AI解析：
窄依赖：父RDD的每个分区最多被子RDD的一个分区使用（如map、filter、union）。
宽依赖：父RDD的每个分区被子RDD的多个分区使用，需要Shuffle（如groupByKey、reduceByKey、join）。
区分意义：窄依赖可以在一个Stage内流水线执行；宽依赖是Stage划分的边界，需要Shuffle。

📌 关键知识点：窄依赖=父子分区1:1或N:1、宽依赖=父子分区1:N、Stage划分依据
⚠️ 易错点：co-partitioned join是窄依赖（特殊情况）；未协同划分的join是宽依赖

讲解Spark Shuffle原理和特性？Shuffle write和Shuffle read过程做些什么？
Spark Shuffle经历了HashShuffle、SortShuffle的演进，目前默认使用SortShuffleManager。

---

🤖 AI解析：
Shuffle Write阶段：Map任务将数据按分区规则写入磁盘，每个Reduce分区对应一个数据文件。
Shuffle Read阶段：Reduce任务从Map端拉取属于自己分区的数据。
演进：HashShuffle（产生大量小文件）→ SortShuffle（排序后索引，减少文件数）→ Tungsten Sort（堆外内存序列化）。
优化：SortShuffle在满足条件时使用Bypass机制直接写不排序。

📌 关键知识点：Shuffle Write/Read两阶段、SortShuffleManager、Bypass机制、Tungsten优化
⚠️ 易错点：HashShuffle有未优化和优化版区别；Bypass触发条件是分区数<=200且无map端聚合

从HDFS中读取文件后创建RDD对象，DAGScheduler计算RDD之间的依赖关系形成DAG。
划分Stage的主要依据是当前计算因子的输入是否确定。整体思路：从后往前推，遇到宽依赖就断开划分为一个Stage；遇到窄依赖就将该RDD加入该Stage中。

---

🤖 AI解析：
Stage划分由DAGScheduler完成：从最后一个RDD开始向前遍历，遇到宽依赖（ShuffleDependency）就断开，生成新的Stage；窄依赖则合并到同一个Stage中。
ResultStage对应action算子，ShuffleMapStage对应shuffle依赖。
Stage内部任务可流水线执行，Stage之间需要Shuffle传输数据。

📌 关键知识点：从后往前遍历、宽依赖断开、窄依赖合并、DAGScheduler
⚠️ 易错点：Stage数量=宽依赖数量+1；一个Job至少一个Stage

RDD弹性体现在：自动进行内存和磁盘切换、基于lineage的高效容错、task失败会特定次数重试、
stage失败会自动重试且只计算失败分片、checkpoint和persist机制、数据调度弹性、数据分片的高度弹性（repartition）。
缺陷：惰性计算导致中间数据默认不保存，每次动作操作都会重复计算。

---

🤖 AI解析：
弹性体现在7个方面：
1. 自动内存/磁盘切换
2. 基于lineage的高效容错（不需完整复制）
3. Task失败自动重试
4. Stage失败自动重试（只算失败分片）
5. Checkpoint和Persist
6. 数据调度弹性（DAG/Task与资源管理无关）
7. 数据分片高度弹性（repartition）
缺陷：惰性计算导致中间数据默认不保存，重复计算开销大。

📌 关键知识点：Lineage血统容错、Checkpoint vs Persist、Task/Stage重试机制
⚠️ 易错点：Persist的MEMORY_ONLY在内存不足时直接丢弃分区（不溢写到磁盘），需用MEMORY_AND_DISK

reduceByKey性能更高，更适合大数据集。reduceByKey会在map端进行预聚合（combine），减少shuffle数据量；
groupByKey不会预聚合，所有数据直接shuffle到reduce端，导致网络IO和内存压力大。

---

🤖 AI解析：
reduceByKey性能更高。原因：reduceByKey在Shuffle前会在Map端进行预聚合(combine)，相同Key的数据先局部合并，大幅减少Shuffle数据量。
groupByKey不做Map端预聚合，所有数据直接Shuffle到Reduce端，网络IO和内存压力都更大。
在大数据集上，reduceByKey可以减少80%+的Shuffle数据量。

📌 关键知识点：Map端combine预聚合、Shuffle数据量差异、网络IO优化
⚠️ 易错点：groupByKey后紧跟reduce不算优化，必须用reduceByKey才能触发combine

Hive表关联查询时如何解决数据倾斜？倾斜原因：key分布不均匀、业务数据本身特性、建表时考虑不周、某些SQL语句本身就有数据倾斜。
解决方案：(1)参数调节：hive.map.aggr=true, hive.groupby.skewindata=true (2)SQL语句调节：选用join key分布最均匀的表作为驱动表；大小表Join使用map join；大表Join大表把空值key加随机数分散；count distinct大量相同特殊值时单独处理空值。

---

🤖 AI解析：
参数调节方案：
1. hive.map.aggr=true 开启Map端聚合
2. hive.groupby.skewindata=true 开启倾斜负载均衡（两个MR Job，第一个随机分布，第二个正确聚合）
SQL优化方案：
1. 大小表Join → Map Join（小表进内存）
2. 大表Join大表 → 空key加随机数分散 + 过滤异常key
3. Count Distinct → 先Group By再Count替换
4. 选用join key分布均匀的表做驱动表

📌 关键知识点：skewindata两阶段聚合、Map Join、空key随机化、count distinct优化
⚠️ 易错点：Map Join适合小表<25MB的场景；空key加随机数后JOIN结果需过滤掉空key的虚假关联

HiveSQL -> AST(抽象语法树) -> QB(查询块) -> OperatorTree(操作树) -> 优化后的操作树 -> MapReduce任务树 -> 优化后的MapReduce任务树。
SQL Parser用Antlr完成词法语法解析转AST；Semantic Analyzer遍历AST抽象出QueryBlock；Logical plan翻译为OperatorTree；优化器变换减少shuffle；Physical plan翻译为MapReduce任务。

---

🤖 AI解析：
完整转换链路：HiveSQL → AST(抽象语法树) → QB(查询块) → OperatorTree(操作树) → 优化后操作树 → MR任务树 → 优化后MR任务树。
1. SQL Parser: Antlr词法语法解析 → AST
2. Semantic Analyzer: 遍历AST → QueryBlock
3. Logical plan: 翻译 → OperatorTree
4. Logical optimizer: 合并ReduceSinkOperator减少shuffle
5. Physical plan: 翻译 → MR任务
6. Physical optimizer: 生成最终执行计划

📌 关键知识点：Antlr解析、AST→QB→OperatorTree→MR、逻辑优化vs物理优化
⚠️ 易错点：不是所有SQL都走MR（Fetch抓取优化）；Tez/Spark引擎走不同执行计划

创建内部表时，会将数据移动到数据仓库指向的路径；创建外部表仅记录数据所在路径，不移动数据。
删除表时，内部表的元数据和数据一起删除，外部表只删除元数据不删除数据。外部表更安全，数据组织更灵活，方便共享源数据。

---

🤖 AI解析：
创建时：内部表将数据移动到仓库路径（/user/hive/warehouse）；外部表只记录数据路径不移动。
删除时：内部表删除元数据+数据；外部表只删除元数据，数据保留。
外部表优势：更安全（误删表不丢数据）、灵活（数据可被多个表共享）、适合与其他系统共享数据。
生产建议：ODS层用外部表（原始数据不丢失），DWD/DWS层用内部表。

📌 关键知识点：数据移动vs路径记录、删除行为差异、生产分层建议
⚠️ 易错点：外部表LOCATION指定路径后DROP TABLE不会删数据，但数据可能被其他系统依赖

order by：全局排序，只有一个reducer，大规模数据时耗时。
sort by：非全局排序，数据进入reducer前完成排序。
distribute by：按指定字段将数据划分到不同reduce中。
cluster by：兼具distribute by和sort by的功能。

---

🤖 AI解析：
ORDER BY：全局排序，单个Reducer，保证全局有序但性能差（大数据集OOM风险）。
SORT BY：局部排序，每个Reducer内部有序，全局不保证有序。
DISTRIBUTE BY：按字段Hash分配到不同Reducer，控制数据分发。
CLUSTER BY = DISTRIBUTE BY + SORT BY（同一字段），即按某字段分发并排序。
注意：CLUSTER BY不能指定ASC/DESC，需用DISTRIBUTE BY + SORT BY替代。

📌 关键知识点：全局vs局部排序、分发控制、CLUSTER BY限制
⚠️ 易错点：ORDER BY只有一个Reducer，大数据集需加LIMIT；CLUSTER BY不能排序方向

TextFile：默认格式，行存储，不压缩，磁盘开销大，不支持split。
SequenceFile：二进制行存储，可分割可压缩，支持NONE/RECORD/BLOCK压缩。
RCFile：数据按行分块每块按列存储，结合行列存储优点，压缩比和查询响应较好。
ORCFile：RCFile改良版，按行分块按列存储，压缩快、快速列存取、效率比RCFile更高。

---

🤖 AI解析：
TextFile：默认行存储，不压缩，可读性强但性能最差，配合Gzip后不支持split。
SequenceFile：二进制行存储，可split可压缩，支持NONE/RECORD/BLOCK压缩。
RCFile：行列混合存储（按行分块、块内按列），压缩比和查询性能较好。
ORCFile：RCFile改良版，行列存储+轻量级索引+高效压缩，Hive推荐格式。
性能排序：ORCFile > RCFile > SequenceFile > TextFile
压缩比：ORCFile可达70%+压缩率

📌 关键知识点：行存储vs列存储、ORC索引和压缩、split支持
⚠️ 易错点：TextFile+Gzip不支持split是常见考点；ORCFile的stripe结构需了解

Flink的Checkpoint机制是容错核心，基于Chandy-Lamport算法的分布式快照。
JobManager定期发送Checkpoint Barrier到Source，Barrier随数据流流动，当所有算子都收到Barrier后完成一次快照。
状态后端将快照持久化到HDFS或RocksDB，故障时从最近完成的Checkpoint恢复。

---

🤖 AI解析：
基于Chandy-Lamport分布式快照算法：
1. JobManager定期向Source注入Checkpoint Barrier
2. Barrier随数据流向下游流动，将数据流切分为当前快照和下一次快照
3. 算子收到所有输入的Barrier后，将当前状态持久化到State Backend
4. 所有算子完成快照后，JobManager确认Checkpoint完成
5. 故障时从最近成功的Checkpoint恢复状态
状态后端：MemoryStateBackend（测试）、FsStateBackend（HDFS）、RocksDBStateBackend（大状态）

📌 关键知识点：Chandy-Lamport算法、Barrier注入与流动、State Backend选型、对齐vs非对齐
⚠️ 易错点：对齐Barrier可能导致反压；非对齐Checkpoint（Flink 1.11+）牺牲精确性换低延迟；RocksDB状态后端支持增量Checkpoint

Watermark是Flink处理事件时间乱序数据的机制。Watermark = 最大事件时间 - 允许迟到时间。
当Watermark超过窗口结束时间时，触发窗口计算。Watermark允许在一定范围内处理迟到数据。
如果数据迟到超过Watermark允许范围，可通过sideOutput将迟到数据收集到侧输出流。

---

🤖 AI解析：
Watermark是事件时间的进度指示器：
Watermark = 当前最大事件时间 - 允许迟到时间(maxOutOfOrderness)
作用：当Watermark超过窗口结束时间时触发窗口计算。
迟到数据处理：
1. 在允许范围内 → 正常处理
2. 超过Watermark但窗口未清理 → 可用allowedLateness设置允许延迟
3. 完全迟到 → sideOutput收集到侧输出流
生成方式：周期性(Periodic)和标点(Punctuated)

📌 关键知识点：事件时间vs处理时间、Watermark计算、窗口触发、迟到数据处理
⚠️ 易错点：Watermark不是全局单调递增的；多分区Watermark取最小值（木桶效应）

Keyed State：与Key绑定的状态，只能在KeyedStream上使用，每个Key有独立的状态副本。
包括ValueState、ListState、MapState、ReducingState、AggregatingState。
Operator State：与算子并行度绑定的状态，如Kafka Source的offset。支持ListState和UnionListState。

---

🤖 AI解析：
Keyed State：与Key绑定，每个Key独立状态副本，只能在KeyedStream使用。
类型：ValueState(单值)、ListState(列表)、MapState(映射)、ReducingState(聚合)、AggregatingState(聚合带输出)
Operator State：与算子并行度绑定，如Kafka Source的offset。
类型：ListState(均匀分布)、UnionListState(全量广播)
状态TTL：可设置过期时间自动清理，避免状态无限增长。

📌 关键知识点：Keyed State五种类型、Operator State两种分布方式、状态TTL
⚠️ 易错点：Operator State的UnionListState恢复时每个并行度都拿到全量数据需手动选择；ValueState需先调用update再value

Flink通过Checkpoint + 两阶段提交(2PC)实现端到端Exactly-Once。
内部：Checkpoint Barrier对齐保证状态一致性。
Sink端：开启两阶段提交，预提交(Pre-commit)成功后正式提交(Commit)，任一阶段失败则回滚。
Kafka Sink配合事务机制实现端到端Exactly-Once。

---

🤖 AI解析：
内部Exactly-Once：Checkpoint Barrier对齐保证算子状态一致性。
端到端Exactly-Once需要：
1. Source可重放（如Kafka offset可回退）
2. Checkpoint持久化状态
3. Sink两阶段提交(2PC)：
   - 预提交(Pre-commit)：Checkpoint完成时，Sink开启事务写入但不提交
   - 正式提交(Commit)：所有算子Checkpoint成功后提交事务
   - 回滚(Abort)：任一算子失败则回滚事务
Kafka 0.11+的事务特性支持Flink端到端Exactly-Once。

📌 关键知识点：两阶段提交、Kafka事务、Checkpoint与2PC配合
⚠️ 易错点：2PC在Sink端实现需实现TwoPhaseCommitSinkFunction；事务超时需合理配置

Flink是真正的流处理引擎，逐条处理；Spark Streaming是微批处理，按批次间隔处理。
一致性：Flink通过Checkpoint天然支持Exactly-once；Spark Streaming实现Exactly-once需额外配置。
乱序处理：Flink通过Watermark机制；Spark Streaming窗口基于处理时间。
延迟：Flink毫秒级；Spark Streaming秒级（取决于batch interval）。

---

🤖 AI解析：
处理模型：Flink是真正的流处理（逐条处理）；Spark Streaming是微批处理（DStream=RDD序列）。
延迟：Flink毫秒级；Spark Streaming秒级（取决于batchInterval）。
时间语义：Flink支持事件时间/处理时间/注入时间；Spark Streaming主要处理时间。
乱序处理：Flink有Watermark机制；Spark Streaming窗口基于处理时间。
状态管理：Flink原生支持Keyed/Operator State+TTL；Spark Streaming需外部维护。
容错：Flink Checkpoint；Spark Streaming WAL+Checkpoint。
Exactly-Once：Flink原生支持；Spark Streaming需额外配置。

📌 关键知识点：流vs微批、事件时间支持、状态管理、容错机制
⚠️ 易错点：Spark Structured Streaming已改进（支持事件时间、Watermark），但仍基于微批

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...结果被一道算法题坑了，"有效的括号"使用栈来解，会非常简单.

终于来了，算法相关的。 其实个人理解，前端岗位对于算法的要求与其他IT岗位相比，是低得多的。 但是小白我经历了如蚂蚁金服、网易这样的大厂教做人之后，还是觉得，对于一些基本算法、思想的掌握还是必须的。 然后，就把自己遇到的、学到的算法相关的再总结一下，方便自己随时备战面试。 JS…

看到一篇算法文章，觉得着实有趣，但不知为何我看到题后首先想到的是田忌赛马。今天我也试着解释下这题，当做是一个学习的过程。 64 匹马分 8 次在全部比完一次，然后我们可以把目标缩小到 32 匹马。 1、八次比完后，我们可以将每一匹马的速度按下表排好。 剩下的 8 组 32 匹马…

链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n …

回想以前遇到过的面试官，甚至包括自己作为面试官的时候，大都是停留在问【是什么】的问题上，而很少去追问【为什么】。。。

1. 概述 排序算法分为内部排序和外部排序，内部排序把数据记录放在内存中进行排序，而外部排序因排序的数据量大，内存不能一次容纳全部的排序记录，所以在排序过程中需要访问外存。 经常提及的八大排序算法指的就是内部排序的八种算法，分别是冒泡排序、快速排序、直接插入排序、希尔排序、简单…

持续更新，持续更新...

【前端面试复习系列文章】 2024前端高频面试题-- html篇 2024前端高频面试题-- CSS篇 2024前端高频面试题-- JS篇 2024前端高频面试题-- VUE篇 2024前端高频面试题

1. KMP 算法 谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致…

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置（找不到返回 -1）。 有一个祖先树状 json 对象，当一个人有一个儿子的时候，其 child …

0. 几个概念 完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~ 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子…

前言 本文题目选自 LeetCode 精选 TOP 面试题，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所

前几天有个朋友去面试字节跳动，面试官问了他一道链表相关的算法题，不过他一时之间没做出来，就来问了我一下，感觉这道题还不错，拿来讲一讲。 给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一…

数据结构是对实际问题中的数据元素及相互间的联系的抽象。一般用线性表来表示常用数据结构，线性表分为顺序存储的顺序表和连式存储的链表。 在学习算法之前，必须要了解一些常用数据结构的概念。 栈：一种特殊串联形式的抽象数据类型，可由链表或数组实现，通过链表或数组的栈顶（Top）指针对数…

2019年马上就要结束了，相信很多童鞋都开始蠢蠢欲动了，寻找新的机会了，但是工作太忙没有时间刷算法题，面试的时候好心虚。这里双手奉上40道LeetCode上经典面试算法题，整理的内容有点长，建议先收藏，慢慢消化，在来年顺利拿到满意的offer。 内容较多，整理不易，希望大家关注…

腾讯年终奖 什么是真正的好公司？ 一年到头，出不了几次裁员等劳务纠纷的吃瓜新闻。 只有到年底了，才因为年终奖远高于行业水平，实在没法低调了，"被迫"上热搜。 最近网友爆料了腾讯头牌部门的年终奖： WX

限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣…

接触 Android 开发也有一段时间了，前段时间便开始想抽空整理一些知识点，通过笔记整理的方式减少自己重复学习的时间成本和提高自身的效率。 本文总结的部分是常见面试算法题，算法题解均有 java 实现。目录可以在右边侧边栏查看跳转。 之后会整理的知识点还会有 java、And…

本文题目选自 LeetCode 精选 TOP 面试题，这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。 上版本部分请参考# 简单题上 二叉树（DFS） 二叉树前

大家好，我是薇薇，一名沪漂女程序员，年前惨遭被裁，正值在家悲伤抠脚之际，突然看到两位朋友在合谋开发一款刷leetcode的小工具——leetcode-practice…… 下面重点稍微来介绍一下 在神

大家好，今早在B站看到up主的vscode里藏了leetcode插件，这才知道原来还有这款神器。但是没想到在用的时候遇到了一些麻烦，花了一点时间才解决。所以写这篇文章除了给大家安利这个好用的插件之外，也是为了帮助更多的同学避免踩坑。 vscode在工业界鼎鼎大名，被誉为微软少有…

花了十几天，把《算法》看了一遍。然后重新 AC 了一遍 LeetCode 的题并记录下心得。

算法一直是大厂前端面试常问的一块，而大家往往准备这方面的面试都是通过leetcode刷题。 我特地整理了几道leetcode中「很有意思」而且非常「高频」的算法题目，分别给出了思路分析（带图解）和代码实现。 给定一个整数数组 nums 和一个目标值 target，请你在该数组中…

题目分类及刷题顺序推荐 一. 数组 二. 字符串 三. 数与位 四. 栈与递归 五. 链表 六. 哈希表 七. 贪心算法 八. 双指针法 九. 树 十. 图与搜索 十一. 二分查找 十二. 二进制运算

虽然很多人都觉得前端算法弱，但其实 JavaScript 也可以刷题啊！最近两个月断断续续刷完了 leetcode 前 200 的 middle + hard ，总结了一些刷题常用的模板代码。走过路过发现 bug 请指出，拯救一个辣鸡（但很帅）的少年就靠您啦！ 包括打印函数和一…

众所周知，现在的互联网公司面试，只要是写代码的岗位，都会来一套算法题组合拳伺候。 所以大家在准备校招、社招，或者闲暇的时候，都可以刷刷题，保持良好的手感。

我就是那个 @量子位 答案里面提到的“lucifer 小哥哥”。 我本人从开始准备算法以来，大概经过了几个月的时间，这期间自己成长了很多，从刷题菜鸡，到现在对刷题套路，题型有了自己的理解，感受还是蛮多的。我本人不是算法高手，算是勤能补拙类型。不过经过几个月的学习和练习，不仅面试…

1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串

leetcode网站中的编程环境，代码提示，快捷键并不友好，我们在刷题的时候往往不高效，且过后也不能快速，随时随地的进行方便的复盘。所以在这篇文章中我将介绍如何在 VsCode 中通过插件来高效的刷题

老司机带你刷 LeetCode

LeetCode热题100道-Day02 136. 只出现一次的数字 在stream流中的reduce方法使用异或运算。

作为一个前端同学，为什么不用JavaScript刷LeetCode，而是使用TypeScript来刷题呢？ 当然，你也可以选择c++、java来刷题，但我认为还是用自己研究方向的语言比较好

作为一个多年的老菜鸟，有感于大部分的公司面试 “面试造航母，工作螺丝钉” 的作风，特整理了这个数据结构和算法面试题系列。对于校招而言，如果没有太多实践/实习经验，大公司往往喜欢考察数据结构和算法，如微软就特别喜欢在校招时手写算法题，而且难度还不小，当年我毕业找工作时也是颇受折磨…

数学是科学之基础，数字题往往也是被面试玩出花来。数学本身是有趣味的一门学科，前段时间有点不务正业，对数学产生了浓厚的兴趣，于是看了几本数学史论的书，也买了《几何原本》和《陶哲轩的实分析》，看了部分章节，受益良多，有兴趣的朋友可以看看。特别是几何原本，欧几里得上千年前的著作，里面…

500 Data structures and algorithms interview questions and their solutions

背包问题包括0-1背包问题、完全背包问题、部分背包问题等多种变种。其中，最简单的是部分背包问题，它可以采用贪心法来解决，而其他几种背包问题往往需要动态规划来求解。本文主要来源于《背包问题九讲》，我选择了比较简单的0-1背包问题和完全背包问题进行汇总。同时给出实现代码，如有错误，…

继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。本文所有代码在 这里 。 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 题： 给定一棵…

HashMap 是我们熟悉的散列表实现，也是 “面试八股文” 的标准题库之一。今天，我给出一份 HashMap 高频面试题口述简答答案，希望对你刷题有帮助。

前面总结了随机算法，这次再把以前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，希望这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，如有错误，也恳请各路大牛指正。二叉树的递归示例代码请参…

在用C语言实现一些常见的数据结构和算法时，C语言的基础不能少，特别是指针和结构体等知识。 linux中的C编译得到的目标文件和可执行文件都是ELF格式的，可执行文件中以segment来划分，目标文件中，我们是以section划分。一个segment包含一个或多个section，…

随机算法涉及大量概率论知识，有时候难得去仔细看推导过程，当然能够完全了解推导的过程自然是有好处的，如果不了解推导过程，至少记住结论也是必要的。本文总结最常见的一些随机算法的题目，是几年前找工作的时候写的。需要说明的是，这里用到的随机函数 randInt(a, b) 假定它能随机…

栈作为一种基本的数据结构，在很多地方有运用，比如函数递归，前后缀表达式转换等。本文会用C数组来实现栈结构(使用链表实现可以参见链表那一节，使用头插法构建链表即可)，并对常见的几个跟栈相关的面试题进行分析，本文代码在 这里。 我们使用结构体来定义栈，使用柔性数组来存储元素。几个宏…

链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的…

快速排序也是基于分治模式，类似归并排序那样，不同的是快速排序划分最后不需要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤： 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每个元…

字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。本文相关代码见 这里。 首先来看一些字符串的基本函数的实现，以下代码取自MIT6.828课程。 题： 给定一个字符串，找出该…

排序算法也是面试中常常提及的内容，问的最多的应该是快速排序、堆排序。这些排序算法很基础，但是如果平时不怎么写代码的话，面试的时候总会出现各种bug。虽然思想都知道，但是就是写不出来。本文打算对各种排序算法进行一个汇总，包括插入排序、冒泡排序、选择排序、计数排序、归并排序，基数排…

在说二叉树前，先来看看什么是树。树中基本单位是结点，结点之间的链接，称为分支。一棵树最上面的结点称之为根节点，而下面的结点为子结点。一个结点可以有0个或多个子结点，没有子结点的结点我们称之为叶结点。 二叉树是指子结点数目不超过2个的树，它是一种很经典的数据结构。而二叉搜索树(B…

二分查找本身是个简单的算法，但是正是因为其简单，更容易写错。甚至于在二分查找算法刚出现的时候，也是存在bug的（溢出的bug），这个bug直到几十年后才修复（见《编程珠玑》）。本文打算对二分查找算法进行总结，并对由二分查找引申出来的问题进行分析和汇总。若有错误，请指正。本文完整…

本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(…

存储过程就像我们编程语言中的函数一样，封装了我们的代码(PLSQL、T-SQL)。 上面的文字我们肯定是看不懂的，也不愿意看下去的。接下来我就总结一下： 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的 第二范式：满足第一范式,表…

例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话…

使用group by的sql语句，select后的字段只能是group by后的字段，如果需要展示其他字段数据，需要给该列使用聚合函数，否则默认展示分组后的第一行数据。 左连接：左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录。右表记录不足的地方均为NULL（用户信…

SQL（结构化查询语言）是一种设计用于检索和操作数据的数据库。它属于美国国家标准协会（ANSI）的一种标准，可用于执行Select（选择）、Update（更新）、Delete（删除）和Insert（插入）等数据任务。 表是在具有列和行的模型中设计的数据集合。在表中，指定了列数称…

😊：“读题，入职时候的薪水，加上提示一个员工有多次涨薪的情况，所以本质上是求解每个员工的最低薪水，还要按照emp_no降序排列。阿，求每个员工的薪水最小值，用group by就可以实现，要输出的字段在salaries这张表中都有，所以别看他给了2张表，只需要1张表就能算出结果。1...

Sql常用语法下列语句部分是Mssql语句，不可以在access中使用。 SQL分类： DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) DML—数据操纵语言(SELECT，

1/连续最长登陆天数 2/下一次登陆时间距离上一次登陆时间大于30天时，从1开始计数 3/一张包含全国各城市用户的观看记录表view_info（表中一条数据代表一次观看记录），包含city_name、

MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引。 MySQL官方对索引的定义为：索引（In…

面试官：要不你来讲讲你们对MySQL是怎么调优的？ 候选者：哇，这命题很大阿…我认为，对于开发者而言，对MySQL的调优重点一般是在「开发规范」、「数据库索引」又或者说解决线上慢查询上。 候选者：而对

这天我正在午休呢，公司DBA就把我喊醒了，说某库出现大量慢SQL，很快啊，很快，我还没反应过来，库就挂了，我心想现在的用户不讲武德啊，怎么在我睡觉的时候大量请求呢。 这是很常见的一个场景哈，因为很多业务开始数据量级不大，所以写sql的时候就没注意性能，等量级上去，很多业务就需要…

敖丙：加索引。 敖丙：没了。 哈哈开头这个场景是我臆想的一个面试场景，但是大家是不是觉得很真实，每个人的简历上但凡写到了数据库，都会在后面顺便写一句，会数据库调优。 我觉得调优能回答的点还是很多很多的，我自己看了《MySQL实战》、《高性能MySQL》、《丁奇MySQL47讲》…

一、前言 上一篇我们说了 腾讯一面：说一说 MySQL 中索引的底层原理，相信你对索引有个很清晰的认识了，这一篇我们来说一说慢 SQL 的排查以及调优。为啥面试官要问这个问题，其实跟上一篇的索引底层原

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

大家好，我是 V 哥。SQL调优对于提升数据库查询性能至关重要，特别是当数据量大时。以下是20个详细的SQL调优指南和高级技巧，结合案例说明，帮助优化SQL查询的性能。 1. 选择合适的索引 技巧: 

一次线上慢SQL调优分享 一周前，客户反馈做题页面经常卡顿，加载慢；我们监控比较少，所以根据直觉去MySQL慢查询日志一看，果然是一条慢SQL。废话不多，开整！！！ 业务背景 一个在线做题的代码评测系

作为开发人员，我们免不了与sql打交道。有些sql可能在业务的最开始，执行是毫无问题的。但是随着业务量的提升以及业务复杂度的加深，可能之前的sql就会逐渐展现出疲惫之势了。这时就会面临sql调优。 那么调优到底如何调？不同的人有不同的姿势。可能大部分人首先想到的就是加索引。 没…

order by字段尽量走索引... 其中有些手段也许跟随者MySQL版本的升级过时了。我们真的需要背这些调优手段吗？我觉得是没有必要的，在掌握MySQL存储架构和SQL执行原理的情况下，我们就很自然的明白，为什么要提议这么优化了，甚至能够发现别人提的不太合理的优化手段。 在 …

背景 基于TPCDS的100G，500G数据进行了99SQL综合调优测试 测试机为物理机5台，1台为管理节点，4台为计算节点 可用内存约1T，核心数（vCore）200大概 重要参数 执行器个数 --

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情 1.写在前面 在昨天的时候，我们就谈到了数据库连接池优化 详情可参考这里：点击查看 经过昨天的分析，我们已

面试官：MySQL如何进行性能调优？ 具体操作我这里整理了慢查询、explain、@@profiling关键字 慢查询 DBA有时候会发现有些语句比较慢，他们怎么发现的呢？ 编辑配置文件打开慢查询 然

在系统运行过程中，总会与数据库的交互，通过数据库端的日志查询执行时间最长与执行次数最多的sql语句，就可以有针对性的进行调优处理。 取执行时间最长的前50条sql语句。

引言 数据库性能优化是每个后端程序猿必备的基础技能之一，而Mysql中的explain堪称Mysql的性能优化分析神器，我们可以通过它来分析SQL语句的对应的执行计划在Mysql底层到底是如何执行的，

这几周系统访问量也是居高不下，不出意外系统又出现瓶颈了，大量用户反馈判题结果响应太慢；经排查，又是关于SQL的问题 业务背景 一个类似于力扣在线做题的代码评测模块，用户提交判题任务后，后台会进行异步判

什么是 SQL 调优？是不是觉得自己知道但又很模糊说不清楚，面试被问没有真实的案例，并不具备说服力。本文以为详细案例给大家解读。

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

Spark SQL是Spark生态系统中非常重要的组件， 能够利用 Spark 进行结构化的存储和操作。本文将围绕Spark内存泄露问题进行排查，并且给出具体的Spark调优方法。

Hive的架构 Hive元数据默认存储在derby数据库，不支持多客户端访问，所以将元数据存储在MySQl，支持多客户端访问。 2 Hive和e和数据库比较，Hive 和数据库除了拥有类似的查询语言，

1. hive 内部表和外部表的区别？ 未被external修饰的是内部表（managed table），被external修饰的为外部表（external table）； 内部表数据由Hive自身管

Hive SQL基本上适用大数据领域离线数据处理的大部分场景。Hive SQL的优化也是我们必须掌握的技能，而且，面试一定会问。那么，我希望面试者能答出其中的80%优化点，在这个问题上才算过关。 JVM重利用可以使得JOB长时间保留slot,直到作业结束，这在对于有较多任务和较…

第一题 需求 实现 数据准备 查询SQL 第二题 需求 实现 数据准备 查询SQL实现 第三题 需求 实现 数据准备 查询SQL 第四题 需求 实现 数据准备 查询SQL 第五题 需求 实现 数据准备

有用户点击日志记录表 t_click_log_025，包含user_id(用户ID),click_time(点击时间)，请查询出连续点击三次的用户数。

1.Hive的架构 2 Hive和数据库比较 Hive 和数据库除了拥有类似的查询语言，再无类似之处。 1）数据存储位置 Hive 存储在 HDFS 。数据库将数据保存在块设备或者本地文件系统中。 2

有如下数据，记录每天每只股票的收盘价格，请查出每只股票的波峰和波谷的日期和价格；
波峰：股票价格高于前一天和后一天价格时为波峰；
波谷：股票价格低于前一天和后一天价格时为波谷。

---

🤖 AI解析：
思路：使用LEAD/LAG窗口函数获取前一天和后一天价格，再比较。
1. LAG(closing_price,1) OVER(PARTITION BY stock_code ORDER BY trade_date) 获取前日价格
2. LEAD(closing_price,1) OVER(...) 获取后日价格
3. WHERE当前价>前日价 AND 当前价>后日价 → 波峰；当前价<前日价 AND 当前价<后日价 → 波谷

📌 关键知识点：LAG/LEAD窗口函数、PARTITION BY按股票分组、边界处理（首尾无前/后日数据）
⚠️ 易错点：首尾交易日无法判断波峰波谷需排除；注意等价情况不算波峰/波谷

已知有表记录了每个大厅的活动开始日期和结束日期，每个大厅可以有多个活动。
请编写一个SQL查询合并在同一个大厅举行的所有重叠的活动，如果两个活动至少有一天相同，那他们就是重叠的。

---

🤖 AI解析：
思路：使用窗口函数标记重叠区间，然后合并。
1. 按hall_id和start_date排序
2. 如果当前行的start_date <= 上一行的end_date，则重叠，合并
3. 使用LAG获取上一行end_date，判断是否重叠
4. 对非重叠的行标记为新组，GROUP BY组合并取MIN(start_date)和MAX(end_date)

📌 关键知识点：区间合并、LAG窗口函数、分组标记技巧
⚠️ 易错点：注意活动可能多次重叠形成长区间；日期是否含边界需确认

现有订单表t_order，包含订单ID，订单时间，下单用户，当前订单是否有效。
查询每个用户最近一笔有效订单。

---

🤖 AI解析：
思路：过滤有效订单后按用户分组取最新一条。
1. WHERE is_valid = 1 过滤有效订单
2. ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY order_time DESC) = 1
取每个用户最近一条

📌 关键知识点：ROW_NUMBER窗口函数、PARTITION BY用户分组、过滤条件优先于排序
⚠️ 易错点：注意先过滤有效再排序；如果同一时间有多笔需定义二级排序规则

现有用户登录日志表，记录了每个用户登录的IP地址，请查询共同使用过3个及以上IP的用户对。

---

🤖 AI解析：
思路：先找共用IP的用户对，再筛选>=3个IP的对。
1. 自连接登录表找同一IP的不同用户对(user_a < user_b)
2. GROUP BY用户对COUNT(DISTINCT ip)
3. HAVING COUNT(DISTINCT ip) >= 3

📌 关键知识点：自连接找用户对、COUNT DISTINCT去重、HAVING过滤
⚠️ 易错点：自连接时避免重复组合(a,b)和(b,a)；用户对要用较小id+较大id组合去重

现有各省地级市的gdp数据,求从高到底累加刚好超过各省GDP40%的地市名称，临界地市也需要。
例如:浙江省的杭州24% 宁波20%,杭州+宁波=44%大于40%,取出杭州、宁波。

---

🤖 AI解析：
思路：计算累计占比，找出刚好超过40%的临界点。
1. 按省份分组，地市按GDP降序排列
2. SUM(gdp) OVER(PARTITION BY province ORDER BY gdp DESC) 计算累计GDP
3. SUM(gdp) OVER(PARTITION BY province) 计算省总GDP
4. 累计GDP/省总GDP <= 0.4 的全部取，加上第一个超过0.4的地市

📌 关键知识点：窗口函数累计求和、百分比计算、临界值处理
⚠️ 易错点：临界地市必须包含（刚好超过的那一条）；注意浮点数精度问题

有一张表t_id记录了id，id不重复，但是会存在间断，求出连续段的起始位置和结束位置。

---

🤖 AI解析：
思路：用id减去行号得到分组标识，连续id的差值相同。
1. ROW_NUMBER() OVER(ORDER BY id) 生成行号rn
2. group_key = id - rn，连续的id会得到相同group_key
3. GROUP BY group_key，取MIN(id)和MAX(id)即为连续段的起止位置

📌 关键知识点：id减行号的经典技巧、连续区间检测、分组聚合
⚠️ 易错点：确保id无重复（题意已说明）；行号从1开始，id和rn的差值要一致

有一张表t_id记录了id，id不重复，但是会存在间断，求出连续段的最后一个数及每个连续段的个数。

---

🤖 AI解析：
思路：同上用id-rn分组，再聚合。
1. id - ROW_NUMBER() OVER(ORDER BY id) 作为group_key
2. GROUP BY group_key
3. MAX(id)为连续段最后一个数，COUNT(*)为连续段个数

📌 关键知识点：连续区间分组技巧、GROUP BY聚合
⚠️ 易错点：注意连续段个数的定义是包含的id数量

有营销活动记录表，记录了每个品牌每次营销活动的开始日期和结束日期，现需要统计出每个品牌的总营销天数。
注意：重叠的日期要去重计算；不连续的日期不统计。

---

🤖 AI解析：
思路：先合并重叠日期区间，再计算每个区间的天数求和。
1. 按品牌分组，活动按开始日期排序
2. 如果当前行start_date <= 上一行end_date，则重叠，合并
3. 对合并后的区间计算(end_date - start_date + 1)天数
4. SUM各区间天数

📌 关键知识点：区间合并、日期差计算、重叠去重
⚠️ 易错点：重叠部分只算一次；不连续的区间之间不算天数（如9月7日和9月8日中间不算）

已知有购买记录表t_order和用户收藏记录表t_collect_log，请用一句sql语句得出所有用户的商品行为特征：
是否已购买、购买未收藏、收藏未购买、收藏且购买。

---

🤖 AI解析：
思路：全外连接购买表和收藏表，根据是否有购买/收藏记录判断行为特征。
1. FULL OUTER JOIN t_order和t_collect_log ON user_id, goods_id
2. CASE WHEN判断：有购买有收藏→收藏且购买；有购买无收藏→购买未收藏；无购买有收藏→收藏未购买；无购买无收藏→不可能（不会出现在JOIN结果中）

📌 关键知识点：FULL OUTER JOIN、CASE WHEN多条件判断、行为特征分类
⚠️ 易错点：注意用FULL OUTER JOIN而非LEFT/RIGHT JOIN；需要处理NULL值判断

现有一张订单表t_order有订单ID、用户ID、商品ID、购买商品数量、购买时间，请查询出每个用户的第一条记录和最后一条记录。

---

🤖 AI解析：
思路：使用ROW_NUMBER窗口函数分别按时间升序和降序排序。
1. ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY purchase_time ASC) rn_asc
2. ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY purchase_time DESC) rn_desc
3. WHERE rn_asc = 1 OR rn_desc = 1

📌 关键知识点：ROW_NUMBER窗口函数、PARTITION BY分组、双向排序
⚠️ 易错点：如果只有一条记录则第一条和最后一条相同，用UNION或OR去重

现有三张表：用户关注表t_follow(user_id,follower_id)，请给用户1推荐他关注的用户喜欢的音乐名称。

---

🤖 AI解析：
思路：找用户1关注的人喜欢的音乐，排除用户1已经喜欢的。
1. 从t_follow找用户1关注的人(follower_id)
2. 从t_music_likes找这些人喜欢的音乐
3. NOT IN排除用户1已喜欢的音乐

📌 关键知识点：多表JOIN、NOT IN/NOT EXISTS排除已存在记录、好友推荐逻辑
⚠️ 易错点：注意去重（多个好友可能喜欢同一首歌）；排除用户已喜欢的歌

有两个表，朋友关系表user_friend，用户步数表user_steps。查询占据多少个好友的封面（在好友的列表中排行第一，且必须超过好友的步数）。

---

🤖 AI解析：
思路：计算用户步数在好友步数中排第一的数量。
1. JOIN朋友关系表和步数表两次（自己和好友的步数）
2. WHERE自己的步数 > 好友的步数，且自己在好友好友列表中排第一
3. COUNT

📌 关键知识点：自关联JOIN、排名比较、子查询
⚠️ 易错点：好友关系是双向的需考虑；排第一必须超过好友步数而非等于

现有一张用户支付表t_user_pay包含字段订单ID,用户ID,商户ID,支付时间,支付金额。
如果同一用户在同一商户存在多笔订单，且中间该用户没有其他商户的支付记录，则认为是连续订单，
请把连续订单进行合并，时间取最早支付时间，金额求和。

---

🤖 AI解析：
思路：标记同一商户的连续订单，再分组聚合。
1. 按用户ID、支付时间排序
2. 检测商户ID是否变化：LAG(merchant_id) != 当前merchant_id时标记为新组
3. 累计标记形成组ID
4. GROUP BY用户ID、组ID，取MIN(支付时间)和SUM(支付金额)

📌 关键知识点：LAG检测变化、累计标记分组、连续区间识别
⚠️ 易错点：连续是指同一商户中间没有其他商户；非连续的同商户订单不合并

现有一张股票价格表stock_data有3个字段：股票代码(stock_code),日期(trade_date)，收盘价格(closing_price)，
请找出满足连续5天以上（含）每天上涨超过5%的股票,并给出连续满足天数及开始和结束日期。

---

🤖 AI解析：
思路：计算每日涨幅，标记是否>5%，然后检测连续满足条件的天数。
1. 计算涨幅：(closing_price - LAG(closing_price)) / LAG(closing_price)
2. 标记涨幅>5%为1否则为0
3. 用经典连续区间技巧（行号-分组行号）找连续为1的段
4. HAVING COUNT(*) >= 5

📌 关键知识点：涨幅计算、连续区间检测、条件标记+分组
⚠️ 易错点：涨幅=(今-昨)/昨；连续5天含第5天；注意停牌等特殊情况题意已说明不考虑

现有用户登录日志表t_login_log,包含用户ID(user_id),登录日期(login_date)。
数据已经按照用户日期去重，请查出连续登录超过4天的用户ID。

---

🤖 AI解析：
思路：经典连续区间问题，用login_date减行号分组。
1. ROW_NUMBER() OVER(PARTITION BY user_id ORDER BY login_date) rn
2. group_key = login_date - rn（用DATE_SUB或整数天数差）
3. GROUP BY user_id, group_key HAVING COUNT(*) > 4
4. DISTINCT user_id

📌 关键知识点：日期减行号的连续区间技巧、DATE_SUB处理日期、HAVING过滤
⚠️ 易错点：login_date是日期类型不能直接减整数，需先转天数；题目说已去重不需再DISTINCT日期

有某城市网吧上网记录表，包含网吧id、访客id、上线时间、下线时间。
规则1：两个用户在同一个网吧上线或下线时间间隔10分钟以内，则可能认识；
规则2：在三家以上网吧出现规则1情况，则一定认识。计算两人一定认识的组合数。

---

🤖 AI解析：
此题考察大数据/SQL核心知识点，需结合业务场景分析。建议从原理→实现→优化三步作答。

📌 关键知识点：原理理解、实现方案、优化策略
⚠️ 易错点：注意边界条件和性能影响

有一份用户访问记录表，记录用户id和访问时间，如果用户访问时间间隔小于60s则认为是一次浏览，请合并用户的浏览行为。

---

🤖 AI解析：
此题考察大数据/SQL核心知识点，需结合业务场景分析。建议从原理→实现→优化三步作答。

📌 关键知识点：原理理解、实现方案、优化策略
⚠️ 易错点：注意边界条件和性能影响

已知有表t_cost_detail包含id和money两列，id为自增，请累加计算money值，并求出累加值与1000差值最小的记录。

---

🤖 AI解析：
此题考察大数据/SQL核心知识点，需结合业务场景分析。建议从原理→实现→优化三步作答。

📌 关键知识点：原理理解、实现方案、优化策略
⚠️ 易错点：注意边界条件和性能影响

已知有表记录了每个大厅的活动开始日期和结束日期，每个大厅可以有多个活动。请编写SQL查询合并同一大厅的所有重叠活动。

---

🤖 AI解析：
思路：使用窗口函数标记重叠区间，然后合并。
1. 按hall_id和start_date排序
2. 如果当前行的start_date <= 上一行的end_date，则重叠，合并
3. 使用LAG获取上一行end_date，判断是否重叠
4. 对非重叠的行标记为新组，GROUP BY组合并取MIN(start_date)和MAX(end_date)

📌 关键知识点：区间合并、LAG窗口函数、分组标记技巧
⚠️ 易错点：注意活动可能多次重叠形成长区间；日期是否含边界需确认

## 题目描述

在Spark任务中，某partition的key数据量是其他key的1000倍，导致该partition执行时间远超其他partition。请给出至少3种解决方案，并分析每种方案的优缺点。

## 场景

```
Table A: 10亿行，user_id分布不均，user_id=0的行占5亿
Table B: 1000万行，均匀分布
SQL: SELECT A.* FROM A JOIN B ON A.user_id = B.user_id
```

## 参考答案

**方案1：加盐（Salting）**
- 对大表A的user_id=0随机加盐为0_1,0_2,...0_N
- 小表B对user_id=0扩容N倍，分别对应0_1,...0_N
- 优点：数据均匀分布，并行度提升
- 缺点：小表扩容增加内存，需修改业务逻辑

**方案2：两阶段聚合**
- 阶段1：局部聚合（加随机前缀group by）
- 阶段2：全局聚合（去掉前缀group by）
- 优点：不需要修改join逻辑
- 缺点：增加一轮shuffle

**方案3：广播小表**
- B表只有1000万，可以broadcast
- A不做shuffle，每个executor持有B的完整副本
- 优点：完全消除shuffle
- 缺点：仅适用于小表能放入内存的场景

**方案4：采样后单独处理**
- 先采样发现倾斜key
- 倾斜key单独处理（如与B表filter后join）
- 非倾斜key正常join
- 最后union
- 优点：不影响正常数据处理
- 缺点：逻辑复杂，需两次join

## 题目描述

Flink从Kafka消费数据，经过窗口聚合后写入MySQL，如何保证端到端Exactly-Once语义？请画出数据流并说明每个环节的一致性保障机制。

## 数据流

```
Kafka Source → Flink 窗口聚合 → MySQL Sink
```

## 参考答案

**1. Kafka Source端**
- Flink Kafka Consumer支持Exactly-Once，通过定期提交offset到Kafka
- offset提交与checkpoint绑定，只有checkpoint成功才提交offset
- 依赖：Kafka 0.11+的事务特性

**2. Flink内部**
- Checkpoint机制：Chandy-Lamport算法，周期性barrier对齐
- 算子状态随checkpoint保存到分布式存储（HDFS/S3）
- 重启时从最近一次成功checkpoint恢复

**3. MySQL Sink端**
- 两阶段提交（2PC）：
  - 预提交：在checkpoint barrier到达时，将事务标记为pre-commit
  - 正式提交：JobManager确认所有算子checkpoint成功后，通知sink提交事务
- 幂等写入：用业务主键做UPSERT，重复写入不会产生副作用

**4. 端到端保障条件**
- Source支持重置偏移量（Kafka支持）
- 内部计算依赖Checkpoint（Flink原生支持）
- Sink支持事务或幂等写入（2PC或UPSERT）

## 题目描述

设计一个Kafka消息不丢失的端到端方案，覆盖Producer、Broker、Consumer三个环节，并说明每个环节的配置参数和原理。

## 参考答案

**1. Producer端**
- 设置 acks=all（或acks=-1）：等待所有ISR副本确认
- 设置 retries>0：网络异常自动重试
- 设置 enable.idempotence=true：幂等生产，防止重试导致重复
- 设置 max.in.flight.requests.per.connection=5（幂等开启时自动设置）
- 使用回调callback确认发送成功

**2. Broker端**
- replication.factor>=3：至少3个副本
- min.insync.replicas=2：至少2个ISR副本确认写入
- unclean.leader.election.enable=false：禁止非ISR副本成为leader
- 这样即使1台broker宕机，数据仍可从ISR副本恢复

**3. Consumer端**
- 手动提交offset（enable.auto.commit=false）
- 业务处理完成后再提交offset
- 消费逻辑做幂等处理（防重复消费）
- 具体流程：poll → 处理业务 → 提交offset

**4. 极端场景**
- Broker全部宕机：依赖多机房副本/跨集群镜像（MirrorMaker）
- Consumer处理失败：不提交offset，重启后重新消费

## 题目描述

Hive SQL执行时某Reducer运行时间远超其他Reducer（数据倾斜），请给出排查步骤和至少4种优化方案。

## 场景

```sql
SELECT user_id, COUNT(*) AS cnt
FROM user_behavior_log
GROUP BY user_id;
```

user_id=0的行占60%（默认值/测试数据），导致一个Reducer处理大部分数据。

## 参考答案

**排查步骤：**
1. 查看YARN日志，找到运行时间最长的Reducer
2. 检查该Reducer处理的key分布
3. 确认倾斜key（如user_id=0）

**方案1：Map端聚合**
- 设置 hive.map.aggr=true（默认开启）
- 在Map端做局部聚合，减少Shuffle数据量

**方案2：Skew Join优化**
- 设置 hive.optimize.skewjoin=true
- 设置 hive.skewjoin.key=100000（超过10万行的key视为倾斜key）
- Hive自动将倾斜key的join走单独的Map任务

**方案3：加盐打散**
- 对倾斜key随机加盐：CONCAT(user_id, '_', FLOOR(RAND()*10))
- 先局部聚合，再去掉盐值全局聚合

**方案4：过滤无效数据**
- 如果user_id=0是默认值/脏数据，直接WHERE过滤
- WHERE user_id != 0

**方案5：增加Reducer数**
- set mapreduce.job.reduces=200
- 将倾斜数据分到更多Reducer
- 对轻度倾斜有效，重度倾斜效果有限

## 题目描述

电商平台用户维度表中，用户的会员等级会随时间变化（如从普通→银卡→金卡）。请设计数仓分层方案，并说明如何处理这种缓慢变化维（SCD Type 2）。

## 参考答案

**数仓分层：**
- ODS：原始日志（binlog同步，不加工）
- DWD：明细层（清洗+标准化，如user_id统一、时间格式化）
- DWS：汇总层（按主题聚合，如用户维度表）
- ADS：应用层（直接服务于报表/推荐）

**SCD Type 2实现：**
- 维度表增加 effective_start_date、effective_end_date、is_current 三个字段
- 每次属性变更时：关闭旧记录（end_date=变更日期，is_current=0），插入新记录（start_date=变更日期，is_current=1）

```sql
-- 维度表示例
user_id | level  | start_date | end_date   | is_current
1001    | 普通   | 2024-01-01 | 2024-03-15 | 0
1001    | 银卡   | 2024-03-15 | 2024-06-01 | 0
1001    | 金卡   | 2024-06-01 | 9999-12-31 | 1
```

**查询某时间点的维度：**
```sql
SELECT * FROM dim_user
WHERE user_id = 1001
  AND '2024-04-01' BETWEEN start_date AND end_date;
-- 返回：银卡
```

**查询当前维度：**
```sql
SELECT * FROM dim_user WHERE is_current = 1;
```

## 题目描述

公司需要建设实时数仓，请对比Lambda架构和Kappa架构的优缺点，并给出选型建议。

## 参考答案

**Lambda架构：**
- 批处理层（Hadoop/Spark）+ 实时层（Flink/Storm）+ 服务层
- 优点：批处理保证准确性，实时层保证低延迟
- 缺点：两套代码逻辑需维护一致性，运维成本高

**Kappa架构：**
- 只有一条实时流（Flink），通过回放Kafka历史数据实现重算
- 优点：一套代码，逻辑一致性好
- 缺点：全量回放耗时长，对Flink稳定性要求高

**选型建议：**
- 数据准确性要求极高（金融）→ Lambda
- 团队规模小、迭代快 → Kappa
- 实际中常混用：核心链路用Lambda，辅助分析用Kappa
- 趋势：Flink SQL + Hudi/Iceberg正在模糊两套架构的边界

## 题目描述

请设计一个电商用户画像标签系统，包含标签定义、数据流、存储选型和更新策略。

## 参考答案

**标签分类：**
1. 统计标签：消费金额、登录次数、购买品类数（从事实表聚合）
2. 规则标签：高价值用户（消费>1万）、活跃用户（7日内登录>3次）
3. 预测标签：流失概率、购买倾向（ML模型输出）

**数据流：**
```
用户行为日志 → Kafka → Flink实时计算 → HBase（实时标签）
                → Hive离线计算 → MySQL（全量标签）
```

**存储选型：**
- HBase：实时标签读写，支持rowkey快速查询
- Hive/ClickHouse：离线分析，复杂查询
- Redis：热门用户标签缓存，毫秒级响应
- MySQL：标签元数据+规则配置

**更新策略：**
- 实时标签：Flink消费Kafka实时更新
- 日标签：T+1离线批量计算覆盖
- 月标签：每月1号全量重算

**标签服务：**
- API层：根据user_id查标签，先查Redis→HBase→降级
- 标签组合：支持多标签AND/OR筛选，导出人群包

1. 如何从大量的 URL 中找出相同的 URL？ 给定 a、b 两个文件，各存放 50 亿个 URL，每个 URL 各占 64B，内存限制是 4G。请找出 a、b 两个文件共同的 URL。 每个 URL 占 64B，那么 50 亿个 URL占用的空间大小约为 320GB。 由…

一千个读者眼中有一千个哈姆雷特，一千名 大数据 程序员心目中就有一千套 大数据面试题。本文就是笔者认为可以用来面试大数据 程序员的面试题。 这套题的题目跟公司和业务都没有关系，而且也并不代表笔者本人可以把这些题回答得非常好，笔者只是将一部分觉得比较好的题从收集的面试题里面抽出来…

1、集群的最主要瓶颈 磁盘IO 2、Hadoop运行模式 单机版、伪分布式模式、完全分布式模式 3、HDFS写流程 1）client 客户端发送上传请求，通过 RPC 与 namenode 建立通信，

大数据工程师是近几年异常火爆的职位，市场需求旺盛，众多互联网公司都打出了高薪招聘的广告，本文整理了网络上部分技术人员分享的各大互联网公司大数据类(Hadoop、Spark等)面试题以及面试时需要注意的一些问题，希望对各位技术人员有所帮助。 分享之前我还是要推荐下我自己创建的大数…

前言 随着 5G 时代的到来，大数据人工智能产业链又一次迎来了井喷式的爆发，随着岗位需求的不断增加，越来越多的人选择大数据课程，但是没有真正从事大数据工作的人面对企业面试有种无从下手的感觉，面对面试说

「Offer 驾到，掘友接招！我正在参与2022春招系列活动-经验复盘，点击查看 活动详情 题目来源 作者：是锅粥 链接：https://www.nowcoder.com/discuss/745950

1、HAnamenode 是如何工作的? ZKFailoverController主要职责 1）健康监测：周期性的向它监控的NN发送健康探测命令，从而来确定某个NameNode是否处于健康状态，如果机

本文整理了互联网大厂数据开发、数据分析、数仓等数据相关岗位面试过程中经常出现的SQL面试题，并给出了参考答案。涉及了炸裂函数、开窗函数、聚合函数开窗、在线直播人数等 以及这两年各大厂面疯了各种连续问题

1. hadoop 架构 Hadoop2.0版本，引入了Yarn。核心：HDFS+Yarn+Mapreduce Yarn是资源调度框架。能够细粒度的管理和调度任务。此外，还能够支持其他的计算框架，比如spark等。 Namenode：也叫名称节点，是HDFS的守护程序（一个核心…

六、描述HBase 中scan 和get 的功能以及实现的异同？七、hbase如何导入数据？八、hbase 的存储结构？九、解释下 hbase 实时查询的原理十、详细描述 HBase 中一个 cell 的结构？十一、简述 HBase 中 compact 用途是什么，什么时候触发，...

1. 通常来说，Spark与MapReduce相比，Spark运行效率更高。请说明效率更高来源于Spark内置的哪些机制？ spark是借鉴了Mapreduce,并在其基础上发展起来的，继承了其分布式

1、Flink怎么做压力测试和监控？ 参考答案：我们一般碰到的压力来自以下几个方面： （1）产生数据流的速度如果过快，而下游的算子消费不过来的话，会产生背压。背压的监控可以使用FlinkWebUI(l

local 本地，通常是测试的时候用。 standalone，Spark 自己模拟作为一个调度系统，任务提交给 Master。 SparkonYarn 交给Yarn来进行资源调度，有 yarn-clu

​ 目录 HDFS文件写入和读取流程 HDFS组成架构 介绍下HDFS，说下HDFS优缺点，以及使用场景 HDFS作用 HDFS的容错机制 HDFS的存储机制 HDFS的副本机制 HDFS的常见数据格

什么是数据湖 数据湖（Data Lake）是一个大型数据存储和处理系统， 它能够存储各种类型和格式的数据，包括结构化数据、半结构化数据和非结构化数据。以下是关于数据湖的详细解释： 定义与特点 数据存储

​ 1、介绍下YARN 2、YARN有几个模块 3、YARN工作机制 4、YARN有什么优势，能解决什么问题? 5、YARN容错机制 6、YARN高可用 7、YARN调度器 8、YARN中Contai

分享大数据常见的面试题 一、mr的shuffle流程 说到mr的Shuffle，那么首先要明确shuffle属于哪个阶段。shuffle就是从Map端输出到Reduce输入的整个过程，这个过程广义上称

介绍下Flume  Flume架构  Flume有哪些Source  说下Flume事务机制  介绍下Flume采集数据的原理？底层实现？  Flume如何保证数据的可靠性  Flume传输数据时如何

介绍一下Mysql和Hivesql的区别？ 一方面，可以从底层原理出发回答，例如： 查询语言不同： Hive是hql语言，Mysql是sql语句； 存储位置不同： Hive是建立在 Hadoop 之上

一种特殊的线性表（数据元素首尾相接），特殊之处在于只允许在首部移除元素和在尾部追加元素。入队、出队。 3. 消息队列的分类 每个消息可以有多个消费者，彼此互不影响。比如我发布一个微博：关注我的人都能够看到。 4. Kafka的简介 5. Kafka的特点 基于分布式的扩展和容错…

Spark解决什么问题 二 Spark为什么会有自己的资源调度器 三 Spark运行模式 四 Spark常用端口号 五 Spark提交作业参数 六 Spark的transformation算子

Spark Streaming第一次运行不丢失数据 kafka参数 auto.offset.reset 参数设置成earliest 从最初始偏移量开始消费数据

Spark是一个围绕速度、易用性和复杂分析构建的大数据处理框架，Spark提供了一个全面、统一的框架用于管理各种有着不同性质(文本数据、图表数据等)的数据集和数据源(批量数据或实时的流数据)的大数据处理的需求。成为大数据核心技术之一，自然也成为了众多企业面试的核心专业问题，小编…

Spark系列面试题 Spark面试题（一） Spark面试题（二） Spark面试题（三） Spark面试题（四） Spark面试题（五）——数据倾斜调优 Spark面试题（六）——Spark资源调

微信搜索公众号：知了小巷公众号后台回复“资料”两个字，有大数据神秘学习大礼包！1.Spark的几种部署模式及其特点SparkSubmit#prepareSubmitEnvironment本地模式Spa

## Spark系列面试题 - [Spark面试题（一）](https://www.ikeguang.com/?p=1922) - [Spark面试题（二）](https://www.ikeguang

Spark是一种由Scala语言开发的快速、通用、可扩展的大数据分析引擎。Spark Core中提供了Spark最基础与最核心

1）本地模式   Spark不一定非要跑在hadoop集群，可以在本地，起多个线程的方式来指定。将Spark应用以多线程的方式直接运行在本地，一般都是为了方便调试，本地模式分三类   local：只启动一个executor   local[k]:启动k个executor   lo...

Spark的任务执行流程 https://wenku.baidu.com/view/9bf37bd07f1cfad6195f312b3169a4517723e513.html Spark总体架构和运行

简单介绍一下 Flink   Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽

概述2019年是大数据实时计算领域最不平凡的一年，2019年1月阿里巴巴Blink（内部的Flink分支版本）开源，大数据领域一夜间从Spark独步天下走向了两强争霸的时代。Flink因为其天然的流式

有没有去面试的时候被问到Flink的面试题你答不上来，为什么那？，菜吗？ 不是。原因是你接触的面试题太少了，那我今天就根据不同的群体来给大家你分享。 好今天的Flink的题目就分享到这里，背过上面的那些题目害怕面试官提问？信自己，努力和汗水总会能得到回报的。我是大数据老哥，我们…

相信小伙伴们对于Flink一定不会感到陌生，作为连续三年蝉联第一，荣膺全球最活跃的 Apache 开源项目，Flink在中国的热度也一直是居高不下。近几年，在社区的推动下，Flink 技术栈在越来越多的公司开始得到应用，因此在大数据的求职招聘中，对于Flink的着重考察也变得越…

简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象层的

1，简单介绍一下 Flink Flink 是一个框架和分布式处理引擎，用于对无界和有界数据流进行有状态计算。并且 Flink 提供了数据分布、容错机制以及资源管理等核心功能。Flink提供了诸多高抽象

Flink中的执行图一般是可以分为四类，按照生成顺序分别为：StreamGraph-> JobGraph-> ExecutionGraph->物理执行图。顾名思义，这里代表的是我们编写的流程序图。通过Stream API生成，这是执行图的最原始拓扑数据结构。StreamGraph...

16. Flink中有哪些窗口？ Flink 支持两种划分窗口的方式，按照time和count。如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个coun

1 Flink的并行度了解吗？Flink的并行度设置是怎样的？ Flink中的任务被分为多个并行任务来执行，其中每个并行的实例处理一部分数据。这些并行实例的数量被称为并行度。我们在实际生产环境中可以从

你对大数据有什么理解？Hadoop有哪些了解？Hadoop的优势劣势？高可用怎么做的？不同database的应用场景？

---

🤖 AI解析：
大数据定义：处理海量数据的技术工具体系。Hadoop=HDFS(存储)+MapReduce(计算)+YARN(调度)。优势：海量离线存储稳定、数据安全(NameNode HA)；劣势：计算慢(比Spark差20倍)、不支持多任务并发、基于磁盘。高可用=双NameNode策略。Database场景：Hive(离线数仓)、HBase(实时数仓)、ClickHouse(实时+SQL)、ES(全文检索)、MySQL(RDBMS)。

📌 关键知识点：Hadoop三大组件功能；NameNode HA原理；不同数据库的选型依据；大数据从2012发展到后红海时代的趋势
⚠️ 易错点：不要只说Hadoop=大数据，Spark/Flink才是当前主流计算引擎；Hadoop3的纠删码将3倍存储压缩为1.5倍是重要更新

小红书数据开发一面：介绍项目、ODS和DWD怎么区分分别存什么数据、跨数据域问题怎么做、有哪些宽表、对数仓的理解。

---

🤖 AI解析：
ODS：原始数据层，保持与业务库一致的结构，不做清洗，是数仓的'原材料'。DWD：明细数据层，对ODS做清洗(去重/空值处理/格式统一)，按主题域组织，是数仓的'净菜'。跨数据域：通过DWS(汇总层)打通，如用户域+交易域的交叉分析。宽表：将多维度指标合并到一张表减少JOIN，如用户行为宽表。

📌 关键知识点：数仓分层模型(ODS→DWD→DWS→ADS)的设计逻辑；跨域分析要在汇总层做而非直接跨明细层JOIN；宽表vs窄表的取舍
⚠️ 易错点：ODS不等于'脏数据层'——它保持原始是为了溯源；跨域直接JOIN明细层会导致数据膨胀和笛卡尔积

周五发现小红书DAU相比前一周同一天下降了5%，从哪些维度展开归因分析？

---

🤖 AI解析：
归因框架：内部拆解×外部排查。内部：①新老用户拆分(新用户看拉新渠道/获客成本，老用户看留存拐点)；②产品模块拆(社区feed/搜索/商城/消息)；③版本拆(新版本bug/体验变差)；④地域渠道拆(iOS/Android/一线/下沉)。外部：竞品动作(抖音/快手运营活动)、季节性(节假日/考试季)、技术层面(接口异常/CDN延迟/崩溃率)。

📌 关键知识点：归因分析的标准框架(内部×外部)；新老用户拆分是第一步；要给出结论和行动建议而非只列可能性
⚠️ 易错点：先验证数据本身是否正常(埋点/ETL问题经常被忽略)；归因要落到具体行动而非泛泛分析

什么是Shuffle？哪些操作触发Shuffle？如何优化Shuffle性能？

---

🤖 AI解析：
Shuffle=数据在不同分区间重新分布的过程，发生在宽依赖操作中。触发Shuffle的操作：groupByKey、reduceByKey、join(非广播)、distinct、repartition、sortByKey。优化方法：①reduceByKey替代groupByKey(Map端预聚合)；②调整spark.sql.shuffle.partitions；③Kryo序列化；④广播Join替代Shuffle Join(小表广播)；⑤启用AQE自动合并小分区(Spark3.0+)。

📌 关键知识点：Shuffle=Spark最大性能瓶颈；reduceByKey预聚合vs groupByKey无预聚合；Broadcast Join是零Shuffle方案
⚠️ 易错点：groupByKey不做预聚合，Shuffle数据量巨大；Broadcast Join小表默认阈值10MB，超阈值需手动调或显式broadcast()

什么是RDD？五大特性是什么？Transformation和Action的区别？

---

🤖 AI解析：
RDD=Resilient Distributed Dataset，不可变、可分区、可并行操作的元素集合。五大特性：①一组分区(Partitions)；②每个分区的计算函数；③依赖关系(Lineage)；④分区器(Partitioner，KV RDD可选)；⑤首选位置(Preferred Locations，数据本地性)。Transformation=懒执行返回新RDD(map/filter/groupByKey等)；Action=触发实际计算返回结果(collect/count/saveAsTextFile等)。

📌 关键知识点：RDD的Lineage血统机制是容错基础；Transformation Lazy执行只有Action才触发Job；五大特性决定了RDD的分布式计算能力
⚠️ 易错点：不要混淆Transformation和Action——Transformation不触发计算；频繁创建RDD链但不Action会导致资源浪费

Spark如何避免数据倾斜(Data Skew)？

---

🤖 AI解析：
数据倾斜表现：少数Task处理大量数据拖慢整个Job。解决方案：①加盐(Salting)打散热点Key——加随机前缀分散到不同分区；②两阶段聚合(局部聚合+全局聚合)；③采样分析倾斜Key单独处理；④repartition/coalesce调整分区；⑤Broadcast Join小表避免Shuffle倾斜；⑥AQE自动检测拆分倾斜分区(Spark3.0+)。

📌 关键知识点：加盐打散是数据倾斜最常用的方案；两阶段聚合=先局部聚合减数据量再全局聚合；AQE是Spark3.0的自动优化利器
⚠️ 易错点：加盐后Join需两步(先加盐Join再去盐聚合)；AQE需设置spark.sql.adaptive.enabled=true才能生效

生产环境中Flink实时ETL任务出现延迟，下游Kafka消费lag持续上涨，如何诊断和处理反压问题？

---

🤖 AI解析：
诊断：①Flink Web UI查看BackPressure指标(红色=高反压)；②看TaskManager日志是否有buffer耗尽；③分析哪个算子是瓶颈(通常是聚合/Join)。处理：①增大并行度分散负载；②优化算子逻辑(预过滤减少数据量)；③调整网络buffer配置(taskmanager.network.memory)；④异步IO替代同步查询；⑤分区重平衡(rebalance/rescale)。

📌 关键知识点：反压是Flink自稳机制——下游慢时自动减缓上游速率；但持续反压意味着性能瓶颈需人工干预；Kafka lag是反压的外在信号
⚠️ 易错点：反压不等于数据丢失——Flink的checkpoint保证一致性；但持续反压会导致延迟累积，需及时定位瓶颈算子

Flink架构是怎样的？核心组件有哪些？

---

🤖 AI解析：
Flink架构：①JobManager(调度+协调)：接收Job、生成执行图、调度Task、协调checkpoint/barrier；②TaskManager(执行)：执行Task、维护状态、报告心跳；③Client(提交)：用户提交Job的入口。编程模型：Source→Transformation→Sink。核心概念：Stream(无界/有界)、State(Keyed/Operator)、Time(Event/Processing/Ingestion)、Window(Tumbling/Sliding/Session)。

📌 关键知识点：JobManager是大脑(调度协调)、TaskManager是手脚(执行计算)；Flink同时支持批流统一(DataStream API)；Checkpoint是容错的基石
⚠️ 易错点：Flink不是'只做流处理'——批处理是有界流的特例；Checkpoint间隔太短影响吞吐、太长影响恢复速度

Flink的Checkpoint容错机制怎么实现的？和Spark Streaming有什么区别？

---

🤖 AI解析：
Checkpoint原理：①JobManager定期向Source注入Barrier标记；②Barrier随数据流流经每个算子；③算子收到Barrier后快照当前State到StateBackend；④所有算子完成快照后向JobManager报告；⑤JobManager确认Checkpoint完成。与Spark Streaming区别：Flink是原生流处理(逐条处理)，Checkpoint是exactly-once语义；Spark Streaming是微批(Micro-batch)，容错靠RDD Lineage重算，是at-least-once。

📌 关键知识点：Barrier算法是Checkpoint的核心——异步快照不阻塞数据流；Flink exactly-once vs Spark at-least-once是本质区别
⚠️ 易错点：Checkpoint不是'保存所有数据'而是只保存State快照；StateBackend选择(RocksDB/Heap)影响性能和内存占用

抖音推荐算法从A模型换成B模型提高观看时长，设计AB实验方案包括分流、样本量、评估指标、注意事项。

---

🤖 AI解析：
实验设计：①用户ID hash分流保证同一用户始终在同一组；②对照组A模型、实验组B模型；③时长≥2周覆盖完整周期。样本量：n=(Z_α/2+Z_β)²×2σ²/δ²，字节要求power=0.8、α=0.05。评估指标：核心=人均观看时长(正指标)，辅助=完播率/点赞率/分享率，负向=跳出率/负反馈率。注意事项：①网络效应(社交产品实验组内容可能被对照组看到造成污染)；②新奇效应(新算法上线初期用户新鲜感异常行为)；③多重比较(看太多指标容易假阳性)。

📌 关键知识点：分流用hash保证一致性；样本量公式需指定效应量和显著性水平；网络效应是社交产品AB实验的特殊挑战
⚠️ 易错点：p=0.08不显著≠不能上线——需考虑成本收益权衡；新奇效应需跑足够长时间稀释；多重比较需Bonferroni校正

某天抖音DAU下降了5%，作为数据分析师怎么排查原因？

---

🤖 AI解析：
框架：①验证数据(埋点/ETL是否异常，最常见但最易忽略)；②看大盘(同比环比判断周期性vs突发)；③拆维度：新老用户(新用户看渠道/获客，老用户看留存拐点)、产品模块(哪个模块日活降最多)、版本(新版bug)、地域渠道；④外部因素：竞品活动、公共事件、技术异常。结论要落到行动：如'新用户次日留存从60%降到45%，原因是拉新渠道从信息流广告换线下地推，用户质量下降'。

📌 关键知识点：先验证数据再分析是铁律；新老用户拆分是第一步；结论必须给出具体行动建议而非泛泛分析
⚠️ 易错点：忽略数据质量问题直接归因会误判；DAU下降可能是正常的周期性波动而非异常

小红书笔记曝光量近一个月持续下降但发布量稳定，分析可能原因并给出建议。

---

🤖 AI解析：
问题在流量分发端而非内容供给端。可能原因：①推荐系统匹配效率下降(CTR/完播率/互动率趋势变差)；②低质量内容占比上升(标题党/同质化/搬运)挤压优质内容曝光；③流量池规则调整(冷启动流量减少导致新笔记曝光不足)；④广告位/电商卡片增多挤压自然内容；⑤用户疲劳(同质化导致活跃频率降低)。建议：优化推荐算法权重、打压低质内容、调整流量池分配、控制广告加载率。

📌 关键知识点：曝光降但发布稳=分发端问题而非供给端；小红书分级流量池机制是关键约束；推荐效率+内容质量双维分析
⚠️ 易错点：不能简单归因'用户减少了'——需区分是推荐效率低还是内容质量差导致曝光不足

小红书在某综艺节目投放广告，如何评估拉新效果？

---

🤖 AI解析：
评估框架：①核心指标：新增用户数、CPA(获客成本)、新用户次日/7日留存、人均时长、首周发布率(衡量是否有价值的内容贡献者)；②归因方式：双重差分法——选未投放的相似时段作对照排除季节性；③自然增量vs广告增量(品牌溢出效应)；④长期价值：30日/90日留存对比自然渠道用户；⑤归因模型：末次点击vs多触点归因(不同模型ROI差异大)。

📌 关键知识点：双重差分法排除季节性干扰；品牌溢出效应=自然渠道也增长说明投放有品牌价值；长期留存才是真质量指标
⚠️ 易错点：末次点击归因会忽略前置触达的价值；'一锤子用户'拉新成本看似低但长期LTV可能远低于自然渠道

小红书信息流广告收入环比下降10%，分析可能原因并给出改进建议。

---

🤖 AI解析：
拆解公式：广告收入=展示量×CPM。展示量下降：①DAU/session数下降(用户少了)；②广告加载率下降(产品调整了广告位策略)；③内容供给不足用户刷不到底。CPM下降：①广告主出价降低(大促后淡季)；②广告CTR下降(创意疲劳/用户免疫)；③填充率下降(DMP定向能力变差)。建议：提升DAU/session数、优化CTR(更新创意素材)、调整出价策略(oCPM)、改进归因模型(多触点归因)。

📌 关键知识点：收入=展示量×CPM是拆解起点；展示量和CPM需分别排查；商业sense是数据分析师的核心竞争力
⚠️ 易错点：不能只看总收入——需拆到展示量和CPM再分别定位；广告加载率过高会影响用户体验导致长期留存下降

设计一套视频质量评分体系评估每条视频在推荐系统中的表现，设计哪些指标怎么综合打分？

---

🤖 AI解析：
分层指标体系：①消费层(完播率/播放时长/重播率)；②互动层(点赞率/评论率/分享率/关注转化率)；③负向层(划走率/不感兴趣率/举报率)。综合打分：加权打分法(权重通过回归模型或专家经验定)，借鉴YouTube'观看时长预期'或抖音内部'视频价值分'。防作弊：点赞没有完播要降权重。需按视频时长分层归一化(不同时长视频互动率天差地别)。

📌 关键知识点：指标分层(消费→互动→负向)而非只列互动率；按时长归一化是必须的；防作弊权重调整体现业务理解深度
⚠️ 易错点：不同时长视频互动率不可直接比较(15秒vs5分钟)；只有互动没有完播的'刷量'视频需降权

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...结果被一道算法题坑了，"有效的括号"使用栈来解，会非常简单.

终于来了，算法相关的。 其实个人理解，前端岗位对于算法的要求与其他IT岗位相比，是低得多的。 但是小白我经历了如蚂蚁金服、网易这样的大厂教做人之后，还是觉得，对于一些基本算法、思想的掌握还是必须的。 然后，就把自己遇到的、学到的算法相关的再总结一下，方便自己随时备战面试。 JS…

看到一篇算法文章，觉得着实有趣，但不知为何我看到题后首先想到的是田忌赛马。今天我也试着解释下这题，当做是一个学习的过程。 64 匹马分 8 次在全部比完一次，然后我们可以把目标缩小到 32 匹马。 1、八次比完后，我们可以将每一匹马的速度按下表排好。 剩下的 8 组 32 匹马…

链表即是由节点（Node）组成的线性集合，每个节点可以利用指针指向其他节点。它是一种包含了多个节点的、能够用于表示序列的数据结构。 单向链表: 链表中的节点仅指向下一个节点，并且最后一个节点指向空。 双向链表: 其中每个节点具有两个指针 p、n，使得 p 指向先前节点并且 n …

回想以前遇到过的面试官，甚至包括自己作为面试官的时候，大都是停留在问【是什么】的问题上，而很少去追问【为什么】。。。

1. 概述 排序算法分为内部排序和外部排序，内部排序把数据记录放在内存中进行排序，而外部排序因排序的数据量大，内存不能一次容纳全部的排序记录，所以在排序过程中需要访问外存。 经常提及的八大排序算法指的就是内部排序的八种算法，分别是冒泡排序、快速排序、直接插入排序、希尔排序、简单…

持续更新，持续更新...

【前端面试复习系列文章】 2024前端高频面试题-- html篇 2024前端高频面试题-- CSS篇 2024前端高频面试题-- JS篇 2024前端高频面试题-- VUE篇 2024前端高频面试题

1. KMP 算法 谈到字符串问题，不得不提的就是 KMP 算法，它是用来解决字符串查找的问题，可以在一个字符串（S）中查找一个子串（W）出现的位置。KMP 算法把字符匹配的时间复杂度缩小到 O(m+n) ,而空间复杂度也只有O(m)。因为“暴力搜索”的方法会反复回溯主串，导致…

尽可能的全面正确的解析一个任意 url 的所有参数为 Object，注意边界条件的处理。 请使用最基本的遍历来实现判断字符串 a 是否被包含在字符串 b 中，并返回第一次出现的位置（找不到返回 -1）。 有一个祖先树状 json 对象，当一个人有一个儿子的时候，其 child …

0. 几个概念 完全二叉树：若二叉树的高度是h，除第h层之外，其他（1~h-1）层的节点数都达到了最大个数，并且第h层的节点都连续的集中在最左边。想到点什么没？实际上，完全二叉树和堆联系比较紧密哈~~~ 满二叉树：除最后一层外，每一层上的所有节点都有两个子节点，最后一层都是叶子…

前言 本文题目选自 LeetCode 精选 TOP 面试题，而这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。本文挑选其中所有简单题做归类和解法分析。后续更新所

前几天有个朋友去面试字节跳动，面试官问了他一道链表相关的算法题，不过他一时之间没做出来，就来问了我一下，感觉这道题还不错，拿来讲一讲。 给定一个单链表的头节点 head,实现一个调整单链表的函数，使得每K个节点之间为一组进行逆序，并且从链表的尾部开始组起，头部剩余节点数量不够一…

数据结构是对实际问题中的数据元素及相互间的联系的抽象。一般用线性表来表示常用数据结构，线性表分为顺序存储的顺序表和连式存储的链表。 在学习算法之前，必须要了解一些常用数据结构的概念。 栈：一种特殊串联形式的抽象数据类型，可由链表或数组实现，通过链表或数组的栈顶（Top）指针对数…

2019年马上就要结束了，相信很多童鞋都开始蠢蠢欲动了，寻找新的机会了，但是工作太忙没有时间刷算法题，面试的时候好心虚。这里双手奉上40道LeetCode上经典面试算法题，整理的内容有点长，建议先收藏，慢慢消化，在来年顺利拿到满意的offer。 内容较多，整理不易，希望大家关注…

腾讯年终奖 什么是真正的好公司？ 一年到头，出不了几次裁员等劳务纠纷的吃瓜新闻。 只有到年底了，才因为年终奖远高于行业水平，实在没法低调了，"被迫"上热搜。 最近网友爆料了腾讯头牌部门的年终奖： WX

限流是指在系统面临高并发、大流量请求的情况下，限制新的流量对系统的访问，从而保证系统服务的安全性。常用的限流算法有计数器固定窗口算法、滑动窗口算法、漏斗算法和令牌桶算法，下面将对这几种算法进行分别介绍，并给出具体的实现。本文目录如下，略长，读者可以全文阅读，同样也可以只看感兴趣…

接触 Android 开发也有一段时间了，前段时间便开始想抽空整理一些知识点，通过笔记整理的方式减少自己重复学习的时间成本和提高自身的效率。 本文总结的部分是常见面试算法题，算法题解均有 java 实现。目录可以在右边侧边栏查看跳转。 之后会整理的知识点还会有 java、And…

本文题目选自 LeetCode 精选 TOP 面试题，这些题在自己和同事亲身经历中，确实遇到的几率在百分之80%以上（成都和北京的前端岗位）。 上版本部分请参考# 简单题上 二叉树（DFS） 二叉树前

众所周知，与后台开发人员相比，算法是我们前端开发人员的一个弱项。 而近两年随着互联网行业竞争愈发激烈，市场上对前端岗位的算法要求也有一定的提升。 我记得大三参加腾讯的校招面试时只准备了几种常见的排序算法就足以应对了，然而今年包括今日头条在内的多家大厂的前端笔试题目中都出现了"贪…

大家好，我是薇薇，一名沪漂女程序员，年前惨遭被裁，正值在家悲伤抠脚之际，突然看到两位朋友在合谋开发一款刷leetcode的小工具——leetcode-practice…… 下面重点稍微来介绍一下 在神

大家好，今早在B站看到up主的vscode里藏了leetcode插件，这才知道原来还有这款神器。但是没想到在用的时候遇到了一些麻烦，花了一点时间才解决。所以写这篇文章除了给大家安利这个好用的插件之外，也是为了帮助更多的同学避免踩坑。 vscode在工业界鼎鼎大名，被誉为微软少有…

花了十几天，把《算法》看了一遍。然后重新 AC 了一遍 LeetCode 的题并记录下心得。

算法一直是大厂前端面试常问的一块，而大家往往准备这方面的面试都是通过leetcode刷题。 我特地整理了几道leetcode中「很有意思」而且非常「高频」的算法题目，分别给出了思路分析（带图解）和代码实现。 给定一个整数数组 nums 和一个目标值 target，请你在该数组中…

题目分类及刷题顺序推荐 一. 数组 二. 字符串 三. 数与位 四. 栈与递归 五. 链表 六. 哈希表 七. 贪心算法 八. 双指针法 九. 树 十. 图与搜索 十一. 二分查找 十二. 二进制运算

虽然很多人都觉得前端算法弱，但其实 JavaScript 也可以刷题啊！最近两个月断断续续刷完了 leetcode 前 200 的 middle + hard ，总结了一些刷题常用的模板代码。走过路过发现 bug 请指出，拯救一个辣鸡（但很帅）的少年就靠您啦！ 包括打印函数和一…

众所周知，现在的互联网公司面试，只要是写代码的岗位，都会来一套算法题组合拳伺候。 所以大家在准备校招、社招，或者闲暇的时候，都可以刷刷题，保持良好的手感。

我就是那个 @量子位 答案里面提到的“lucifer 小哥哥”。 我本人从开始准备算法以来，大概经过了几个月的时间，这期间自己成长了很多，从刷题菜鸡，到现在对刷题套路，题型有了自己的理解，感受还是蛮多的。我本人不是算法高手，算是勤能补拙类型。不过经过几个月的学习和练习，不仅面试…

1. 两数之和 2. 两数相加 3. 无重复字符的最长子串 4. 寻找两个正序数组的中位数 5. 最长回文子串

leetcode网站中的编程环境，代码提示，快捷键并不友好，我们在刷题的时候往往不高效，且过后也不能快速，随时随地的进行方便的复盘。所以在这篇文章中我将介绍如何在 VsCode 中通过插件来高效的刷题

老司机带你刷 LeetCode

LeetCode热题100道-Day02 136. 只出现一次的数字 在stream流中的reduce方法使用异或运算。

作为一个前端同学，为什么不用JavaScript刷LeetCode，而是使用TypeScript来刷题呢？ 当然，你也可以选择c++、java来刷题，但我认为还是用自己研究方向的语言比较好

作为一个多年的老菜鸟，有感于大部分的公司面试 “面试造航母，工作螺丝钉” 的作风，特整理了这个数据结构和算法面试题系列。对于校招而言，如果没有太多实践/实习经验，大公司往往喜欢考察数据结构和算法，如微软就特别喜欢在校招时手写算法题，而且难度还不小，当年我毕业找工作时也是颇受折磨…

数学是科学之基础，数字题往往也是被面试玩出花来。数学本身是有趣味的一门学科，前段时间有点不务正业，对数学产生了浓厚的兴趣，于是看了几本数学史论的书，也买了《几何原本》和《陶哲轩的实分析》，看了部分章节，受益良多，有兴趣的朋友可以看看。特别是几何原本，欧几里得上千年前的著作，里面…

500 Data structures and algorithms interview questions and their solutions

背包问题包括0-1背包问题、完全背包问题、部分背包问题等多种变种。其中，最简单的是部分背包问题，它可以采用贪心法来解决，而其他几种背包问题往往需要动态规划来求解。本文主要来源于《背包问题九讲》，我选择了比较简单的0-1背包问题和完全背包问题进行汇总。同时给出实现代码，如有错误，…

继上一篇总结了二叉树的基础操作后，这一篇文章汇总下常见的二叉树相关面试题，主要分为判断类、构建类、存储类、查找类、距离类、混合类这六类大问题。本文所有代码在 这里 。 判断类问题主要分下下判断二叉树是否是二叉搜索树、二叉完全树，以及两棵二叉树是否同构这三个问题。 题： 给定一棵…

HashMap 是我们熟悉的散列表实现，也是 “面试八股文” 的标准题库之一。今天，我给出一份 HashMap 高频面试题口述简答答案，希望对你刷题有帮助。

前面总结了随机算法，这次再把以前写的递归算法的文章梳理一下，这篇文章主要是受到宋劲松老师写的《Linux C编程》的递归章节启发写的。最能体现算法精髓的非递归莫属了，希望这篇文章对初学递归或者对递归有困惑的朋友们能有所帮助，如有错误，也恳请各路大牛指正。二叉树的递归示例代码请参…

在用C语言实现一些常见的数据结构和算法时，C语言的基础不能少，特别是指针和结构体等知识。 linux中的C编译得到的目标文件和可执行文件都是ELF格式的，可执行文件中以segment来划分，目标文件中，我们是以section划分。一个segment包含一个或多个section，…

随机算法涉及大量概率论知识，有时候难得去仔细看推导过程，当然能够完全了解推导的过程自然是有好处的，如果不了解推导过程，至少记住结论也是必要的。本文总结最常见的一些随机算法的题目，是几年前找工作的时候写的。需要说明的是，这里用到的随机函数 randInt(a, b) 假定它能随机…

栈作为一种基本的数据结构，在很多地方有运用，比如函数递归，前后缀表达式转换等。本文会用C数组来实现栈结构(使用链表实现可以参见链表那一节，使用头插法构建链表即可)，并对常见的几个跟栈相关的面试题进行分析，本文代码在 这里。 我们使用结构体来定义栈，使用柔性数组来存储元素。几个宏…

链表作为一种基础的数据结构，在很多地方会用到。如在Linux内核代码，redis源码，python源码中都有使用。除了单向链表，还有双向链表，本文主要关注单向链表(含部分循环链表题目，会在题目中注明，其他情况都是讨论简单的单向链表)。双向链表在redis中有很好的实现，也在我的…

快速排序也是基于分治模式，类似归并排序那样，不同的是快速排序划分最后不需要merge。对一个数组 A[p..r] 进行快速排序分为三个步骤： 划分： 数组 A[p...r] 被划分为两个子数组 A[p...q-1] 和 A[q+1...r]，使得 A[p...q-1] 中每个元…

字符串作为数据结构中的基础内容，也是面试中经常会考察的基本功之一，比如实现 strcpy，strcmp等基本函数等，回文字符串，字符串搜索，正则表达式等。本文相关代码见 这里。 首先来看一些字符串的基本函数的实现，以下代码取自MIT6.828课程。 题： 给定一个字符串，找出该…

排序算法也是面试中常常提及的内容，问的最多的应该是快速排序、堆排序。这些排序算法很基础，但是如果平时不怎么写代码的话，面试的时候总会出现各种bug。虽然思想都知道，但是就是写不出来。本文打算对各种排序算法进行一个汇总，包括插入排序、冒泡排序、选择排序、计数排序、归并排序，基数排…

在说二叉树前，先来看看什么是树。树中基本单位是结点，结点之间的链接，称为分支。一棵树最上面的结点称之为根节点，而下面的结点为子结点。一个结点可以有0个或多个子结点，没有子结点的结点我们称之为叶结点。 二叉树是指子结点数目不超过2个的树，它是一种很经典的数据结构。而二叉搜索树(B…

二分查找本身是个简单的算法，但是正是因为其简单，更容易写错。甚至于在二分查找算法刚出现的时候，也是存在bug的（溢出的bug），这个bug直到几十年后才修复（见《编程珠玑》）。本文打算对二分查找算法进行总结，并对由二分查找引申出来的问题进行分析和汇总。若有错误，请指正。本文完整…

本文要描述的堆是二叉堆。二叉堆是一种数组对象，可以被视为一棵完全二叉树，树中每个结点和数组中存放该结点值的那个元素对应。树的每一层都是填满的，最后一层除外。二叉堆可以用于实现堆排序，优先级队列等。本文代码地址在 这里。 使用数组来实现二叉堆，二叉堆两个属性，其中 LENGTH(…

## 题目描述

用户登录日志表，记录用户每天的登录日期。请查出连续登录超过4天的用户ID及起止日期。

## 表结构

```sql
CREATE TABLE t_login_log (
  user_id    INT,
  login_date DATE
);
```

## 示例数据

| user_id | login_date  |
|---------|-------------|
| 1       | 2024-01-01  |
| 1       | 2024-01-02  |
| 1       | 2024-01-03  |
| 1       | 2024-01-04  |
| 1       | 2024-01-05  |
| 2       | 2024-01-01  |
| 2       | 2024-01-03  |
| 2       | 2024-01-04  |
| 2       | 2024-01-05  |
| 3       | 2024-01-01  |
| 3       | 2024-01-02  |
| 3       | 2024-01-03  |
| 3       | 2024-01-04  |
| 3       | 2024-01-05  |
| 3       | 2024-01-06  |

## 期望输出

| user_id | start_date | end_date   | days |
|---------|------------|------------|------|
| 1       | 2024-01-01 | 2024-01-05 | 5    |
| 3       | 2024-01-01 | 2024-01-06 | 6    |

## 参考SQL

```sql
SELECT user_id,
       MIN(login_date) AS start_date,
       MAX(login_date) AS end_date,
       COUNT(*) AS days
FROM (
  SELECT user_id, login_date,
         DATE_SUB(login_date, INTERVAL ROW_NUMBER()
           OVER(PARTITION BY user_id ORDER BY login_date) DAY) AS grp
  FROM (SELECT DISTINCT user_id, login_date FROM t_login_log) t
) t2
GROUP BY user_id, grp
HAVING COUNT(*) > 4;
```

**核心思路**：login_date - ROW_NUMBER() 相同的行属于同一段连续登录

## 题目描述

用户登录记录表，以用户最早登录日期为注册日，计算次日留存率和7日留存率。

## 表结构

```sql
CREATE TABLE t_user_login (
  user_id    INT,
  login_date DATE
);
```

## 示例数据

| user_id | login_date  |
|---------|-------------|
| 1       | 2024-01-01  |
| 1       | 2024-01-02  |
| 1       | 2024-01-08  |
| 2       | 2024-01-01  |
| 3       | 2024-01-01  |
| 3       | 2024-01-02  |
| 3       | 2024-01-09  |
| 4       | 2024-01-01  |
| 4       | 2024-01-02  |

## 期望输出

| reg_date   | new_users | d1_retained | d1_rate | d7_retained | d7_rate |
|------------|-----------|-------------|---------|-------------|---------|
| 2024-01-01 | 4         | 3           | 75.00%  | 2           | 50.00%  |

## 参考SQL

```sql
WITH first_login AS (
  SELECT user_id, MIN(login_date) AS reg_date
  FROM t_user_login GROUP BY user_id
)
SELECT f.reg_date,
       COUNT(DISTINCT f.user_id) AS new_users,
       COUNT(DISTINCT CASE WHEN l.login_date = DATE_ADD(f.reg_date, INTERVAL 1 DAY) THEN f.user_id END) AS d1_retained,
       COUNT(DISTINCT CASE WHEN l.login_date = DATE_ADD(f.reg_date, INTERVAL 7 DAY) THEN f.user_id END) AS d7_retained
FROM first_login f
LEFT JOIN t_user_login l ON f.user_id = l.user_id
GROUP BY f.reg_date;
```

**核心思路**：找首次登录=注册日 → LEFT JOIN所有登录 → CASE WHEN判断N日后是否回访

## 题目描述

每个大厅有多个活动，起止日期可能重叠。合并同一大厅所有重叠的活动区间。

## 表结构

```sql
CREATE TABLE t_hall_activity (
  hall_id     INT,
  activity_id INT,
  start_date  DATE,
  end_date    DATE
);
```

## 示例数据

| hall_id | activity_id | start_date | end_date   |
|---------|-------------|------------|------------|
| 1       | 101         | 2024-01-01 | 2024-01-05 |
| 1       | 102         | 2024-01-04 | 2024-01-10 |
| 1       | 103         | 2024-01-15 | 2024-01-20 |
| 2       | 201         | 2024-01-01 | 2024-01-03 |

## 期望输出

| hall_id | merged_start | merged_end |
|---------|-------------|------------|
| 1       | 2024-01-01  | 2024-01-10 |
| 1       | 2024-01-15  | 2024-01-20 |
| 2       | 2024-01-01  | 2024-01-03 |

## 参考SQL

```sql
SELECT hall_id,
       MIN(start_date) AS merged_start,
       MAX(end_date)   AS merged_end
FROM (
  SELECT *,
    SUM(CASE WHEN start_date <= prev_end THEN 0 ELSE 1 END)
      OVER(PARTITION BY hall_id ORDER BY start_date) AS grp
  FROM (
    SELECT *,
      MAX(end_date) OVER(PARTITION BY hall_id ORDER BY start_date
        ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prev_end
    FROM t_hall_activity
  ) t1
) t2
GROUP BY hall_id, grp;
```

**核心思路**：排序→判断当前开始<=前一结束→标记新分组→分组取MIN/MAX

## 题目描述

记录每天每只股票收盘价格，查出波峰(高于前后两天)和波谷(低于前后两天)。

## 表结构

```sql
CREATE TABLE t_stock_price (
  stock_code    VARCHAR(10),
  trade_date    DATE,
  closing_price DECIMAL(10,2)
);
```

## 示例数据

| stock_code | trade_date  | closing_price |
|------------|-------------|---------------|
| A          | 2024-01-01  | 10.00         |
| A          | 2024-01-02  | 15.00         |
| A          | 2024-01-03  | 12.00         |
| A          | 2024-01-04  | 8.00          |
| A          | 2024-01-05  | 11.00         |

## 期望输出

| stock_code | trade_date  | closing_price | type |
|------------|-------------|---------------|------|
| A          | 2024-01-02  | 15.00         | peak |
| A          | 2024-01-04  | 8.00          | valley |

## 参考SQL

```sql
SELECT stock_code, trade_date, closing_price,
       CASE WHEN closing_price > prev AND closing_price > nxt THEN 'peak'
            WHEN closing_price < prev AND closing_price < nxt THEN 'valley' END AS type
FROM (
  SELECT *, LAG(closing_price) OVER(PARTITION BY stock_code ORDER BY trade_date) AS prev,
           LEAD(closing_price) OVER(PARTITION BY stock_code ORDER BY trade_date) AS nxt
  FROM t_stock_price
) t
WHERE (closing_price > prev AND closing_price > nxt)
   OR (closing_price < prev AND closing_price < nxt);
```

**核心思路**：LAG/LEAD取前后价格，比较判断波峰/波谷

## 题目描述

表t_cost_detail包含id和money，按id顺序累加money，求累加值与1000差值最小的记录。

## 表结构

```sql
CREATE TABLE t_cost_detail (
  id    INT PRIMARY KEY,
  money DECIMAL(10,2)
);
```

## 示例数据

| id | money |
|----|-------|
| 1  | 200   |
| 2  | 300   |
| 3  | 400   |
| 4  | 150   |
| 5  | 100   |

## 期望输出

| id | money | cumulative | diff |
|----|-------|------------|------|
| 4  | 150   | 1050       | 50   |

## 参考SQL

```sql
SELECT id, money, cumulative, ABS(cumulative - 1000) AS diff
FROM (
  SELECT id, money, SUM(money) OVER(ORDER BY id) AS cumulative
  FROM t_cost_detail
) t
ORDER BY diff LIMIT 1;
```

**核心思路**：窗口SUM累计求和→ABS差值→排序取最小

## 题目描述

表t_id记录id，id不重复但存在间断，求连续段的起始、结束位置及每段个数。

## 表结构

```sql
CREATE TABLE t_id (
  id INT PRIMARY KEY
);
```

## 示例数据

| id |
|----|
| 1  |
| 2  |
| 3  |
| 5  |
| 6  |
| 8  |
| 9  |
| 10 |

## 期望输出

| start_id | end_id | count |
|----------|--------|-------|
| 1        | 3      | 3     |
| 5        | 6      | 2     |
| 8        | 10     | 3     |

## 参考SQL

```sql
SELECT MIN(id) AS start_id, MAX(id) AS end_id, COUNT(*) AS count
FROM (
  SELECT id, id - ROW_NUMBER() OVER(ORDER BY id) AS grp
  FROM t_id
) t
GROUP BY grp
ORDER BY start_id;
```

**核心思路**：id - ROW_NUMBER() 相同的行属于同一段连续区间

## 题目描述

用户操作行为表，统计A操作后紧接B操作的用户数。

## 表结构

```sql
CREATE TABLE t_act_log (
  user_id  INT,
  op_id    VARCHAR(10),
  op_time  DATETIME
);
```

## 示例数据

| user_id | op_id | op_time             |
|---------|-------|---------------------|
| 1       | A     | 2024-01-01 10:00:00 |
| 1       | B     | 2024-01-01 10:01:00 |
| 1       | D     | 2024-01-01 10:02:00 |
| 2       | A     | 2024-01-01 11:00:00 |
| 2       | C     | 2024-01-01 11:01:00 |
| 3       | A     | 2024-01-01 12:00:00 |
| 3       | B     | 2024-01-01 12:01:00 |

## 期望输出

| metric   | user_count |
|----------|------------|
| A紧接B   | 2          |

## 参考SQL

```sql
SELECT 'A紧接B' AS metric, COUNT(DISTINCT user_id) AS user_count
FROM (
  SELECT user_id, LEAD(op_id) OVER(PARTITION BY user_id ORDER BY op_time) AS next_op
  FROM t_act_log WHERE op_id = 'A'
) t WHERE next_op = 'B';
```

**核心思路**：LEAD取下一步操作，判断是否紧接B

## 题目描述

将学生成绩表从行格式(A,语文,90)转为列格式(A,语文=90,数学=85)，以及反向操作。

## 表结构

```sql
CREATE TABLE t_row_col (
  student VARCHAR(20),
  subject VARCHAR(20),
  score   INT
);
```

## 示例数据

| student | subject | score |
|---------|---------|-------|
| 张三    | 语文    | 90    |
| 张三    | 数学    | 85    |
| 李四    | 语文    | 88    |
| 李四    | 数学    | 92    |

## 期望输出（行转列）

| student | 语文 | 数学 |
|---------|------|------|
| 张三    | 90   | 85   |
| 李四    | 88   | 92   |

## 参考SQL（行转列）

```sql
SELECT student,
  MAX(CASE WHEN subject='语文' THEN score END) AS 语文,
  MAX(CASE WHEN subject='数学' THEN score END) AS 数学
FROM t_row_col GROUP BY student;
```

## 参考SQL（列转行）

```sql
SELECT student, '语文' AS subject, 语文 AS score FROM t_col_row WHERE 语文 IS NOT NULL
UNION ALL
SELECT student, '数学' AS subject, 数学 AS score FROM t_col_row WHERE 数学 IS NOT NULL;
```

**核心思路**：行转列用CASE WHEN+聚合；列转行用UNION ALL

## 题目描述

订单表，查询过去至少存在3天销售额连续增长的商户。

## 表结构

```sql
CREATE TABLE t_order (
  order_id   INT,
  shop_id    INT,
  order_time DATETIME,
  order_amt  DECIMAL(10,2)
);
```

## 示例数据（聚合后）

| shop_id | dt         | daily_sales |
|---------|------------|-------------|
| 1       | 2024-01-01 | 100         |
| 1       | 2024-01-02 | 120         |
| 1       | 2024-01-03 | 150         |
| 1       | 2024-01-04 | 130         |
| 2       | 2024-01-01 | 200         |
| 2       | 2024-01-02 | 180         |

## 期望输出

| shop_id | start_date | end_date   | days |
|---------|------------|------------|------|
| 1       | 2024-01-01 | 2024-01-03 | 3    |

## 参考SQL

```sql
WITH daily AS (
  SELECT shop_id, DATE(order_time) dt, SUM(order_amt) sales
  FROM t_order GROUP BY shop_id, DATE(order_time)
),
growth AS (
  SELECT *, CASE WHEN sales > LAG(sales) OVER(PARTITION BY shop_id ORDER BY dt) THEN 0 ELSE 1 END AS brk
  FROM daily
),
grp AS (
  SELECT *, SUM(brk) OVER(PARTITION BY shop_id ORDER BY dt) AS gid
  FROM growth
)
SELECT shop_id, MIN(dt) AS start_date, MAX(dt) AS end_date, COUNT(*) AS days
FROM grp GROUP BY shop_id, gid HAVING COUNT(*) >= 3;
```

**核心思路**：日聚合→LAG标记增长中断→累计分组→HAVING过滤

## 题目描述

员工薪资表，去除最高和最低薪资后计算平均薪水（部门人数>=3人才计算）。

## 表结构

```sql
CREATE TABLE t_salary (
  emp_id    INT,
  depart_id INT,
  salary    DECIMAL(10,2)
);
```

## 示例数据

| emp_id | depart_id | salary |
|--------|-----------|--------|
| 1      | 10        | 6000   |
| 2      | 10        | 8000   |
| 3      | 10        | 10000  |
| 4      | 10        | 12000  |
| 5      | 20        | 9000   |

## 期望输出

| depart_id | avg_salary |
|-----------|------------|
| 10        | 9000.00    |

**去掉6000和12000，剩余(8000+10000)/2=9000**

## 参考SQL

```sql
SELECT depart_id, ROUND(AVG(salary), 2) AS avg_salary
FROM (
  SELECT *,
    ROW_NUMBER() OVER(PARTITION BY depart_id ORDER BY salary) AS rn_asc,
    ROW_NUMBER() OVER(PARTITION BY depart_id ORDER BY salary DESC) AS rn_desc,
    COUNT(*) OVER(PARTITION BY depart_id) AS cnt
  FROM t_salary
) t
WHERE cnt >= 3 AND rn_asc > 1 AND rn_desc > 1
GROUP BY depart_id;
```

**核心思路**：正反ROW_NUMBER→排除rn=1的最高最低→剩余求平均

## 题目描述

同一用户同一商户的连续订单（中间无其他商户）合并，时间取最早，金额求和。

## 表结构

```sql
CREATE TABLE t_user_pay (
  order_id    INT,
  user_id     INT,
  merchant_id INT,
  pay_time    DATETIME,
  pay_amt     DECIMAL(10,2)
);
```

## 示例数据

| order_id | user_id | merchant_id | pay_time            | pay_amt |
|----------|---------|-------------|---------------------|---------|
| 1        | 100     | M1          | 2024-01-01 10:00:00 | 50      |
| 2        | 100     | M1          | 2024-01-01 10:05:00 | 30      |
| 3        | 100     | M2          | 2024-01-01 11:00:00 | 80      |
| 4        | 100     | M1          | 2024-01-01 12:00:00 | 60      |

## 期望输出

| user_id | merchant_id | start_time          | total_amt |
|---------|-------------|---------------------|-----------|
| 100     | M1          | 2024-01-01 10:00:00 | 80.00     |
| 100     | M2          | 2024-01-01 11:00:00 | 80.00     |
| 100     | M1          | 2024-01-01 12:00:00 | 60.00     |

## 参考SQL

```sql
SELECT user_id, merchant_id,
       MIN(pay_time) AS start_time,
       SUM(pay_amt) AS total_amt
FROM (
  SELECT *, SUM(CASE WHEN merchant_id = prev_m THEN 0 ELSE 1 END)
    OVER(PARTITION BY user_id ORDER BY pay_time) AS grp
  FROM (
    SELECT *, LAG(merchant_id) OVER(PARTITION BY user_id ORDER BY pay_time) AS prev_m
    FROM t_user_pay
  ) t1
) t2
GROUP BY user_id, grp, merchant_id;
```

**核心思路**：LAG判断是否与上一条同商户→标记分组→分组聚合

## 题目描述

各省地级市GDP数据，从高到低累加，找出刚好超过各省GDP 40%的地市（含临界城市）。

## 表结构

```sql
CREATE TABLE t_city_gdp (
  province VARCHAR(20),
  city     VARCHAR(20),
  gdp      DECIMAL(12,2)
);
```

## 示例数据

| province | city | gdp   |
|----------|------|-------|
| 浙江     | 杭州 | 2400  |
| 浙江     | 宁波 | 2000  |
| 浙江     | 温州 | 1000  |
| 江苏     | 苏州 | 1900  |
| 江苏     | 南京 | 1400  |
| 江苏     | 无锡 | 1200  |

## 期望输出

| province | city | gdp  | cumulative_pct |
|----------|------|------|----------------|
| 浙江     | 杭州 | 2400 | 44.4%          |
| 浙江     | 宁波 | 2000 | 81.5%          |
| 江苏     | 苏州 | 1900 | 42.2%          |
| 江苏     | 南京 | 1400 | 73.3%          |
| 江苏     | 无锡 | 1200 | 100.0%         |

**浙江GDP=5400，40%=2160，杭州2400已超→杭州入选**
**江苏GDP=4500，40%=1800，苏州1900已超→苏州入选，后续全部入选**

## 参考SQL

```sql
WITH total AS (
  SELECT province, SUM(gdp) AS tot FROM t_city_gdp GROUP BY province
),
cum AS (
  SELECT c.province, c.city, c.gdp,
    SUM(c.gdp) OVER(PARTITION BY c.province ORDER BY c.gdp DESC) AS cum_gdp,
    t.tot
  FROM t_city_gdp c JOIN total t USING(province)
)
SELECT province, city, gdp,
  ROUND(cum_gdp / tot * 100, 1) AS cumulative_pct
FROM cum
WHERE cum_gdp - gdp < tot * 0.4;
```

**核心思路**：窗口SUM累计，cum_gdp - gdp < 40% 表示加上本行后首次超过40%

## 题目描述

用户登录日志表记录每个用户登录的IP地址，查询共同使用过3个及以上IP的用户对。

## 表结构

```sql
CREATE TABLE t_user_ip (
  user_id   INT,
  ip_addr   VARCHAR(20),
  login_time DATETIME
);
```

## 示例数据

| user_id | ip_addr     | login_time          |
|---------|-------------|---------------------|
| 1       | 192.168.1.1 | 2024-01-01 08:00:00 |
| 1       | 192.168.1.2 | 2024-01-01 09:00:00 |
| 1       | 192.168.1.3 | 2024-01-01 10:00:00 |
| 2       | 192.168.1.1 | 2024-01-01 08:30:00 |
| 2       | 192.168.1.2 | 2024-01-01 09:30:00 |
| 2       | 192.168.1.3 | 2024-01-01 10:30:00 |
| 3       | 192.168.1.1 | 2024-01-01 11:00:00 |

## 期望输出

| user_a | user_b | shared_ips |
|--------|--------|------------|
| 1      | 2      | 3          |

## 参考SQL

```sql
SELECT a.user_id AS user_a, b.user_id AS user_b, COUNT(DISTINCT a.ip_addr) AS shared_ips
FROM t_user_ip a
JOIN t_user_ip b ON a.ip_addr = b.ip_addr AND a.user_id < b.user_id
GROUP BY a.user_id, b.user_id
HAVING COUNT(DISTINCT a.ip_addr) >= 3;
```

**核心思路**：自连接同一IP的不同用户 → GROUP BY用户对 → HAVING过滤共享IP数>=3

## 题目描述

营销活动记录表，统计每个品牌的总营销天数。重叠日期只算一次，不连续日期不补。

## 表结构

```sql
CREATE TABLE t_brand_campaign (
  brand_id   INT,
  campaign_id INT,
  start_date DATE,
  end_date   DATE
);
```

## 示例数据

| brand_id | campaign_id | start_date | end_date   |
|----------|-------------|------------|------------|
| 1        | 101         | 2024-01-01 | 2024-01-05 |
| 1        | 102         | 2024-01-04 | 2024-01-08 |
| 1        | 103         | 2024-01-15 | 2024-01-20 |
| 2        | 201         | 2024-01-01 | 2024-01-03 |

## 期望输出

| brand_id | total_days |
|----------|------------|
| 1        | 13         |
| 2        | 3          |

**品牌1：01-01~01-08共8天 + 01-15~01-20共6天 = 14天。去重后01-01~01-08(8)+01-15~01-20(6)=14? 不，01-01到01-08是8天，01-15到01-20是6天，共14天**

## 参考SQL

```sql
SELECT brand_id, SUM(DATEDIFF(merged_end, merged_start) + 1) AS total_days
FROM (
  SELECT brand_id,
    MIN(start_date) AS merged_start,
    MAX(end_date) AS merged_end
  FROM (
    SELECT *,
      SUM(CASE WHEN start_date <= prev_end THEN 0 ELSE 1 END)
        OVER(PARTITION BY brand_id ORDER BY start_date) AS grp
    FROM (
      SELECT *,
        MAX(end_date) OVER(PARTITION BY brand_id ORDER BY start_date
          ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING) AS prev_end
      FROM t_brand_campaign
    ) t1
  ) t2
  GROUP BY brand_id, grp
) t3
GROUP BY brand_id;
```

**核心思路**：先合并重叠区间→DATEDIFF计算每段天数→SUM求总

## 题目描述

购买表和收藏表，分类用户商品行为：购买未收藏、收藏未购买、购买且收藏。

## 表结构

```sql
CREATE TABLE t_order (
  user_id  INT,
  goods_id INT,
  order_time DATETIME
);
CREATE TABLE t_collect (
  user_id    INT,
  goods_id   INT,
  collect_time DATETIME
);
```

## 示例数据

**t_order:**

| user_id | goods_id | order_time          |
|---------|----------|---------------------|
| 1       | 100      | 2024-01-01 10:00:00 |
| 1       | 200      | 2024-01-02 10:00:00 |
| 2       | 100      | 2024-01-01 11:00:00 |

**t_collect:**

| user_id | goods_id | collect_time        |
|---------|----------|---------------------|
| 1       | 100      | 2024-01-01 09:00:00 |
| 1       | 300      | 2024-01-03 09:00:00 |
| 2       | 200      | 2024-01-01 09:00:00 |

## 期望输出

| user_id | goods_id | behavior |
|---------|----------|----------|
| 1       | 100      | 购买且收藏 |
| 1       | 200      | 购买未收藏 |
| 1       | 300      | 收藏未购买 |
| 2       | 100      | 购买未收藏 |
| 2       | 200      | 收藏未购买 |

## 参考SQL

```sql
SELECT user_id, goods_id,
  CASE WHEN has_order = 1 AND has_collect = 1 THEN '购买且收藏'
       WHEN has_order = 1 THEN '购买未收藏'
       WHEN has_collect = 1 THEN '收藏未购买'
  END AS behavior
FROM (
  SELECT COALESCE(o.user_id, c.user_id) AS user_id,
    COALESCE(o.goods_id, c.goods_id) AS goods_id,
    CASE WHEN o.user_id IS NOT NULL THEN 1 ELSE 0 END AS has_order,
    CASE WHEN c.user_id IS NOT NULL THEN 1 ELSE 0 END AS has_collect
  FROM (SELECT DISTINCT user_id, goods_id FROM t_order) o
  FULL OUTER JOIN (SELECT DISTINCT user_id, goods_id FROM t_collect) c
    ON o.user_id = c.user_id AND o.goods_id = c.goods_id
) t;
```

**核心思路**：FULL OUTER JOIN两表 → CASE WHEN分类

## 题目描述

用户访问记录表，访问间隔<60秒视为同一次浏览，合并用户浏览会话。

## 表结构

```sql
CREATE TABLE t_page_view (
  user_id    INT,
  view_time  DATETIME,
  page_url   VARCHAR(200)
);
```

## 示例数据

| user_id | view_time           | page_url |
|---------|---------------------|----------|
| 1       | 2024-01-01 10:00:00 | /home    |
| 1       | 2024-01-01 10:00:30 | /product |
| 1       | 2024-01-01 10:01:00 | /cart    |
| 1       | 2024-01-01 10:05:00 | /home    |
| 2       | 2024-01-01 11:00:00 | /home    |

## 期望输出

| user_id | session_id | session_start       | session_end         | pages |
|---------|------------|---------------------|---------------------|-------|
| 1       | 1          | 2024-01-01 10:00:00 | 2024-01-01 10:01:00 | 3     |
| 1       | 2          | 2024-01-01 10:05:00 | 2024-01-01 10:05:00 | 1     |
| 2       | 1          | 2024-01-01 11:00:00 | 2024-01-01 11:00:00 | 1     |

## 参考SQL

```sql
SELECT user_id, grp AS session_id,
  MIN(view_time) AS session_start,
  MAX(view_time) AS session_end,
  COUNT(*) AS pages
FROM (
  SELECT *, SUM(is_new) OVER(PARTITION BY user_id ORDER BY view_time) AS grp
  FROM (
    SELECT *, CASE WHEN TIMESTAMPDIFF(SECOND, prev_time, view_time) >= 60 OR prev_time IS NULL THEN 1 ELSE 0 END AS is_new
    FROM (
      SELECT *, LAG(view_time) OVER(PARTITION BY user_id ORDER BY view_time) AS prev_time
      FROM t_page_view
    ) t1
  ) t2
) t3
GROUP BY user_id, grp
ORDER BY user_id, session_id;
```

**核心思路**：LAG算时间差→标记新会话起点→累计求和生成session_id→分组聚合

## 题目描述

股票价格表，找出连续5天以上每天涨幅>5%的股票，给出连续天数及起止日期。

## 表结构

```sql
CREATE TABLE t_stock (
  stock_code    VARCHAR(10),
  trade_date    DATE,
  closing_price DECIMAL(10,2)
);
```

## 示例数据

| stock_code | trade_date  | closing_price |
|------------|-------------|---------------|
| A          | 2024-01-01  | 100.00        |
| A          | 2024-01-02  | 108.00        |
| A          | 2024-01-03  | 116.00        |
| A          | 2024-01-04  | 125.00        |
| A          | 2024-01-05  | 135.00        |
| A          | 2024-01-06  | 140.00        |
| B          | 2024-01-01  | 50.00         |
| B          | 2024-01-02  | 53.00         |
| B          | 2024-01-03  | 49.00         |

## 期望输出

| stock_code | start_date | end_date   | days |
|------------|------------|------------|------|
| A          | 2024-01-02 | 2024-01-06 | 5    |

## 参考SQL

```sql
WITH daily_chg AS (
  SELECT *, CASE WHEN closing_price / LAG(closing_price) OVER(PARTITION BY stock_code ORDER BY trade_date) > 1.05 THEN 1 ELSE 0 END AS is_up
  FROM t_stock
),
grp AS (
  SELECT *, SUM(CASE WHEN is_up = 1 THEN 0 ELSE 1 END) OVER(PARTITION BY stock_code ORDER BY trade_date) AS gid
  FROM daily_chg
)
SELECT stock_code, MIN(trade_date) AS start_date, MAX(trade_date) AS end_date, COUNT(*) AS days
FROM grp WHERE is_up = 1
GROUP BY stock_code, gid
HAVING COUNT(*) >= 5;
```

**核心思路**：计算日涨幅→标记是否>5%→连续分组→HAVING过滤

存储过程就像我们编程语言中的函数一样，封装了我们的代码(PLSQL、T-SQL)。 上面的文字我们肯定是看不懂的，也不愿意看下去的。接下来我就总结一下： 学生信息组成学生信息表，有年龄、性别、学号等信息组成。这些字段都不可再分，所以它是满足第一范式的 第二范式：满足第一范式,表…

例如上述 Employee 表，n = 2 时，应返回第二高的薪水 200。如果不存在第 n 高的薪水，那么查询应返回 null。 编写一个 SQL 查询来实现分数排名。如果两个分数相同，则两个分数排名（Rank）相同。请注意，平分后的下一个名次应该是下一个连续的整数值。换句话…

使用group by的sql语句，select后的字段只能是group by后的字段，如果需要展示其他字段数据，需要给该列使用聚合函数，否则默认展示分组后的第一行数据。 左连接：左表的记录将会全部表示出来，而右表只会显示符合搜索条件的记录。右表记录不足的地方均为NULL（用户信…

SQL（结构化查询语言）是一种设计用于检索和操作数据的数据库。它属于美国国家标准协会（ANSI）的一种标准，可用于执行Select（选择）、Update（更新）、Delete（删除）和Insert（插入）等数据任务。 表是在具有列和行的模型中设计的数据集合。在表中，指定了列数称…

😊：“读题，入职时候的薪水，加上提示一个员工有多次涨薪的情况，所以本质上是求解每个员工的最低薪水，还要按照emp_no降序排列。阿，求每个员工的薪水最小值，用group by就可以实现，要输出的字段在salaries这张表中都有，所以别看他给了2张表，只需要1张表就能算出结果。1...

Sql常用语法下列语句部分是Mssql语句，不可以在access中使用。 SQL分类： DDL—数据定义语言(CREATE，ALTER，DROP，DECLARE) DML—数据操纵语言(SELECT，

1/连续最长登陆天数 2/下一次登陆时间距离上一次登陆时间大于30天时，从1开始计数 3/一张包含全国各城市用户的观看记录表view_info（表中一条数据代表一次观看记录），包含city_name、

MySQL支持诸多存储引擎，而各种存储引擎对索引的支持也各不相同，因此MySQL数据库支持多种索引类型，如BTree索引，哈希索引，全文索引等等。为了避免混乱，本文将只关注于BTree索引，因为这是平常使用MySQL时主要打交道的索引。 MySQL官方对索引的定义为：索引（In…

面试官：要不你来讲讲你们对MySQL是怎么调优的？ 候选者：哇，这命题很大阿…我认为，对于开发者而言，对MySQL的调优重点一般是在「开发规范」、「数据库索引」又或者说解决线上慢查询上。 候选者：而对

这天我正在午休呢，公司DBA就把我喊醒了，说某库出现大量慢SQL，很快啊，很快，我还没反应过来，库就挂了，我心想现在的用户不讲武德啊，怎么在我睡觉的时候大量请求呢。 这是很常见的一个场景哈，因为很多业务开始数据量级不大，所以写sql的时候就没注意性能，等量级上去，很多业务就需要…

敖丙：加索引。 敖丙：没了。 哈哈开头这个场景是我臆想的一个面试场景，但是大家是不是觉得很真实，每个人的简历上但凡写到了数据库，都会在后面顺便写一句，会数据库调优。 我觉得调优能回答的点还是很多很多的，我自己看了《MySQL实战》、《高性能MySQL》、《丁奇MySQL47讲》…

一、前言 上一篇我们说了 腾讯一面：说一说 MySQL 中索引的底层原理，相信你对索引有个很清晰的认识了，这一篇我们来说一说慢 SQL 的排查以及调优。为啥面试官要问这个问题，其实跟上一篇的索引底层原

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

大家好，我是 V 哥。SQL调优对于提升数据库查询性能至关重要，特别是当数据量大时。以下是20个详细的SQL调优指南和高级技巧，结合案例说明，帮助优化SQL查询的性能。 1. 选择合适的索引 技巧: 

一次线上慢SQL调优分享 一周前，客户反馈做题页面经常卡顿，加载慢；我们监控比较少，所以根据直觉去MySQL慢查询日志一看，果然是一条慢SQL。废话不多，开整！！！ 业务背景 一个在线做题的代码评测系

作为开发人员，我们免不了与sql打交道。有些sql可能在业务的最开始，执行是毫无问题的。但是随着业务量的提升以及业务复杂度的加深，可能之前的sql就会逐渐展现出疲惫之势了。这时就会面临sql调优。 那么调优到底如何调？不同的人有不同的姿势。可能大部分人首先想到的就是加索引。 没…

order by字段尽量走索引... 其中有些手段也许跟随者MySQL版本的升级过时了。我们真的需要背这些调优手段吗？我觉得是没有必要的，在掌握MySQL存储架构和SQL执行原理的情况下，我们就很自然的明白，为什么要提议这么优化了，甚至能够发现别人提的不太合理的优化手段。 在 …

背景 基于TPCDS的100G，500G数据进行了99SQL综合调优测试 测试机为物理机5台，1台为管理节点，4台为计算节点 可用内存约1T，核心数（vCore）200大概 重要参数 执行器个数 --

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第3天，点击查看活动详情 1.写在前面 在昨天的时候，我们就谈到了数据库连接池优化 详情可参考这里：点击查看 经过昨天的分析，我们已

面试官：MySQL如何进行性能调优？ 具体操作我这里整理了慢查询、explain、@@profiling关键字 慢查询 DBA有时候会发现有些语句比较慢，他们怎么发现的呢？ 编辑配置文件打开慢查询 然

在系统运行过程中，总会与数据库的交互，通过数据库端的日志查询执行时间最长与执行次数最多的sql语句，就可以有针对性的进行调优处理。 取执行时间最长的前50条sql语句。

引言 数据库性能优化是每个后端程序猿必备的基础技能之一，而Mysql中的explain堪称Mysql的性能优化分析神器，我们可以通过它来分析SQL语句的对应的执行计划在Mysql底层到底是如何执行的，

这几周系统访问量也是居高不下，不出意外系统又出现瓶颈了，大量用户反馈判题结果响应太慢；经排查，又是关于SQL的问题 业务背景 一个类似于力扣在线做题的代码评测模块，用户提交判题任务后，后台会进行异步判

什么是 SQL 调优？是不是觉得自己知道但又很模糊说不清楚，面试被问没有真实的案例，并不具备说服力。本文以为详细案例给大家解读。

之前曾经拜读过《收获，不止sql调优》一书，此书是国内DBA写的一本很不错的调优类型的书，是一些很不错的调优经验的分享。虽然读了一遍，做了下读书笔记，觉得很有所收获，但是到实际的实践中觉得还是很缺实践。刚好最近又有一次sql调优培训活动，去参加后，重新复习Oracle执行计划，…

Spark SQL是Spark生态系统中非常重要的组件， 能够利用 Spark 进行结构化的存储和操作。本文将围绕Spark内存泄露问题进行排查，并且给出具体的Spark调优方法。

Hive的架构 Hive元数据默认存储在derby数据库，不支持多客户端访问，所以将元数据存储在MySQl，支持多客户端访问。 2 Hive和e和数据库比较，Hive 和数据库除了拥有类似的查询语言，

1. hive 内部表和外部表的区别？ 未被external修饰的是内部表（managed table），被external修饰的为外部表（external table）； 内部表数据由Hive自身管

Hive SQL基本上适用大数据领域离线数据处理的大部分场景。Hive SQL的优化也是我们必须掌握的技能，而且，面试一定会问。那么，我希望面试者能答出其中的80%优化点，在这个问题上才算过关。 JVM重利用可以使得JOB长时间保留slot,直到作业结束，这在对于有较多任务和较…

第一题 需求 实现 数据准备 查询SQL 第二题 需求 实现 数据准备 查询SQL实现 第三题 需求 实现 数据准备 查询SQL 第四题 需求 实现 数据准备 查询SQL 第五题 需求 实现 数据准备

有用户点击日志记录表 t_click_log_025，包含user_id(用户ID),click_time(点击时间)，请查询出连续点击三次的用户数。