Posts on SERRINI — AI Engineer

精读Navigating the Digital World as Humans Do：UNIVERSAL VISUAL GROUNDING FOR GUI AGENTS

Fri, 02 Jan 2026 00:00:00 +0000

introduction

第一段：GUI agents的定义，与LLM的关系
第二段：参考人类感知数字世界的方式，GUI agent需要做的事，即感知+操作。
1. 对于感知，当前agent大多依赖于阅读html和ally tree，随着MLLM的发展，视觉感知变得可行。
  1. a11y树是一种紧凑但信息丰富的表示，旨在用于辅助技术，以方便残疾人
2. 对于操作，当前agent大多是通过选择html元素或labeled bounding boxes来操作，而不是基于图形界面进行像素级操作。
  1. 补充说了获取html元素或labeled bounding boxes需要文本的输入和用于检测的单独模型。
第三段：当前方案的局限性。
1. 基于文本的表示是嘈杂、不完整的。（相比之下，视觉输入只包含和用户相关的信息）
2. 解析html编码输入增加了延迟和推理成本，消耗token数比视觉编码多出10倍。（补充说了获取ally tree本身就很耗时，损害用户体验和实用性）
第四段：我们的工作关注的是：只有视觉感知和像素级操作的GUI agent能做到什么程序。
1. 再去介绍一下前人在这个方向上的尝试和瓶颈。grounding：(M)LLM生成的文本怎么映射到GUI上的精确位置。
2. GUI agent grounding model的要求：。
  1. 高准确性：grounding错误会整个任务失败
  2. 高概括性：应该是跨平台通用的
  3. 高灵活性：应该在不同的MLLM中即插即用，而不是与某个模型紧密耦合
3. 现在的GUI agent都不能满足以上三个要求。
第五段：介绍这项工作的主要贡献，做了那些事情（3方面）。
1. 论证+案例，结果是提出一个通用框架SeeAct-V，基于此框架构建的GUI agent，完全以视觉感知+像素级操作。
2. 一个简单的recipe，包含了网络数据和轻微调整后的[[LLaVA]]架构。使用整个recipe，构建并发布了迄今为止最大的GUI视觉基础数据集，包含了1000万个GUI元素和引用，超过130万个GUI截图。在这个数据集上训练和发布了通用视觉基础模型UGround。
3. 对GUI agent进行全面的评估和总结一下结果。
  1. 评估涵盖6大基准测试（3平台*3种任务类型）。“Figure 1”，这个图放在摘要下面。
    2. 前提：使用GPT-4作为planner
    3. GUI grounding（“♣: ScreenSpot)” ）、offline agent（“♠: Multimodal-Mind2Web, AndroidControl, and OmniACT” ）、online agent benchmarks（“♥: Mind2Web-Live and AndroidWorld” ）
  2. 结果是：
    1. UGround优于现有模型绝对值高达20%；
    2. 与额外使用文本输入的最先进agent相比，他们至少可以实现相当且通常更好的性能。

method

先放一个图，然后是三部分内容。

任务：找到最便宜的4k显示器。
Planning给出搜索栏在页面顶部，要搜索的是4k显示器。
Grounding给出用户需要的，搜索框的像素坐标，即（556，26）。
Human-Like Operation去对应的像素点输入”4k monitor”并执行click操作。

Overview：

他们采用流行的[[SeeAct]]框架，把他该进程仅对环境进行视觉观察+像素级操作，作为SeeAct-V。然后对比了一下原来的SeeAct和现在的SeeAct-V。
1. 原来的SeeAct：
  1. planning和grounding都由MLLM处理，每一步都是MLLM先生成文本计划，然后选择grounding元素（都需要html或ally tree作为额外输入）。
2. 现在的SeeAct-V：
  1. 仅输入屏幕截图，且grounding使用单独模型，由模型生成坐标。
引出需要一个强大的视觉基础模型。他们工作的主要技术贡献：一个recipe（包含data和modeling），用来训练此类通用视觉基础模型。

Data construction（简单的数据合成策略）

“⟨screenshot, referring expression, coordinates⟩” 三元组作为训练数据
1. 〈网页截图、指称表达（RE）、坐标〉
2. 使用元素的中心点坐标作为预期输出
数据合成完全基于网页，他认为在web data上训练的模型完全可以推广到桌面和移动UI（由于GUI设计的相似性）
1. 网页有结构化的数据，完整的html/dom
2. 网页还有可视化渲染，即截图
3. 浏览器能提供前两者的精细对应关系，即哪个html元素对应到截图里的哪个框

小标题：常见的RE类型（[[RE]] is “referring expressions” ）

前人的visual grounding works没有考虑多样性，所以他把RE分成三种类型。

视觉RE：视觉特征，如文本或图像的内容、形状、颜色
位置RE：包括绝对（页面的左上角）和相对（元素X的右侧）位置
功能RE：通过元件的功能指代元件，如导航至主页、前往我的购物车

小标题：来自Web的混合RE合成

翻译：提出一种混合合成的pipeline，为html元素生成不同的RE。（这里看不太懂），他把html属性及其可用属性输入到MLLM，并提示他生成不同的RE。这个过程产生将html属性与视觉特征相结合的复合RE或来自MLLM的新知识（如蓝鸟表示twitter）。还用到LLM使生成的RE更加简洁。

混合的意思是即有规则又有LLM/MLLM的自由生成。
步骤：
1. 步骤1：生成主描述
  1. 从html属性中抽取视觉和功能信息
  2. html属性可能不完整，用多模态大模型 LLaVA-NeXT-13B把截图和jhtml属性输入模型，提示生成REs
  3. 输出两类数据：
    1. 复合RE，能把html属性和视觉特征结合起来，如"空心爱心图标"
    2. 来自MLLM的新知识：如蓝鸟表示twitter，即使html没有这个信息
  4. 生成后用文本模型 Llama-3-8B-Instruct做精炼，让描述更简洁
  5. 随机选择之前两类数据中的一个，作为元素的主描述
2. 步骤2：Positional Expressions（位置描述）
  1. 规则生成位置类RE，如”在页面顶部“，“在A和B之间”
  2. 规则生成语境类RE：
    1. 先识别控件类型，是单选框、复选框、输入框等
    2. 再根据DOM树层级，lable和input的关联，生成有语境的表达，如“标注为birthday的输入框”
3. 数据来源和标注：
  1. 从[[Common Crawl]]汇集网页截图（横竖屏混合、不同分辨率）和元素元数据

小标题：补充数据

之前有多个为Android构建基础数据的操作，所以他们合并了现有的数据集。还用GPT-4o来直接合成一小部分用于Web元素的RE

总结一下：

一个总计10M（1000万）个UI元素的数据集，其中90%来自混合合成管道。同一屏幕截图上的元素被批量处理以加速训练。

Model design

翻译：
1. 采用开源模型架构：[[7B LLaVA-NeXT]]：视觉编码器+轻量投影+7B语言模型
2. 输入输出公式：
  1. 任务统一成问答式指令：在这张截图中，描述{Description}对应的像素坐标是什么？
  2. 模型回答的是自然语言，但内容是精确的像素坐标
3. Image Resolution：
  1. 挑战：
    1. GUI截图比自然图像大得多，早期LLaVA是为336px图像构建的，后来通过AnyRes技术放大到最多772px。然后介绍了AnyRes技术。
      1. 把大图像拆分成小切片，
      2. 用vision encoder独立编码每个切片，
      3. 每一行切片末尾添加token，帮助语言模型知道图像的“行”边界。所以AnyRes允许轻松扩展输入分辨率。但切片越多，训练/推理越慢。
  2. 他们的做法：
    1. 他们把允许的切片数量上限设为36个ViT切片
    2. 使用CLIP@224px作为image encoder来拆分，支持的最大分辨率达到
      1. 1,344 × 1,344 (landscape)
      2. 896 × 2,016 (portrait)
    3. 语言模型使用Vicuna-1.5-7b-16k，支持16K上下文长度，处理长视觉上下文。
    4. 常见的AnyRes会把“一张低分辨率的整图”与“高分辨率切片”融合，以提供全局语境。他们实测在 GUI 场景中，这个低分辨率整图（224px）几乎不提供有用的全局信息（小字和细控件看不清），还增加开销，因此干脆不使用该融合模块。
总结：这一段主要说怎么把开源多模态模型框架改造成专门做GUI视觉定位的模型。他们用 LLaVA‑NeXT 7B 做 GUI 定位，把回答统一为自然语言里的“像素坐标”，通过 AnyRes 式的切片（最多 36 个、每块 224px）把大分辨率截图拆分编码，并用长上下文的 Vicuna 语言模型处理大量视觉token；同时剔除了低分辨率整图的融合，因为在 GUI 中对全局理解帮助不大。

experiments

先是一段总结（对比一般的研究是一两个基准的评估，他们更全面，用了6个基准），然后分5段。
三种评估：
1. GUI视觉Grounding评估
  1. UGround视觉定位模型，能否把自然语言描述准确的落到截图的坐标上
  2. 感知能力评估，关注定位精度
2. 缓存环境状态的离线代理评估
  1. 使用预先记录或缓存的截图与界面状态，不与真实环境交互
  2. 不包含真实交互的不确定性，如网络延迟、弹窗等
3. 实时环境中的在线代理评估。
  1. 评估端到端的成功率，更真实
分两步，先看UGround的定位是否准，再看集成到他们的完整代理框架SeeAct-V后，端到端代理能否完成任务。

GUI VISUAL GROUNDING

ScreenSpot基准上评估UGround。这个基准测试专门为visual grounding on GUIs设计的。
1. 1272个单步指令和目标元素的边界框（跨平台的）。
2. 元素分类：基于文本的元素、图标（比如垃圾桶图标）、小部件（比如todo list）
评估基于两种settings：
1. standard setting：
  1. ScreenSpot的标准设置，instruction是人写的，主要关注功能。比如一个叉叉表示关闭窗口的意思。
  2. 专注模型能否根据功能性描述准确定位到对应的界面元素。
2. agent setting：
  1. 把每个ScreenSpot示例输入到MLLM，要求为目标元素生成不同的RE。
对比模型
1. UGround主要和SeeClick（ScreenSpot上最先进的视觉模型）（SOTA is state of the art）和CogAgent对比。
2. 还有GPT-4、GPT-4o，展示通用模型在GUI grounding上的难度。
结果：两个表。
1. 在ScreenSpot基准上，UGround表现很好。两种settings都提升很多。尽管从未在桌面UI上训练，但在桌面UI上表现突出。在图标和小部件上表现尤其出色。

OFFLINE AGENT EVALUATION

总体思路：用事先缓存好的环境状态和金标准轨迹来评测代理。
分Web/Mobile/Desktop。
1. Web：
  1. Mind2Web的多模态扩展：Multimodal-Mind2Web，用来评估web task。
    1. 测试集有1013个task，覆盖100+website。
      1. 每个task提供高层指令、逐步动作序列，以及每步动作前的网页截图，所有沿着金标准轨迹的网页都已缓存，便于离线评测。
    2. 使用元素准确率作为指标
    3. 对比Grounding的基线策略：都依赖文本或结构表示
      1. 基于html的Choice：先用html过滤出候选元素，再让规划模型从中选择
      2. SoM策略（Set-of-Mark）：在截图上覆盖标签编号，再让规划模型从标签中选
  2. 结论：
    1. SeeAct-V仅使用视觉输入，元素准确率由于所有依赖html的基线方法
2. Mobile：
  1. 使用AndroidControl数据集
    1. 833个App上的15K个任务
    2. 高级/低级两种任务
      1. 高级任务只给意图
      2. 低级任务给意图+每步对应的低层具体指令
    3. 使用逐步准确率作为指标
    4. 对比基线
      1. 基于ally树的M3A文本变体：用 GPT-4 生成文本动作并从 a11y 树中选择元素（Choice 式选择）。
  2. 结论：
    1. 高级/低级任务中都优于文本基线方法
    2. 低级任务中表现尤其出色
3. Desktop：
  1. OmniACT
    1. 38个桌面应用和27个网站的9802个任务，跨操作系统
    2. 使用动作分数作为指标
    3. 对比基线
      1. DetACT方法：
        
        通过OCR、图标匹配和颜色检测提取UI元素和坐标
        
        按任务相关性过滤
        
        再交给LLM/MLLM生成含有正确坐标的PyAutoGUI脚本
    4. 他们的方法（SeeAct-V+UGround）：
      1. 只用原始截图作为输入，不用OCR/HTML/ally树等
      2. 让MLLM先生成元素描述，再用UGround把描述转化成坐标，最后填入PyAutoGUI脚本
      3. 为了公平，严格复用DetACT的提示词和检索策略
  2. 结论：
    1. 动作分数上优于DetACT
    2. 证明了仅凭视觉输入可以处理复杂桌面应用

ONLINE AGENT EVALUATION

在真实环境中评估，成本较高，只使用UGround作为grouding模块。
Web：Mind2Web-Live
1. 基于Mind2Web添加功能评估
2. 对比基线：
  1. 来自Pan et al. (2024) is text-only，主要基于 HTML 结构感知和交互，一次处理上百个 HTML 元素。
3. 关键机制：
  1. 为每个任务标注关键节点（key nodes）。无论代理采取何种路径，只要完成这些关键节点就可判定任务进展或成功。
4. 指标：
  1. 微完成率（micro completion rate）：跨所有任务计算，完成的关键节点占比。
  2. 任务成功率（task success rate）：完全完成所有关键节点的任务比例。
5. 结论：
  1. 微观完成率和任务成功率达到或优于使用html元素的基线
  2. 证明视觉输入足以完成实际的Web任务
Mobile：AndroidWorld
1. 20个应用中的116个任务
2. 使用任务成功率作为指标
3. 对比基线：SOTA 代理M3A及其SoM变体，Rawles et al. (2024)
  1. M3A 接收“原始截图 + SoM 标注图 + 文本化的 UI 元素”，或仅“文本化 UI 元素”（文本-only 版）作为观察。
  2. 决策方式：采用 ReAct 风格推理，从 UI 元素列表中选择下一目标元素；并加入自反（self-reflection）来总结当前动作、提升后续决策。
  3. SoM（Set-of-Mark）：在截图上叠加编号标记，方便模型从标记里选元素。
4. 结论：
  1. 任务成功率优于M3A的SoM变体
  2. 尽管AndroidUI通常更适合SoM方法，但视觉输入仍表现出色

ERROR ANALYSIS

对失败案例分析，结论是规划错误是主要的失败原因（60%-70%），并不是grounding错误，表示UGround的grounding能力很强。
常见的规划错误：生成错误元素的描述、产生不存在的元素、过于模糊的描述。
grounding错误主要源于长尾图标的特殊语义，难以捕捉。比如特定应用中的自定义图标。
在实际agent任务中，由于头部元素（？）占主导，UGround表现相对稳健。

conclusions and limitations

结论：

GUI agent框架 SeeAct-V
1. GUI agent应该完全通过视觉感知+像素级操作，而非依赖html和ally树等文本表示。
2. 框架设计上：
  1. 模块化架构：分离规划和视觉定位。通过MLLM生成文本计划作为规划，再用专用模型生成坐标作为视觉定位。灵活可扩展。
  2. 纯视觉输入：仅使用截图作为环境感知，消除文本表示的噪声、不完整和计算开销。
构建通用视觉定位模型UGround
1. 数据创新：
  1. Web-Hybrid，网页合成数据，生成最大规模的GUI视觉定位数据集（1300万张截图，1000万UI元素）。覆盖多样化的指代表达式REs。（视觉、位置、功能REs）
  2. 融合现有的Android数据集和GPT-4生成的开放性REs。
2. 模型创新：
  1. 基于LLaVA-NeXT-7B架构，适配高分辨率输入（最高1344*1344）
  2. 输出格式：直接生成像素坐标
多平台实验验证
1. 视觉定位任务：
  1. UGround在标准设置和代理设置下均显著超越SOTA模型（如SeeClick），平均提升20%-29%。
  2. 跨平台泛化：在桌面端（未训练数据）和移动端均表现优异，尤其擅长图标和小部件定位。
  3. 端到端代理任务：
    1. 离线评估（Web/Mobile/Desktop）：
      1. SeeAct-V在Multimodal-Mind2Web、AndroidControl、OmniACT上均优于依赖文本输入的SOTA方法。
    2. 在线评估（Mind2Web-Live/AndroidWorld）：
      1. 任务成功率与基线相当或更高，证明视觉代理的实用性。

局限

数据效率问题
- 训练数据基于网页合成，存在元素重复率高的问题（如常见按钮/链接）。未来可通过数据去重和分组提升训练效率。
长尾语义泛化不足
1. 模型难以捕捉长尾图标的特殊语义（如应用特有的自定义图标），导致部分定位错误。
2. 解决方向：需结合文档学习或针对性探索长尾元素。
桌面UI数据稀缺
1. UGround未在桌面UI数据上训练，虽实验显示跨平台泛化能力，但桌面UI（如macOS/Windows）的特定设计仍需更多数据支持。
模块化设计的定位
1. UGround是专用定位模块，需依赖外部规划器（如MLLM）生成计划。未来可探索端到端模型，但需解决训练数据获取成本高的问题。

未来工作方向

提升数据质量与效率
1. 开发更智能的数据去重策略，减少合成数据的冗余。
解决长尾问题
1. 结合领域知识或用户反馈增强模型对特殊图标的理解。
构建桌面UI数据集
1. 收集多样化桌面环境数据，提升模型在桌面任务中的鲁棒性。
推动端到端模型发展
1. 探索将定位能力整合到单一模型中，但需平衡训练成本与效果。

关键意义

实践价值：SeeAct-V证明了纯视觉代理的可行性，为跨平台GUI自动化提供新范式。
理论贡献：强调模块化设计在复杂环境中的优势，定位模块可独立优化并适配不同规划器。
数据资源：公开最大规模GUI视觉定位数据集和模型（[GitHub链接]），推动领域发展。

精读SeeClick：Harnessing GUI Grounding for Advanced Visual GUI Agents

Fri, 02 Jan 2026 00:00:00 +0000

背景：现有GUI agent都是通过提取的结构化数据（html等）与环境交互。

研究方法：纯视觉方案（仅依赖截图）的SeekClick。

关键挑战：GUI grounding（接地）：根据指令准确定位屏幕元素的能力。

提出：通过基础预训练来增强SeeClick，并设计一种自动化图形界面用户基础数据管理的方法。创建跨平台，首创的，真实的，GUI grouding benchmark。

结论：通过预训练后，SeekClick在不同基线上展示了ScreenSpot的显著改进。

Introduction

GUI agent现在的发展：Siri和Copilot（GPT-4的发展）
依赖结构化文本的限制：
1. 不可访问；
2. 冗长导致llm的低效上下文，还会忽略布局等信息；
3. 多结构文本需要对特定任务做特定处理。
介绍SeekClick，基于LVLMs（Large Vision-Language Models）。引出挑战：GUI grounding，根据指令准确定位屏幕元素的能力。通过预训练策略增强了LVLM。设计了一种方法来获取基础数据。SeeClick使用上述精心策划的数据集对LVLM进行持续预训练，使其能够在各种图形界面环境中准确定位文本、小部件和图标等元素。
介绍SreenSpot。ScreenSpot包含来自iOS、Android、macOS、Windows和网页的600多个屏幕截图和1200条指令，特别包括基于文本的元素以及各种小部件和图标。评估结果证实了SeeClick相对于当前LVLM的优越性，验证了图形用户界面接地预训练的有效性。
SeeClick超越了强大的视觉基线Pix2Act，同时仅利用了0.3%的训练数据。此外，这三个基准的实验结果一致支持我们的发现，即图形用户界面基础的改善与增强的代理任务性能直接相关。
主要贡献有四点：
1. SeekClick
2. 探索GUI grounding，通过提出的预训练策略增强SeekClick
3. 创建benchmark ScreenSpot
4. GUI grounding能力是提高下游代理任务性能的管理

第一段：

早期研究：

受限场景下的自动化，web自动化和移动自动化
依赖结构化数据

LLM驱动的范式转变

利用LLM的规划与推理能力，将GUI交互转化成文本理解+动作生成流程。
工作贡献：
1. Web任务：WebGUM、AgentGPT
2. 跨平台：CogAgent、Mind2Web
关键依赖：
1. 输入：HTML、DOM、Android VH等结构化文本
2. 输出：基于文本标签的动作（如点击 <button id> =”submit”）

第二段（LVLMs）：

最近的研究在于构建LVLM，通过connecting layers将视觉编码器（vision encoders）与LLM集成，集成LLM的语言和推理能力。
很多研究专注于定位（grounding），提供响应的时候提供边界框。但这些都针对的自然图像。

Approach（方法）

GUI grounding for LVLMs

如何训练LVLM进行语言生成。
给定截图s和元素集合。Xi表示第i个元素的文本描述，Yi表示元素的位置（边界框或点）。LVLM基于s和X，来预测元素Y的位置。
LVLM生成的是语言格式，怎么来预测数字坐标？
1. 之前的研究把图片分成1000个bins，然后创建一个1000token词汇表来表示x和y的坐标。
2. 我们采用LVLM中更直观的方式，将数值视为自然语言，无需额外标记、预处理或后处理。
3. 例子：一个截图和一个指令描述“查看Jony J的新专辑”，构造了一个查询prompt：“在UI中，我想做<指令>，应该点哪里”。
4. 然后计算模型输出和ground truth（click(0.49, 0.40)）之间的cross-entropy loss，交叉熵损失，来优化LVLM。

Data Construction（数据建设）

通过三个数据集合训练SeekClick

Web数据
1. 从Common Crawl库收集30万个网页，作为Web UI训练数据。每个网页收集两种数据：1）显示可见文本内容的元素；2）具有title属性的元素（悬停时能显示文本）。
2. 两个任务，%% 一个是基于s和x预测坐标y %%，还有基于s和坐标y预测文本描述x。
Mobile数据分三种类型
1. widget captioning（小部件字幕，比如播放按钮上的描述“播放音乐”）、mobile UI grounding、mobile UI summarization

Training Details

在QWen-VL（Bai等人，2023）的基础上预训练，构建了SeekClick。QWEN-VL本身具有接地能力和448*448的分辨率。
在构建的数据集上训练QWen-VL有10k steps（around 1 epoch），来获得SeekClick。
应用了LoRA去微调visual encoder和LLM。细节在附录A中。

ScreenSpot: A Grounding Benchmark

早期的LVLM能力受限所以关注有限，缺乏研究，主要是2017年的，Android dataset。
填补研究空白，引入ScreenSpot。
1. 跨平台的：移动（iOS、Android）；桌面（macOS、Windows）和Web。
2. 图标/小工具：每个GUI中都有大量的图标和小部件。
ScreenSpot确保样本新颖且不包含在现有的训练资源中。

Exprements

大体分为三部分：

VLM和我们的SeekClick的定位能力。
然后SeekClick适应mobile&web的代理任务，分析高级定位能力和下游任务性能之间的相关性
探索了基于纯视觉的GUI agent的潜力。

GUI Grounding on ScreenSpot

Compared LVLMs & Evaluation

两种LVLM：
1. 能执行对话、识别和定位等通用任务的LVLM：MiniGPT-v2（Chen等人，2023 a）、Qwen-BL（Bai等人，2023年）和GPT-4V
2. 最近发布的专门为GUI任务设计的LVLM：Fuyu（Bavishi等人，2023年）和CogAgent（Hong等人，2023年）
以点击准确度作为指标，指标定义为模型预测位置落在真实元素边界框中的测试样本的比例。
结果：每一列中最好的结果加粗表示。
1. SeekClick参数量比CogAgent少
2. SeekClick在Desktop和Web表现比CogAgent差一点，可能是分辨率较低和训练数据小得多。
3. 所有模型都难以定位Icon/Widget。

Visual GUI Agent Tasks

MiniWob
1. 数据准备：
  1. MiniWob数据缺乏截图，先通过LLM为每个任务生成50个成功轨迹（？），创建一个仅含2.8k个样本的小型训练集。
2. 对比基线：
  1. WebGUM（SOTA）：html+截图的混合方法，当时最先进的离线训练模型
  2. Pix2Act（视觉SOTA）：之前的纯视觉方法，但需要大量训练数据
  3. Qwen-VL（LVLM基线）：与seekclick底层模型相同的版本，但未经过GUI定位训练
3. 实验结果：
  1. SeekClick仅用0.3%的Pix2Act训练数据，就超越Pix2Act
  2. 同等数据量下，SeekClick还是超过了WebGUM
  3. SeekClick比基线模型QWen-VL高出近20%，证明了GUI定位预训练是提升性能的关键
AITW
1. AITW是Android自动化数据集，Android in the wild，来评估智能手机环境中的SeekClick。每个样本包含一条指令和一条带有截图的动作轨迹（？）介绍AITW。
2. 提出一个问题：
  1. 现有的训练-测试划分有显著的过拟合风险，导致实验结果不能反映代理在真实世界的泛化能力。导致SeekClick的性能和CogAgent相当。
  2. AITW数据集的问题？，同一条指令的不同变体会同时出现在训练集和测试集中，导致模型可能只是记忆了某些指令的步骤。
3. 解决方案：
  1. 以指令为单位重新划分训练集/验证集/测试集。
  2. 从AITW的5个子集中分别选择545/688/306/700/700条指令，并为每条指令仅保留一个标注片段。这些指令的80%用于训练，剩余20%用于测试，并从原始数据中额外选择5*100个片段构成验证集。
4. 结果：SeeClick在基于API的LLM和经过训练的LVLM中实现了最好的平均性能。SeeClick的点击准确性比Qwen-BL提高了9%。
Mind2Web
1. Mind2Web是从137个真实网站收集来的2000多个开放性任务。
2. 方法：
  1. 传统是代理从html结构中选择可操作的元素；SeekClick首次尝试仅以来截图+点击坐标，不看html。
  2. 元素准确率（Ele.Acc），点击精度（Op.F1），步骤成功率（Step SR）
3. 结果：
  1. SeekClick在多维度（操作准确率、点击精度、步骤成功率）均显著优于QWen-VL
  2. 下划线是SeekClick over LVLM的部分，几乎是翻倍的。
Grounding and Agent Performance
1. 分析了几个ScreenSpot上的几个SeekClick的检查点和三个下游任务的平均得分改进。
2. 结果：
  2. agent tasks的表现也会随着GUI Grounding的表现提升而提升
SeekClick as Unified GUI Agent（Unified统一的）
1. 联合训练SeekClick处理所有三类任务，验证其统一模型（？）的能力
2. 结果：
  1. 表现略有下降，说明三类GUI差异大，统一模型存在挑战
  3. 但是从这个表看，仍然是优秀的

Conclusion

提出纯视觉方案的GUI agent，名为SeekClick
关键挑战：GUI grounding
解决方案：提出了GUI Grounding预训练机制
评估与数据集：创建ScreenSpot的数据集，跨平台，用来测试GUI Grounding
结果：
1. ScreenSpot上，SeekClick明显优于现有LVLM
2. 在三个不同的GUI自动化任务中表现出色，说明GUI Grounding的优秀表现可提升下游自动化任务的性能。

Limitations

当前的SeekClick目前只支持click和typing，点击和输入，不支持拖拽（dragging）或双击（double-clicking）等复杂操作。
当前开源LVLM的能力有限，如果要在移动端和桌面端完成多步骤任务，还需要专门的数据来训练模型，不能完全依赖通用模型。

A Details of SeekClick Pre-training

A.1 Pre-training Tasks

训练任务两大类：
1. GUI grounding：定位
  1. text_2_point：给出对应UI元素的中心点坐标(x, y)
  2. text_2_bbox：bounding box边界框，给出上下左右。
2. GUI 文本生成：根据位置，反推出对应的文字
  1. point_2_text
  2. bbox_2_text
数据表示：
1. 坐标都是归一化数值，在[0,1]区间内的浮点数，保留两位小数，表示相对于整个图片的宽和高的比例。
2. 例如，(0.32, 0.77) 表示在图片宽度 32% 的地方，和高度 77% 的地方。

A.2 Training Configurations

开源多模态大模型QWen-VL-Chat作为基础，进行continual pre-training。
解锁视觉编码器visual encoder的梯度？
使用LoRA做微调
采用AdamW作为优化器，并使用一个Cosine anneal调度器，其init学习率为3e-5，全局批量大小为64。所有训练需要在8个NVIDIA A100图形处理器上进行约24小时。

B ScreenSpot Annotation & Evaluation

B.1 Human Annotation

4位有经验的标注员，用 Makesense工具给截图中常用的可点击元素打框；为这些被标注的元素写英文的操作指令。

B.2 Sample Showcase

图10给了很多例子

B.3 Evaluation Detail

对比了主流的多模态模型CogAgent、GPT-4V
1. CogAgent推荐的prompt是 “What steps do I need to take to <instruction>? (with grounding)”
2. GPT-4V，输入指令，要求他输出对应的位置
比较他们的输出位置坐标和真实值之间的误差
SeekClick的评估选择了使用中心点，而不是边界框，因为这个表现略好点

B.4 SeekClick Case Study & Error Analysis

分析错误，发现即使是预测错误，预测点也很靠近真实目标，说明模型能大致识别出目标，只是精度需要提升。 ![[Pasted image 20251021165942.png]]

Downstream Agent Tasks

C.1 Formulation of SeekClick as Visual GUI Agent

动作：点击、输入文本、选择、滑动屏幕、返回上一步、返回主页、回车提交
agent公式：
1. 根据截图和之前步操作，预测下一步

C.2 MiniWob

C.3 AITW

原来的5个子集General、Install、GoogleApps、Single、WebShopping，划分的不好，有过拟合风险
新的训练/验证/测试划分策略

C.4 Mind2Web

面向真实网页任务的通用智能体数据集
做了哪些改动：
1. 原来用于文本，输入仅为html，为了支持视觉模型，从原始网页dump中提取了截图和坐标元素的框
2. 原始html的截图很大，处理太复杂，就裁剪了截图，仅保留1920*1080的窗口

Agent 工具接入

Fri, 06 Jun 2025 00:00:00 +0000

Agent 工具接入方式

背景：如何让大模型使用外部工具

一般有原生Function Calling方式和通过MCP协议（模型上下文协议）调用。原生Function Calling方式是由模型直接输出结构化的json，包含工具名称和参数，客户端调用本地工具，再回传ToolMesage。而MCP协议是由Anthropic提出的标准，工具运行在独立的MCP Server进程中，通过JSON-RPC协议与Agent通信，无需为每个Agent写单独的工具代码。

工具调用时的Agent与模型交互通信全流程

整个过程分为三个回合（Turn）：

Turn 1 (Request): Client 发送用户问题。
Turn 2 (Tool Call): Model 返回 “通过工具查天气” 的指令。
Turn 3 (Tool Output): Client 也就是 Agent 执行代码，把结果传回 Model，Model 生成最终回复。

第一回合：用户提问

Agent 发送给 Model 的 Messages 列表： (注意：System Prompt 里其实隐含了工具定义，但在 ChatML格式（即下方的messages 列表结构）中，工具定义通常作为 tools 参数单独传递，这里为了直观展示，主要关注 messages 数组) ChatML (Chat Markup Language) 是 OpenAI 为了解决“纯文本 Prompt”的安全性与结构化问题而推出的一种交互格式。以前所有的对话只是一个长字符串（如 User: Hi\nAI: Hello）。现在对话被拆分为结构化的 Message List，每条消息都有明确的 Role (system/user/assistant/tool)。这种结构让模型能清楚地区分，哪句话是用户说的，哪句话是系统指令，有效防止 Prompt Injection 攻击，同时为 Tool Calling 提供了专用的数据通道。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// POST /v1/chat/completions body
{
 "model": "gpt-4",
 "tools": [ ... ], // 这里定义了 weather 工具的 schema
 "messages": [
 {
 "role": "system",
 "content": "你是一个有用的助手..."
 },
 {
 "role": "user",
 "content": "北京今天天气怎么样？"
 }
 ]
}

第二回合：模型下达指令 (The Tool Call)

Model 返回给 Agent 的 Response： 模型没有返回 Content 文本，而是返回了 tool_calls 字段。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// Model Response
{
 "id": "chatcmpl-123",
 "choices": [
 {
 "index": 0,
 "message": {
 "role": "assistant",
 "content": null, // 注意这里是 null，因为模型没在说话，而是在思考
 "tool_calls": [
 {
 "id": "call_abc123", // 【关键】这是这次操作的唯一身份证
 "type": "function",
 "function": {
 "name": "weather",
 "arguments": "{\"city\": \"Beijing\"}" // 模型生成的 JSON 字符串参数
 }
 }
 ]
 },
 "finish_reason": "tool_calls" // 告诉 Client：我完事主要是因为我要调工具
 }
 ]
}

Agent 本地执行

此时，Agent 的 Python 代码捕获到了上面的响应。

解析 function.name 是 “weather”。
解析 function.arguments 得到 city="Beijing"。
调用本地 Python 函数 weather_tool(city="Beijing")。
得到结果串："22°C, 晴天"。

第三回合：回填结果与最终响应

Agent 再次发送给 Model 的 Messages 列表： (注意：这次必须把之前的历史全带上，包括模型刚才的工具调用指令，以及我们新生成的工具结果)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


// POST /v1/chat/completions body (第二次请求)
{
 "messages": [
 // 1. 系统提示
 {"role": "system", "content": "..."},
 // 2. 用户的原始问题
 {"role": "user", "content": "北京今天天气怎么样？"},
 // 3. 【必须】带上模型上一轮的回复（包含 tool_calls）
 {
 "role": "assistant",
 "content": null,
 "tool_calls": [
 {
 "id": "call_abc123",
 "type": "function",
 "function": {"name": "weather", "arguments": "{\"city\": \"Beijing\"}"}
 }
 ]
 },
 // 4. 【必须】带上工具执行的结果 (Tool Output)
 {
 "role": "tool",
 "tool_call_id": "call_abc123", // ID 必须和上面对应！
 "content": "{\"temperature\": \"22°C\", \"description\": \"晴天\"}"
 }
 ]
}

Model 最终返回给 Agent 的 Response

模型看到用户问题、自己的调用意图、以及工具回来的真实数据，终于可以生成人话了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// Model Final Response
{
 "choices": [
 {
 "message": {
 "role": "assistant",
 "content": "北京今天天气不错，气温 22°C，是晴天。"
 },
 "finish_reason": "stop"
 }
 ]
}

代码核心链路

定义

每个工具有自己的参数结构和内部逻辑，模型依靠args_schema字段自动生成的JSON Schema知道如何调用。

注册与绑定

.bind_tools() 是 LangChain 提供的方法，它会将写的函数转化成 OPEN API需要的JSON Schema格式，然后底层自动调用 OpenAI API 的 tools 参数。

1
2
3


self.all_tools = self._load_all_tools() # 实例化所有工具
# 将 Python 对象转换为 OpenAI API 能懂的 JSON 描述
self.default_llm_with_tools = self.default_llm.bind_tools(self.all_tools)

决策是否调用

在chat中，模型接收messages，如果它决定调用工具，会在返回的response.tool_calls中携带以下数据。

1
2
3
4
5


{
 "name": "file_system",
 "args": {"action": "read", "path": "D:/data.txt"},
 "id": "call_xyz123"
}

执行

简单循环

先来看一个最简单的循环，后面会有线程池支持工具并发执行版本。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


messages = [
 {"role": "user", "content": "帮我查一下北京现在的天气"}
]

while True:
 # 问模型
 response = llm.invoke(messages)

 # 响应中有tool_calls的情况
 if response.tool_calls:
 print(f"AI决定调用工具: {response.tool_calls}")

 # 【重点】必须先把“AI想调工具”这句话记下来
 messages.append(response)

 # 串行执行工具
 for tool_call in response.tool_calls:
 # 假装执行了工具函数，拿到了结果
 tool_result = my_fake_weather_tool(tool_call['args'])

 # 【重点】把工具运行结果记下来
 messages.append({
 "role": "tool",
 "tool_call_id": tool_call['id'], # 必须对应 ID
 "content": str(tool_result)
 })

 # 循环继续... 带着最新的结果（含工具结果）再次回到前面问模型

 else:
 # else分支，模型说“我不需要工具了，这是我的回答”
 print("最终回答:", response.content)
 break

工具并发调用

如果response.tool_calls 是一个列表，可以用线程池跑工具，减少等待时间。

1
2
3
4


[
 {"name": "weather", "args": {"city": "Beijing"}, "id": "call_1"},
 {"name": "weather", "args": {"city": "Shanghai"}, "id": "call_2"}
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


# 1. 准备任务清单
tool_call_infos = []
for tool_call in response.tool_calls:
 tool_call_infos.append({
 "name": tool_call["name"],
 "args": tool_call["args"],
 "id": tool_call["id"] # 一定要保存 ID，后续要对号入座
 })

# 2. 定义包装函数
def execute_tool_wrapper(info):
 # 这个函数会在独立的线程中运行
 result = self._execute_tool(info["name"], info["args"])
 return {
 "tool_call_id": info["id"], # 带着 ID 回来，证明我是谁的结果
 "result": result["result"],
 # ...
 }

# 3. 扔进线程池
parallel_results = []
# max_workers 设为调用数量，即有多少个工具就开多少个线程（适合IO密集型任务）
with ThreadPoolExecutor(max_workers=len(tool_call_infos)) as executor:
 # 提交任务，建立 Future 对象到原始 info 的映射
 future_to_tool = {
 executor.submit(execute_tool_wrapper, info): info
 for info in tool_call_infos
 }
 # as_completed 会在某个任务一完成就立刻 yield，不需要等所有都做完
 # 这样可以尽早处理部分结果（虽然本例中是收集齐了一起处理）
 for future in as_completed(future_to_tool):
 result = future.result() # 获取线程执行的返回值
 parallel_results.append(result)

插入一个字典推导式的写法，但它完全等价于for循环写字典。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


future_to_tool = {
 executor.submit(func, info): info
 for info in tool_call_infos
 }

# 与下面这一段完全等价
future_to_tool = {}
for info in tool_call_infos:
 future = executor.submit(execute_tool_wrapper, info)
 future_to_tool[future] = info

OpenAI 要求 ToolMessage 的顺序最好和 tool_calls 的顺序对应（虽然现在的版本宽松了一些，但他依然强依赖 tool_call_id）。所以由于as_completed 返回的顺序是乱的，就需要重组一下响应。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 1. 建立索引 (ID -> Result)
result_map = {r["tool_call_id"]: r for r in parallel_results}
# 2. 按原始顺序 (tool_call_infos) 取结果
for info in tool_call_infos:
 result = result_map[info["id"]] # 通过 ID 找回对应的结果
 # 3. 追加消息
 messages.append({
 "role": "tool",
 "tool_call_id": info["id"], # 这里的 ID 必须和 assistant 消息里的对应 ID 严格一致
 "content": str(result["result"])
 })

Function Calling实现

使用Pydantic定义输入，描述清楚Description

在我的项目中，即在real_tools.py中新增class。Description类似使用说明书。

1
2
3
4


from pydantic import BaseModel, Field

class CalculatorInput(BaseModel):
 expression: str = Field(description="要计算的数学表达式，例如 '2 + 2 * (3 - 1)'")

实现工具内部逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class CalculatorTool(BaseTool):
 name: str = "calculator" # 工具ID，模型通过这个名字调用
 description: str = "执行数学计算，支持加减乘除和括号" # 这一行决定了模型什么时候用它
 args_schema: type[CalculatorInput] = CalculatorInput

def _run(self, expression: str) -> str:
 try:
 # xxxx
 except Exception as e:
 return f"计算错误: {str(e)}"

注册工具

1
2
3
4
5
6
7
8


ALL_TOOLS = {
 'calculator': CalculatorTool, # 在工具字典中新增
}

def _load_all_tools(self) -> List[BaseTool]:
 real_tools = [
 CalculatorTool(), # 新增实例
 ]

基于 LangGraph 的高并发 Multi-Agent 流式系统设计

Wed, 04 Jun 2025 00:00:00 +0000

同步阻塞式流式响应

Web框架使用Flask，在run_stream()函数中手写for循环驱动agent，等待LLM返回token，拿到token即yield，发给前端。业务逻辑严格依赖既定的pipeline顺序，不涉及高并发，不需要复杂的并行agent执行。

使用 Server-Sent Events (SSE) 实现的流式 API 接口

SSE通信机制

一种服务器向客户端单向推送实时数据的技术，WebSocket是双向的。

1
2


客户端 ----(HTTP请求)----> 服务器
客户端 <---(持续推送数据)-- 服务器

SSE数据格式

1
2
3
4
5
6


# 注意必须是两个换行符
data: {"type": "agent_output_chunk", "content": "分析中..."}\n\n
# 比如以下消息
data: {"type": "agent_start", "agent": "Researcher"}\n\n
data: {"type": "agent_output_chunk", "content": "正在分析..."}\n\n
data: {"type": "done"}\n\n

API端分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


@api_bp.route('/agent/research/stream', methods=['POST'])
def multi_agent_research_stream():
 # 1. 接收研究主题
 data = request.get_json()
 message = data.get('message', '') # 如分析人工智能在医疗领域的应用

 # 2. 验证输入
 if not message:
 return jsonify({'success': False, 'msg': '研究主题不能为空'}), 400

 # 3. 创建生成器函数
 def generate():
 # 获取多智能体系统实例
 multi_agent = get_research_multi_agent()

 # 执行流式处理，逐个yield事件
 for event in multi_agent.run_stream(message):
 # 将事件转换为SSE格式
 yield f"data: {json_module.dumps(event, ensure_ascii=False)}\n\n"

 # 发送完成标记
 yield f"data: {json_module.dumps({'type': 'done'})}\n\n"

 # 4. 返回SSE响应
 return Response(
 stream_with_context(generate()),
 mimetype='text/event-stream',
 headers={
 'Cache-Control': 'no-cache', # 禁用缓存
 'Connection': 'keep-alive', # 保持连接
 'X-Accel-Buffering': 'no' # 禁用Nginx缓冲
 }
 )

Multi-Agent执行流程

pipeline模式，定义好了agent执行顺序。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


def run_stream(self, user_input: str):
 # 1. 工作流开始
 yield {
 "type": "workflow_start",
 "workflow": "academic_research",
 "agents": ["Supervisor", "Researcher", "Critic", "Ideator", "Writer"]
 }

 # 2. 定义Agent执行顺序
 agent_sequence = [
 ("supervisor", self.supervisor, "任务理解与规划"), # 理解用户需求
 ("researcher", self.researcher, "文献调研"), # 查找相关文献
 ("critic", self.critic, "批判性分析"), # 分析现有研究
 ("ideator", self.ideator, "创意生成"), # 提出新想法
 ("writer", self.writer, "研究报告撰写") # 撰写最终报告
 ]

 # 3. 依次执行每个Agent
 for agent_key, agent, description in agent_sequence:
 # 通知Agent开始
 yield {"type": "agent_start", "agent": agent.name, "description": description}

 # 执行Agent并流式输出
 for event in agent.run_stream(state):
 yield event # 包含 agent_output_chunk 等事件

 # 如果Agent完成，更新状态
 if event.get("type") == "agent_complete":
 result = event.get("result", {})
 state = {**state, **result} # 合并结果到状态

 # 通知Agent结束
 yield {"type": "agent_end", "agent": agent.name}

 # 4. 工作流完成
 yield {
 "type": "workflow_complete",
 "final_output": state.get("final_output"), # 最终研究报告
 "elapsed_time": elapsed_time
 }

子agent服务端实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# 发送事件，表示agent开始输出
yield {"type": "agent_output_start", "agent": self.name}
full_response = ""
for chunk in self._invoke_llm_stream(self.get_system_prompt(), user_prompt):
 full_response += chunk
 # 每收到一个文本块，立即发送给客户端，同时累积完整响应
 yield {"type": "agent_output_chunk", "agent": self.name, "content": chunk}
yield {"type": "agent_output_end", "agent": self.name}

yield {
 "type": "agent_complete",
 "agent": self.name,
 "result": {
 "critique_results": {
 "topic": research_topic,
 "analysis": full_response
 }
 }
}

pipeline设计模式的通信流程

1
2
3
4
5
6
7
8


 第1层：前端 → Flask（HTTP）
 # 前端发起请求
 fetch('/api/paper/read/stream', { method: 'POST', body: {...} })

 # Flask 接收
 @api_bp.route('/paper/read/stream', methods=['POST'])
 def paper_read_stream():
 ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


第2层：Flask → LangGraph（函数调用）
 # Flask 路由中调用 LangGraph
 def paper_read_stream():
 multi_agent = get_paper_reader_multi_agent()

 def generate():
 # 这里调用 LangGraph
 for event in multi_agent.run_stream(images, paper_name):
 yield f"data: {json.dumps(event)}\n\n"

 return Response(generate(), mimetype='text/event-stream')

1
2
3
4
5
6


第3层：LangGraph 内部（Agent 执行）
 #（同步 for 循环）
 def run_stream(self, images, paper_name):
 for agent in [planner, extractor, analyzer, critic, summarizer]:
 for token in agent.run_stream(state):
 yield token # 一个个 token 往外吐

异步高并发

想要实现真正的异步高并发Multi-Agent架构，supervisor节点可以动态路由，worker节点可以并行执行，支持自动合并多个worker的处理结果。可以充分利用LangGraph的能力（Send、Annotated、astream_events），或者把 LangGraph 当成状态容器然后自己写调度逻辑。

LangGraph内置能力

图拓扑管理

每一条边自定义任务逻辑，通过Send API，根据Supervisor的决策，动态生成需要执行的节点。

状态管理

Supervisor和所有的Worker节点通过共享的状态字典State交换数据；在LangGraph中，可以通过 TypedDict 和 Python 的 operator.add，用自动合并函数处理多个Worker的并行结果。

1
2
3
4
5


class ResearchState(TypedDict):
 research_outputs: Annotated[List[WorkerOutput], operator.add] # 自动合并
 messages: Annotated[List[str], operator.add] # 对话历史累积

builder.set_state(ResearchState) # 定义共享状态

利用Send API自动实现并行任务调度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


 V1 事件格式（当前）

 // SSE event 名称统一是 "message"，通过 data.type 区分
 event: message
 data: {"type": "conversation_id", "conversation_id": "xxx"}

 event: message
 data: {"type": "reading_start", "paper_name": "xxx", "agents": [...]}

 event: message
 data: {"type": "agent_start", "agent": "Planner", "description": "..."}

 event: message
 data: {"type": "agent_output_chunk", "agent": "Planner", "content": "方"}

 event: message
 data: {"type": "agent_output_end", "agent": "Planner"}

 event: message
 data: {"type": "agent_complete", "agent": "Planner", "result": {...}}

 event: message
 data: {"type": "reading_complete", "final_output": "...", "elapsed_time": 10.5}

 event: message
 data: {"type": "done"}

1

from langgraph.constants import Send

1
2
3
4
5


# 返回单个 Send = 顺序执行
return Send("extractor", state)

# 返回 Send 列表 = 并行执行
return [Send("analyzer", state), Send("critic", state)]

并行执行的完整流程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# graph.py
def parallel_router(state: PaperReaderState) -> List[Send] | Literal["finalize"]:
 steps = state.get("next_steps", []) # 来自Supervisor，如analyzer,critic

 if not steps or "FINISH" in steps:
 return "finalize"

 routes = []
 for step in steps:
 routes.append(Send(step, state)) # 每个 step 创建一个 Send

 # 返回 [Send("analyzer", state), Send("critic", state)]
 # LangGraph 引擎会并行调度这两个节点
 return routes

LangGraph原生 astream_events 实现动态路由和Token级流式

一般这样拿到结果result = await graph.ainvoke(state)

astream_events可以获取每个token、每个节点的变化 async for event in graph.astream_events(state, version="v2"):

处理三类事件：节点开始、Token流、节点结束，然后yield各种类型的输出。

核心步骤

创建共享状态 state.py

Annotated写法对三个字段messages、messages、completed_agents的类型提示。 Annotated允许在不改变变量类型的前提下，给这个类型贴上标签或附加元数据，T是原本的类型，x可以是字符串、函数、类的实例等。对于Langraph框架，会检查第二个参数operator.add，做自己的更新处理。

operator.add在List上的作用就是拼接，避免覆盖了原本的输出，实现状态更新。

1
2


from typing import Annotated
Annotated[T, x]

1
2
3
4
5


# 使用 Annotated + operator.add 实现自动累加合并
class PaperReaderState(TypedDict, total=False):
 messages: Annotated[List[BaseMessage], operator.add]
 worker_outputs: Annotated[List[WorkerOutput], operator.add]
 completed_agents: Annotated[List[str], operator.add]

创建Woker

每一个worker都是一个异步函数，返回状态更新：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


async def analyzer_node(state: PaperReaderState, config: RunnableConfig = None) -> Dict[str, Any]:
 images = state.get("paper_images", [])
 metadata = state.get("paper_metadata", {})

 llm = get_llm(streaming=True)
 messages = build_messages(
 system_prompt="你是方法论分析专家...",
 user_prompt="请分析这篇论文的方法...",
 images=images
 )

 full_response = ""
 async for chunk in llm.astream(messages, config=config):
 if chunk.content:
 full_response += chunk.content

 # 返回状态更新（会自动合并到全局状态）
 return {
 "methodology": {"raw_content": full_response},
 "worker_outputs": [{"source": "analyzer", "content": full_response, "metadata": {}}],
 "completed_agents": ["analyzer"]
 }

创建Supervisor，实现动态路由

指定supervisor_node输出两个字段，next_steps和iteration。用pydantic.BaseModel，定义输出格式是RouteDecision。 with_structured_output(RouteDecision) 是LangChain的一个方法，在底层将RouteDecision转化成json，调用OpenAI的Function Calling能力，强制模型按照这个Schema生成数据。这样返回的decision不再是一段文本，而是一个对象，包含了next_steps字段。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


from pydantic import BaseModel, Field

class RouteDecision(BaseModel):
 next_workers: List[str] = Field(description="下一步执行的 Agent 列表")
 reasoning: str = Field(description="决策理由")

class SupervisorAgent:
 def __init__(self):
 self.llm = ChatOpenAI(...).with_structured_output(RouteDecision)

 async def decide(self, state: PaperReaderState) -> RouteDecision:
 # 构建状态摘要
 state_summary = self._build_state_summary(state)

 # LLM 决策
 decision = await self.llm.ainvoke({
 "workers_description": "...",
 "state_summary": state_summary
 })
 return decision

async def supervisor_node(state: PaperReaderState) -> Dict[str, Any]:
 supervisor = get_supervisor()
 decision = await supervisor.decide(state)
 return {
 "next_steps": decision.next_workers, # 如 ["analyzer", "critic"] 或 ["FINISH"]
 "iteration": state.get("iteration", 0) + 1
 }

构建图 graph.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


from langgraph.graph import StateGraph, END
from langgraph.constants import Send

def parallel_router(state: PaperReaderState) -> List[Send] | str:
 """根据 Supervisor 决策路由，支持并行"""
 steps = state.get("next_steps", [])

 if not steps or "FINISH" in steps:
 return "finalize"

 # 使用 Send 实现真正的并行执行
 routes = []
 for step in steps:
 routes.append(Send(step, state))
 return routes

def build_graph():
 workflow = StateGraph(PaperReaderState)

 # 1. 添加节点
 workflow.add_node("supervisor", supervisor_node)
 workflow.add_node("planner", planner_node)
 workflow.add_node("extractor", extractor_node)
 workflow.add_node("analyzer", analyzer_node)
 workflow.add_node("critic", critic_node)
 workflow.add_node("summarizer", summarizer_node)
 workflow.add_node("finalize", finalize_node)

 # 2. 设置入口
 workflow.set_entry_point("supervisor")

 # 3. Supervisor → 条件路由（支持并行）
 workflow.add_conditional_edges(
 "supervisor",
 parallel_router,
 ["planner", "extractor", "analyzer", "critic", "summarizer", "finalize"]
 )

 # 4. Workers → 回到 Supervisor（循环）
 workflow.add_edge("planner", "supervisor")
 workflow.add_edge("extractor", "supervisor")
 workflow.add_edge("analyzer", "supervisor")
 workflow.add_edge("critic", "supervisor")
 workflow.add_edge("summarizer", "supervisor")

 # 5. Finalize → END
 workflow.add_edge("finalize", END)

 return workflow.compile(checkpointer=MemorySaver())

流式输出处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


async def stream_graph_events(graph, input_state, config) -> AsyncGenerator:
 async for event in graph.astream_events(input_state, config=config, version="v2"):
 kind = event.get("event")
 node_name = event.get("metadata", {}).get("langgraph_node", "")

 if kind == "on_chain_start" and node_name not in skip_nodes:
 yield {"type": "agent_start", "agent": node_name}

 elif kind == "on_chat_model_stream":
 chunk = event.get("data", {}).get("chunk")
 if chunk and chunk.content:
 yield {"type": "agent_output_chunk", "agent": node_name, "content": chunk.content}

 elif kind == "on_chain_end":
 yield {"type": "agent_end", "agent": node_name}

主执行器封装

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class PaperReaderMultiAgent:
 def __init__(self):
 self.graph = build_graph()

 async def run_stream_async(self, paper_images, paper_name, conversation_id):
 initial_state = create_initial_state(paper_images, paper_name, conversation_id)

 yield {"type": "reading_start", "paper_name": paper_name}

 async for event in stream_graph_events(self.graph, initial_state):
 yield event

核心API设计

整个后端的核心链路：FastAPI 路由 → SSE 响应 → 异步迭代 Multi-Agent → 流式输出事件。

由于paper功能需要支持read和chat两部分功能，同时read部分需要支持断点继续执行功能，API设计如下：

1
2
3


POST /paper/read/stream
POST /paper/chat/stream
POST /paper/read/continue

主接口代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


@router.post("/paper/read/stream")
async def paper_read_stream(req: PaperReadRequest, user_id: Optional[str] = Depends(...)):
 # 1. 创建会话（可选）
 if user_id and not req.conversation_id:
 conversation_id = ConversationService.create_conversation(...)

 # 2. 获取 Multi-Agent 实例
 multi_agent = get_paper_reader_multi_agent()

 # 3. 定义 SSE 事件生成器
 async def event_generator():
 async for event in multi_agent.run_stream_async(req.images, req.paper_name, conversation_id):
 yield {"event": "message", "data": json.dumps(event)}

 # 保存到数据库（可选）
 if event["type"] == "agent_output_end":
 MessageService.add_message(...)

 # 4. 返回 SSE 响应
 return EventSourceResponse(event_generator())

@router.post("/paper/chat/stream")
async def paper_chat_stream(req: PaperChatRequest, ...):
 async def event_generator():
 async for event in multi_agent.chat_stream_async(
 req.question, req.images, req.paper_metadata, req.context
 ):
 yield {"event": "message", "data": json.dumps(event)}

 return EventSourceResponse(event_generator())

OpenAI API结构化输出

Tue, 03 Jun 2025 00:00:00 +0000

要实现从自然语言到强类型对象的映射，在某些场景下，我需要LLM输出指定的json格式，或类型，或数据结构，可以利用OpenAI的response_format和Pydantic库实现结构化数据。示例如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


from pydantic import BaseModel
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

class Person(BaseModel):
 name: str
 age: int

client = OpenAI(
 api_key="sk-xxxxxx",
 base_url="https://xxxx",
 timeout=120
)

completion = client.beta.chat.completions.parse(
 model="gpt-4o",
 messages=[
 {"role": "user", "content": "我是张三，今年已经28岁了。"}
 ],
 response_format=Person,
)

result = completion.choices[0].message.parsed

print(f"姓名: {result.name}") # 输出张三 
print(f"年龄: {result.age}") # 输出28 

print(f"JSON格式: {result.model_dump_json()}")

GUI Agent相关

Mon, 02 Jun 2025 00:00:00 +0000

定义

在图形界面上看、想、点、打字、拖拽并完成任务的智能体。它通过“观察屏幕状态→规划→执行操作→再观察→纠错”的闭环，在桌面应用、网页、移动端 App 等界面中自主操作。

典型体系结构

发展历史：

最早是基于规则和脚本的自动化；
2010s开始的由于深度学习技术的发展，计算学习用户交互轨迹；
2020s后，由于MLLMs的发展，给GUI agent带来了革命性的进展。

paper list：

https://github.com/OSU-NLP-Group/GUI-Agents-Paper-List/
https://github.com/showlab/Awesome-GUI-Agent
https://github.com/slavakurilyak/awesome-ai-agents

通用LVLMs与专用于GUI agent的LVLMs

两者区别	能力	训练数据	输出接口
通用LVLMs	“能看懂图”的通用聊天型LVLM 坐标/动作是附带能力	通用图文对齐	需要用提示词告诉他输出坐标，受格式和缩放影响
专用于GUI agent的LVLMs	“能看懂并去点”的代理型LVLM，训练与接口都围绕可执行的GUI交互优化	大量使用屏幕截图、UI布局、流程轨迹、合成交互数据等训练	直接输出动作click(x,y) 相对“用提示让模型说出坐标”，专门有一个负责输出几何量的预测分支，还能给置信度。

分类	举例	介绍	能力侧重	出处
专用于GUI agent的LVLMs	CogAgent 开源视觉语言模型	1. 支持1120*1120的超高分辨率图像输入和对话式问答 2. 跨平台泛化能力 3. 首个专门为GUI理解设计的LVLM	1. 界面元素识别和语义对齐 2. 元素级定位 3. GUI任务分解和步骤规划 4. 结合文本信息，候选元素列表，提升语义对齐与命中率	CogAgent (Hong et al., 2023) https://github.com/zai-org/CogVLM https://arxiv.org/abs/2312.08914 清华大学、智谱AI，完全开源
	Fuyu-8B	1. 通用多模态大模型 2. 重点是理解和问答	1. 理解内容，尤其是文本密集和结构化视觉（表格、流程图等） 2. 擅长解释页面上写了什么，图标表达了什么	Fuyu (Bavishi et al., 2023) https://www.adept.ai/blog/fuyu-8b Adept AI完全开源
通用LVLMs	LLaVA系列（开源）、Qwen-VL系列（开源）、GPT-4V/GPT-4o（闭源）、Claude Vision系列 (Opus/Sonnet)（闭源）、Gemini（闭源）

多智能体架构multiagent

Sun, 01 Jun 2025 00:00:00 +0000

需要考虑的问题

劳动分工（角色界定和责任划分）
智能体间通信机制（允许智能体交换数据、委托子任务，协调输出）

协作形式：

顺序交接：一个输出作为另一个输入
并行：同时处理问题的不同部分，最后将结果合并
辩论共识：多代理处理不同信源信息
分层：管理代理分配任务，综合结果
专家团队：不同领域有专业知识的代理协作
批评者-审阅者：解释：代理a创建初始输出，第二组代理b批判性评估，原来的代理a（或最终代理c）根据反馈修改输出。适用于：代码生成、研究写作、逻辑检查等

介绍Crew AI和Google ADK框架

Crew AI框架：

简单来说，分三步：定义agent、定义task、创建团队（团队里指定agent和task）。

Google ADK框架：

层级代理

LoopAgent（迭代模式）

SequentialAgent（线性工作流.）

ParallelAgent（并发模式）

A2A协议

基本框架

提供一个基于 HTTP 的通用框架，确保基于不同框架（例如Google ADK、LangGraph 或 CrewAI）开发的agent之间的通信。支持的特性：提供一个例子，后面有运行截图：代码：https://github.com/a2aproject/a2a-samples/blob/main/samples/python/agents/langgraph langgrzzaph实现的agent，为用户提供货币兑换信息。通信过程：

客户端通过A2A协议发送获取查询请求，到服务端，服务器端将请求转发到langgraph的agent
agent调用api获取实时汇率，处理数据后响应给服务端，服务端再响应客户端

交互方式

A2A 支持三种交互方式：

请求/响应（轮询）：客户端发送请求，服务器响应。对于长时间运行的任务，客户端定期轮询服务器以获取更新。
使用服务器发送事件（SSE）的流式传输：客户端发起流以通过开放的HTTP连接从服务器接收实时、增量结果或状态更新。
推送通知：对于非常长时间运行的任务或断开连接的场景，当发生重要任务更新时，服务器可以主动向客户端提供的webhook发送异步通知。举例：第1种是网购时关心物流状态，每天打开app刷新，我的快递到哪了，对方回应我；第2种是我打开一个物流连接，不需要我刷新页面，服务器会实时推送更新；第3种是我指定一个电话号码，服务器会在关键节点给我发通知短信，告诉我快递到哪一站了。

运行示例

启动服务端：另外一个终端启动客户端：客户端去连接，发现了agentcard，agentcard内容：对比服务端日志打印，多了一行get方法：

LangGraph

Supervisor架构（监督者模式）

Supervisor决定下一步调用哪个Agent，子Agent不直接通信，通过Supervisor中转，使用共享State传递信息。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class AgentState(TypedDict):
 messages: Annotated[list, add_messages]
 next: str # 下一个要执行的agent

def supervisor(state):
 # 决定下一步
 return {"next": "agent_a"}

graph = StateGraph(AgentState)
graph.add_node("supervisor", supervisor)
graph.add_node("agent_a", agent_a_node)
graph.add_conditional_edges("supervisor", lambda s: s["next"])

通信机制：共享state

核心就是所有的Agent读写同一个state对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class SharedState(TypedDict):
 messages: list # 消息历史
 context: dict # 共享上下文
 agent_outputs: dict # 各agent的输出
 current_task: str # 当前任务

 def agent_a(state: SharedState):
 # 读取其他agent的输出
 prev_output = state["agent_outputs"].get("agent_b")

 # 执行任务
 result = do_something(prev_output)

 # 写入自己的输出
 return {
 "agent_outputs": {"agent_a": result},
 "messages": [AIMessage(content=result)]
 }

独立上下文

State数据在Agent之间共享，但每个LLM调用的token窗口独立。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class AgentState(TypedDict):
 messages: list # 完整历史，可能很长
 summary: str # 压缩的摘要
 current_context: dict # 当前任务相关上下文

def agent_a(state):
 # 不推荐传全部历史（token消耗过多）
 # response = llm.invoke(state["messages"])

 # 推荐只传需要的上下文
 prompt = f"""
 任务摘要: {state["summary"]}
 最近消息: {state["messages"][-5:]}
 当前任务: {state["current_context"]}
 """
 response = llm.invoke(prompt)

leetcode14.最长公共前缀

Tue, 07 Mar 2023 00:00:00 +0000

Question-14-最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “"。

示例 1：

输入：strs = [“flower”,“flow”,“flight”] 输出：“fl”

示例 2：

输入：strs = [“dog”,“racecar”,“car”] 输出：”" 解释：输入不存在公共前缀。

提示：

1 <= strs.length <= 200 0 <= strs[i].length <= 200 strs[i] 仅由小写英文字母组成

Related Topics 字典树字符串 👍 2664 👎 0

Answer-14

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


/*
 * 14
 * strs = ["flower","flow","flight"]
 * "fl"
 * nums = 3: 比较01、12
 * nums = 4：比较01、12、23
 * flower
 * flow
 * flight
 * 按照列对比，j列从0到3，i行从0到1（比较01、12）
 */
string longestCommonPrefix_func1(vector<string>& strs) {
 int nums = strs.size(); //3
 int resLen = INT_MAX;
 for (auto it : strs) {
 if (it.size() < resLen) resLen = it.size(); //公共前缀长度一定<=最短串的长度
 }
 int i, j;
 for (j = 0; j < resLen; ++j) {
 for (i = 0; i < nums - 1; i++) {
 printf("i[%d], j[%d]\n", i, j);
 if (strs[i][j] != strs[i+1][j]) {
 cout << "break1" << endl;
 break;
 }
 }
 if(i < nums - 1) { //nums-1此时为2
 cout << "break2" << endl;
 break; //???
 }
 }
 return strs[0].substr(0, j);
}

/*
 * 纵向比较，假设第一个元素是公共前缀，逐个比较第一个元素的各个位置
 * flower
 * flow
 * flight
 */
string longestCommonPrefix_func2(vector<string>& strs) {
 int j = 0;
 while (j < strs[0].size()) {
 char cur = strs[0][j]; //假设第一个元素是公共前缀flower，cur是当前想要比较的字符，从f开始
 for (auto item : strs) {
 printf("item[%s], j[%d]\n", item.c_str(), j);
 if (item.size() < j || item[j] != cur) { //该轮检查有异常 ???
 return j > 0 ? strs[0].substr(0, j) : "";
 }
 }
 ++j; //依次向后找
 }
 return strs[0]; //如果j>=resLen，直接返回第一个元素
}

leetcode17.电话号码的字母组合.全排列问题.78.子集.90.子集II.39.组合总和.40组合总和II

Tue, 07 Mar 2023 00:00:00 +0000

Question-17-电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：

输入：digits = “23” 输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

示例 2：

输入：digits = "" 输出：[]

示例 3：

输入：digits = “2” 输出：[“a”,“b”,“c”]

提示：

0 <= digits.length <= 4 digits[i] 是范围 [‘2’, ‘9’] 的一个数字。

Related Topics 哈希表字符串回溯 👍 2345 👎 0

Answer-17

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


/*
 * 17电话号码的字母组合
 * 回溯法
 */
void dfs_func2(const vector<string> vecInput, vector<string> &vecOutput, string strRes, int index, string digits) {
 if (index == digits.size()) { //递归边界
 vecOutput.push_back(strRes);
 return;
 }
 int x = digits[index]-'0'; //数组下标
 string strTmp = vecInput[x]; //临时str = "abc"，获取数字代表的字符串
 for (int i = 0; i < strTmp.size(); i++) {
 strRes.push_back(strTmp[i]); //push第index个字符串的第i个字母
 dfs_func2(vecInput, vecOutput, strRes, index+1, digits); //index后移
 printf("strRes[%s]\n", strRes.c_str());
 strRes.pop_back(); //***回溯
 }
}
vector<string> letterCombinations_func2(string digits) {
 const vector<string> strVec = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
 vector<string> vecOutput;
 string str;
 vecOutput.clear();
 if (digits.size() == 0) {return vecOutput;} //测试用例:""、测试结果:[""]、期望结果:[]
 dfs_func2(strVec, vecOutput, str, 0, digits);
 return vecOutput;
}

Q&A-回溯法经典全排列问题

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


/*
 * 17plus_func1
 * {2、3、5、7、9}的全排列问题
 * 回溯法
 */
void backtrace_func1(vector<vector<int>> &vecOutput, vector<int> vecInput, vector<bool> &used, vector<int> vecTmp, int index) {
 /*检验当前维度数组是否是一个解*/
 if (index == vecInput.size()) {
 vecOutput.push_back(vecTmp);
 return;
 }
 /*列举当前维度的所有取值的情况，并且进入到下一维度*/
 for (int i = 0; i < vecInput.size(); i++) {
 if (!used[i]) { //去重
 vecTmp.push_back(vecInput[i]);
 used[i] = true;
 backtrace_func1(vecOutput, vecInput, used, vecTmp, index+1); //进入下一个纬度
 vecTmp.pop_back(); //***需要恢复当前纬度的临时变量修改
 used[i] = false; //***
 }
 }
}
vector<vector<int>> quanpailie(vector<int> vecInput, int size) {
 vector<vector<int>> vecOutput;
 vector<int> vecTmp;
 vector<bool> used = {false};
 backtrace_func1(vecOutput, vecInput, used, vecTmp, 0);
 return vecOutput;
}

Question-78-子集

给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。你可以按任意顺序返回解集。

示例 1：

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

示例 2：

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

提示：

1 <= nums.length <= 10 -10 <= nums[i] <= 10 nums 中的所有元素互不相同

Related Topics 位运算数组回溯 👍 1947 👎 0

Answer-78

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


/*
 * 78子集合问题 ac code
 * 2、3、5，对应的index表示位置取值012
 * index取0时（0、01、012），index取1时（1、12），index取2的时候（2）
 * 2、3、5总共有「空、2、23、235、25、3、35、5」共8种结果
 * 下标表示即共有「空、0、01、012、02、1、12、2」
 * 1、2、3总共有「空、1、12、123、13、2、23、3」共8种结果
 * 下标表示即共有「空、0、01、012、02、1、12、2」
 *
 * 没有约束条件，所有路径都应该加入结果集
 */
void backtrace_func78(vector<vector<int>> &vecOutput, vector<int> vecInput, vector<int> vecTmp, int index) {
 printf("index[%d]\n", index);
 for (auto it : vecTmp) {
 printf("%d ", it);
 }
 printf("\n");
 vecOutput.push_back(vecTmp); //不需要边界条件，index >= vecInput.size()会自动退出
 for (int i = index; i < vecInput.size(); i++) { //for循环是当前维度所有可能的情况， index取值：0、1、2，vecInput.size()=3
 vecTmp.push_back(vecInput[i]);
 backtrace_func78(vecOutput, vecInput, vecTmp, i + 1); //下一维度
 vecTmp.pop_back();
 }
}
vector<vector<int>> subsets(vector<int> vecInput, int size) {
 vector<vector<int>> vecOutput;
 vector<int> vecTmp;
 backtrace_func78(vecOutput, vecInput, vecTmp, 0);
 return vecOutput;
}


/*
 * 78 ac code
 * 子集合
 * 回溯法
 */
void backtrack_subsets_ac(vector<int> &nums, int start, vector<int> &subset, vector<vector<int>> &solution) {
 solution.push_back(subset);
 for (int i = start; i < nums.size(); ++i) {
 subset.push_back(nums[i]);
 backtrack_subsets_ac(nums, i+1, subset, solution);
 subset.pop_back();
 }
}
vector<vector<int>> subsets_ac(vector<int>& nums) {
 vector<vector<int>> solution;
 vector<int> subset;
 backtrack_subsets_ac(nums, 0, subset, solution);
 return solution;
}

Question-90-子集II

给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。

解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。

示例 1：

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

示例 2：

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

提示：

1 <= nums.length <= 10 -10 <= nums[i] <= 10

Related Topics 位运算数组回溯 👍 1042 👎 0

Answer-90

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


/*
 * 90
 * 子集合II（不允许重复）
 * 用标志位记录上一步的取值，每次处理前重复数字不处理
 * nums = [1,2,2]，vecInput.size()=3
 * [[],[1],[1,2],[1,2,2],[2],[2,2]]
 * 选值问题：输入index从0到2，i从index到2
 * index：0，i从0到2
 * index：1，i从1到2
 * index：2，i选2
 */
void backtrace_func90(vector<vector<int>> &vecOutput, vector<int> vecInput, vector<int> vecTmp, int index) {
 vecOutput.push_back(vecTmp); //不需要边界条件，index >= vecInput.size()会自动退出
 int prevN = INT_MAX;
 for (int i = index; i < vecInput.size(); i++) { //index取012，i从index到2
 if (vecInput[i] != prevN) { //当前层处理数不重复
 vecTmp.push_back(vecInput[i]);
 prevN = vecInput[i]; //为下一层做准备
 backtrace_func90(vecOutput, vecInput, vecTmp, i+1); //i+1不是index+1，区别于全排列问题 ***
 vecTmp.pop_back();
 }
 }
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
 sort(nums.begin(), nums.end());
 vector<vector<int>> vecOutput;
 vector<int> vecTmp;
 backtrace_func90(vecOutput, nums, vecTmp, 0);
 return vecOutput;
}

Quesion-39-组合总和

给你一个无重复元素的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的所有不同组合，并以列表形式返回。你可以按任意顺序返回这些组合。

candidates 中的同一个数字可以无限制重复被选取。如果至少一个数字的被选数量不同，则两种组合是不同的。

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7 输出：[[2,2,3],[7]] 解释： 2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。 7 也是一个候选， 7 = 7 。仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8 输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1 输出: []

提示：

1 <= candidates.length <= 30 2 <= candidates[i] <= 40 candidates 的所有元素互不相同 1 <= target <= 40

Related Topics 数组回溯 👍 2377 👎 0

Answer-39

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


/*
 * 39组合总和
 * candidates = [2,3,6,7], target = 7
 * [[7],[2,2,3]]
 * candidates = [2,3,5], target = 8
 * [[2,2,2,2],[2,3,3],[3,5]]
 * candidates = [2], target = 1
 * []
 * candidates = [1], target = 1
 * [[1]]
 * candidates = [1], target = 2
 * [[1,1]]
 */
void backtrace_func39(vector<vector<int>> &vecOutput, vector<int>vecInput, vector<int>vecTmp, int target, int index){
 /*检验当前维度结果是否是一个解*/
 if (target == 0) {
 vecOutput.push_back(vecTmp);
 return;
 }
 /*列举当前维度的所有取值的情况，并且进入到下一维度*/
 for (int i = index; i < vecInput.size(); ++i) { //index初始输入0，i可选从0到2（可重复选数）
 if (target - vecInput[i] >= 0) {
 vecTmp.push_back(vecInput[i]);
 backtrace_func39(vecOutput, vecInput, vecTmp, target - vecInput[i], i);
 //输入参数i，不是index，注意此处***
 //选择子集合问题，区别于全排列问题
 //可以重复选择元素，此处是i，不是i+1
 vecTmp.pop_back();
 }
 }
};
vector<vector<int>> combinationSum_func1(vector<int>& candidates, int target) {
 vector<vector<int>> vecOutput;
 vector<int> vecTmp;
 backtrace_func39(vecOutput, candidates, vecTmp, target, 0);
 return vecOutput;
}

Quesion-40-组合总和II

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用一次。

注意：解集不能包含重复的组合。

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8, 输出: [ [1,1,6], [1,2,5], [1,7], [2,6] ]

示例 2:

输入: candidates = [2,5,2,1,2], target = 5, 输出: [ [1,2,2], [5] ]

提示:

1 <= candidates.length <= 100 1 <= candidates[i] <= 50 1 <= target <= 30

Related Topics 数组回溯 👍 1262 👎 0

Answer-40

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


/*
 * 40组合总和II ac
 * 输入: candidates =[2,5,2,1,2], target =5,
 * 输出:
 * [
 * [1,2,2],
 * [5]
 * ]
 */
void backtrace_func40(vector<vector<int>> &vecOutput, vector<int>vecInput, vector<int>vecTmp, int target, int index){
 /*检验当前维度结果是否是一个解*/
 if (target == 0) {
 vecOutput.push_back(vecTmp);
 return;
 }
 /*列举当前维度的所有取值的情况，并且进入到下一维度*/
 int prevN = INT_MAX; //记录上一层选择的数，避免本轮选择的数与上一轮相同，剪枝
 for (int i = index; i < vecInput.size(); ++i) { //index初始输入0，i可选从1到2（不可重复选数）
// printf("i = %d, vecInput[i] = %d, prevN = %d\n", i, vecInput[i], prevN);
 if (vecInput[i] != prevN) {
 if (target - vecInput[i] >= 0) {
 vecTmp.push_back(vecInput[i]);
 prevN = vecInput[i];
 backtrace_func40(vecOutput, vecInput, vecTmp, target - vecInput[i], i+1);
 //输入参数i，不是index，注意此处***
 //选择子集合问题，区别于全排列问题
 //不可重复选择元素，此处是i+1，不是i
 vecTmp.pop_back();
 }
 }
 }
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
 vector<vector<int>> vecOutput;
 vector<int> vecTmp;
 sort(candidates.begin(), candidates.end());
 backtrace_func40(vecOutput, candidates, vecTmp, target, 0);
 return vecOutput;
}

Attention

回溯法和DFS区别： DFS往某个方向搜索，为了找到一个目标，而回溯法在DFS的基础上，在搜索过程中，达到结束条件后，恢复状态，回溯上一层，再次搜索。回溯法和DFS最大的区别是有无状态重置。当问题需要 “回头”，以此来查找出所有的解的时候，使用回溯算法。比如leetcode78子集合问题、leetcode90子集合II、全排列问题（01234的5个数的全排列）、leetcode17电话号码的字母组合、leetcode39组合总和leetcode40组合总和II。

leetcode26.删除有序数组中的重复项.80.删除有序数组中的重复项II.27.移除元素

Tue, 07 Mar 2023 00:00:00 +0000

Question-26-删除有序数组中的重复项

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = […]; // 输入数组 int[] expectedNums = […]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length; for (int i = 0; i < k; i++) { assert nums[i] == expectedNums[i]; }

如果所有断言都通过，那么您的题解将被通过。

示例 1：

输入：nums = [1,1,2] 输出：2, nums = [1,2,_] 解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4] 输出：5, nums = [0,1,2,3,4] 解释：函数应该返回新的长度 5 ，并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 10⁴ -10⁴ <= nums[i] <= 10⁴ nums 已按升序排列

Related Topics 数组双指针 👍 3049 👎 0

Answer-26

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


/*
 * 26
 * in:[0,0,1,1,1,2,2,3,3,4]
 * out:5, nums = [0,1,2,3,4]
 * 指针j遍历数组，指针i作为不重复元素的下标
 */
int removeDuplicates_func1(vector<int>& nums) {
 int i = 1; //i=0一定不变
 for (int j = 1; j < nums.size(); ++j) {
 if (nums[j] != nums[j-1]) {
 nums[i] = nums[j];
 i++;
 }
 }
 return i;
}

int removeDuplicates_func2(vector<int> &nums) {
 if (nums.empty()) {
 return 0;
 }
 int flag = nums[0];
 for (int i = 1; i < nums.size(); i++) {
 if (nums[i] == flag) {
 nums[i] = INT_MAX;
 } else {
 flag = nums[i];
 }
 }
 nums.erase(remove(nums.begin(), nums.end(), INT_MAX), nums.end());
 return nums.size();
}

Question-27-移除元素

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

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝 int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }

示例 1：

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

示例 2：

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

提示：

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

Related Topics 数组双指针 👍 1691 👎 0

Answer-27

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


/*
 * 27
 * in: [0,1,2,2,3,0,4,2], val = 2
 * out: 5, nums = [0,1,4,0,3]
 */
int removeElement(vector<int>& nums, int val) {
 int i = 0;
 for (int j = 0; j < nums.size(); ++j) {
 if (nums[j] != val) {
 nums[i] = nums[j];
 i++;
 }
 }
 return i;
}

Question-80-删除有序数组中的重复项

给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }

示例 1：

输入：nums = [1,1,1,2,2,3] 输出：5, nums = [1,1,2,2,3] 解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,1,2,3,3] 输出：7, nums = [0,0,1,1,2,3,3] 解释：函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 10⁴ -10⁴ <= nums[i] <= 10⁴ nums 已按升序排列

Related Topics 数组双指针 👍 769 👎 0

Answer-80

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


/*
 * 80
 * in:nums = [0,0,1,1,1,1,2,3,3]
 * out:7, nums = [0,0,1,1,2,3,3]
 * i慢指针记录修改后的值，j快指针遍历数组
 */
int removeDuplicates_80(vector<int>& nums) {
 if (nums.size() < 3) {
 return nums.size();
 }
 int i = 2;
 for (int j = 2; j < nums.size(); ++j) {
 if (nums[i-2] != nums[j]) { //当前值不等于上上个被保留的值
 nums[i] = nums[j]; //更新当前被保留的值
 i++;
 }
 }
 return i;
}

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

Tue, 07 Mar 2023 00:00:00 +0000

Question-3

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

示例 1:

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

示例 2:

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

示例 3:

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

提示：

0 <= s.length <= 5 * 10⁴ s 由英文字母、数字、符号和空格组成

Related Topics 哈希表字符串滑动窗口 👍 8835 👎 0

Answer-3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


/*
 * 3
 */
int lengthOfLongestSubstring_func1(string s) {
 int start = 0, ans = 0;
 unordered_set<char> strset; //滑动窗口，临时子串
 for (int i = 0; i < s.size(); i++) {
 while (strset.find(s[i]) != strset.end()){ //有重复
 strset.erase(s[start]); //窗口右移
 start++;
 }
 ans = max(ans, i-start+1);
 strset.insert(s[i]); //set中没该字符，加入窗口
 }
 return ans;
}

int lengthOfLongestSubstring_func2(string s) {
 int start = 0, end = 0, ans = 0; //双指针
 unordered_set<char> strset;
 while (end < s.size()) {
 if (strset.find(s[end]) != strset.end()) { //有重复
 strset.erase(s[start]); //左指针移动，删除..
 start++;
 } else { //无重复
 strset.insert(s[end]); //右指针移动，加入..
 end++;
 }
 if (strset.size() > ans) ans = strset.size();
// ans = max(ans, strset.size());
 }
 return ans;
}

Attention

方法一，滑动窗口
1. unordered_set保存临时子串，while循环当当前字符有重复时，窗口右移动，起始指针右移，在set中移除该字符；当前字符无重复时，将当前字符加入窗口
2. 返回结果长度在当前字符无重复时更新
方法二，双指针
1. end指针移动，while循环
2. 判断当前字符有重复时，左指针右移动，删除start指向的字符；无重复，当前字符加入set，右指针继续右移动

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

Tue, 07 Mar 2023 00:00:00 +0000

Question-4

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

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

示例 1：

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

示例 2：

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

提示：

nums1.length == m nums2.length == n 0 <= m <= 1000 0 <= n <= 1000 1 <= m + n <= 2000 -10⁶ <= nums1[i], nums2[i] <= 10⁶

Related Topics 数组二分查找分治 👍 6337 👎 0

Answer-4

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


/*
 * 4
 * nums1 = [1,2], nums2 = [3,4]
 * 2.50000
 */
double findMedianSortedArrays_func1_merge(vector<int>& nums1, vector<int>& nums2) {
 int len = nums1.size() + nums2.size();
 vector<int> res(len, 0);
 int i = 0, j = 0, k = 0;
 while (i < nums1.size() && j < nums2.size()) {
 if (nums1[i] < nums2[j]) {
 res[k++] = nums1[i++];
 } else {
 res[k++] = nums2[j++];
 }
 }
 while (i < nums1.size()) res[k++] = nums1[i++]; //nums1更长，把nums1剩下的加上
 while (j < nums2.size()) res[k++] = nums2[j++]; //nums2更长，把nums2剩下的加上
// for (auto it : res) printf("%d ", it);
 printf("\n");
 if (k % 2) {
 return res[k/2];
 } else {
 return (res[k/2-1] + res[k/2]) / 2.0;
 }
}

Attention

使用归并的方式，合并两个有序数组，得到一个大的有序数组。大的有序数组的中间位置的元素，即为中位数
时间复杂度是 O(m+n)，空间复杂度是 O(m+n)

leetcode5.最长回文子串

Tue, 07 Mar 2023 00:00:00 +0000

Question-5

给你一个字符串 s，找到 s 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

示例 1：

输入：s = “babad” 输出：“bab” 解释：“aba” 同样是符合题意的答案。

示例 2：

输入：s = “cbbd” 输出：“bb”

提示：

1 <= s.length <= 1000 s 仅由数字和英文字母组成

Related Topics 字符串动态规划 👍 6220 👎 0

Answer-5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


//法一
//"babad"
//"bab"
string longestPalindrome(string s) {
 if (s.empty()) return "";
 int start = 0, maxsize = 1;
 for (int i = 0; i < s.size(); ++i) {
 for (int j = i+1; j < s.size(); ++j) {
 int p1 = i, p2 = j;
 while (p1 < p2) {
 if (s[p1] != s[p2]) break;
 p1++;
 p2--;
 }
 if (p1 >= p2 && j-i+1 > maxsize) {
 maxsize = max(maxsize, j-i+1);
 start = i; //仅在需要更新时更新start，否则"ccc"返回"cc"
 cout << "[i: " << i << " j:" << j << endl;
 cout << "p1: " << p1 << " p2:" << p2 << endl;
 cout << "maxsize: " << maxsize << "]" << endl;
 }
 }
 }
 cout << "start: " << start << ", maxsize: " << maxsize << endl;
 return s.substr(start, maxsize);
}


/*
 * 法二
 * 1、分解成更小的问题解决，判断abba，先判断最外侧dp[0][3]=1，内侧dp[1][2]=1，若为假不需要继续判断
 * 2、已知：长度是1必然true，长度为2或3，仅需判断最外侧
 * 3、当s[i]=s[j]时，如果s[i+1...j-1]是回文串，则s[i...j]也是回文串；如果s[i+1...j-1]不是回文串，则s[i...j]不是回文串
 * 4、注意：两层循环写法。i从0到s.size()，j从i+1到s.size()会导致abba在i=0,j=3时，无法获取子串dp[1][2]的值
 * 需要j从1到s.size()，i从前往后到j的位置
 */
string longestPalindrome_withdp(string s) {
 if (s.empty()) return "";
 int start = 0, maxsize = 1;
 vector<vector<int>> dp(s.size(), vector<int>(s.size())); //s*s
 for (int j = 1; j < s.size(); ++j) {
 for (int i = 0; i < j; i++) {
 if (s[i] == s[j]) {
 if (j-i+1 == 2 || j-i+1 == 3){
 dp[i][j] = 1;
 } else {
 if (dp[i+1][j-1] == 0) continue;
 dp[i][j] = 1;
 }

 if (dp[i][j] == 1 && j-i+1 > maxsize) {
 maxsize = j-i+1;
 start = i;
 cout << "[start: " << start << ", maxsize: " << maxsize << " ,ij " << i << j << "]" << endl;
 }
 }
 }
 }
 return s.substr(start, maxsize);
}

Attention

方法一暴力法，i从0到s.size()，j从i+1到s.size()，枚举出所有子串，判断长度大于1的子串是否是回文子串。
1. 判断子串是否为回文子串，可while循环双指针移动，当p1>=p2时，必为回文，更新maxsize
2. substr函数返回结果
3. 时间复杂度：O(N3)
方法二动态规划
1. 回文天然具有「状态转移」性质：一个长度严格大于 2 的回文去掉头尾字符以后，剩下的部分依然是回文。反之，如果一个字符串头尾两个字符都不相等，那么这个字符串一定不是回文
2. 初始化一个n*n的空间，dp[i][j]，i为子串初始位置，j为子串截止位置
3. 截止位置j从1到s.size()，起始位置i从0到j，i为行，j为列，先遍历j，然后遍历i
4. dp[i][j] = dp[i + 1][j - 1];

leetcode9.回文数

Tue, 07 Mar 2023 00:00:00 +0000

Question-9

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121 输出：true

示例 2：

输入：x = -121 输出：false 解释：从左向右读, 为 -121 。从右向左读, 为 121- 。因此它不是一个回文数。

示例 3：

输入：x = 10 输出：false 解释：从右向左读, 为 01 。因此它不是一个回文数。

提示：

-2³¹ <= x <= 2³¹ - 1

进阶：你能不将整数转为字符串来解决这个问题吗？

Related Topics 数学 👍 2440 👎 0

Answer-9

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


/*
 * 9
 * x = -121, false
 */
bool isPalindrome(int x) {
 if (x < 0) return false;
 int x_ = x; //备份x
 long long res = 0; //定义int会溢出
 while(x != 0) {
 int n = x % 10;
 res = res * 10 + n;
 x /= 10;
 }
 cout << res << endl;
 if (res == x_) {
 return true;
 } else {
 return false;
 }
}

Attention

不转化成字符串判断，主要是int型溢出的问题。res定义成long long类型
模拟过程：·输入123，n=3，res=0*10+3=3，x=12；n=2，res=3*10+2=32，x=1；n=1，res=32*10+1=321，x=0
x=0时退出循环

leetcode96.不同的二叉搜索树

Mon, 06 Mar 2023 00:00:00 +0000

Question

给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的二叉搜索树有多少种？返回满足题意的二叉搜索树的种数。

示例 1：

输入：n = 3 输出：5

示例 2：

输入：n = 1 输出：1

提示：

1 <= n <= 19

Related Topics 树二叉搜索树数学动态规划二叉树 👍 2126 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


//95,返回所有的子树
//96
//n = 3
//5
//1.1~n中n个数字为root，求以i为根的bst个数
//2.以i为根的左子树个数 * 以i为根的右子树的个数 = 以i为根的bst个数
//3.以i为根的左子树，有1～i-1这些数字组成(i-1个)；以i为根的右子树，以i+1～n这些数字组成(n-i个)
int dfs0(int n) {
 int ans = 0;
 if (n==0 ||n==1)
 return 1;//n==0时返回1，否则相乘为0
 for (int i = 1; i <= n; ++i) {
 ans += dfs0(i-1)*dfs0(n-i);
 }
 return ans;
}
int numTrees0(int n) {
 //暴力法，Time Limit Exceeded，o(n!)
 return dfs0(n);
}

int dfs1(vector<int> &store, int n) {
 int ans = 0;
 if (n==0 || n==1) {
 return 1;
 }
 if (store[n] != -1) {
 return store[n];
 }
 for (int i = 1; i <= n; ++i) {
 store[i-1] = dfs1(store, i-1);
 store[n-i] = dfs1(store, n-i);
 ans += store[i-1]*store[n-i];
 }
 return ans;
}
int numTrees1(int n) {
 //vec存下计算过的数量，避免超时
 vector<int> store(n+1, -1);
 return dfs1(store, n);
}

// f[i] : 表示以i为根节点组成的树的个数，对于每个f[i] = G[i-1] * G[n-i]
// G[n] : 表示n个节点组成的二叉树的个数
// G[n] = f[1] + f[2] + ... + f[n];
// G[n] = G[0]*G[n-1] + G[1]*G[n-2] + ....G[n-1]*G[0]
// G[2] = f[1] + f[2] = G[0]*G[1] + G[1]*G[0]
// G[3] = G[0]*G[2] + G[1]*G[1] + G[2]*G[0]
int numTrees2(int n) {
 //o(n)
 vector<int> G(n+1,0);
 G[0] = 1;
 G[1] = 1;
 for(int i = 2; i <= n; i++){
 for(int j = 1; j <= i; j++){
 G[i] += G[j-1]*G[i-j];
 }
 }
 return G[n];
}

Attention

结论一：以i为根的左子树，有1～i-1这些数字组成(i-1个)；以i为根的右子树，以i+1～n这些数字组成(n-i个)
结论二：以i为根的左子树个数 * 以i为根的右子树的个数 = 以i为根的bst个数
numTrees0方法超时，可以通过vector<int> store(n+1, -1)记录下已经计算过的组合数量
注意递归边界：n==0 || n==1
numTrees2是动态规划

同步和互斥

Mon, 27 Jun 2022 00:00:00 +0000

软件实现法
- 单标志法：
  - 设置公共bool变量turn
  - p1完成后p2阻塞，不能做到空闲让进
- 双标志先检查法
  - bool的数组flag[2]，初始值为false，flag[0]=true表示p1允许进入临界区
  - p1和p2同时进入临界区，不能做到忙则等待
- 双标志，先修改后检查
  - 先赋值操作，表示自己想要进入临界区
  - 并发进入，导致都在while循环，产生饥饿
- Peterson’s算法
  - 先修改，后检查，后修改者等待。
  - turn的值收到并发执行速度有关，turn值先变1再变0，根据后修改者等待原则，p1执行p2等待
  - 该方法实现了空闲让进和忙则等待
硬件实现法
- 禁止中断
- 专用机器指令
  - TS指令
  - swap指令

leetcode105.从前序与中序遍历序列构造二叉树.106.从中序与后序遍历序列构造二叉树

Tue, 31 May 2022 00:00:00 +0000

Question

105

给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7] Output: [3,9,20,null,null,15,7]

示例 2:

Input: preorder = [-1], inorder = [-1] Output: [-1]

提示:

1 <= preorder.length <= 3000 inorder.length == preorder.length -3000 <= preorder[i], inorder[i] <= 3000 preorder 和 inorder 均无重复元素 inorder 均出现在 preorder preorder 保证为二叉树的前序遍历序列 inorder 保证为二叉树的中序遍历序列

Related Topics 树数组哈希表分治二叉树 👍 1258 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


//105 ac
//Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
TreeNode* builder(vector<int>& preorder, int pre_start, int pre_end, vector<int>& inorder, int in_start, int in_end) {
 if (pre_start == pre_end) {
 return nullptr;
 }
 TreeNode *root = new TreeNode(preorder[pre_start]);
 int in_root;
 for (int i = in_start; i < in_end; ++i) {
 if (inorder[i] == root->val) {
 printf("root->val[%d]\n", root->val);
 in_root = i;
 break;
 }
 }
 int left_len = in_root - in_start;
 root->left = builder(preorder, pre_start + 1, pre_start + left_len + 1, inorder, in_start, in_root);
 root->right = builder(preorder, pre_start + left_len + 1, pre_end, inorder, in_root + 1, in_end);
 return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
 return builder(preorder, 0, preorder.size(), inorder, 0, inorder.size());
}

//105 ac
//Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
TreeNode* builder_105(vector<int>& preorder, int pre_start, int pre_end, vector<int>& inorder, int in_start, int in_end) {
// if (pre_end < pre_start) {
// return nullptr;
// }
 if (in_end < in_start) {
 //递归边界可以是in可以是pre
 return nullptr;
 }
 printf("pre_start[%d], pre_end[%d], in_start[%d], in_end[%d]\n", pre_start, pre_end, in_start, in_end);
 TreeNode *root = new TreeNode(preorder[pre_start]);//pre的第一个结点作为root,3
 int in_root;
 for (int i = in_start; i <= in_end; ++i) {
 if (inorder[i] == root->val) {
 printf("root->val[%d]\n", root->val);
 in_root = i;//在in数组中找到值为root的结点
 break;
 }
 }
 int left_len = in_root - in_start;//1=1-0
 //注意边界，左子树[in_start, in_root-1], [pre_start+1, pre_start+left_len];
 //右子树[in_root+1, in_end], [pre_start+left_len+1, pre_end];
 //对于in数组，选择左右子树时候，左子树是in_root-1，右子树是in_root+1
 //对于pre数组，选择左右子树的时候，左子树需要pre_start+1(pre_start是根结点), 右子树还是pre_end
 root->left = builder_105(preorder, pre_start + 1, pre_start + left_len, inorder, in_start, in_root - 1);
 root->right = builder_105(preorder, pre_start + left_len + 1, pre_end, inorder, in_root + 1, in_end);
 return root;
}
TreeNode* buildTree_105(vector<int>& preorder, vector<int>& inorder) {
 return builder(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1);
}

Question

106

根据一棵树的中序遍历与后序遍历构造二叉树。

注意: 你可以假设树中没有重复的元素。

例如，给出

中序遍历 inorder = [9,3,15,20,7] 后序遍历 postorder = [9,15,7,20,3]

返回如下的二叉树：

3 /
9 20 /
15 7

Related Topics 树数组哈希表分治二叉树 👍 598 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


//106 ac
//inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
TreeNode* builder_106(vector<int>& inorder, int in_start, int in_end, vector<int>& postorder, int post_start, int post_end) {
 if (in_end < in_start) {
 return nullptr;
 }
 TreeNode *root = new TreeNode(postorder[post_end]);//post的最后一个结点作为root
 int in_root;
 for (int i = in_start; i <= in_end; ++i) {
 if (inorder[i] == root->val) {
 printf("root=[%d], in_root=[%d]\n", root->val, i);
 in_root = i;//在in数组中找到值为root的结点
 break;
 }
 }
 int left_len = in_root - in_start;//1
 //注意边界，左子树[in_start, in_root-1], [post_start, post_start+left_len-1];
 //右子树[in_root+1, in_end], [post_start+left_len, post_end-1];
 //对于in数组，选择左右子树时候，左子树是in_root-1，右子树是in_root+1
 //对于pre数组，选择左右子树的时候，左子树需要post_start, 右子树是post_end-1(post_end是根结点)
 root->left = builder_106(inorder, in_start, in_root - 1, postorder, post_start, post_start + left_len - 1);
 root->right = builder_106(inorder, in_root + 1, in_end, postorder, post_start + left_len, post_end - 1);
 return root;
}

TreeNode* buildTree_106(vector<int>& inorder, vector<int>& postorder) {
 return builder_106(inorder, 0, inorder.size()-1, postorder, 0, postorder.size()-1);
}

Attention

leetcode200.岛屿数量

Tue, 31 May 2022 00:00:00 +0000

Question

给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。

岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

此外，你可以假设该网格的四条边均被水包围。

示例 1：

输入：grid = [ [“1”,“1”,“1”,“1”,“0”], [“1”,“1”,“0”,“1”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“0”,“0”,“0”] ] 输出：1

示例 2：

输入：grid = [ [“1”,“1”,“0”,“0”,“0”], [“1”,“1”,“0”,“0”,“0”], [“0”,“0”,“1”,“0”,“0”], [“0”,“0”,“0”,“1”,“1”] ] 输出：3

提示：

m == grid.length n == grid[i].length 1 <= m, n <= 300 grid[i][j] 的值为 ‘0’ 或 ‘1’

Related Topics 深度优先搜索广度优先搜索并查集数组矩阵 👍 1733 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68


//200
//11110
//11010
//11000
//00000
//1
//200-Solution1
void bfs(int i, int j, int n, int m, vector<vector<char>>& grid) {
 if (i<0 || i>n-1 || j<0 || j>m-1 || grid[i][j]=='0')
 //[0~n-1],递归边界是出界或者找到为0的值
 return;
 grid[i][j]='0';//搜索到为1的值置0，不用再次遍历
 bfs(i-1, j, n, m, grid);
 bfs(i+1, j, n, m, grid);
 bfs(i, j-1, n, m, grid);
 bfs(i, j+1, n, m, grid);//上下左右，可以换顺序
}
int numIslands0(vector<vector<char>>& grid) {
 if (grid.empty()) {
 return 0;
 }
 int n = grid.size();
 int m = grid[0].size();
 int res = 0;
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < m; ++j) {
 if (grid[i][j] == '1') {
 bfs(i, j, n, m, grid);
 res++;
 }
 }
 }
 return res;
}

//200-Solution2
void dfs(int i, int j, int n, int m, vector<vector<char>>& grid) {
 grid[i][j] = 0;
 if (i>0 && grid[i-1][j] == '1') {
 dfs(i-1, j, n, m, grid);
 }
 if (i<n-1 && grid[i+1][j] == '1') {
 dfs(i+1, j, n, m, grid);
 }
 if (j>0 && grid[i][j-1] == '1') {
 dfs(i, j-1, n, m, grid);
 }
 if (j<m-1 && grid[i][j+1] == '1') {
 dfs(i, j+1, n, m, grid);
 }
}
int numIslands(vector<vector<char>>& grid) {
 if (grid.empty()) {
 return 0;
 }
 int n = grid.size();
 int m = grid[0].size();
 int res = 0;
 for (int i = 0; i < n; ++i) {
 for (int j = 0; j < m; ++j) {
 if (grid[i][j] == '1') {
 dfs(i, j, n, m, grid);
 res++;
 }
 }
 }
 return res;
}

Attention

94.144.145.102.107.树的基本遍历操作

Mon, 30 May 2022 00:00:00 +0000

Question

实现二叉树的前中后序遍历

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150


struct TreeNode {
 int val;
 TreeNode *left;
 TreeNode *right;
 TreeNode() : val(0), left(nullptr), right(nullptr) {}
 TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

void inOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 if (root->left) {
 inOrder(root->left, res);
 }
 res.push_back(root->val);
 if (root->right) {
 inOrder(root->right, res);
 }
}

void postOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 if (root->left) {
 postOrder(root->left, res);
 }
 if (root->right) {
 postOrder(root->right, res);
 }
 res.push_back(root->val);
}


void preOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 res.push_back(root->val);
 if (root->left) {
 preOrder(root->left, res);
 }
 if (root->right) {
 preOrder(root->right, res);
 }
}

//94
vector<int> inorderTraversal(TreeNode* root) {
 vector<int> res;
 inOrder(root, res);
 return res;
}

//144
vector<int> preorderTraversal(TreeNode* root) {
 vector<int> res;
 preOrder(root, res);
 return res;
}

//145
vector<int> postorderTraversal(TreeNode* root) {
 vector<int> res;
 postOrder(root, res);
 return res;
}


// 3
// / \
// 9 20
// / \
// 15 7
//inout : [3,9,20,null,null,15,7]
//vector<int> level_vecs = {3,9,20,-1,-1,15,7};


//levelOrderByQueue
//102
vector<vector<int>> levelOrder(TreeNode* root) {
 //迭代
 //广度优先搜索(BFS队列)
 vector<vector<int>> res;
 if (!root)
 return res;
 queue<TreeNode*> q;
 q.push(root);

 while(!q.empty()) {
 res.emplace_back();//容器尾部添加一个元素
 int len = q.size();
 for (int i = 0; i < len; i++) {
 TreeNode* node = q.front();
 res.back().push_back(node->val);
 q.pop();

 if (node->left) {
 q.push(node->left);
 }
 if (node->right) {
 q.push(node->right);
 }
 }
 }
 return res;
}

void leveOrderByQueue(TreeNode* root) {
 queue<TreeNode*> q;
 if (root != nullptr) {
 q.push(root);
 }
 while (!q.empty()) {
 TreeNode *node = q.front();
 cout << "node: " << node->val << endl;
 if (node->left) {
 q.push(node->left);
 }
 if (node->right) {
 q.push(node->right);
 }
 q.pop();
 }
}

//107
//自底向上的层序遍历
vector<vector<int>> levelOrderBottom(TreeNode* root) {
 vector<vector<int>> res;
 if (!root)
 return res;
 queue<TreeNode*> q;
 q.push(root);

 while(!q.empty()) {
 res.emplace_back();
 int len = q.size();
 for (int i = 0; i < len; i++) {
 TreeNode* node = q.front();
 res.back().push_back(node->val);
 q.pop();

 if (node->left) {
 q.push(node->left);
 }
 if (node->right) {
 q.push(node->right);
 }
 }
 }
 reverse(res.begin(), res.end());
 return res;
}

Attention

leetcode912.排序数组

Mon, 30 May 2022 00:00:00 +0000

Question

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

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

示例 2：

输入：nums = [5,1,1,2,0,0] 输出：[0,0,1,1,2,5]

提示：

1 <= nums.length <= 5 * 104 -5 * 104 <= nums[i] <= 5 * 104

Related Topics 数组分治桶排序计数排序基数排序排序堆（优先队列）归并排序 👍 535 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


void quickSort(vector<int>&nums, int left, int right) {
 if (left >= right) return;
 int privot = nums[left];//privot选择左边的数，让j指针先向左移动
 int i = left;
 int j = right;
 while(i < j) {
 while(nums[j] >= privot && i < j) {
 j--;
 }
 while(nums[i] <= privot && i < j) {
 i++;
 }

 if (i<j) {
 swap(nums[i], nums[j]);
 }
 }
 for(auto it : nums) {
 cout << it << " ";
 }
 cout << endl;

 swap(nums[left], nums[i]);//i==j时

 quickSort(nums, left, i-1);
 quickSort(nums, i+1, right);
}

vector<int> sortArray(vector<int>& nums) {
 quickSort(nums, 0, nums.size()-1);
 return nums;
}

//快速排序，从大到小
//AC
void quickSort2(vector<int>&nums, int left, int right) {
 if (left >= right) return;
 int privot = nums[left];
 int i = left;
 int j = right;
 while(i < j) {
 while(nums[j] <= privot && i < j) {
 j--;
 }
 while(nums[i] >= privot && i < j) {
 i++;
 }

 if (i<j) {
 swap(nums[i], nums[j]);
 }
 }

 swap(nums[left], nums[i]);
 quickSort2(nums, left, i-1);
 quickSort2(nums, i+1, right);
}

Attention

privot选择左边的数，让j指针先向左移动，privot选择右边的数，让指针i先向右移动。i==j时交换。

leetcode155.最小栈

Tue, 24 May 2022 00:00:00 +0000

Question

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

实现 MinStack 类:

MinStack() 初始化堆栈对象。 void push(int val) 将元素val推入堆栈。 void pop() 删除堆栈顶部的元素。 int top() 获取堆栈顶部的元素。 int getMin() 获取堆栈中的最小元素。

示例 1:

输入： [“MinStack”,“push”,“push”,“push”,“getMin”,“pop”,“top”,“getMin”] [[],[-2],[0],[-3],[],[],[],[]]

输出： [null,null,null,null,-3,null,0,-2]

解释： MinStack minStack = new MinStack(); minStack.push(-2); minStack.push(0); minStack.push(-3); minStack.getMin(); –> 返回 -3. minStack.pop(); minStack.top(); –> 返回 0. minStack.getMin(); –> 返回 -2.

提示：

-2³¹ <= val <= 2³¹ - 1 pop、top 和 getMin 操作总是在非空栈上调用 push, pop, top, and getMin最多被调用 3 * 10⁴ 次

Related Topics 栈设计 👍 1310 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


//155
// MinStack() 初始化堆栈对象。
// void push(int val) 将元素val推入堆栈。
// void pop() 删除堆栈顶部的元素。
// int top() 获取堆栈顶部的元素。
// int getMin() 获取堆栈中的最小元素。
class MinStack {
 stack<int> s;
 stack<int> s_helper;
public:
 MinStack() {
 s_helper.push(INT_MAX);
 }

 void push(int val) {
 s.push(val);
 s_helper.push(min(s_helper.top(), val));
 }

 void pop() {
 s.pop();
 s_helper.pop();
 }

 int top() {
 return s.top();
 }

 int getMin() {
 return s_helper.top();
 }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(val);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->getMin();
 */

Attention

leetcode121.122.买卖股票的最佳时机

Thu, 19 May 2022 00:00:00 +0000

Question

121.买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4] 输出：5 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

1 <= prices.length <= 105 0 <= prices[i] <= 104

Related Topics 数组动态规划 👍 2151 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


//121
//in：[7,1,5,3,6,4]
//5
int maxProfit121(vector<int>& prices) {
 //贪心
 if (!prices.size())
 return 0;
 int tmpM = prices[0], res = 0;
 for (auto x : prices) {
 if (x < tmpM) {
 tmpM = x;
 } else {
 res = max(res, x-tmpM);
 }
 }
 return res;
}

Question

122.买卖股票的最佳时机II

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。

返回你能获得的最大利润。

示例 1：

输入：prices = [7,1,5,3,6,4] 输出：7 解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

1 <= prices.length <= 3 * 10⁴ 0 <= prices[i] <= 10⁴

Related Topics 贪心数组动态规划 👍 1706 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


//122
//in：prices = [7,1,5,3,6,4]
//7
int maxProfit122(vector<int>& prices) {
 int res = 0;
 for (int i = 1; i < prices.size(); i++) {
 int tmp = prices[i] - prices[i - 1];
 if (tmp > 0) {
 res += tmp;
 }
 }
 return res;
}

Attention

leetcode128.最长连续序列

Thu, 19 May 2022 00:00:00 +0000

Question

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1：

输入：nums = [100,4,200,1,3,2] 输出：4 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

示例 2：

输入：nums = [0,3,7,2,5,8,4,6,0,1] 输出：9

提示：

0 <= nums.length <= 10⁵ -10⁹ <= nums[i] <= 10⁹

Related Topics 并查集数组哈希表 👍 1254 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


//128最长连续序列，并查集
//in：nums = [100,4,200,1,3,2]
//4
//in：nums = [0,3,7,2,5,8,4,6,0,1]
//9
unordered_map<int, int> fa, cnt;
int find0(int x) {
 //无压缩find
 while (fa[x] != x)
 x = fa[x];//向上找
 return x;//return root
}
int find(int x) {
 //压缩路径，fa[x]==root
 if (fa[x] == x)
 return x;//出口，root
 return fa[x] = find(fa[x]);
}
int join(int x, int y) {
 //合并，修改每颗合并后的层高
 x = find(x);
 y = find(y);
 if (x==y) return cnt[x];
 if (cnt[x] > cnt[y]) {
 fa[y] = x;
 cnt[x] += cnt[y];
 return cnt[x];
 } else {
 fa[x] = y;
 cnt[y] += cnt[x];
 return cnt[y];
 }
}
int longestConsecutive(vector<int>& nums) {
 if (!nums.size()) return 0;
 for (auto x : nums) {
 //让每个num自成一个子树，指定层高为1
 fa[x] = x;
 cnt[x] = 1;
 }
 int res = 1;
 for (auto x : nums) {
 //遍历nums，如果x+1也在nums中，则合并这两个子树
 if (fa.count(x+1)) {
 //统计合并后子树层高，与之前的res取大的一个
 res = max(res, join(x, x+1));
 }
 }
 return res;
}

Attention

leetcode108.将有序数组转换为二叉搜索树

Thu, 12 May 2022 00:00:00 +0000

Question

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。

高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5] 解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3] 输出：[3,1] 解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 10⁴ -10⁴ <= nums[i] <= 10⁴ nums 按严格递增顺序排列

Related Topics 树二叉搜索树数组分治二叉树 👍 1035 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


//108
TreeNode* buildBST(vector<int>& nums, int l, int r) {
 //递归，找到中间node作为root
 if (l>r)
 return nullptr;
 int mid = (l+r)/2;
 TreeNode *root = new TreeNode(nums[mid]);
 root->left = buildBST(nums, l, mid-1);
 root->right = buildBST(nums, mid+1, r);
 return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
 return buildBST(nums, 0, nums.size()-1);
}

Attention

leetcode110.平衡二叉树

Thu, 12 May 2022 00:00:00 +0000

Question

给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。

高度平衡二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9] 输出：[0,-3,9,-10,null,5] 解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3] 输出：[3,1] 解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。

提示：

1 <= nums.length <= 10⁴ -10⁴ <= nums[i] <= 10⁴ nums 按严格递增顺序排列

Related Topics 树二叉搜索树数组分治二叉树 👍 1035 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//110
//两层递归判断是否平衡
int getDepth(TreeNode* root) {
 if (!root)
 return 0;
 int leftDepth = getDepth(root->left);
 int rightDepth = getDepth(root->right);
 return max(leftDepth, rightDepth) + 1;
}
bool isBalanced(TreeNode* root) {
 if (!root)
 return true;
 if (abs(getDepth(root->left) - getDepth(root->right)) > 1) {
 return false;
 } else {
 return isBalanced(root->left) && isBalanced(root->right);
 }
}

Attention

leetcode111.二叉树的最小深度

Thu, 12 May 2022 00:00:00 +0000

Question

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

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7] 输出：2

示例 2：

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

提示：

树中节点数的范围在 [0, 10⁵] 内 -1000 <= Node.val <= 1000

Related Topics 树深度优先搜索广度优先搜索二叉树 👍 749 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


//111，求二叉树的最小深度（最小深度是指从根节点到叶节点的最短距离）
//dfs，递归
int minDepth(TreeNode* root) {
 if (!root)
 return 0;
 if (!root->left && !root->right) {
 return 1;
 }
 int minDepthRes = INT_MAX;//最大！！
 if (root->left)
 minDepthRes = min(minDepthRes, minDepth(root->left));
 if (root->right)
 minDepthRes = min(minDepthRes, minDepth(root->right));
 return 1+minDepthRes;
}

//非递归层次遍历
int minDepth2(TreeNode* root) {
 if (!root)
 return 0;
 queue<TreeNode*> q;
 q.push(root);
 int depth = 0;
 while (!q.empty()) {
 depth++;
 int len = q.size();
 for (int i = 0; i < len; ++i) {
 TreeNode *tmp = q.front();
 q.pop();
 if (!tmp->left && !tmp->right) {
 //无左右子结点即退出
 return depth;
 }
 if (tmp->left)
 q.push(tmp->left);
 if (tmp->right)
 q.push(tmp->right);
 }
 }
 return depth;
}

Attention

leetcode112.路径总和

Thu, 12 May 2022 00:00:00 +0000

Question

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出：true 解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5 输出：false 解释：树中存在两条根节点到叶子节点的路径： (1 –> 2): 和为 3 (1 –> 3): 和为 4 不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0 输出：false 解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

树中节点的数目在范围 [0, 5000] 内 -1000 <= Node.val <= 1000 -1000 <= targetSum <= 1000

Related Topics 树深度优先搜索广度优先搜索二叉树 👍 877 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


//112
// 5
// 4 8
// 11 n 13 4
//7 2 n n n 1
//5.4.11.2=22
//从root开始，用sum减去路过的结点值，到达叶子结点时判断sum是否为0，为0则true。
//递归的循环左右子树，用或条件。
bool hasPathSum(TreeNode* root, int targetSum) {
 if (!root)
 return false;
 targetSum -= root->val;
 if (!root->left && !root->right) {
 if (targetSum == 0) {
 return true;
 } else {
 return false;
 }
 }
 return hasPathSum(root->left, targetSum) || hasPathSum(root->right, targetSum);
}

//bfs,遍历
bool hasPathSum2(TreeNode* root, int targetSum) {
 if (!root)
 return false;
 queue<TreeNode*> qNode;
 queue<int> qValue;
 qNode.push(root);
 qValue.push(root->val);
 while (!qNode.empty()) {
 TreeNode* now = qNode.front();
 int tmpV = qValue.front();
 qNode.pop();
 qValue.pop();
 if (!now->left && !now->right) {
 //到达叶子结点，判断，返回
 if (tmpV == targetSum) {
 return true;
 }
 continue;//如果不等，需要继续向下遍历，先左后右
 }
 if (now->left) {
 qNode.push(now->left);
 qValue.push(tmpV + now->left->val);
 }
 if (now->right) {
 qNode.push(now->right);
 qValue.push(tmpV + now->right->val);
 }
 }
 return false;
}

Attention

leetcode113.路径总和II

Thu, 12 May 2022 00:00:00 +0000

Question

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。

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

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22 输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5 输出：[]

示例 3：

输入：root = [1,2], targetSum = 0 输出：[]

提示：

树中节点总数在范围 [0, 5000] 内 -1000 <= Node.val <= 1000 -1000 <= targetSum <= 1000

Related Topics 树深度优先搜索回溯二叉树 👍 745 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


//113，跟112相比需要找出所有的路径,dfs
void dfs(TreeNode* root, vector<vector<int>> &res, vector<int> &cur, int targetSum) {
 if (!root)
 return;
 cur.push_back(root->val);
 if (root && !root->left && !root->right && root->val == targetSum) {
 res.push_back(cur);
 }

 dfs(root->left, res, cur, targetSum-root->val);
 dfs(root->right, res, cur, targetSum-root->val);
 cur.pop_back();
}
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
 vector<vector<int>> res;
 vector<int> cur;
 dfs(root, res, cur, targetSum);
 return res;
}

Attention

leetcode226.翻转二叉树

Thu, 12 May 2022 00:00:00 +0000

Question

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

示例 1：

输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1]

示例 2：

输入：root = [2,1,3] 输出：[2,3,1]

示例 3：

输入：root = [] 输出：[]

提示：

树中节点数目范围在 [0, 100] 内 -100 <= Node.val <= 100

Related Topics 树深度优先搜索广度优先搜索二叉树 👍 1282 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


//226
TreeNode* invertTree(TreeNode* root) {
 if (!root)
 return nullptr;
 TreeNode *tmp = root->left;
 root->left = root->right;
 root->right = tmp;

 invertTree(root->left);
 invertTree(root->right);
 return root;
}

Attention

leetcode100.相同的树

Wed, 11 May 2022 00:00:00 +0000

Question

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3] 输出：true

示例 2：

输入：p = [1,2], q = [1,null,2] 输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2] 输出：false

提示：

两棵树上的节点数目都在范围 [0, 100] 内 -10⁴ <= Node.val <= 10⁴

Related Topics 树深度优先搜索广度优先搜索二叉树 👍 833 👎 0

Answer

1
2
3
4
5
6
7
8
9


 if (p == nullptr && q == nullptr)
 return true;
 if (p == nullptr || q == nullptr)
 return false;
 if (p->val == q->val) {
 return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
 } else {
 return false;
 }

Attention

两树为空则相同，有一个为空则不同。
递归当两树根结点相同时，分别比较左右子树，左右子树都相同时才相同。

leetcode101.对称二叉树

Wed, 11 May 2022 00:00:00 +0000

Question

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

输入：root = [1,2,2,3,4,4,3] 输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3] 输出：false

提示：

树中节点数目在范围 [1, 1000] 内 -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？ Related Topics 树深度优先搜索广度优先搜索二叉树 👍 1908 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


//同100，递归出口条件不同
bool isMirror(TreeNode* p, TreeNode* q) {
 if (!p && !q)
 return true;//左右两个结点有都为空，出口
 if (!p || !q)
 return false;//左右两个结点只有一个为空，说明不对称
 if (p->val == q->val) {
 return isMirror(p->left, q->right) && isMirror(p->right, q->left);
 } else {
 return false;
 }
}
//递归
bool isSymmetric1(TreeNode* root) {
 if (!root)
 return true;
 return isMirror(root->left, root->right);
}


//迭代
bool isSymmetric2(TreeNode* root) {
 if (!root)
 return true;
 queue<TreeNode*> q;
 q.push(root->left);
 q.push(root->right);
 //左右子树分别比较
 while (!q.empty()) {
 auto p1 = q.front();
 q.pop();
 auto p2 = q.front();
 q.pop();
 if (!p1 && !p2)
 continue;
 if (!p1 || !p2)
 return false;
 if (p1->val != p2->val) {
 return false;
 }
 q.push(p1->left);
 q.push(p2->right);
 q.push(p1->right);
 q.push(p2->left);//注意顺序
 }
 return true;
}

Attention

leetcode109.有序链表转换二叉搜索树

Wed, 11 May 2022 00:00:00 +0000

Question

给定一个单链表的头节点 head ，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差不超过 1。

示例 1:

输入: head = [-10,-3,0,5,9] 输出: [0,-3,9,-10,null,5] 解释: 一个可能的答案是[0，-3,9，-10,null,5]，它表示所示的高度平衡的二叉搜索树。

示例 2:

输入: head = [] 输出: []

提示:

head 中的节点数在[0, 2 * 10⁴] 范围内 -10⁵ <= Node.val <= 10⁵

Related Topics 树二叉搜索树链表分治二叉树 👍 702 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


//in: head = [-10,-3,0,5,9]
//out: [0,-3,9,-10,null,5]
TreeNode *buildTree1(ListNode *head, ListNode *tail) {
 //递归边界，head==tail
 if (head == tail) return nullptr;
 ListNode *fast = head;
 ListNode *slow = head;
 while (fast != tail && fast->next != tail) {
 slow = slow->next;
 fast = fast->next->next;
 }
 TreeNode *root = new TreeNode(slow->val);//双指针找到中间结点
 root->left = buildTree(head, slow);
 root->right = buildTree(slow->next, tail);
 return root;
}
TreeNode* sortedListToBST1(ListNode* head) {
 return buildTree1(head, nullptr);
}


//vector
TreeNode *buildTree2(vector<int> v, int begin, int end){
 if (begin == end) return nullptr;
 int mid = (begin+end)/2;
 TreeNode *root = new TreeNode(v[mid]);
 root->left = buildTree1(v, begin, mid);
 root->right = buildTree1(v, mid+1, end);
 return root;
}
TreeNode* sortedListToBST2(ListNode* head) {
 vector<int> vec;
 while (head != nullptr) {
 vec.push_back(head->val);
 head = head->next;
 }
 return buildTree2(vec, 0, vec.size());
}

Attention

leetcode114.二叉树展开为链表

Wed, 11 May 2022 00:00:00 +0000

Question

给你二叉树的根结点 root ，请你将它展开为一个单链表：

展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null 。展开后的单链表应该与二叉树先序遍历顺序相同。

示例 1：

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

示例 2：

输入：root = [] 输出：[]

示例 3：

输入：root = [0] 输出：[0]

提示：

树中结点数在范围 [0, 2000] 内 -100 <= Node.val <= 100

进阶：你可以使用原地算法（O(1) 额外空间）展开这棵树吗？ Related Topics 栈树深度优先搜索链表二叉树 👍 1166 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


//114
//in：root = [1,2,5,3,4,null,6]
//out：[1,null,2,null,3,null,4,null,5,null,6]
//前序遍历存到数组后，第i个元素left置空，right指向后一个元素
void preOrder(TreeNode* root, vector<TreeNode*> &v) {
 if (root == nullptr) return;
 v.push_back(root);
 preOrder(root->left, v);
 preOrder(root->right, v);
}
void flatten(TreeNode* root) {
 if (root == nullptr) return;//[]
 vector<TreeNode*> vec;
 preOrder(root, vec);
 for (int i = 0; i < vec.size()-1; i++) {
 vec[i]->left = nullptr;
 vec[i]->right = vec[i+1];//vec[i++]导致stackoverflow
 }
}

Attention

原地？

leetcode33.81.搜索旋转排序数组I和II

Wed, 11 May 2022 00:00:00 +0000

Question-33

整数数组 nums 按升序排列，数组中的值互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[ k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2 ,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

示例 1：

输入：nums = [4,5,6,7,0,1,2], target = 0 输出：4

示例 2：

输入：nums = [4,5,6,7,0,1,2], target = 3 输出：-1

示例 3：

输入：nums = [1], target = 0 输出：-1

提示：

1 <= nums.length <= 5000 -10^4 <= nums[i] <= 10^4 nums 中的每个值都独一无二题目数据保证 nums 在预先未知的某个下标上进行了旋转 -10^4 <= target <= 10^4

进阶：你可以设计一个时间复杂度为 O(log n) 的解决方案吗？ Related Topics 数组二分查找 👍 1623 👎 0

Answer-33

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


//33 //81\153\154
//[4,5,6,0,1,2,3]
//in：nums = [4,5,6,7,0,1,2], target = 0
//out：4
//O(log(n))
//中间值>最右边值，说明左侧有序；中间值<最右值，说明右侧有序。判断target是否在有序列首尾之间...
int search(vector<int>& nums, int target) {
 int l = 0, r = nums.size()-1;
// while (l < r) {
 while (l <= r) {
 int mid = (l+r)/2;
 printf("nums[%d] = [%d]\n", mid, nums[mid]);
 if (nums[mid] == target) return mid;
 if (nums[mid] > nums[r]) {
 if (nums[l] <= target && nums[mid] >= target) {
 r = mid - 1;
 } else {
 l = mid + 1;
 }
 } else if (nums[mid] <= nums[r]){
 if (nums[mid] <= target && nums[r] >= target) {
 l = mid + 1;
 } else {
 r = mid - 1;
 }
 }
 }
 return -1;
}

Question-81

已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1, 2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你旋转后的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。

你必须尽可能减少整个操作步骤。

示例 1：

输入：nums = [2,5,6,0,0,1,2], target = 0 输出：true

示例 2：

输入：nums = [2,5,6,0,0,1,2], target = 3 输出：false

提示：

1 <= nums.length <= 5000 -10⁴ <= nums[i] <= 10⁴ 题目数据保证 nums 在预先未知的某个下标上进行了旋转 -10⁴ <= target <= 10⁴

进阶：

这是搜索旋转排序数组的延伸题目，本题中的 nums 可能包含重复元素。这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

Related Topics 数组二分查找 👍 694 👎 0

Answer-81

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


/*
 * 81
 * in：nums = [2,5,6,0,0,1,2], target = 0
 * out：true
 * in：nums = [2,5,6,0,0,1,2], target = 3
 * out：false
 * nums 可能包含重复元素
 */
bool search_81(vector<int>& nums, int target) {
 int l = 0, r = nums.size() - 1;
 while (l <= r) {
 int mid = (l + r) / 2;
 if (nums[mid] == target) return true;
 if (nums[mid] < nums[r]) { //中间数<最右数，右边有序，[5,6,0,1,2,3,4]，1<4，12345有序
 if (nums[mid] <= target && nums[r] >= target) {
 l = mid + 1;
 } else {
 r = mid - 1;
 }
 } else if (nums[mid] > nums[r]) { //中间数>最右数, 左边有序, [2,5,6,7,0,1,2]，7>2，2567有序
 if (nums[mid] >= target && nums[l] <= target) {
 r = mid - 1;
 } else {
 l = mid + 1;
 }
 } else { //{1,0,1,1,1} target0 超时，nums可能包含重复元素，移动指针位置
 if (nums[l] == target) return true;
 l++;
// if (nums[r] == target) return true;
// r--;
 }
 }
 return false;
}

Attention

leetcode82/83.删除排序链表中的重复元素

Wed, 11 May 2022 00:00:00 +0000

Question

82:

给定一个已排序的链表的头 head ，删除原始链表中所有重复数字的节点，只留下不同的数字。返回已排序的链表。

示例 1：

输入：head = [1,2,3,3,4,4,5] 输出：[1,2,5]

示例 2：

输入：head = [1,1,1,2,3] 输出：[2,3]

提示：

链表中节点数目在范围 [0, 300] 内 -100 <= Node.val <= 100 题目数据保证链表已经按升序排列

Related Topics 链表双指针 👍 884 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


//82
//in：head = [1,2,3,3,4,4,5]
//out：[1,2,5]
//[1,1,3,5]
ListNode* deleteDuplicates82(ListNode* head) {
 ListNode *dummy = new ListNode(-1);
 dummy->next = head;
 ListNode *ptr = dummy;
 while (head != nullptr && head->next != nullptr) {
 if (head->val == head->next->val) {
 //[1,1]
// while (head->val == head->next->val) {
 while (head && head->next && head->val == head->next->val) {
 head = head->next;
 }
 head = head->next;
 ptr->next = head;
 } else {
 ptr = head;
 head = head->next;
 }
 }
 ListNode *res = dummy->next;
 delete dummy;
 return res;
}

Question

给定一个已排序的链表的头 head ，删除所有重复的元素，使每个元素只出现一次。返回已排序的链表。

示例 1：

输入：head = [1,1,2] 输出：[1,2]

示例 2：

输入：head = [1,1,2,3,3] 输出：[1,2,3]

提示：

链表中节点数目在范围 [0, 300] 内 -100 <= Node.val <= 100 题目数据保证链表已经按升序排列

Related Topics 链表 👍 785 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//83
//in：head = [1,1,2,3,3]
//out：[1,2,3]
//[1,1,1,2,3]
//[1,1]
ListNode* deleteDuplicates83(ListNode* head) {
 ListNode *res = head;
 ListNode *ptr = nullptr;
 while (head != nullptr) {
 ptr = head->next;
 while (ptr != nullptr && ptr->val == head->val) {
 ptr = ptr->next;
 }
 head->next = ptr;
 head = ptr;
 }
 return res;
}

Attention

leetcode160.相交链表

Mon, 09 May 2022 00:00:00 +0000

Question

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

自定义评测：

评测系统的输入如下（你设计的程序不适用此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0 listA - 第一个链表 listB - 第二个链表 skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数 skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数

评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案。

示例 1：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, sk ipB = 3 输出：Intersected at ‘8’ 解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

示例 2：

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Intersected at ‘2’ 解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 输出：null 解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m listB 中节点数目为 n 1 <= m, n <= 3 * 104 1 <= Node.val <= 105 0 <= skipA <= m 0 <= skipB <= n 如果 listA 和 listB 没有交点，intersectVal 为 0 如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？ Related Topics 哈希表链表双指针 👍 1683 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
 //hashset
 //先将链表A写入hashtable，再遍历链表b，判断hash表中是否有重复结点
 if (headA == nullptr || headB == nullptr)
 return nullptr;
 unordered_set<ListNode *> set;
 while (headA != nullptr) {
 if (headA != nullptr) {
 set.insert(headA);
 headA = headA->next;
 }
 }
 while (headB != nullptr) {
 if (set.count(headB)) {
 return headB;
 }
 headB = headB->next;
 }
}


ListNode *getIntersectionNode2(ListNode *headA, ListNode *headB) {
 //stack
 //相交结点往后的所有节点相同，stack从上往下pop，top元素不相等时相交
 stack<ListNode *>stackA, stackB;
 while (headA != nullptr) {
 stackA.push(headA);
 headA = headA->next;
 }
 while (headB != nullptr) {
 stackB.push(headB);
 headB = headB->next;
 }

 ListNode *tmp = nullptr;
 while (!stackA.empty() && !stackB.empty() && stackA.top() == stackB.top()) {
 tmp = stackA.top();
 stackA.pop();
 stackB.pop();
 }

 return tmp;
}


//A: a1,a2,c1,c2,c3
//B: b1,b2,b3,c1,c2,c3
//p1:a1,a2,c1,c2,c3,b1,b2,b3,c1,c2,c3
//p2:b1,b2,b3,c1,c2,c3,a1,a2,c1
//当p1遍历完A再遍历B，p2遍历完B再遍历A，链表相交则会相遇
ListNode *getIntersectionNode3(ListNode *headA, ListNode *headB) {
 if (headA == nullptr || headB == nullptr)
 return nullptr;
 ListNode *p1 = headA, *p2 = headB;
 while (p1 != p2) {
 if (p1 == nullptr) {
 p1 = headB;
 } else {
 p1 = p1->next;
 }

 if (p2 == nullptr) {
 p2 = headA;
 } else {
 p2 = p2->next;
 }
 }
 return p1;
}

Attention

leetcode234.回文链表

Sat, 07 May 2022 00:00:00 +0000

Question

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：head = [1,2,2,1] 输出：true

示例 2：

输入：head = [1,2] 输出：false

提示：

链表中节点数目在范围[1, 105] 内 0 <= Node.val <= 9

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ Related Topics 栈递归链表双指针 👍 1350 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87


//array
//需要O(n)空间存放链表结点
bool isPalindrome(ListNode* head) {
 vector<int> p;
 int i = 0, j = 0;
 while (head != nullptr) {
 p.push_back(head->val);
 j++;
 head = head->next;
 }
 j--;
 printf("j = %d\n", j);
 while (i < j) {
 if (p[j--] != p[i++]) {
 return false;
 }
 }
 return true;
}


bool isPalindrome2(ListNode* head) {
 ListNode *fast = head;
 ListNode *slow = head;
 while (fast != nullptr && fast->next != nullptr) {
 slow = slow->next;
 fast = fast->next->next;
 }
 ListNode *p1 = head;
 if (slow->next != nullptr) {
 ListNode *p2 = reverseList(slow);//lc206.反转链表
 while (p1 != nullptr && p2 != nullptr) {
 printf("p1[%d], p2[%d]\n", p1->val, p2->val);
 if (p1->val != p2->val) {
 return false;
 }
 p1 = p1->next;
 p2 = p2->next;
 }
 } else {
 //[1,2]
 if (slow->val == head->val) {
 return true;
 } else {
 return false;
 }
 }
 return true;
}


bool isPalindrome3(ListNode* head) {
 ListNode *fast = head;
 ListNode *slow = head;
 while (fast != nullptr && fast->next != nullptr) {
 slow = slow->next;
 fast = fast->next->next;
 }
 ListNode *p1 = head;
 if (slow->next != nullptr) {
 //reverse list
 ListNode *p2 = nullptr;
 ListNode *cur = slow;
 while (cur != nullptr) {
 ListNode *next = cur->next;
 cur->next = p2;
 p2 = cur;
 cur = next;
 }
 while (p1 != nullptr && p2 != nullptr) {
 printf("p1[%d], p2[%d]\n", p1->val, p2->val);
 if (p1->val != p2->val) {
 return false;
 }
 p1 = p1->next;
 p2 = p2->next;
 }
 } else {
 //[1,2]
 if (slow->val == head->val) {
 return true;
 } else {
 return false;
 }
 }
 return true;
}

Attention

leetcode203.移除链表元素

Fri, 06 May 2022 00:00:00 +0000

Question

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回新的头节点。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1 输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7 输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内 1 <= Node.val <= 50 0 <= val <= 50

Related Topics 递归链表 👍 899 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


//203
//in：head = [1,2,6,3,4,5,6], val = 6
//out：[1,2,3,4,5]
ListNode* removeElements(ListNode* head, int val) {
//迭代
 if (head == nullptr) return nullptr;
 ListNode *dummy = new ListNode(-1);
 dummy->next = head;
 ListNode *p = dummy;
 while (p != nullptr) {
 if (p->next && p->next->val == val) {
 p->next = p->next->next;
 } else {
 p = p->next;
 }
 }
 return dummy->next;
}

ListNode* removeElements2(ListNode* head, int val) {
//递归
 if (head == nullptr) return nullptr;
 head->next = removeElements2(head->next, val);
 return head->val == val ? head->next : head;
}

Attention

leetcode206.反转链表

Fri, 06 May 2022 00:00:00 +0000

Question

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2] 输出：[2,1]

示例 3：

输入：head = [] 输出：[]

提示：

链表中节点的数目范围是 [0, 5000] -5000 <= Node.val <= 5000

进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

Related Topics 递归链表 👍 2501 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


ListNode* reverseList(ListNode* head) {
//迭代
 ListNode *pre = nullptr;
 ListNode *cur = head;
 while (cur != nullptr) {
 ListNode *next = cur->next;//记住当前结点的下一个位置
 cur->next = pre;//当前结点的next指向前一个结点
 pre = cur;
 cur = next;//往后移动当前结点
 }
 return pre;
}
ListNode* reverseList2(ListNode* head) {
//递归
 if (head == nullptr || head->next == nullptr) return head;
 ListNode *newHead = reverseList2(head->next);//结点后移
 head->next->next = head;//箭头反转
 head->next = nullptr;//防止成环
 return newHead;
}

Attention

leetcode24.两两交换链表中的结点

Fri, 06 May 2022 00:00:00 +0000

Question

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4] 输出：[2,1,4,3]

示例 2：

输入：head = [] 输出：[]

示例 3：

输入：head = [1] 输出：[1]

提示：

链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100

Related Topics 递归链表 👍 1367 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


ListNode* swapPairs(ListNode* head) {
 ListNode *dummy = new ListNode(-1);
 dummy->next = head;
 ListNode *p = dummy;
 for (p; p->next && p->next->next; ) {
 ListNode *a = p->next;
 ListNode *b = a->next;
 p->next = b; //p指向2，作为头结点
 a->next = b->next; //1连接3
 b->next = a; //2连接1
 p = a; //p每次处理完成后指向a
 }
 return dummy->next;
}

Attention

leetcode61.旋转链表

Fri, 06 May 2022 00:00:00 +0000

Question

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1：

输入：head = [1,2,3,4,5], k = 2 输出：[4,5,1,2,3]

示例 2：

输入：head = [0,1,2], k = 4 输出：[2,0,1]

提示：

链表中节点的数目在范围 [0, 500] 内 -100 <= Node.val <= 100 0 <= k <= 2 * 109

Related Topics 链表双指针 👍 753 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


ListNode* rotateRight(ListNode* head, int k) {
 if (head == nullptr)
 return nullptr;
 ListNode *p = head;
 ListNode *tail;
 int num = 0;
 while (p != nullptr) {
 num++;
 tail = p;
 p = p->next;
 }
 k = k % num;//k可能大于num
 printf("nums[%d], tail.val[%d], k[%d]\n", num, tail->val, k);
 ListNode *ptr = head;
 for (int i = 0; i < num-k-1; ++i) {
 ptr = ptr->next;//找到第n-k个结点，即3
 }
 printf("ptr.val[%d]\n", ptr->val);

 tail->next = head;//5跟1连接
 head = ptr->next;//第n-k个结点的下一个结点，作为head
 ptr->next = nullptr;//第n-k个结点作为尾结点
 return head;
}

Attention

leetcode19.删除链表的倒数第 N 个结点

Thu, 28 Apr 2022 00:00:00 +0000

Question

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]

示例 2：输入：head = [1], n = 1 输出：[]

示例 3：输入：head = [1,2], n = 1 输出：[1]

提示：链表中结点的数目为 sz 1 <= sz <= 30 0 <= Node.val <= 100 1 <= n <= sz

进阶：你能尝试使用一趟扫描实现吗？ Related Topics 链表双指针 👍 2001 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


struct ListNode {
 int val;
 ListNode *next;
 ListNode() : val(0), next(nullptr) {}
 ListNode(int x) : val(x), next(nullptr) {}
 ListNode(int x, ListNode *next) : val(x), next(next) {}
};

ListNode* removeNthFromEnd1(ListNode* head, int n) {
 //两次遍历
 ListNode *dummy = new ListNode(-1);//记住head位置
 dummy->next = head;
 int nodeSum = 0;
 //第一次遍历获取结点总数
 while (head != nullptr) {
 nodeSum++;
 head = head->next;
 }

 ListNode *ptr = dummy;
 int i = nodeSum - n;//i=5-2=3
 while(i--) {
 ptr = ptr->next;//ptr移动3次后指向4的前驱结点
 }
 ptr->next = ptr->next->next;//直接删除
 return dummy->next;
}

ListNode* removeNthFromEnd2(ListNode* head, int n) {
 //一次遍历
 ListNode *dummy = new ListNode(-1);//记住head位置
 dummy->next = head;
 ListNode *slow = dummy;
 ListNode *fast = dummy;
 while (n--) {
 //fast指针比slow快n步，即fast先指向正数第n个
 fast = fast->next;
 }
 while (fast->next != nullptr) {
 //slow/fast同时后移，直到fast指向最后一个node
 slow = slow->next;
 fast = fast->next;
 }
 //slow指向待删除结点的前一个结点
 slow->next = slow->next->next;
 return dummy->next;
}

Attention

两次遍历即第一次记住共有多少个node，计算出倒数第n个结点为正数第nodeSum-n个结点，找到后直接删除
一次遍历即双指针，先让fast指向正数第n个结点，fast和slow同步向后移，直到fast移到最后一个结点，slow指向的是需要删除结点的前一个结点
ptr指向需要删除结点的前一个结点，直接删除即可，ptr->next = ptr->next->next
需要dummy结点来记住head结点的位置

leetcode232.用栈实现队列&225.用队列实现栈

Tue, 26 Apr 2022 00:00:00 +0000

Question

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾 int pop() 从队列的开头移除并返回元素 int peek() 返回队列开头的元素 boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：输入： [“MyQueue”, “push”, “push”, “peek”, “pop”, “empty”] [[], [1], [2], [], [], []] 输出： [null, null, null, 1, 1, false]

解释： MyQueue myQueue = new MyQueue(); myQueue.push(1); // queue is: [1] myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue) myQueue.peek(); // return 1 myQueue.pop(); // return 1, queue is [2] myQueue.empty(); // return false

提示：

1 <= x <= 9 最多调用 100 次 push、pop、peek 和 empty 假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）

进阶：

你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。

Related Topics 栈设计队列 👍 629 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


//leetcode submit region begin(Prohibit modification and deletion)
class MyQueue {
public:
 stack<int> st1, st2;
 MyQueue() {

 }

 void push(int x) {
 st1.push(x);
 //push即压入st1
 }

 int pop() {
 int val;
 while(!st2.empty())
 {
 //如果st2中有数据，说明st1中数全部压入st2，pop出st2栈顶元素
 val = st2.top();
 st2.pop();
 return val;
 }
 while(!st1.empty())
 {
 //如果st1中有数据，说明st1中数据还未全部压入st2，需要全部push进st2
 val = st1.top();
 st1.pop();
 st2.push(val);
 }
 //st1中所有元素压到st2中，即可pop出st2栈顶元素
 val = st2.top();
 st2.pop();
 return val;
 }

 int peek() {
 int val;
 while(!st2.empty())
 {
 //st2的栈顶元素即队首元素
 val = st2.top();
 return val;
 }
 while(!st1.empty())
 {
 //st1不为空，需要把st1中数全部压入st2
 val = st1.top();
 st1.pop();
 st2.push(val);
 }
 //pop出st2栈顶->队首元素
 val = st2.top();
 return val;
 }

 bool empty() {
 return st1.empty() && st2.empty();//st1和st2都为空，即队列为空
 }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */
//leetcode submit region end(Prohibit modification and deletion)

Attention

用stack实现queue：两个stack，将一串数字一次放入st1，再从st1中依次取出放到st2，最后从st2中pop出的数，符合queue先进先出的性质

Question

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

void push(int x) 将元素 x 压入栈顶。 int pop() 移除并返回栈顶元素。 int top() 返回栈顶元素。 boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。你所使用的语言也许不支持队列。你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入： [“MyStack”, “push”, “push”, “top”, “pop”, “empty”] [[], [1], [2], [], [], []] 输出： [null, null, null, 2, 2, false]

解释： MyStack myStack = new MyStack(); myStack.push(1); myStack.push(2); myStack.top(); // 返回 2 myStack.pop(); // 返回 2 myStack.empty(); // 返回 False

提示：

1 <= x <= 9 最多调用100 次 push、pop、top 和 empty 每次调用 pop 和 top 都保证栈不为空

进阶：你能否仅用一个队列来实现栈。 Related Topics 栈设计队列 👍 491 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


class MyStack {
public:
 queue<int> q;
 MyStack() {

 }

 void push(int x) {
 int size = q.size();
 q.push(x);
 while (size > 0) {
 int tmp = q.front();
 q.pop();
 q.push(tmp);
 size--;
 }
 }

 int pop() {
 int popVal = q.front();
 q.pop();
 return popVal;
 }

 int top() {
 return q.front();
 }

 bool empty() {
 return q.empty();
 }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

Attention

用queue实现stack：需要符合先进后出。
入栈，即把数据进行入队，为了保证栈的特性先进后出，因此需要在push方法中对入队之前的所有元素进行一次出队入队操作，以保证所有数据达到先进后出的顺序。
出栈，由于队列数据顺序已经调整，所以只需取队头元素即可。

leetcode215.数组中的第K个最大元素

Sun, 24 Apr 2022 00:00:00 +0000

Question

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2 输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4 输出: 4

提示：

1 <= k <= nums.length <= 104 -104 <= nums[i] <= 104

Related Topics 数组分治快速选择排序堆（优先队列） 👍 1620 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public:
 void quickSort2(vector<int>&nums, int left, int right) {
 if (left >= right) return;
 int privot = nums[left];
 int i = left;
 int j = right;
 while(i < j) {
 while(nums[j] <= privot && i < j) {
 j--;
 }
 while(nums[i] >= privot && i < j) {
 i++;
 }

 if (i<j) {
 swap(nums[i], nums[j]);
 }
 }

 swap(nums[left], nums[i]);
 quickSort2(nums, left, i-1);
 quickSort2(nums, i+1, right);
 }

 int findKthLargest(vector<int>& nums, int k) {
 quickSort2(nums, 0, nums.size()-1);
 return nums[k-1];
 }
};
//leetcode submit region end(Prohibit modification and deletion)

Attention

暴力从大到小快排，返回下标。

leetcode217.存在重复元素

Tue, 19 Apr 2022 00:00:00 +0000

Question

给你一个整数数组 nums 。如果任一值在数组中出现至少两次，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

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

示例 2：

输入：nums = [1,2,3,4] 输出：false

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2] 输出：true

提示：

1 <= nums.length <= 105 -109 <= nums[i] <= 109

Related Topics 数组哈希表排序 👍 711 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public:
 bool containsDuplicate(vector<int>& nums) {
 unordered_set<int> setNum;
 for(auto it : nums) {
 if(setNum.find(it) == setNum.end()) {
 setNum.insert(it);
 } else {
 return true;
 }
 }
 return false;
 }
};
//leetcode submit region end(Prohibit modification and deletion)

Attention

hashtable，需要#include <unordered_set>。
判断链表是否有环时可以用到，202，141，142。

leetcode147.对链表进行插入排序

Mon, 18 Apr 2022 00:00:00 +0000

Question

对链表进行插入排序。

插入排序的动画演示如上。从第一个元素开始，该链表可以被认为已经部分排序（用黑色表示）。每次迭代时，从输入数据中移除一个元素（用红色表示），并原地将其插入到已排好序的链表中。

插入排序算法：

插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列中适当的位置，并将其插入。重复直到所有输入数据插入完为止。

示例 1：

输入: 4->2->1->3 输出: 1->2->3->4

示例 2：

输入: -1->5->3->4->0 输出: -1->0->3->4->5

Related Topics 链表排序 👍 438 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* insertionSortList(ListNode* head) {
 ListNode* dummy = new ListNode(-1);
 dummy->next = head;
 ListNode* ptr = head->next;//无序区第一个结点
 ListNode* rear = head;//有序区最后一个结点
 while (ptr != nullptr) {
 if (ptr->val >= rear->val) {
 //ptr>rear,直接insert到rear后面
 rear->next = ptr;
 rear = ptr;
 } else {
 //ptr<rear,pre从head往后找到比ptr大的第一个结点
 ListNode* pre = dummy;
 while (pre->next->val <= ptr->val) {
 pre = pre->next;
 }
 rear->next = ptr->next;
 ptr->next = pre->next;
 pre->next = ptr;
 }
 ptr = rear->next;
 }
 return dummy->next;

 }
};
//leetcode submit region end(Prohibit modification and deletion)

Attention

需要两个指针，一个ptr指向无序区的第一个结点，即每次处理的结点，一个rear指向有序区的最后一个结点。每次ptr和rear对比，如果大于等于当前尾结点，则直接插入；如果小于尾结点，则需要从head开始往后找到第一个比ptr大的结点。
1. 尾结点后插入新结点：rear->next = ptr; rear = ptr;
2. [1,2,4]中插入[3,6]，修改指针在已有序链表中插入结点：由于需要保存第一个比ptr大的结点的前一个位置，需要一个dummy结点指向head。pre->next为4时大于3，首先需要先保存下一个待排序结点结点rear->next = ptr->next，4->6，然后ptr->next = pre->next，将3跟4连接，最后pre->next = ptr，将2和3连接。
链表的插入排序时间复杂度，O(n^2)。最坏情况外层需要遍历(n-1)次，内层需要1+2+3+…+(n-2)=(n-2)(n-1)/2次，最坏情况O(n^2)；最好的情况每次只需要在尾结点后插入，时间复杂度O(n)，平均复杂度(n^2 + n)/2，即O(n^2)。空间复杂度O(1)，辅助变量ListNode* pre。

leetcode148.排序链表

Mon, 18 Apr 2022 00:00:00 +0000

Question

给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。

示例 1：

输入：head = [4,2,1,3] 输出：[1,2,3,4]

示例 2：

输入：head = [-1,5,3,4,0] 输出：[-1,0,3,4,5]

示例 3：

输入：head = [] 输出：[]

提示：

链表中节点的数目在范围 [0, 5 * 104] 内 -105 <= Node.val <= 105

进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？ Related Topics 链表双指针分治排序归并排序 👍 1565 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* sortList(ListNode* head) {
 //归并
 return sort(head);
 }
 ListNode* sort(ListNode* head) {
 //快慢指针找到中间结点
 if(head==nullptr || head->next==nullptr) return head;//递归出口
 ListNode* slow = head;
 ListNode* fast = head;
 ListNode* mid = head;
 while (fast != nullptr && fast->next != nullptr) {
 mid = slow;//slow作为中间结点，退出while循环时mid->next==slow
 slow = slow->next;
 fast = fast->next->next;
 }
 mid->next = nullptr;//断开前后，分别排序head->mid,slow->fast
 ListNode* l1 = sort(head);
 ListNode* l2 = sort(slow);
 return merge(l1, l2);//递归sort后l1和l2都是有序链表
 }
 ListNode* merge(ListNode* l1, ListNode* l2) {
 //同21，合并两个有序链表
 if (l1 == nullptr) return l2;
 if (l2 == nullptr) return l1;
 ListNode *mergeHead = nullptr;
 if (l1->val < l2->val) {
 mergeHead = l1;
 mergeHead->next = merge(l1->next, l2);
 } else {
 mergeHead = l2;
 mergeHead->next = merge(l1, l2->next);
 }
 return mergeHead;
 }
};

Attention

mergesort
1. sort的递归出口条件：head->next == nullptr，判断head==nullptr，是为了满足测试用例[]。
2. 快慢指针找到中点后，需要断开，mid->next = nullptr，断开后一部分是head到mid，另一部份是slow到fast。
3. merge函数同21，合并两个有序链表。递归出口是如果l1或l2有空链表，直接return。选择链表l1和l2头结点较小的一个作为mergerHead剩下的将递归的决定将哪一个元素加到结点链表中。
4. 要求时间复杂度 O(n log n) 和空间复杂度 O(1)，如果是数组结构则空间需要占用O(n)，链表则不需要另外开辟空间。O(nlogn)，排序中可选快速排序、归并排序和堆排序。

链表的基本操作

Mon, 18 Apr 2022 00:00:00 +0000

Question

237.删除链表中的结点

请编写一个函数，用于删除单链表中某个特定节点。在设计函数时需要注意，你无法访问链表的头节点 head ，只能直接访问要被删除的节点。

题目数据保证需要删除的节点不是末尾节点。

示例 1：

输入：head = [4,5,1,9], node = 5 输出：[4,1,9] 解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9

示例 2：

输入：head = [4,5,1,9], node = 1 输出：[4,5,9] 解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

提示：

链表中节点的数目范围是 [2, 1000] -1000 <= Node.val <= 1000 链表中每个节点的值都是唯一的需要删除的节点 node 是链表中的节点，且不是末尾节点

Related Topics 链表 👍 1131 👎 0

876.链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5] 输出：此列表中的结点 3 (序列化形式：[3,4,5]) 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。注意，我们返回了一个 ListNode 类型的对象 ans，这样： ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.

示例 2：

输入：[1,2,3,4,5,6] 输出：此列表中的结点 4 (序列化形式：[4,5,6]) 由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

提示：

给定链表的结点数介于 1 和 100 之间。

Related Topics 链表双指针 👍 547 👎 0

912.排序数组

给你一个整数数组 nums，请你将该数组升序排列。

示例 1：

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

示例 2：

输入：nums = [5,1,1,2,0,0] 输出：[0,0,1,1,2,5]

提示：

1 <= nums.length <= 5 * 104 -5 * 104 <= nums[i] <= 5 * 104

Related Topics 数组分治桶排序计数排序基数排序排序堆（优先队列）归并排序 👍 535 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


//237
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 void deleteNode(ListNode* node) {
 node->val = node->next->val;
 node->next = node->next->next;
 }
};
//leetcode submit region end(Prohibit modification and deletion)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


//876
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* middleNode(ListNode* head) {
 ListNode* slow = head;
 ListNode* fast = head;
 ListNode* mid = head;
 while(fast!=nullptr && fast->next!=nullptr) {
 mid = slow;
 slow = slow->next;
 fast = fast->next->next;
 }
 return slow;
 }
};
//leetcode submit region end(Prohibit modification and deletion)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


//912
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public:
 vector<int> sortArray(vector<int>& nums) {
 sort(nums.begin(), nums.end());
 return nums;
 }
};
//leetcode submit region end(Prohibit modification and deletion)

Attention

237，没有给出head，原始链表，所以无法遍历原来链表。
876，快慢指针找到链表的中间结点，在链表的归并排序中会用到。
912，STL的sort函数

leetcode142.环形链表II

Thu, 14 Apr 2022 00:00:00 +0000

Question

给定一个链表的头节点 head ，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改链表。

示例 1：

输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0 输出：返回索引为 0 的链表节点解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1 输出：返回 null 解释：链表中没有环。

提示：

链表中节点的数目范围在范围 [0, 104] 内 -105 <= Node.val <= 105 pos 的值为 -1 或者链表中的一个有效索引

进阶：你是否可以使用 O(1) 空间解决此题？ Related Topics 哈希表链表双指针 👍 1517 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
 ListNode *detectCycle(ListNode *head) {
 if (head == nullptr || head->next == nullptr) {
 //[] -1
 //[1] -1
 return nullptr;
 }

 ListNode *slow = head;
 ListNode *fast = head;
 while (fast != nullptr && fast->next != nullptr) {
 if (fast->next->next == nullptr) {
 //[1,2] -1
 return nullptr;
 }
 fast = fast->next->next;
 slow = slow->next;
 if (fast == slow) {
 break;
 }
 }

 if(slow == head) {
 //[1,2] 0
 return slow;
 } else {
 slow = head;
 }
 while (slow->next != nullptr && fast->next != nullptr) {
 slow = slow->next;
 fast = fast->next;
 if (slow == fast)
 return slow;
 }
 return nullptr;
 }
};
//leetcode submit region end(Prohibit modification and deletion)

Attention

主要思路是fast_point走的是slow_point的路程的两倍，已知a是head到环起点距离，b是环起点到相遇点距离，c是相遇点到环起点距离。2(a+b)=a+2b+c，即a=c，即从head到环起点的距离等于相遇点到环起点的距离，即当slow和fast相遇时，slow从head以step为1往前，fast从相遇点以step为1往前，第一次相遇点即为环起点。
注：根据测试用例调整，判断特殊情况。

leetcode141.环形链表

Wed, 13 Apr 2022 00:00:00 +0000

Question

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递。仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。否则，返回 false 。

示例 1：

输入：head = [3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

输入：head = [1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

输入：head = [1], pos = -1 输出：false 解释：链表中没有环。

提示：

链表中节点的数目范围是 [0, 104] -105 <= Node.val <= 105 pos 为 -1 或者链表中的一个有效索引。

进阶：你能用 O(1)（即，常量）内存解决此问题吗？ Related Topics 哈希表链表双指针 👍 1404 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


class Solution {
public:
 bool hasCycleByPoint(ListNode *head) {
 ListNode *faptr = head;
 ListNode *slptr = head;
 while (faptr != nullptr && faptr->next != nullptr) {
 faptr = faptr->next->next;
 slptr = slptr->next;
 if (faptr == slptr)
 return true;
 }
 return false;
 }


 bool hasCycleBySet(ListNode *head) {
 unordered_set<ListNode*> setNode;
 if(head == nullptr) return false;
 if(head->next == nullptr) return false;
 while(true) {
 ListNode *node = head->next;
 if(setNode.find(node) == setNode.end()) {
 setNode.insert(node);
 head = node;
 } else {
 return true;
 }
 }
 }
};

Attention

pos的意思是尾结点指向链表中的结点的下表，从0开始，pos=-1表示链表无环。
判断链表有无环：hasCycleByPoint->双指针，hasCycleBySet->hash表存储。

postgresql的GSSAPI认证

Fri, 01 Apr 2022 00:00:00 +0000

pgsql的GSSAPI 认证踩坑

常见报错

1、GSSAPI authentication failed for user “postgres@EXAMPLE.COM”

postgresql.log

1
2
3
4
5


2022-04-01 15:09:14.234 CST [11468] LOG: provided user name (postgres@EXAMPLE.COM) and authenticated user name (postgres) do not match

2022-04-01 15:09:14.234 CST [11468] FATAL: GSSAPI authentication failed for user "postgres@EXAMPLE.COM"

2022-04-01 15:09:14.234 CST [11468] DETAIL: Connection matched pg_hba.conf line 95: "host all all all gss include_realm=0 krb_realm=EXAMPLE.COM"

原因

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


Connection conn =
 (Connection) Subject.doAs(specificSubject, new PrivilegedExceptionAction() {
 public Object run() {
 Connection con = null;
 Properties prop = new Properties();
 prop.setProperty("user", "postgres"); //value是postgre@EXAMPLE.COM导致的报错
 prop.setProperty("jaasApplicationName", "pgjdbc");
 prop.setProperty("gss","true");
 String url = URL;
 try {
 con = DriverManager.getConnection(url, prop);
 } catch (Exception except) {
 except.printStackTrace();
 }
 return con;
 }
 });

2、Unspecified GSS failure. Minor code may provide more information: Request ticket server postgres/10.211.55.11@EXAMPLE.COM kvno 4 not found in keytab; keytab is likely out of date

postgresql.log

1
2
3
4
5


2022-04-01 14:41:35.628 CST [7881] LOG: accepting GSS security context failed
2022-04-01 14:41:35.628 CST [7881] DETAIL: Unspecified GSS failure. Minor code may provide more information: Request ticket server postgres/10.211.55.11@EXAMPLE.COM kvno 4 not found in keytab; keytab is likely out of date
2022-04-01 14:41:35.628 CST [7881] FATAL: GSSAPI authentication failed for user "postgres"
2022-04-01 14:41:35.628 CST [7881] DETAIL: Connection matched pg_hba.conf line 95: "host all all all gss include_realm=0 krb_realm=EXAMPLE.COM"
202

jdbc连接时的报错

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


Entered Krb5Context.initSecContext with state=STATE_IN_PROCESS
org.postgresql.util.PSQLException: GSS Authentication failed
 at org.postgresql.gss.GssAction.run(GssAction.java:145)
 at org.postgresql.gss.GssAction.run(GssAction.java:32)
 at java.base/java.security.AccessController.doPrivileged(Native Method)
 at java.base/javax.security.auth.Subject.doAs(Subject.java:361)
 at org.postgresql.gss.MakeGSS.authenticate(MakeGSS.java:60)
 at org.postgresql.core.v3.ConnectionFactoryImpl.lambda$doAuthentication$3(ConnectionFactoryImpl.java:768)
 at org.postgresql.core.v3.AuthenticationPluginManager.withPassword(AuthenticationPluginManager.java:81)
 at org.postgresql.core.v3.ConnectionFactoryImpl.doAuthentication(ConnectionFactoryImpl.java:767)
 at org.postgresql.core.v3.ConnectionFactoryImpl.tryConnect(ConnectionFactoryImpl.java:180)
 at org.postgresql.core.v3.ConnectionFactoryImpl.openConnectionImpl(ConnectionFactoryImpl.java:235)
 at org.postgresql.core.ConnectionFactory.openConnection(ConnectionFactory.java:49)
 at org.postgresql.jdbc.PgConnection.<init>(PgConnection.java:223)
 at org.postgresql.Driver.makeConnection(Driver.java:400)
 at org.postgresql.Driver.connect(Driver.java:259)
 at java.sql/java.sql.DriverManager.getConnection(DriverManager.java:677)
 at java.sql/java.sql.DriverManager.getConnection(DriverManager.java:189)
 at pgsql.client$1.run(client.java:64)
 at java.base/java.security.AccessController.doPrivileged(Native Method)
 at java.base/javax.security.auth.Subject.doAs(Subject.java:423)
 at pgsql.client.main(client.java:53)
Caused by: GSSException: Defective token detected (Mechanism level: AP_REP token id does not match!)
 at java.security.jgss/sun.security.jgss.krb5.AcceptSecContextToken.<init>(AcceptSecContextToken.java:80)
 at java.security.jgss/sun.security.jgss.krb5.Krb5Context.initSecContext(Krb5Context.java:757)
 at java.security.jgss/sun.security.jgss.GSSContextImpl.initSecContext(GSSContextImpl.java:266)
 at java.security.jgss/sun.security.jgss.GSSContextImpl.initSecContext(GSSContextImpl.java:196)
 at org.postgresql.gss.GssAction.run(GssAction.java:102)
 ... 19 more
Exception in thread "main" java.lang.NullPointerException
 at pgsql.client.main(client.java:72)

Process finished with exit code 1

原因

需要重新生成server的keytab文件，过期了

3、Krb认证报错 KrbException: Message stream modified (41)

删除 krb5.conf 配置文件里的 renew_lifetime = xxx 这行配置即可

renew_lifetime：代表凭证最长能够被延期的时限，通常为一个礼拜。当凭证过时以后，对安全认证的服务的后续访问则会失败

ticket_lifetime：代表凭证生效的时限，通常为24小时

4、Unspecified GSS failure. Minor code may provide more information: Key table entry not found

postgresql.log

1
2
3
4
5
6


2022-03-28 20:02:36.172 CST [10294] LOG: could not accept GSSAPI security context
2022-03-28 20:02:36.172 CST [10294] DETAIL: Unspecified GSS failure. Minor code may provide more information: Key table entry not found
2022-03-28 20:02:36.177 CST [10295] LOG: accepting GSS security context failed
2022-03-28 20:02:36.177 CST [10295] DETAIL: Unspecified GSS failure. Minor code may provide more information: Key table entry not found
2022-03-28 20:02:36.177 CST [10295] FATAL: GSSAPI authentication failed for user "postgres"
2022-03-28 20:02:36.177 CST [10295] DETAIL: Connection matched pg_hba.conf line 95: "host all all all gss include_realm=0 krb_realm=EXAMPLE.COM"

原因

没有正确读取到pgsql server的keytab文件，配置文件指定keytab文件在/root目录下，用户postgres对/root目录无权限导致的读取失败。

tlv相关

Wed, 30 Mar 2022 00:00:00 +0000

背景

在hive数据库的kerberos加密协议解析中，加密套件默认是ETYPE_AES256_CTS_HMAC_SHA1_96。解密后的cipher部分是asn.1编码过的，拿到想要的字段就需要解密tlv协议。TLV三元组<Type, Length,Value>。

描述Value部分所占字节的个数，编码格式分两类：定长方式（DefiniteForm）和不定长方式（IndefiniteForm）。定长模式中，根据长度是否超过一个字节（127）分短/长形式。

短：0-127，二进制表示01111 111，第8位是0，即length用一个字节即可

长：>127，二进制表示10000000，第8位是1，即length需要用多个字节表示，此时0-7位用来描述length值需要占用的字节数。

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


//
// Created by Serrini on 2022/1/6.
//

#ifndef TEST021_HDFS_TLV_H
#define TEST021_HDFS_TLV_H
#include <iostream>


class TLV{
public:
 TLV();
 int ParseTLV(const unsigned char* data, int len);
 void SkipHead(int len);
 void SkipTLV(int len);
 void Clear();
public:
 int m_type;
 int m_length;
 unsigned char* m_data;
 int m_headLen;

 unsigned char* m_skipPtr;
 int m_skipLength;
};

#endif //TEST021_HDFS_TLV_H

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69


//
// Created by Serrini on 2022/1/6.
//

#include "TLV.h"
TLV::TLV():m_type(0) , m_length(0), m_data(NULL), m_headLen(0), m_skipPtr(NULL), m_skipLength(0){

}

int TLV::ParseTLV(const unsigned char *data, int len) {
 if((data == NULL) || (len < 2)){
 printf("Check tlv data and len failed\n");
 return -1;
 }
 m_type = data[0];
 if(data[1] > 0x7F){
 m_length = 0;
 if(len > (1 + 1 + (data[1] - 0x80))){
 int i = 0;
 m_data = (unsigned char*)data + 1 + 1 + (data[1] - 0x80);
 for(i = 0; i < (data[1] - 0x80); ++i){
 m_length = m_length * 256 + data[1 + 1 + i];
 }
 m_headLen = 1 + 1 + (data[1] - 0x80);
 }else{
 printf("Check value length len failed, length len:%d, len:%d\n", (1 + 1 + (data[1] - 0x80)), len);
 return -1;
 }
 }else{
 m_headLen = 1 + 1;
 m_length = data[1];
 m_data = (unsigned char*)data + 1 + 1;
 }
 if((m_headLen + m_length) > len){
 printf("Check value length and package length failed, tlv:%d, package len:%d\n", (m_headLen + m_length), len);
 return -1;
 }
 printf("type:%x, length:%d, head length:%d\n", m_type, m_length, m_headLen);
 return 0;
}

void TLV::SkipHead(int len){
 m_skipPtr = m_data;
 m_skipLength = len - m_headLen;
 if(m_skipLength <= 0){
 m_skipPtr = NULL;
 m_skipLength = 0;
 printf("[SkipHead]:Skip head length failed. len:%d, head len:%d\n", len, m_headLen);
 }
}

void TLV::SkipTLV(int len){
 m_skipPtr = m_data + m_length;
 m_skipLength = len - m_headLen - m_length;
 if(m_skipLength <= 0){
 m_skipPtr = NULL;
 m_skipLength = 0;
 printf("[SkipTLV]:Skip head length failed. len:%d, head len:%d, value length: %d\n", len, m_headLen, m_length);
 }
}

void TLV::Clear(){
 m_type = 0;
 m_length = 0;
 m_data = NULL;
 m_headLen = 0;
 m_skipLength = 0;
 m_skipPtr = NULL;
}

kerberos相关（3）

Tue, 29 Mar 2022 00:00:00 +0000

AP-REQ的结构如下:

AP-REQ ::= [APPLICATION 14] SEQUENCE {

pvno [0] INTEGER (5),

msg-type [1] INTEGER (14),

ap-options [2] APOptions,

ticket [3] Ticket,

authenticator [4] EncryptedData – Authenticator

}

TGT票据放在这个结构体里面，就是放在ticket里面。 authenticator 的内容包括加密类型和用session_key加密Authenticator加密成的密文。

Authenticator的结构如下:

Authenticator ::= [APPLICATION 2] SEQUENCE {

authenticator-vno [0] INTEGER (5),

crealm [1] Realm,

cname [2] PrincipalName,

cksum [3] Checksum OPTIONAL,

cusec [4] Microseconds,

ctime [5] KerberosTime,

subkey [6] EncryptionKey OPTIONAL,

seq-number [7] UInt32 OPTIONAL,

authorization-data [8] AuthorizationData OPTIONAL

}

kerberos相关（2）

Mon, 28 Mar 2022 00:00:00 +0000

流程

创建用户名为test的Principal

kadmin创建一个用户test，之后可以用密码登录，如果不想记住密码可以用keytab文件登录。（也可以不设置密码，-randkey随机生成一个） kadmin在kdc服务器上可以是kadmin.local，如果是kerberos客户端就是kadmin。

addprinc -pw 123456 test ktadd -k /root/user.keytab test

创建TGT

创建TGT需要在hive客户端

方式一：账号密码登录

方式二：用户keytab文件登录

访问hive

示意图

审计需要的keytab文件

审计系统需要的keytab文件是server的keytab文件，是需要保存在配置文件hive_site.xml指定的位置，hdfs/spark等同理。里面相当于是server端的密码，可以指定也可以随机生成，这个跟集群配置有关。

用户登录认证有两种方式，kinit sl(密码登录)或者是kinit -kt user.keytab sl（用户keytab文件登录），不管怎样，klist回显的信息，表示TGT创建成功了，这时候的principal表示是用哪个用户登录的。

如果我们拿到的是user.keytab，里面相当于存的是client的密码，是没法解密的。

优点：

Kerberos实际上就是使用对称秘钥，比使用公钥操作的SSL性能更好；所有的用户/服务密钥存在KDC的数据库里，可以认为是一个集中管理平台，如果想要删除一个用户，直接在KDC中删除该用户即可。

Hive相关

文档：https://hive.apache.org/

hive.server2.authentication

hive.server2.thrift.sasl.qop

#Kerberos的黄金票据/白银票据

Golden Ticket

不用as_req/as_rep，伪造的TGT，通常的TGT都是由TGS加密过的（涉及到krbtgt账户），黄金票据就是伪造的TGT，作为tgs_req的一部分被发送，以获取 serverticket。被krbtgt账户密钥加密过的TGT可以被域中任意kdc解密，但是client/server都不行。

krbtgt账户：每个域控制器都有一个 krbtgt的用户账户，是 KDC的服务账户，用来创建票据授予服务(TGS)加密的密钥

Silver Tickets

……

kerberos相关（1）

Wed, 16 Mar 2022 00:00:00 +0000

背景

namenode节点	hadoop00	172.20.0.2
datanode节点	hadoop01	172.20.0.3
datanode节点	hadoop02	172.20.0.4

kdc 服务器涉及到三个配置文件：

1
2
3


/etc/krb5.conf
/var/kerberos/krb5kdc/kdc.conf
/var/kerberos/krb5kdc/kadm5.acl

1. /etc/krb5.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


# To opt out of the system crypto-policies configuration of krb5, remove the
# symlink at /etc/krb5.conf.d/crypto-policies which will not be recreated.
includedir /etc/krb5.conf.d/

[logging]
 default = FILE:/var/log/krb5libs.log
 kdc = FILE:/var/log/krb5kdc.log
 admin_server = FILE:/var/log/kadmind.log

[libdefaults]
 dns_lookup_realm = false
 ticket_lifetime = 24h
 renew_lifetime = 7d
 forwardable = true
 rdns = false
 pkinit_anchors = FILE:/etc/pki/tls/certs/ca-bundle.crt
 spake_preauth_groups = edwards25519
 default_realm = EXAMPLE.COM
# default_ccache_name = KEYRING:persistent:%{uid}
 udp_preference_limit = 1
[realms]
EXAMPLE.COM = {
 kdc = hadoop00:88
 admin_server = hadoop00:789
}

[domain_realm]
.example.com = EXAMPLE.COM
example.com = EXAMPLE.COM

说明：

udp_preference_limit：禁止使用 udp
realms：域，可以认为是namespace命名空间，一般大写，比如EXAMPLE.COM
- kdc：hostname:port
- admin_server：hostname:port
ticket_lifetime：表明凭证生效的时限，一般为24小时
renew_lifetime：表明凭证最长可以被延期的时限，一般为一周。当凭证过期之后，对安全认证的服务的后续访问则会失败。

2. /var/kerberos/krb5kdc/kdc.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


[kdcdefaults]
 kdc_ports = 88
 kdc_tcp_ports = 88
 spake_preauth_kdc_challenge = edwards25519

[realms]
EXAMPLE.COM = {
 #master_key_type = aes256-cts
 acl_file = /var/kerberos/krb5kdc/kadm5.acl
 dict_file = /usr/share/dict/words
 admin_keytab = /var/kerberos/krb5kdc/kadm5.keytab
 supported_enctypes = aes256-cts:normal aes128-cts:normal arcfour-hmac:normal camellia256-cts:normal camellia128-cts:normal
}

说明：

supported_enctypes：指定此领域的默认主体的键/盐组合，通过kadmin创建的任何主体都将具有这些类型的密钥。
master_key_type：指定主密钥的密钥类型，默认值为aes256-cts-hmac-sha1-96，也是我们目前支持解析的加密套件。
- 虽然所有 Kerberos 操作都支持aes128-cts和aes256-cts ，但我们
  
  的 GSSAPI 实现的非常旧版本（krb5-1.3.1 和更早版本）不支持它们。运行不支持 AES 的 krb5 版本的服务不得在 KDC 数据库中获得这些加密类型的密钥。
```
> from: https://web.mit.edu/kerberos/krb5-latest/doc/admin/conf_files/kdc_conf.html#encryption-types
```
acl_file：标注了admin的用户权限，默认是admin用户拥有所有权限。

3. /var/kerberos/krb5kdc/kadm5.acl

*/admin@EXAMPLE.COM * 名称匹配上*/admin@EXAMPLE.COM的用户都认为是admin用户，权限是*代表全部权限。

kerberos数据库

kdb5_util

1
2
3


[root@hadoop00 krb5kdc]# kdb5_util list_mkeys
Master keys for Principal: K/M@EXAMPLE.COM
KVNO: 1, Enctype: aes256-cts-hmac-sha1-96, Active on: Thu Jan 01 08:00:00 CST 1970 *

如何创建数据库：

kdb5_util -r EXAMPLE.COM create -s

需要记住输入的密码，默认使用db2数据库。

数据库创建好之后，在/var/kerberos/krb5kdc目录下可以看到principal的相关文件。

如何管理数据库

有kadmin.local和kadmin，kadmin.local是必须在KDC所在的机器上执行，这里kdc装在hadoop00主机上；对于kerberos的客户端机器访问，需要输入创建数据库时的密码。

使用kadmind和krb5kdc程序启动Kerberos服务

启动kadmin：

1

systemctl status kadmin

1

systemctl enable kadmin

启动krb5kdc:

1

systemctl status kadmin

1

systemctl enable krb5kdc

如何创建一个hadoop服务主体：addprinc

princepal：认证的主体

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


kadmin.local
kadmin.local: addprinc -randkey hive/hadoop00@EXAMPLE.COM
No policy specified for hive/hadoop00@EXAMPLE.COM; defaulting to no policy
Principal "hive/hadoop00@EXAMPLE.COM" created.
kadmin.local:
kadmin.local: listprincs
K/M@EXAMPLE.COM
hive/hadoop00@EXAMPLE.COM
hive/hadoop00@HIVE.COM
kadmin/admin@EXAMPLE.COM
kadmin/changepw@EXAMPLE.COM
kadmin/hadoop00@EXAMPLE.COM
kiprop/hadoop00@EXAMPLE.COM
krbtest/admin@EXAMPLE.COM
krbtgt/EXAMPLE.COM@EXAMPLE.COM
root/admin@EXAMPLE.COM
root/hadoop00@EXAMPLE.COM
root/hadoop00@HIVE.COM
root/hadoop01@EXAMPLE.COM
root/hadoop02@EXAMPLE.COM
kadmin.local:

查看创建的实体：getprinc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


kadmin.local: getprinc root/hadoop00@EXAMPLE.COM
Principal: root/hadoop00@EXAMPLE.COM
Expiration date: [never]
Last password change: Mon Nov 29 10:24:08 CST 2021
Password expiration date: [never]
Maximum ticket life: 1 day 00:00:00
Maximum renewable life: 0 days 00:00:01
Last modified: Fri Feb 25 10:25:45 CST 2022 (root/admin@EXAMPLE.COM)
Last successful authentication: [never]
Last failed authentication: [never]
Failed password attempts: 0
Number of keys: 5
Key: vno 3, aes256-cts-hmac-sha1-96
Key: vno 3, aes128-cts-hmac-sha1-96
Key: vno 3, DEPRECATED:arcfour-hmac
Key: vno 3, camellia256-cts-cmac
Key: vno 3, camellia128-cts-cmac
MKey: vno 1
Attributes:
Policy: [none]

输入？，可以查看帮助。

流程

1、先创建一个管理员主体（principal），用户主体（UPN）

addprinc root/admin

输入两遍密码，记住密码

2、创建服务主体（principal），服务主体（SPN）

addprinc -randkey hive/hadoop00

addprinc -randkey spark/hadoop01

-randkey参数：随机生成一个值作为principal的key

-pw参数：设置密码

需要为集群中的每个服务/守护程序（如hdfs、yarn），创建一个服务主体，还必须为组件服务(如hive)创建服务主体。在hadoop00机器上的hive服务可以叫hive/hadoop00，在hadoop01机器上的spark服务可以叫spark/hadoop01，创建SPN的时候格式一定是有三部分，即hive/hadoop00@EXAMPLE.COM，默认的realm（域）是EXAMPLE.COM，所以可以省略。

1
2
3
4
5
6
7


[root@hadoop00 /]# beeline
Beeline version 3.1.0 by Apache Hive
beeline> !connect jdbc:hive2://hadoop00:10002/default;principal=sl@EXAMPLE.COM
Connecting to jdbc:hive2://hadoop00:10002/default;principal=sl@EXAMPLE.COM
22/03/23 10:38:24 [main]: WARN jdbc.HiveConnection: Failed to connect to hadoop00:10002
Error: Could not open client transport with JDBC Uri: jdbc:hive2://hadoop00:10002/default;principal=sl@EXAMPLE.COM: Kerberos principal should have 3 parts: sl@EXAMPLE.COM (state=08S01,code=0)
beeline>

每个服务主体都需要一个keytab文件来存储其密码。keytab文件包含主体principal和根据其密码派生的加密密钥对。用户主体UPN可以直接kinit用密码登录到集群上，服务主体SPN无法交互式登录，需要用keytab文件。（可以把多个SPN的密钥存储在同一个keytab文件中）

如何导出密钥文件：

kadmin.local

1

xst -k root.keytab root/hadoop00@EXAMPLE.COM

这样就为root/hadoop00账户创建了一个密钥表文件，这个密钥表文件放在集群配置文件指定的位置，注意需要分发到所有节点上去。

如何免密登录：

klist

1
2


[root@hadoop00 krb5kdc]# klist
klist: No credentials cache found (filename: /tmp/krb5cc_0)

登录失败，用kinit测试这个keytab文件是否可用

1

kinit -kt root.keytab root/hadoop00@EXAMPLE.COM

没有返回表示登录成功

1
2
3
4
5
6
7


[root@hadoop00 keytab]# klist
Ticket cache: FILE:/tmp/krb5cc_0
Default principal: root/hadoop00@EXAMPLE.COM

Valid starting Expires Service principal
03/09/22 11:45:51 03/10/22 11:45:51 krbtgt/EXAMPLE.COM@EXAMPLE.COM
 renew until 03/09/22 11:45:51

如何访问服务

刚刚已经用kinit登录成功了，本地访问可以直接在hadoop00这个机器上执行hdfs dfs -ls /访问；远程访问要用UserGroupInformation这个class载入配置文件、密钥表文件等访问服务。

问题

1、datanode启动失败，报错如下：

2022-03-09 16:09:11,286 ERROR org.apache.hadoop.hdfs.server.datanode.DataNode: Exception in secureMain org.apache.hadoop.security.KerberosAuthException: failure to login: for principal: root/hadoop02@EXAMPLE.COM from keytab /usr/local/keytab/root.keytab javax.security.auth.login.LoginException: Unable to obtain password from user

查看root.keytab文件，只有hadoop00主机：

[root@hadoop00 keytab]# klist -ket root.keytab Keytab name: FILE:root.keytab KVNO Timestamp Principal

2 03/09/22 11:27:11 root/hadoop00@EXAMPLE.COM (aes256-cts-hmac-sha1-96) 2 03/09/22 11:27:11 root/hadoop00@EXAMPLE.COM (aes128-cts-hmac-sha1-96) 2 03/09/22 11:27:11 root/hadoop00@EXAMPLE.COM (DEPRECATED:arcfour-hmac) 2 03/09/22 11:27:11 root/hadoop00@EXAMPLE.COM (camellia256-cts-cmac) 2 03/09/22 11:27:11 root/hadoop00@EXAMPLE.COM (camellia128-cts-cmac)

需要加入hadoop01和hadoop02主机：

addprinc -randkey root/hadoop01

addprinc -randkey root/hadoop02

xst -k root_new.keytab root/hadoop00 root/hadoop01 root/hadoop02

生产一个新的keytab文件，分发到所有主机上去，重启后如果datanode启动成功，在web页面上有Live Nodes两个。

tcpreplay/tcpdump排错

Tue, 15 Mar 2022 00:00:00 +0000

Linux cooked capture

question

tcpdump时不指定网卡，-i any 抓包导致链路层占用16字节，一般链路层占14字节。

如果-i选项指定为一个网卡地址，那么抓取的数据包数据链路层是以太网头部；如果指定any，则以太网头部将被替换为linux cooked capture头部

solution

将linux cooked capture格式的包转换为Ethernet格式

1
2
3
4
5


 # tcpdump -r linux_sll.pcap
reading from file linux_sll.pcap, link-type LINUX_SLL (Linux cooked)
 # tcprewrite --dlt=enet --infile=linux_sll.pcap --outfile=enet.pcap
 # tcpdump -r enet.pcap
reading from file enet.pcap, link-type EN10MB (Ethernet)

tcpreplay:send() [218] Message too long (errno = 90)

solution

数据包长度>mtu值，需要修改发送数据包网卡的MTU，重启network

leetcode202.快乐数（C++实现）

Mon, 07 Mar 2022 00:00:00 +0000

Question

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果这个过程结果为 1，那么这个数就是快乐数。

如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19 输出：true 解释： 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1

示例 2：

输入：n = 2 输出：false

提示：

1 <= n <= 231 - 1

Related Topics 哈希表数学双指针 👍 841 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


#include <iostream>
#include <unordered_set>
using namespace std;
//202ishappy
int getNext(int n) {
 int total = 0;
 while(n > 0) {
 int d = n % 10;
 total += d * d;
 n /= 10;
 }
 return total;
}

bool isHappy(int n) {
 //AC
 int slow = n;
 int fast = getNext(slow);
 while (fast != slow) {
 slow = getNext(slow);
 fast = getNext(getNext(fast));
 }

 if(slow != 1) {
 return false;
 } else {
 return true;
 }
}

bool isHappy1(int n) {
 //AC
 int slow = n;
 int fast = n;
 while (fast!=1 && getNext(fast)!=1) {
 fast = getNext(getNext(fast));
 slow = getNext(slow);
 if (slow == fast) {
 //链表有环，则不是
 return false;
 }
 }
 return true;
}

bool isHappyBySet(int n) {
 unordered_set<int> setN;
 while(1) {
 int num = getNext(n);
 if (setN.find(num) == setN.end()) {
 setN.insert(num);
 n = num;
 } else {
 return false;
 }

 if (num == 1) return true;
 }

}


int main() {
 std::cout << "Hello, World!" << std::endl;
 std::cout << getNext(19) << std::endl;
 std::cout << isHappy(2) << std::endl;
 std::cout << isHappy(19) << std::endl;

 return 0;
}

Attention

一个“快乐数”定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为1，那么这个数就是快乐数。已知前提，如果不是快乐数，经过若干次运算后会进入循环，所以类似于判断链表是否循环。
可以用快慢指针或者哈希表（bfs）来解决

leetcode104.二叉树的最大深度

Tue, 01 Mar 2022 00:00:00 +0000

leetcode104.二叉树的最大深度

Question

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

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

说明: 叶子节点是指没有子节点的节点。

示例：给定二叉树 [3,9,20,null,null,15,7]，

3 /
9 20 /
15 7

返回它的最大深度 3 。 Related Topics 树深度优先搜索广度优先搜索二叉树 👍 1125 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


#include <iostream>
#include <queue>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

void CreatBinaryTreeByLevelVec(const vector<int>& vec, TreeNode* &cur, int index)
{
 if (index < vec.size() && vec[index] != -1) {
 cur = new TreeNode(vec[index]);
 CreatBinaryTreeByLevelVec(vec, cur->left, 2*index+1);
 if (2*index+2 < vec.size()) {
 CreatBinaryTreeByLevelVec(vec, cur->right, 2*index+2);
 }
 }
}


void CreatBinaryTreeByPreVec(const vector<int>& vec, TreeNode* &cur, int index)
{
 if (index < vec.size() && vec[index] != -1)//不能越界
 {
 cur = new TreeNode(vec[index]);
 cout << "cur: " << cur->val << endl;
 CreatBinaryTreeByPreVec(vec, cur->left, ++index);
 CreatBinaryTreeByPreVec(vec, cur->right, ++index);
 }
}

int maxDepthByDFS(TreeNode* root) {
 //DFS
 if (root == nullptr) return 0;
 return (max(maxDepthByDFS(root->left), maxDepthByDFS(root->right)) + 1);
}

int maxDepthByBFS(TreeNode* root) {
 //按照层来循环，每一层循环的长度为此层元素的个数，每次pop出最左侧的元素；如果该元素有子节点，将子节点加入队列；遍历完一层，ans+1
 if (root == nullptr) return 0;
 queue<TreeNode*> Q;
 Q.push(root);
 int ans = 0;
 while(!Q.empty()) {
 int len = Q.size();
 for (int i = 0; i < len; ++i) {
 TreeNode *node = Q.front();
 Q.pop();

 if (node->left) {
 Q.push(node->left);
 }
 if (node->right) {
 Q.push(node->right);
 }
 }
 ans += 1;
 }

 return ans;
}

int main() {
 vector<int> vec = {3,9,20,-1,-1,15,7};
 TreeNode* root = nullptr;
 CreatBinaryTreeByLevelVec(vec, root, 0);
// int res = maxDepthByDFS(root);
 int res = maxDepthByBFS(root);
 std::cout << res << std::endl;
 return 0;
}

Attention

TLS协议（三）

Fri, 12 Nov 2021 00:00:00 +0000

透明加密

用户无感知的加密解密过程，文件打开的时候自动解密，离开使用环境无法打开。文件在磁盘上是密文，在内存里是明文。

TLS协议（二）

Tue, 09 Nov 2021 00:00:00 +0000

密钥交换算法

Diffie-Hellman密钥交换

$A=g^a,,(mod,,,p)$

$B=g^b,,(mod,,,p)$

$SA = B^a,,,mod,,,p=[g^b,,(mod,,,p)]^a,,,mod,,,p$

$SB=A^b,,,mod,,,p=[g^a,,(mod,,,p)]^b,,,,mod,,,p$

$SA=B^a,,,mod,,,p=[g^b,,(mod,,,p)]^a,,,mod,,,p=,g^{ab}(mod,,,p)=[g^a,,(mod,,,p)]^b,,,,mod,,,p=A^b,,,mod,,,p$

$SA=SB可证明$

注：

g和p的值是AB都已知的，a是客户端生成的随机数，b是服务端生成的随机数
客户端发送DHE交换的请求，服务器生成随机数b，可计算出B，发送给客户端，客户端生成随机数a，计算出A，发送给服务端
交换计算出的AB，A用自己的私钥加密得到的B，B用自己的私钥加密得到的A，得到对称密钥
在TLS里，SA和SB就是预主密钥，pre_master_key

RSA

…

TLS 双向认证（mTLS）

客户端发起请求
「验证服务端是否可信」：服务端将自己的 TLS 证书发送给客户端，客户端通过自己的 CA 证书链验证这个服务端证书。
「验证客户端是否可信」：客户端将自己的 TLS 证书发送给服务端，服务端使用它的 CA 证书链验证该客户端证书。
协商对称加密算法及密钥
使用对称加密进行后续通信。

TLS协议（一）

Sat, 06 Nov 2021 00:00:00 +0000

本文数据包来源

对eth0网口抓包，访问github.com，这是TLS通信过程。

TLS

client hello

客户端版本：客户端希望支持的协议版本

客户端随机数：客户端生成，32字节，前4个字节表示epoch格式的当前日期时间，其余28个字节由加密强随机数生成器生成

密码套件：客户端支持的密码套件

server hello

服务端版本：0x0303表示支持1.2的版本

服务端随机数

密码套件：服务端选择了一个密码套件

Certificate

服务器证书

Server Key Exchange（服务器密钥交换）

服务器密钥交换(Server Key Exchange)是可选的。仅当服务器提供的证书不足以允许客户端交换预主密钥时，才会发送此消息。

使用Elliptic Curve Diffie Hellman算法来交换密钥（ECDHE）。在Diffie-Hellman中，客户端无法自行计算预主密钥，双方都有助于计算它，因此客户端需要从服务器获取Diffie-Hellman公钥。当使用Elliptic Curve Diffie-Hellman时，该公钥不在证书中。因此，服务器必须在单独的消息中向客户端发送其DH公钥，以便客户端可以计算预主密钥。

服务器密钥交换完成后，服务器将发送Server Hello Done 消息。客户端将开始计算Pre-Master Secret。

以上密钥交换算法是ECDHE，服务器会生成一对密钥（公钥和私钥）与客户端共享。客户端和服务器都为每个新会话生成一个新密钥对。一旦计算出预主密钥，将立即删除客户端和服务器的私钥。这意味着私钥永远不会被窃取，比rsa更具有前向安全性。

Server Key Exchange（客户端密钥交换）

通过RSA或ECDHE，客户端和服务端都生成了共同的Pre-Master Secert，之后，客户端将发送Change Cipher Spec消息。

Change Cipher Spec

客户端向服务端发送的Change Cipher Spec：

服务端向客户端发送的Change Cipher Spec：

一些概念

加密算法

对称加密

用同一密钥加解密，常见的对称加密算法：DES、AES、ChaCha20 等。

非对称加密

分公钥、私钥，常见的非对称加密算法：RSA，ECC 等。ECC子算法 ECDHE 用于密钥交换，ECDSA 用于数字签名。

混合加密

TLS在通信刚开始的时候使用非对称加密算法，解决密钥交换的问题。后续全都使用对称加密进行通信。

加密套件

一般是客户端提供一个列表，服务端选择一个加密套件，用openssl命令行查看一些加密套件：

加密套件结构：

TLS数据完整性

消息验证代码（MAC）

当服务器或客户端使用主密钥加密数据时，还会计算明文数据的校验和（哈希值），这个校验和称为消息验证代码（MAC）。发送方用密钥生成MAC包含在加密数据中，接收方将MAC和明文分开，用密钥计算明文的校验和，与接收到的MAC比较，就知道内容有没有被篡改。

以上例子中SHA256就是计算MAC的哈希函数，这是对称加密，客户端和服务端需要用相同的散列算法。

一共有四个密钥来保证TLS的数据完整性：

客户端写入加密密钥：客户端用赖加密数据，服务器用来解密数据。
服务器写入加密密钥：服务器用来加密数据，客户端用来解密数据。
客户端写入MAC密钥：客户端用来创建MAC，服务器用来验证MAC。
服务器写入MAC密钥：服务器用来创建MAC，客户端用来验证MAC。

初始化向量IV

…

证书

CA 证书，就是 CA 公钥+CA机构相关信息构成的一个文件。 TLS 证书，则包含公钥+申请者信息，颁发者(CA)的信息+签名(使用 CA 私钥加密的证书 Hash)，以及一些其他信息。几种文件类型：

xxx.key: 就是一个私钥，一般是一个 RSA 私钥，长度通常指定为 2048 位。
xxx.csr: 即 Certificate Sign Request，证书签名请求。使用 openssl 等工具，通过 TLS 密钥+TLS 证书的相关信息，可生成出一个 CSR 文件。
xxx.crt: 这就是我们所说的 TLS 证书，CA 证书和服务端 TLS 证书都是这个格式。使用 CA 证书、CA 密钥对 csr 文件进行签名，就能得到最终的服务端 TLS 证书——一个 crt 文件。

leetcode39.组合总和

Fri, 29 Oct 2021 00:00:00 +0000

Question

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


//给定一个无重复元素的正整数数组 candidates 和一个正整数 target ，找出 candidates 中所有可以使数字和为目标数 target 的
//唯一组合。
//
// candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同，则两种组合是唯一的。
//
// 对于给定的输入，保证和为 target 的唯一组合数少于 150 个。
//
//
//
// 示例 1：
//
//
//输入: candidates = [2,3,6,7], target = 7
//输出: [[7],[2,2,3]]
//
//
// 示例 2：
//
//
//输入: candidates = [2,3,5], target = 8
//输出: [[2,2,2,2],[2,3,3],[3,5]]
//
// 示例 3：
//
//
//输入: candidates = [2], target = 1
//输出: []
//
//
// 示例 4：
//
//
//输入: candidates = [1], target = 1
//输出: [[1]]
//
//
// 示例 5：
//
//
//输入: candidates = [1], target = 2
//输出: [[1,1]]
//
//
//
//
// 提示：
//
//
// 1 <= candidates.length <= 30
// 1 <= candidates[i] <= 200
// candidate 中的每个元素都是独一无二的。
// 1 <= target <= 500
//
// Related Topics 数组 回溯
// 👍 1592 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


void helper(vector<int>& candidates, int target, int index, vector<vector<int>>& ret, vector<int> cur) {
 if (target == 0) {
 //递归边界
 ret.push_back(cur);
 return;
 }

 if (index == candidates.size()) {
 //索引到达边界
 return;
 }

 if (target < 0) {
 return;
 }

 //选择不添加当前数字
 helper(candidates, target, index+1, ret, cur);

 //选择添加当前数字，索引后移一位
 cur.push_back(candidates[index]);
 helper(candidates, target-candidates[index], index, ret, cur);
 cur.pop_back();
}

vector<vector<int>> combinationSum1(vector<int>& candidates, int target) {
 vector<vector<int>> ret;
 vector<int> cur;
 helper(candidates, target, 0, ret, cur);
 return ret;
}

Attention

集合candidates中的元素，可以选择一次或者多次。
本题用回溯法，helper函数通过dfs（深度优先搜索）遍历，找到可能的组合。对于candidates = [2,3,6,7], target = 7的输入，候选数组是存2，下次循环的target是7-2=5，需要找到和为5的所有组合；候选数组先存3，下次循环的targer是7-3=4，需要找到和为4的所有组合；……
注意递归的边界值是target减到0，可以存下当前数组。另外索引到达candidates的最大长度，多次减去候选值得到的target小于0，需要提前返回。
关于DFS，沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。属于盲目搜索。

leetcode40.组合总和II

Fri, 29 Oct 2021 00:00:00 +0000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


//给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
//
// candidates 中的每个数字在每个组合中只能使用一次。
//
// 注意：解集不能包含重复的组合。
//
//
//
// 示例 1:
//
//
//输入: candidates = [10,1,2,7,6,1,5], target = 8,
//输出:
//[
//[1,1,6],
//[1,2,5],
//[1,7],
//[2,6]
//]
//
// 示例 2:
//
//
//输入: candidates = [2,5,2,1,2], target = 5,
//输出:
//[
//[1,2,2],
//[5]
//]
//
//
//
// 提示:
//
//
// 1 <= candidates.length <= 100
// 1 <= candidates[i] <= 50
// 1 <= target <= 30
//
// Related Topics 数组 回溯
// 👍 719 👎 0

重复

leetcode50.Pow(x,n)

Wed, 20 Oct 2021 00:00:00 +0000

Question

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


//实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
//
//
//
// 示例 1：
//
//
//输入：x = 2.00000, n = 10
//输出：1024.00000
//
//
// 示例 2：
//
//
//输入：x = 2.10000, n = 3
//输出：9.26100
//
//
// 示例 3：
//
//
//输入：x = 2.00000, n = -2
//输出：0.25000
//解释：2-2 = 1/22 = 1/4 = 0.25
//
//
//
//
// 提示：
//
//
// -100.0 < x < 100.0
// -231 <= n <= 231-1
// -104 <= xn <= 104
//
// Related Topics 递归 数学
// 👍 763 👎 0

Answer

$x^n,:,3^5,:,x=3, ,n=5$

n二进制表示0101，n«1表示n*=2，n»1表示n/=2。
n&1==1表示最后一位是1，n&1==0表示最后一位是0。
对n做右移一位操作，n最后一位是1即做ret与x累乘。

$n=5=2^2+2^0$

n=0101	ret=1*3=3	x=3*3=9
n=0010		x=9*9=81
n=0001	ret=3*81=243	x=81*81=6561
n=0001
n=0000
return

n=1010		x=2*2=4
n=0101	ret=1*4=4	x=4*4=16
n=0010		x=16*16=256
n=0001	ret=4*256=1024	x=256*256
n=0000
return

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


double myPow(double x, int n) {
 // x:2, n:10 (1010)
 //n<<1,*2; n>>1,/2
 double ret = 1;
 if (n<0) {
 x = 1/x;
 }
 long long k = abs((long long)n); //防止超时

 while (k) {
 if (k&1) {
 //n的最后一位是1
 ret *= x;
 }
 x *= x;
 k = k>>1;
 cout << "x:" << x << endl;
 }

 return ret;
}

x = 1.00000， n = -2147483648，long long存n，防止溢出
x = 2.00000， n = -2

go-basic

Mon, 18 Oct 2021 00:00:00 +0000

Array&Slice

数组的指针是*[5]int，指针数组是[5]*int
array&slice的定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


//数组
array:=[5]int{4:1}
months := [...]string{1:"Jan", 2:"Feb", 3:"Mar", 4:"APR", 5:"May", 6:"Jun", 7:"July", 8:"Aug", 9:"Sep", 10:"Oct", 11:"Nov", 12:"Dec"}

for i,v := range months {
 fmt.Printf("%d-%s\n", i, v)
}
for _,v := range months {
 fmt.Printf("%s\n", v)
}

tonull(months[:3]) //切片,直接修改内容
zero(&months) //指针,直接修改内容
/**
输出
------tonull------
[null null null Mar APR May Jun July Aug Sep Oct Nov Dec]
-------zero-------
[ ]
**/

func zero(ptr *[13]string) {
 *ptr = [13]string{} //[32]byte{}就可以生成一个32字节的数组。而且每个数组的元素都是零值初始化，也就是0
 //无返回值
}

func tonull(arr []string) {
 for i:=0; i<len(arr); i++ {
 arr[i] = "null"
 }
}

//切片
slice:=[]int{4:1}

nums := [...]int{0, 1, 2, 3, 4}
sumNum(nums[:]) //输出10

func sumNum(arr []int) int {
 s := 0
 for i:=0; i<len(arr); i++ {
 s += arr[i]
 }
 return s //返回值int
}

nil切片和空切片，它们的长度和容量都是0，但是它们指向底层数组的指针不一样，nil切片意味着指向底层数组的指针为nil，而空切片对应的指针是个地址。

1
2
3
4


//nil切片
var nil Slice []int
//空切片
slice:=[]int{}

3个索引的方法，第3个k用来限定新切片的容量，其用法为slice[i:j:k]。
append函数会智能的增长底层数组的容量，目前的算法是：容量小于1000个时，总是成倍的增长，一旦容量超过1000个，增长因子设为1.25，也就是说每次会增加25%的容量。
…操作符，把一个切片追加到另一个切片里

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


/*--------------array-------------*/
var array01[5] int
array02 := [5]int{0,1,2,3,4}
array03 := [5]int{0:8, 1:8}
fmt.Printf("%d\n", array01[3])
fmt.Printf("%d\n", array02[0])
fmt.Printf("%d\n", array03[0])

for i, v:=range array03 {
 fmt.Printf("索引[%d], 值[%d]\n", i, v)
}

array04 := [4]*int{0:new(int), 3:new(int)}
*array04[0] = 1
//*array04[1] = 1 // error
array04[1] = new(int)
*array04[1] = 9
fmt.Printf("%d-%d\n", array04[1], *array04[1])

array05 := [5]int{1:2, 3:4}
fmt.Println("before:", array05)
modify_array0(&array05)
fmt.Println("after :", array05)

var array06 [6]int
fmt.Println("before:", array06)
modify_array1(array06)
fmt.Println("after :", array06)

func modify_array0(a *[5]int) {
 //传递数组指针，修改原数组
 a[1] = 3
 fmt.Println("modify_0:", *a)
}

func modify_array1(a [6]int) {
 //复制数组，不修改原数组
 a[1] = 3
 fmt.Println("modify_1:", a)
}
/*--------------array-------------*/

打印：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


/*--------------array-------------*/
0
0
8
索引[0], 值[8]
索引[1], 值[8]
索引[2], 值[0]
索引[3], 值[0]
索引[4], 值[0]
824633828104-9
before: [0 2 0 4 0]
modify_0: [0 3 0 4 0]
after : [0 3 0 4 0]
before: [0 0 0 0 0 0]
modify_1: [0 3 0 0 0 0]
after : [0 0 0 0 0 0]
/*--------------array-------------*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


/*--------------slice-------------*/
slice := []int{0,1,2,3,4}
for _, v:=range slice {
 // 不想要索引，可以使用_来忽略它
 fmt.Println(v)
}

// 值的方式传递，占用内存小
fmt.Println("before modify_slice:", slice)
fmt.Printf("before modify_slice addr:%p\n", &slice)
modify_slice(slice)
fmt.Println("after modify_slice :", slice)

slice1 := slice[:]
slice2 := slice[0:]
slice3 := slice[:4]
slice4 := slice[1:3]
fmt.Println(slice)
fmt.Println(slice1)
fmt.Println(slice2)
fmt.Println(slice3)
fmt.Println(slice4) //左闭右开

newSlice := slice[1:3]
fmt.Printf("newSlice长度:%d,容量:%d\n",len(newSlice),cap(newSlice))
newSlice = append(newSlice, 10, 20, 30)
newSlice = append(newSlice, slice...) //slice追加到newSlice
fmt.Println(newSlice)

func modify_slice(slice []int) {
 fmt.Printf("%p\n", &slice) //两个slice地址不一样
 slice[1] = 10
}
/*--------------slice-------------*/

打印：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


/*--------------slice-------------*/
0
1
2
3
4
before modify_slice: [0 1 2 3 4]
before modify_slice addr:0xc0000b2138
0xc0000b2168
after modify_slice : [0 10 2 3 4]
[0 10 2 3 4]
[0 10 2 3 4]
[0 10 2 3 4]
[0 10 2 3]
[10 2]
newSlice长度:2,容量:4
[10 2 10 20 30 0 10 2 3 4]
/*--------------slice-------------*/

类型

Go 语言是一种静态类型的编程语
1. 基本类型在多线程里是安全的；
2. 引用类型有切片、map、接口、函数类型以及chan。它的修改可以影响到任何引用到它的变量。
内部类型和外部类型：如果类型名字大写开头，其他包就可以访问；小写开头，其他包就不能访问。
1. 嵌入类型，或者嵌套类型，这是一种可以把已有的类型声明在新的类型里的一种方式。可以用于interface和struct。
2. 外部类型还可以添加自己的方法、字段属性等；外部类型也可以声明同名的字段或者方法，来覆盖内部类型；如果内部类型实现了某个接口，那么外部类型也被认为实现了这个接口。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


/*--------------map-------------*/
dict := make(map[string] int)
dict["cccc"] = 7
dict["aaaa"] = 9
dict["bbbb"] = 8

sort_map(dict)

delete(dict, "aaaa")
dict1 := map[string]int{}
dict1["aaaa"] = 8

func sort_map(dict map[string]int) {
 fmt.Println("Here is sort_map.")
 var names []string
 for name := range dict {
 names = append(names, name)
 }
 sort.Strings(names)
 for _, key:= range names {
 fmt.Println(key, dict[key])
 }
}
/*--------------map-------------*/

1
2
3
4


Here is sort_map.
aaaa 9
bbbb 8
cccc 7

函数&方法

函数没有接收者，方法有接收者（要么是属于一个结构体的，要么属于一个新定义的类型）。
指针接收者传递的是一个指向原值指针的副本，指针的副本，指向的还是原来类型的值，所以修改时，同时也会影响原来类型变量的值。
接口：如果要实现一个接口，必须实现这个接口提供的所有方法。

go-chan

Mon, 18 Oct 2021 00:00:00 +0000

chan

定义：

1
2
3
4
5


ch := make(chan int)
ch<-2//发送数值2给这个通道
x:=<-ch //从通道里读取值，并把读取的值赋值给x变量
<-ch //从通道里读取值，然后忽略
close(ch) //内置close，关闭

1

ch := make(chan int,0)

第二个参数是通道的大小，0则是无缓冲通道。有缓冲通道，其实是一个队列。对于有缓冲的通道，向其发送操作就是向队列的尾部插入元素，接收操作则是从队列的头部删除元素，并返回这个刚刚删除的元素。

单向通道

限制一个通道只可以接收，但是不能发送；有时候限制一个通道只能发送，但是不能接收，这种通道我们称为单向通道。

1
2


var send chan<- int //只能发送
var receive <-chan int //只能接收

单方向的channel类型，分别用于只发送或只接收的channel。类型chan<- int表示一个只发送int的channel，只能发送不能接收。相反，类型<-chan int表示一个只接收int的channel，只能接收不能发送。（箭头<-和关键字chan的相对位置表明了channel的方向。）这种限制将在编译期检测。

带缓存的通道

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


strchan := make(chan string, 10)
strchan <- "a"
strchan <- "b"
strchan <- "c"
fmt.Println(cap(strchan)) //10
fmt.Println(len(strchan)) //3

fmt.Println(<-strchan) //a
fmt.Println(<-strchan) //b
fmt.Println(<-strchan) //c
//fmt.Println(<-strchan) //阻塞

管道pipeline（串联的通道）

example1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


package main

import "fmt"

func main() {
 ch := make(chan int) //无缓冲通道，需要同步操作

 go func() {
 sum := 0
 for i:=0; i<10; i++ {
 sum += i
 }
 ch <- sum
 }()

 fmt.Println(<-ch) // 45

 //用同步通道实现管道，类似bash中的|
 one := make(chan string)
 two := make(chan string)
 go func() {
 one <- "aaa"
 }()
 go func() {
 var v string
 v =<- one
 two <- v
 }()

 fmt.Println(<-two) // aaa

 //有缓冲通道，获取最先返回的服务器信息
 mirrieedQuery() // xxxx from ccccc.io
}

func mirrieedQuery() string {
 responses := make(chan string, 3)
 // 同时发起3个并发goroutine向这三个镜像获取数据
 go func() {
 responses <- requset("aaaaa.io")
 }()

 go func() {
 responses <- requset("bbbbb.io")
 }()

 go func() {
 responses <- requset("ccccc.io")
 }()

 fmt.Println(<-responses)
 return <-responses
}

func requset(hostname string) (response string) {
 return "xxxx from " + hostname
}

example2

一个channel的输出作为另一个channel的输入，即pipeline。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


package main

import "fmt"

func main() {
 //打印0-99的平方
 numbers := make(chan int)
 squares := make(chan int)

 go func() {
 for i:=0; i<100; i++ {
 numbers <- i
 }
 close(numbers)
 }()

 go func() {
 for x := range numbers{
 squares <- x*x
 }

/*
 for {
 x, ok := <-numbers
 if !ok {
 break
 }
 squares <- x*x
 }
*/
 close(squares)
 }()

 for x := range squares{
 fmt.Println(x)
 }
}

example3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import (
 "fmt"
)

func main() {
 numbers := make(chan int)
 squares := make(chan int)

 go number(numbers)
 go square(squares, numbers)
 printer(squares)
}

func number(outnumber chan<- int) {
 // outnumber 只能发送的单向通道
 for i:=0; i<100; i++ {
 outnumber <- i
 }

 close(outnumber)
}

func square(outsquare chan<- int, innumber <-chan int) {
 // innumber 只能接收的单向通道
 for v := range innumber {
 outsquare <- v * v
 }

 close(outsquare)
}

func printer(outprint <-chan int) {
 for u := range outprint {
 fmt.Println(u)
 }
}

go-goroutine

Mon, 18 Oct 2021 00:00:00 +0000

goroutine

go语言中并发指的是让某个函数独立于其他函数运行的能力，一个goroutine就是一个独立的工作单元，Go的runtime（运行时）会在逻辑处理器上调度这些goroutine来运行，一个逻辑处理器绑定一个操作系统线程，所以说goroutine不是线程，它是一个协程，也是这个原因，它是由Go语言运行时本身的算法实现的。

概念	说明
进程	一个程序对应一个独立程序空间
线程	一个执行空间，一个进程可以有多个线程
逻辑处理器	执行创建的goroutine，绑定一个线程
调度器	Go运行时中的，分配goroutine给不同的逻辑处理器
全局运行队列	所有刚创建的goroutine都会放到这里
本地运行队列	逻辑处理器的goroutine队列

Go的并发

当我们创建一个goroutine的后，会先存放在全局运行队列中，等待Go运行时的调度器进行调度，把他们分配给其中的一个逻辑处理器，并放到这个逻辑处理器对应的本地运行队列中，最终等着被逻辑处理器执行即可。

并发可以同时做很多事情，比如有个goroutine执行了一半，就被暂停执行其他goroutine去了，这是Go控制管理的。所以并发的概念和并行不一样，并行指的是在不同的物理处理器上同时执行不同的代码片段，并行可以同时做很多事情，而并发是同时管理很多事情，因为操作系统和硬件的总资源比较少，所以并发的效果要比并行好的多，使用较少的资源做更多的事情，也是Go语言提倡的。

Go的并行

那么Go的并行是怎样的呢？多创建一个逻辑处理器就好了，这样调度器就可以同时分配全局运行队列中的goroutine到不同的逻辑处理器上并行执行。

默认情况下，Go默认是给每个可用的物理处理器都分配一个逻辑处理器。

原子化（atomic）

我们对于同一个资源的读写必须是原子化的，也就是说，同一时间只能有一个goroutine对共享资源进行读写操作。

共享资源竞争的问题，Go语言提供了atomic包和sync包里的一些函数对共享资源同步枷锁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


package main

import (
 "fmt"
 "runtime"
 "sync"
 "sync/atomic"
)

var (
 count int32
 wg sync.WaitGroup
 mutex sync.Mutex
)
func main() {
 //atomic_ex()
 //mutex_ex()
}

func mutex_ex() {
 wg.Add(2)
 count = 8
 go intcount_mutex()
 go intcount_mutex()
 wg.Wait()
}

func intcount_mutex() {
 // 互斥锁
 defer wg.Done()
 for i:=0; i<2; i++ {
 mutex.Lock()
 value := count
 runtime.Gosched()
 value++
 count := value
 mutex.Unlock()
 fmt.Println("cout : ", count)
 }
}

func atomic_ex() {
 // 原子操作
 count = 7
 wg.Add(2)
 go intcount_atomic()
 go intcount_atomic()
 wg.Wait()
 fmt.Println(count)
}

func intcount_atomic() {
 defer wg.Done()
 fmt.Printf("----count[%d]----\n", count)
 for i:=0; i<2; i++ {
 fmt.Printf("count[%d]\n", count)
 value := atomic.LoadInt32(&count)
 runtime.Gosched() //让出cpu时间
 value++
 atomic.StoreInt32(&count, value)
 fmt.Println("count:", count, "value:", value)
 }
}

atomic_ex()输出：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


----count[7]----
----count[7]----
count[7]
count[7]
count: 8 value: 8
count[9]
count: 10 value: 10
count: 9 value: 9
count[10]
count: 11 value: 11
11

mutex_ex()输出：

1
2
3
4


cout : 9
cout : 9
cout : 9
cout : 9

defer延迟语句

defer延迟语句：在函数中添加多个defer语句，当函数执行到最后时，这些defer语句会按照逆序执行，最后该函数返回。进行一些打开资源的操作时，遇到错误需要提前返回，在返回前需要关闭相应的资源，不然容易造成资源泄露等问题。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


func ReadWrite() bool {
 file.Open("file")
 defer file.Close()
 if failureX {
 return false
 }
 if failureY {
 return false
 }
 return true
}

如果有很多调用defer，那么defer是采用后进先出模式，所以如下代码会输出4 3 2 1 0

1
2
3


for i := 0; i < 5; i++ {
 defer fmt.Printf("%d ", i)
}

atomic包

GO语言提供的原子操作都是非入侵式的，由标准库sync/atomic中的众多函数代表
类型包括int32,int64,uint32,uint64,uintptr,unsafe.Pointer，共六个
这些函数提供的原子操作共有五种：增或减，比较并交换，载入，存储和交换

1
2
3
4
5


// 一个32位整数读出或者写入内存
// LoadInt32 atomically loads *addr.
func LoadInt32(addr *int32) (val int32)
// StoreInt32 atomically stores val into *addr.
func StoreInt32(addr *int32, val int32)

Example

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package main

import (
 "fmt"
 "runtime"
 "sync"
)

func main() {
 var wg sync.WaitGroup
 //runtime.GOMAXPROCS(1) // 设置逻辑处理器，1个
 runtime.GOMAXPROCS(runtime.NumCPU())
 fmt.Println("runtime.NumCPU() =", runtime.NumCPU())
 wg.Add(2) // 计数器2
 go func() {
 defer wg.Done() // 延迟语句 -1
 for i:=0; i<100; i++ {
 fmt.Println("A:%d", i)
 }
 }()

 go func() {
 defer wg.Done()
 for i:=0; i<100; i++ {
 fmt.Println("B:%d", i)
 }
 }()

 wg.Wait()
}

输出：runtime.NumCPU() = 4，AB交替输出0-99

go-interface

Mon, 18 Oct 2021 00:00:00 +0000

Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


package main

import (
 "fmt"
)

type hello_inter interface {
 hello()
}

type animal interface {
 printInfo()
}

type cat string
type dog string
type bird string
type edog string

type user struct {
 name string
 email string
}

type admin struct {
 user
 level string
}


func (u user) hello() {
 fmt.Println("hello")
}

func (u user) printHello() {
 fmt.Println("this is user")
}

func (a admin) printHello() {
 fmt.Println("this is admin")
}

func (b bird) printInfo() {
 // 值接收者实现animal接口
 // 方法
 fmt.Println("this is bird")
}

func (c cat) printInfo() {
 //值接收者实现animal接口
 // 方法
 fmt.Println("this is cat")
}

func (d dog) printInfo() {
 //值接收者实现animal接口
 // 方法
 fmt.Println("this is dog")
}

func (e *edog) printInfo() {
 // 指针接收者实现animal接口
 // 调用的地方需要以指针作为参数传递
 fmt.Println("this is e-dog")
}

func invoke(a animal) {
 // 函数
 a.printInfo()
}

func sayHello (a admin) {
 a.hello()
}

func main() {
/*--------------多态-------------*/
 var a animal
 var b bird
 var c cat
 var d dog
 var e edog
 invoke(&e) // this is e-dog

 a = c
 a.printInfo() // this is cat

 a = d
 a.printInfo() // this is dog

 invoke(b) // this is bird

 ad := admin{user{"serrini", "123@qq.com"}, "level001"}
 ad.printHello() // 同名函数重写，打印admin // this is admin
 //ad.hello()

 sayHello(ad) // 内部user实现了接口hello_inter，外部类型admine也被认为实现了该接口 // hello
}

1
2
3
4
5
6


this is e-dog
this is cat
this is dog
this is bird
this is admin
hello

如果要实现一个接口，必须实现这个接口提供的所有方法。

go-struct

Mon, 18 Oct 2021 00:00:00 +0000

Struct

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


type person struct {
 age int
 name string
}


func (p person) String_name() string{
 return "the person name is " + p.name
}

func (p person) Int_age() int{
 return p.age
}

func (p person) modify_value() {
 p.name = "serrini"
}

func (p *person) modify_point() {
 p.name = "serrini"
}

/*--------------struct-------------*/
//var p person
p := person{12, "jim"}
modify_struct_0(&p)
fmt.Println(p)
modify_struct_1(p)
fmt.Println(p)

fmt.Println(p.String_name())
fmt.Println(p.Int_age())

p.modify_value()
fmt.Println("值接收者，修改无效：", p.String_name())
p.modify_point()
fmt.Println("指针接收者，修改有效：", p.String_name())

func modify_struct_0(p *person) {
 //通过传递结构体指针，可以修改age的值
 p.age = p.age + 10
}

func modify_struct_1(p person) {
 // 结构体传递的是其本身以及里面的值的拷贝，无法修改age的值
 p.age = p.age + 10
}


/*--------------struct-------------*/

输出：

1
2
3
4
5
6
7
8


/*--------------struct-------------*/
{22 jim}
{22 jim}
the person name is jim
22
值接收者，修改无效： the person name is jim
指针接收者，修改有效： the person name is serrini
/*--------------struct-------------*/

go开发环境

Mon, 18 Oct 2021 00:00:00 +0000

IDE

IDEA+go插件

常见问题

Question1：无法导入自定义包

import 时无法导入自定义包，提示找不到包。

Solution1

从 GOPATH的src下面去找包作为第三方包引入。

我们可以直接把我们要导入的包(自己写的) 丢在GOPATH下的src里面，这样就可以找到，但是这样不方便管理。
我们把本项目创建为 GOPATH 下面创建src里面放上我们的包。

Question2：报错package xxx is not in GOROOT

导入gopath目录下的包时报错“package xxx is not in GOROOT“，编译器没有去gopath下找包。原因是GO111MODULE没有关， gomod 和 gopath 两个包管理方案，是相互不兼容的。在 gopath 查找包，按照 goroot 和多 gopath 目录下 src/xxx 依次查找。在 gomod 下查找包，解析 go.mod 文件查找包，mod 包名就是包的前缀，里面的目录就后续路径了。在 gomod 模式下，查找包就不会去 gopath 查找，只是 gomod 包缓存在 gopath/pkg/mod 里面。

Solution2

把GO111MODULE置为off。

1

go env -w GO111MODULE=off

go path 和 go mod不能同时使用，关掉 go mod，下次需要用的时候再打开。

Attention

Go有两个很重要的环境变量GOROOT和GOPATH,这是两个定义路径的环境变量，GOROOT是安装Go的路径，比如/usr/local/go；GOPATH是我们自己定义的开发者个人的工作空间。编译器会优先在GOROOT里搜索，其次是GOPATH。

leetcode94、102、107、144、155二叉树相关

Thu, 14 Oct 2021 00:00:00 +0000

Struct Definition

1
2
3
4
5
6
7
8


struct TreeNode {
 int val;
 TreeNode *left;
 TreeNode *right;
 TreeNode() : val(0), left(nullptr), right(nullptr) {}
 TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

CreateBinaryTree

Question

给出先序遍历或层序遍历的数组，创建二叉树，作为输入

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


//先序遍历数组
//输入：root = [1,null,2,3]
//输出：[1,3,2]
//输入：root = [1,null,2]
//输出：[1,2]
/*
 1
 \
 2
 /
3
*/

1
2
3
4
5
6
7
8


//层序遍历数组
// 3
// / \
// 9 20
// / \
// 15 7
//inout : [3,9,20,null,null,15,7]
//vector<int> level_vecs = {3,9,20,-1,-1,15,7};

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


void CreatBinaryTreeByPreVec(const vector<int>& vec, TreeNode* &cur, int index)
{
 if (index < vec.size() && vec[index] != -1)//不能越界
 {
 cur = new TreeNode(vec[index]);
 cout << "cur: " << cur->val << endl;
 CreatBinaryTreeByPreVec(vec, cur->left, ++index);
 CreatBinaryTreeByPreVec(vec, cur->right, ++index);
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


void CreatBinaryTreeByLevelVec(const vector<int>& vec, TreeNode* &cur, int index)
{
 if (index < vec.size() && vec[index] != -1) {
 cur = new TreeNode(vec[index]);
 CreatBinaryTreeByLevelVec(vec, cur->left, 2*index+1);
 if (2*index+2 < vec.size()) {
 CreatBinaryTreeByLevelVec(vec, cur->right, 2*index+2);
 }
 }
}

Pre、In、Post Order

Question

分别先序、中序、后序遍历二叉树

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


void inOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 if (root->left) {
 inOrder(root->left, res);
 }
 res.push_back(root->val);
 if (root->right) {
 inOrder(root->right, res);
 }
}

void postOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 if (root->left) {
 postOrder(root->left, res);
 }
 if (root->right) {
 postOrder(root->right, res);
 }
 res.push_back(root->val);
}


void preOrder(TreeNode *root, vector<int> &res) {
 if (!root) return;
 res.push_back(root->val);
 if (root->left) {
 preOrder(root->left, res);
 }
 if (root->right) {
 preOrder(root->right, res);
 }
}

vector<int> inorderTraversal(TreeNode* root) {
 vector<int> res;
 inOrder(root, res);
 return res;
}

vector<int> preorderTraversal(TreeNode* root) {
 vector<int> res;
 preOrder(root, res);
 return res;
}

vector<int> postorderTraversal(TreeNode* root) {
 vector<int> res;
 postOrder(root, res);
 return res;
}

Question

层序遍历二叉树

1
2
3
4
5
6
7


// 3
// / \
// 9 20
// / \
// 15 7
//inout : [3,9,20,null,null,15,7]
//vector<int> level_vecs = {3,9,20,-1,-1,15,7};

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


vector<vector<int>> levelOrder(TreeNode* root) {
 //迭代
 //广度优先搜索(BFS队列)
 vector<vector<int>> res;
 if (!root)
 return res;
 queue<TreeNode*> q;
 q.push(root);

 while(!q.empty()) {
 res.emplace_back();
 int len = q.size();
 for (int i = 0; i < len; i++) {
 TreeNode* node = q.front();
 res.back().push_back(node->val);
 q.pop();

 if (node->left) {
 q.push(node->left);
 }
 if (node->right) {
 q.push(node->right);
 }
 }
 }
 return res;
}

vector<vector<int>> levelOrderBottom(TreeNode* root) {
 vector<vector<int>> res;
 if (!root)
 return res;
 queue<TreeNode*> q;
 q.push(root);

 while(!q.empty()) {
 res.emplace_back();
 int len = q.size();
 for (int i = 0; i < len; i++) {
 TreeNode* node = q.front();
 res.back().push_back(node->val);
 q.pop();

 if (node->left) {
 q.push(node->left);
 }
 if (node->right) {
 q.push(node->right);
 }
 }
 }
 reverse(res.begin(), res.end());
 return res;
}

Question

层序打印二叉树

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


void PrintFromTopToBottom(TreeNode* pRoot)
{
 //层序打印队列
 if(pRoot == nullptr)
 return;

 deque<TreeNode *> dequeTreeNode;

 dequeTreeNode.push_back(pRoot);
 while(dequeTreeNode.size())
 {
 TreeNode *pNode = dequeTreeNode.front();
 dequeTreeNode.pop_front();
 cout<< pNode->val << " ";
 if(pNode->left)
 dequeTreeNode.push_back(pNode->left);

 if(pNode->right)
 dequeTreeNode.push_back(pNode->right);
 }
 cout << endl;
}

Attention

leetcode20.有效的括号

Wed, 13 Oct 2021 00:00:00 +0000

leetcode20.有效的括号

Question

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。

示例 1：

输入：s = “()” 输出：true

示例 2：

输入：s = “()[]{}” 输出：true

示例 3：

输入：s = “(]” 输出：false

示例 4：

输入：s = “([)]” 输出：false

示例 5：

输入：s = “{[]}” 输出：true

提示：

1 <= s.length <= 104 s 仅由括号 ‘()[]{}’ 组成

Related Topics 栈字符串 👍 2668 👎 0

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


class Solution {
public:
 bool isValid(string s) {
 map<char, char> mymap;
 stack<char> mysta;
 mymap.insert(pair<char, char>(')', '('));
 mymap.insert(pair<char, char>(']', '['));
 mymap.insert(pair<char, char>('}', '{'));
 for (int i = 0; i < s.length(); ++i) {
 if(s[i] == '(' || s[i] == '[' || s[i] == '{') {
 mysta.push(s[i]);
 } else if (s[i] == ')' || s[i] == ']' || s[i] == '}') {
 if (mysta.empty()) {
 return false;
 }
 if (!mysta.empty()) {
 if (mysta.top() == mymap[s[i]]) {
 mysta.pop();
 } else {
 mysta.push(s[i]);
 continue;
 }
 }

 } else {
 return false;
 }
 }

 if (mysta.empty()) {
 return true;
 } else {
 return false;
 }

 }
};

Attention

1、map存相应的括号，遇到左括号压栈，右括号如果栈顶元素是对应的，则pop。

tcprewrite、mergecap修改合并pcap包

Wed, 13 Oct 2021 00:00:00 +0000

tcprewrite、mergecap修改合并pcap包

Example

需要用tcprewrite构造有背景流量的数据包，服务端的IP和端口是固定的，客户端IP和端口在一个范围中轮巡遍历，因此客户端使用了大量的知名端口，27017对应mogonDB，10000对应hive，9200对应ES。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#!/usr/bin/bash
#-*- coding: UTF-8 -*-

import os
import random

if __name__ == '__main__':
 os.system("mkdir output")
 ports = [1111, 2222, 3333, 4444, 5555, 6666, 7777]
 for port in ports:
 os.system("tcprewrite --postmap=59359:%s --seed=%d --infile=016.pcapng --outfile=./output/%d.pcapng --skipbroadcast" % (port, random.randint(1,1000), port))

 os.system("mergecap -w res_1521.pcapng ./output/*.pcapng")
 print("-----ok-----")

Attention

需要tcpreplay和wireshark
tcprewrite文档

Notes

Tcprewrite

-r 字符串，– portmap =字符串

重写 TCP/UDP 端口。此选项最多可出现 9999 次。

指定由冒号分隔的端口号对组成的逗号分隔端口映射列表。每个冒号分隔的端口对由要匹配的端口和要重写的端口号组成。

示例： –portmap=80:8000 –portmap=8080:80 # 80->8000 和 8080->80 –portmap=8000,8080,88888:80 # 3 个不同的端口变成 80 –portmap=8000-8999 :80 # 端口 8000 到 8999 变成 80

-s 数字，– seed =数字

使用给定种子随机化 src/dst IPv4/v6 地址。此选项最多可出现 1 次。此选项不得与以下任何选项一起出现：fuzz-seed。此选项将整数作为其参数。

使源和目标 IPv4/v6 地址伪随机化，但仍保持客户端/服务器关系。由于随机化是基于种子的确定性，您可以重复使用相同的种子值来重新创建流量。

-N 字符串，– pnat =字符串

使用伪 NAT 重写 IPv4/v6 地址。此选项最多可出现 2 次。此选项不得与以下任何选项一起出现：srcipmap。

采用逗号分隔的一系列冒号分隔的 CIDR 网络块对。每个网络块对都按照 IP 地址的顺序进行评估。如果数据包中的 IP 地址与第一个网络块匹配，则使用第二个网络块作为高阶位的掩码对其进行重写。

IPv4 示例：– pnat=192.168.0.0/16:10.77.0.0/16,172.16.0.0/12:10.1.0.0/24 IPv6 示例：– pnat=[2001:db8::/32]:[dead::/ 16],[2001:db8::/32]:[::ffff:0:0/96]

-S 字符串，– srcipmap =字符串

使用伪 NAT 重写源 IPv4/v6 地址。此选项最多可出现 1 次。此选项不得与以下任何选项一起出现：pnat。

就像 –pnat 选项一样工作，但只影响 IPv4/v6 标头中的源 IP 地址。

-D 字符串，– dstipmap =字符串

使用伪 NAT 重写目标 IPv4/v6 地址。此选项最多可出现 1 次。此选项不得与以下任何选项一起出现：pnat。

就像 –pnat 选项一样工作，但只影响 IPv4/v6 标头中的目标 IP 地址。

-e 字符串, –endpoints =字符串

将 IP 地址重写为两个端点之间。此选项最多可出现 1 次。此选项必须与以下选项一起出现：cachefile。

采用一对冒号分隔的 IPv4/v6 地址，用于重写所有流量，使其看起来在两个 IP 地址之间。

IPv4 示例：– endpoints=172.16.0.1:172.16.0.2 IPv6 示例：– endpoints=[2001:db8::dead:beef]:[::ffff:0:0:ac:f:0:2]

–tcp-sequence =数字

更改 TCP 序列（和 ACK）编号 /w 给定种子。此选项将整数作为其参数。number的值被限制为：

大于或等于 1

此选项的默认编号为： 0

更改所有 TCP 序列号和相关的序列确认号。它们将根据提供的种子随机移动。

-b , –skipbroadcast

跳过重写广播/多播 IPv4/v6 地址。

默认情况下，–seed、–pnat 和–endpoints 将重写广播和多播 IPv4/v6 和 MAC 地址。设置此标志将防止广播/多播 IPv4/v6 和 MAC 地址被重写。

csapp第八章-CPU的结构和功能

Mon, 29 Mar 2021 00:00:00 +0000

第八章 CPU的结构和功能

8.1 CPU结构

8.1.1 CPU功能

取指令分析指令执行指令指令控制、操作控制、时间控制、数据加工和处理中断功能

8.1.2 CPU结构框图

ALU（算逻部件）、寄存器、中断系统、CU（控制部件）
系统总线有控制总线、数据总线、地址总线*
- –使用系统总线的CPU
细化
- 算逻部件ALU里面有状态标志、移位、取反、算术和布尔逻辑
- ……

8.1.3 CPU的寄存器

第四章的存储器分层结构图寄存器缓存主存磁盘磁带

用户可见寄存器

通用寄存器
- 基址寻址所需的基址寄存器、变址寻址所需的变址寄存器、堆栈寻址所需的栈指针
数据寄存器
地址寄存器
条件代码寄存器

控制和状态寄存器

大部分之类寄存器对用户是透明的
- MAR
- MDR
- PC程序计数器，存放现行指令的地址，通常有计数功能，遇到转移类指令的时候PC值可被修改
- IR指令寄存器，存放当前欲执行的指令
- PSW：程序状态字寄存器，存放条件码和其他状态信息
- 在具有中断系统的机器中还有中断标记寄存器

8.2 指令周期

取指阶段+执行阶段=指令周期
- 取指阶段完成取指令和分析指令的操作，叫取指周期
- 无条件转移指令JMP X，该阶段不需访问主存，操作简单，完全可以在取指阶段的后期将转移地址X送到PC
  - JMP X指令的指令周期就是-取指周期
- 加法指令ADD X，这种治疗在取指和执行阶段各访问一次存储器
- 乘法指令，其执行阶段完成的操作比加法指令多得多，故执行周期超过了加法指令
间接寻址
- 需要先访存一次，取出有效地址，然后再访存，取出操作数
标志触发器FE、IND、EX、INT

取指周期数据流

取指周期的任务是根据PC中内容从主存中取出指令代码存放在IR中

描述	备注
(PC)-> MAR
1 -> R	CU发出控制信号，读
M(MAR) -> MDR	MAR所指地址中内容送入MDR
(MDR) -> IR	MDR中内容（指令）送入IR
(PC) + 1 -> PC	CU控制信号，计数器加一

间址周期数据流

间址周期的任务是取操作数有效地址

描述	备注
Ad(IR) -> MAR或Ad(MDR) -> MAR	取指周期把指令从MDR传到IR，进入间址周期时MDR里面还没变，可以用
1 -> R	CU发出控制信号，启动主存读
M(MAR) -> MDR，把MAR所指主存中内容经数据总线进入MDR	取到地址可以放在IR中，也可以直接放在MDR中

执行周期数据流

执行周期的任务是根据IR中指令字的操作码和操作数通过ALU操作产生结果

中断周期

中断周期的任务是处理中断请求

堆栈结果保存断点，SP表示栈顶地址，进栈先修改指针，后存入数据

描述	备注
(SP)-1 -> SP, (SP) -> MAR即 a -> MAR	CU控制SP-1，修改后地址送入MAR，即将断点存取某个存储单元
1 -> CU	CU发出控制信号，写
(PC) -> MDR	将断点PC内容送入MDR
CU控制将中断服务程序的入口地址送入PC，即向量地址 -> PC

标志触发器

FE（取址）、IND（间址）、EX（执行）、INT（中断） INT（中断）的进栈sp-1，堆栈向低地址增加

8.3 指令流水

FI、DI、CO、FO、EI、WO

并行性

作业级或程序级、任务级或进程级、指令之间级和指令内部级前两级是粗粒度，又叫过程级，后两级是细粒度，又叫粗粒度并行是在多个处理机上分别运行多个进程，由多台处理机合作完成一个程序细粒度是在处理机的操作机和指令级的并行性

二级流水和四级流水哪个更能提高处理机速度？

什么情况下流水线受阻？

8.3.2 流水线性能影响因素

访存冲突

两个独立的存储器存操作数和指令指令预取技术

数据相关

几条相近的指令间共同用一个存储单元或寄存器时发生的可以用旁路技术解决数据相关又分读后写相关写后读相关写或写相关

8.3.3 流水线中的多发技术

超标量技术并行将两条或两条以上指令编译并执行超流水线技术流水线以3倍于原来时钟频率的速度运行超长指令字技术

8.3.4 流水线结构

指令流水线结构运算流水线

8.4 中断系统

人为中断转管指令

程序性事故

硬件故障

I/O设备

外部事件

8.4.2 中断请求标记和中断判优逻辑

中断请求触发器INTR …

CPU内有PC、IR、MAR、MDR、AC、CU

取指周期全部操作

PC->MAR 现行指令地址->MAR 1->R 命令存储器读 M(MAR)->MDR 现行指令从存储器中读到MDR MDR->IR 现行指令->IR OP(IR)->CU 指令操作码->CU译码 (PC)+1->PC

SUB X

Ad(IR)->MAR 指令的地址码->MAR 1->R 命令存储器读 M(MAR)->MDR 有效地址从存储器中读到MDR (ACC)-(MDR)->ACC

JMP

Ad(IR)->PC ??

取指周期

PC → MAR 现行指令地址→MAR 1 → R 命令存储器读 M（MAR）→ MDR 现行指令从存储器中读至MDR MDR → IR 现行指令→IR OP（IR）→ CU 指令的操作码→CU译码（PC）+1 → PC 形成下一条指令的地址

间址周期

Ad（IR）→ MAR 指令的地址码字段→MAR 1 → R 命令存储器读 M（MAR）→ MDR 有效地址从存储器中读至MDR MDR → Ad(IR)

执行周期

取数指令 LDA X Ad（IR）→ MAR 指令的地址码字段 → MAR 1 → R 命令存储器读 M（MAR）→ MDR 有效地址从存储器中读至MDR MDR → （ACC）操作数 → ACC

存数指令 STA X Ad（IR）→ MAR 指令的地址码字段 → MAR 1 → 320124199901073226 命令存储器写 ACC → MDR 欲写入数据 → MDR MDR → M（MAR）数据写入存储器中

加法指令 ADD X Ad（IR）→ MAR 指令的地址码字段 → MAR 1 → R 命令存储器读 M（MAR）→ MDR 有效地址从存储器中读至MDR （ACC）+（MDR）→ ACC 两数相加结果送ACC

转移指令

无条件转移指令 JMP

Ad（IR）→ PC 转移（目标）地址 Y → PC

csapp第九章-控制单元的功能

Mon, 29 Mar 2021 00:00:00 +0000

第九章控制单元的功能

执行周期

非访存指令
- 清除累加器指令CLA
- 累加器取反指令COM
- 算术右移一位指令SHR
  - L(ACC)->R(ACC), ACC0->ACC0
- 循环左移一位指令
  - R(ACC)->L(ACC)
- 停机指令STP
  - 0->G 停机，G=1是机器运行

访存指令
- ADD X 加法
- STA X 存数指令
- LDA X 取数指令

p377 Attention!

转移类指令
- JMP X
  - 无条件转移指令
  - 执行阶段完成将指令的地址码部分X送到PC的操作
  - Ad(IR)->PC
- BAN X
  - 条件转移（负则转）指令
  - 根据上一条指令结果决定下一条指令的地址，若负（累加器最高位为1，A0=1）则指令的地址码送到PC
  - 取指阶段完成了(PC)+1->PC，A0=0时，就按取指阶段形成的PC执行
  - A0*Ad(IR) + A0取反*(PC) -> PC

中断周期

中断隐指令自动完成保护断点、寻找中断服务入口地址以及硬件关中断的操作 step6 1、向特定地址0送到存储器地址寄存器，0->MAR 2、向主存发写命令，1->W 3、将PC内容（程序断点）送到MDR，PC->MDR 4、将MDR内容（程序断点）通过数据总线写入MAR所指示的主存单元（0地址单元）中，MDR->M(MAR) 反过来是取指数据流：M(MAR) -> MDR，把MAR所指主存中内容经数据总线进入MDR 5、向量地址->PC，为下一条指令周期作准备 6、关中断，将允许中断触发器清0，0->EINT 注：如果程序断点存入堆栈，只需第一步改成SP->MAR

9.2 控制信号

1、不采用CPU内部总线的方式

2、采用CPU内部总线的方式

ADD @X为例

取指周期

操作	备注
PC->MAR	PC经过内部总线送到MAR
1->R	通过控制总线向主存发出读命令
M(MAR)->MDR	存储器通过数据总线把MAR所指示的内容送到MDR
MDR->IR	指令送到IR，其操作码字段开始控制CU
OP(IR)->CU	指令的操作码送到CU译码
PC+1->PC	PC加一

间址周期

MDR->MAR 指令的形式地址经过内部总线送到MAR 1->R 通过控制总线向主存发出读命令 M(MAR)->MDR 存储器通过数据总线将MAR所指示的内容（操作数）送到MDR MDR->Ad(IR) 将MDR中有效地址送到IR的地址码字段

操作	备注
Ad(IR)->MAR	将IR中地址码送到MAR
1->R	让存储器读
M(MAR)->MDR	将有效地址读出到MDR

执行周期

MDRo->MARi MDR o和MAR i有效，将有效地址经内部总线送至MAR 1->R 通过控制总线向主存发出读命令 M(MAR)->MDR 存储器通过数据总线把MAR所指示的内容（操作数）送到MDR MDR->Y MDR o和Y i有效，将操作数送到Y (AC)+(Y)->Z AC o和ALU i有效，同时CU向ALU发ADD加控制信号，使AC内容与Y内容相加，送到寄存器Z Z->AC Z o和AC i有效，把运算结果存到AC

9.2.3 多级时序系统

机器周期

访存时间作为基准时间，即机器周期在存储字长等于指令字长的前提下，取指周期也可以看做机器周期

时钟周期（节拍、状态）

多级时序系统

9.2.4 控制方式

同步控制

采用完全统一的机器周期和节拍对微操作序列较短的指令，会造成时间上的浪费采用不同节拍的机器周期每个机器周期内的节拍数（时钟周期）可以不等可以解决微操作执行时间不统一的问题，复杂的操作可以延长机器周期或者增加节拍采用中央控制和局部控制相结合的方法大部分指令在统一的、较短的机器周期内完成，中央控制少数操作复杂的，局部控制（乘除法和浮点运算）中央控制节拍T0T1T2T3T0T1T2，局部控制节拍T* T*宽度和T0123一样局部控制作为中央控制的延续，穿插 T*的个数不能事先确定

异步控制

时序由专门的应答线路控制，结构比同步复杂

联合控制

同步和异步结合大部分相同指令用同步，时间难以确定的微操作如IO，则异步

人工控制

reset 连续或单条执行转换开关符合停机开关

控制器的功能与工作原理

异常和中断机制

CPU内部-异常，CPU外部-中断

多处理器

SISD、SIMD、MISD、MIMD

SISD
- 传统的串行体系，仅包含一个处理器和一个存储器
SIMD
- 一个指令流同时对多个数据流进行处理，数据级并行技术，包含一个指令控制部件、多个处理单元。
- 处理for循环最有效，case和switch时效率最低，因为每个执行单元必须根据不同的数据执行不同的操作
MISD
- 同时执行多条指令，处理同一个数据，实际不存在
MIMD
- 同时执行多条指令，分别处理多个不同的数据
  - 多计算机系统
    - 每个计算机结点有独立的私有存储器、主存空间，不能通过取址指令访问不同结点的私有存储器，需要通过消息传递。消息传递MIMD
  - 多处理器系统
    - 共享存储多处理器SMP，共享的单一地址空间，通过存取指令来访问系统中的所有存储器，共享存储MIMD
向量处理器是SIMD的变体，实现了直接操作一维数组（向量）指令集的CPU，而SIMD只能处理单一数据集
SIMD和MIMD，SIMD是数据级并行模式，MIMD的并行程度更高，线程级并行或线程级以上并行计算模式

###硬件多线程每个线程有通用寄存器组，程序计数器，省略与存储器数据交换环节

细粒度多线程
- 多线程之间轮流交叉执行指令，乱序并行
粗粒度多线程
仅在一个线程阻塞时才切换线程，如cache缺失
- 阻塞时必须清除被阻塞的流水线，新指令开始前需要重载流水线
同时多线程SMT
- 实现指令级并行的同时实现线程级并行
- 同一个时钟周期中，发射多个不同线程中的多条指令执行
- intel中的超线程就是SMT，一个单处理器或单核中设置了两套线程状态部件…

总线

系统总线的结构

单总线结构
- CPU、主存、I/O设备都在一组总线上，也可细分为地址总线、数据总线和控制总线
- 优：结构简单、成本低、易于接入
- 缺：带宽低、负载重、争用、不支持并发
双总线结构
- 一条是主存总线（CPU、主存和通道之间），另一条是I/O总线
- 优：低速I/O分离，实现存储器总线和I/O总线分离
- 缺：需要增加通道等硬件设备
三总线结构
- 分别为主存总线、I/O总线和直接内存访问（DMA）总线
  - 主存总线用于CPU和内存
  - I/O总线用于CPU和外设
  - DMA总线用于在内存和高速外设之间
- 优：提高了I/O设备性能，提高系统吞吐量
- 缺：系统工作效率较低

常见的总线标准

总线的性能指标

csapp第六章-计算机运算方式

Mon, 29 Mar 2021 00:00:00 +0000

第六章计算机运算方式

6.1 无符号数和有符号数

无符号数

8位，0-255
16位，0-65536，有符号数16位表示范围-32768~+32767

有符号数

分整数和小数
[+0.0000]原=0.0000
[-0.0000]原=1.0000
所以[+0]原 不等于 [-0]原

补码表示法

+9是-3以12为模的补数
-3 +9(mod 12)
-4 +8(mod 12)
-5 +7
这样就可以把减法运算用加法实现
结论
负数加上模，得到负数的补数，如-5+12=+7
一个整数和一个负数如果互为补数，他们绝对值的和是模，5+7=12
规定寄存器位数是4，模就是16，大于16进位的部分就会被丢掉
1011变成0
1011-1011 = 0000
1011+0101 = 10000 最高位被丢掉，0000
所以-1011操作可以替换成+0101，0101是-1011的补数
[-1011]原 = 11011
[-1011]补 = 10101
[+0101]补 = [-0101]补 = 0101 如何表示？
[+0101]补 = 0,0101
[-0101]补 = 1,0101
小数补码
x=-1 [-1]补 = 2+x = 10.0000-1.0000 = 1.0000
-1不属于小数范围，但[-1]补却存在，由于补码的0只有一种表示形式，故它比原码能多表示一个-1
已知补码可以求真值
[x]补 = x+2 -> x = [x]补-2
[x]补 = 2^(n+1) + x -> x = [x]补-2^(n+1)
已知[x]补= 0.0001，正数，所以X真值=+0.0001
已知[x]补= 1.0001，负数，所以真值=-0.1111
符号位保持不变，每位取反，末尾加一，原码1.1110
已知[x]补= 1.1110

反码表示法

真值为正时，原码、补码和反码表示形式相同，符号位0，数值部分和真值相同

真值为负时，符号位都1，数值部分按位取反

x=+1101 [x]反=0,1101 x=-1101 [x]反=1,0010 x=+0.0110 [x]反=0.0110 x=-0.0110 [x]反=1.1001 x=0时 [+0.0000]反 = 0.0000 [-0.0000]反 = 1.1111

*设机器数字长8位，含1符号位，对于整数，当其分别代表无符号数、原码、补码和反码时，对应的真值范围？

*由[y]补求[-y]补？

连同符号位在内，每位取反，末尾加1 ------结论*

移码表示法

难以从补码的形式上直接判断其真值的大小

[x]移 = 2^n + x

x=10100

[x]移=2^5+10100=1,10100

x=-10100

[x]移=2^5-10100=0,01100

x=0

[+0]移=2^5+0=1,00000
[-0]移=2^5-0=1,00000
移码中0的表示唯一

特征最小真值得译码全为0 同一真值得移码和补码只差一个符号位

6.2 数的定点表示和浮点表示

6.2.1 定点表示

纯小数纯整数定点机

6.2.2 浮点表示

浮点数的尾数采用纯小数形式，尾数最高位为1的浮点数成为规格化数，浮点数表示成规格化形式后，其精度最高

浮点数的表示范围
“上溢”“下溢”
短实数32位，阶码8，尾数24
长实数64位，阶码11，尾数53
临时实数80位，阶码15，尾数65
浮点数的规格化

* 阶符，阶码的数值部分(m位)；数符，尾数的数值部分(n位)

举例

x=+(13/128) ？？

x=-54

二进制表示 x=-110110
定点数表示 x=-0000110110
浮点数规格化表示 x=-(0.1101100000)x2^110
定点机中
[x]原 = 1,0000110110
[x]补 = 1,1111001010
[x]反 = 1,1111001001
浮点机中
[x]原 = 0,0110;1.1101100000
[x]补 = 0,0110;1.0010100000
[x]反 = 0,0110;1.0010011111

n=10,m=4,阶符数符各取1位，表示范围 (了解)

最大正数 0,1111;0.1111111111
最小正数 1,0001;0.0000000001
最大负数 1,0001;1.1111111111
最小负数 0,1111;1.0000000001

浮点数字长16位，阶码5位，含1阶符，尾数11位，含1数符。

写出x=-(53/512)对应的浮点规格化数的原码、补码、反码和阶码用移码，尾数用补码的形式。？

注意，只要一个浮点数尾数是0，“机器零”

6.2.5 IEEE754标准

 偏置值
数符 阶符 尾数数值 总尾数 十六进制 十进制

短浮点数（单精度，float） 1 8 23 32 7FH 127 长浮点数（双精度，double） 1 11 52 64 3FFH 1023 临时浮点数 1 15 64 80 3FFFH 16383

IEEE754标准尾数采用隐藏位策略的原码表示，阶码用移码表示的浮点数

规格化的二进制浮点数，数值位最高位总是1，可以隐藏起来，多表示一位有效位，短浮点数和长浮点数都隐含，临时浮点数又称扩展精度浮点数，无隐含位。

阶码是用移码表示的，所以阶码值3

短浮点数中，移码表示的阶码是127+3=130（16进制表示是82）
长浮点数中，移码表示的阶码是1023+3=1026（16进制表示是402）

IEEE754标准中，规格化的短浮点数真值是(-1)^s * 1.M * 2^(E-127) 规格化的长浮点数真值是(-1)^s * 1.M * 2^(E-1023)

6.3 定点运算

6.3.1 算术移位

规则
负数原码，移位时符号位不变，空位添0
负数反码，除符合位外与负数原码正好相反，所以移位后代码与原码相反，全添1
负数补码，左移则低位的空位添0，右移则高位的空位添1
举例
机器数字长8位，含1符号位，A=+-26，三种机器数左右移一位和两位后的表达形式及对应的真值
A=+26=(+11010)
A原补反 = 0,0011010
左移一位 0,0110100
左移两位 0,1101000
右移一位 0,0001101
右移两位 0,0000110
A=-26=(-11010)
原 1,0011010
左移一位 1,0110100
左移两位 1,1101000
右移一位 1,0001101
右移两位 1,0000110
补 1,1100110
左移一位 1,1001100 左移低位添0
左移两位 1,0011000
右移一位 1,1110011
右移两位 1,1111001 右移高位添1
反 1,1100101
左移一位 1,1001011
左移两位 1,0010111
右移一位 1,1110010
右移两位 1,1111001

算术移位和逻辑移位的区别

有符号数是算术，无符号数是逻辑

逻辑移位的规则

左移低位添0，右移高位添0
01010011 算术左移，符号位不变，0,0100110
为了防止最高位的1丢失，就把符号位移至Cy，算术移位后就是0,10100110

6.3.2 加法与减法运算

用补码作减法运算补码表示的两个数在进行加法运算时，符号位和数位同等处理举例已知A=0.1011，B=-0.0101，求[A+B]补 A补=2+x=1.1111+0.1011=？ A补=0.1011 B补=1.1010+0.0001=1.1011 A补+B补 = 0.1011+1.1011 = 10.0110，最高位1丢掉，0.0110 模2^(4+1)，最高位1丢掉已知A=-1001，B=-0101，求[A+B]补 A补=1,0111 B补=1,1011 A补+B补 = 1,0111+1,1011 = 11,0010，最高位1丢掉，1,0010 设机器数字长8位，含1符号位，A=+15，B=+24，求[A-B]补并还原成真值 A=0,0001111 B=0,0011000 -B=0,1100111 A补=0,0001111 B补=0,0011000 [-B]补=0,1100111 A补=0,0001111 [A-B]补 = 0,1100111 + 0,0001111 = 0,1100110

csapp第七章-指令系统

Mon, 29 Mar 2021 00:00:00 +0000

第七章指令系统

7.1.1 指令

操作码

扩展操作码指令字长16位 15位三地址、15位二地址、15位一地址、16位零地址 61条尽量安排指令使用频度低的占用较长的操作码，可缩短经常使用的指令的译码时间

地址码

四地址指令

A1 第一操作数地址 A2 第二操作数地址 A3 结果地址 A4 下一条指令的地址 (A1)OP(A2)->A3 如果指令字长32位，操作码8位，4个地址字段各占6位，（8+6+6+6+6=32），指令的直接寻址范围是2^6=64 如果地址字段均只是主存地址，完成一次四地址指令，访存4次。取指令x1，取两个操作数x2，存结果x1

三地址指令

去掉A4，后续指令地址可以隐含在程序计数器PC中如果字长32位，OP8位，三地址各占8位，指令的直接寻址范围2^8=256（比四地址的直接寻址范围大）访存4次

二地址指令

中间结果存在CPU寄存器中如ACC，去掉A3 (A1)OP(A2)->A1或(A1)OP(A2)->A2 一条指令3次访存，指令的直接寻址范围是2^12=4K

二地址码根据操作数的物理位置，分为： SS（存储器 - 存储器类型） RS（寄存器 - 存储器类型） RR（寄存器 - 寄存器类型）存取速度自上往下越来越快。

一地址访存

(ACC)OP(A1)->ACC ACC即存放操作数，也存放中间结果，一条指令2次访存，指令的直接寻址范围是2^24 = 16M

不设地址字段零地址指令

PUSH、POP操作，操作数地址隐含在堆栈指针SP中

7.1.2 指令字长

Intel8086指令字长可以8、16、24、32、40、48六种

7.2 操作数类型和操作类型

操作类型

转移
- 无条件转移 JMP X
- 条件转移零标志位Z、负标志位N、溢出标志位V、进位标志位C、奇偶标志位P BRO X 表示结果（有符号数）溢出 V=1，则跳转到X BRC Y 表示结果最高位有进位 C=1，则跳转到Y SKP 跳过 205 SKP DZ 206 207 DZ表示若设备的完成触发器D为零，则执行完205后跳到207
- 调用与返回包括过程调用、系统调用和子程序调用 CALL、RETURN notes 允许子程序嵌套每个CALL对应一个RETURN CPU记住返回地址寄存器内子程序的入口地址内栈顶内（RETURN后从栈顶取出地址）
- Trap和陷阱指令 Trap指令一般不提供给用户直接使用，作为隐指令，CPU自动产生并执行也有供用户使用的Trap指令或访管指令，Intel8086的软中断INT TYPE（TYPE是8位常数，表示中断类型）

7.3 寻址方式

指令寻址

顺序寻址
- 程序计数器PC+1
跳跃寻址
- 7.3.2

数据寻址

指令的地址码，不代表操作数的真实地址，称为形式地址，记A，寻址特征为…
操作数的真实地址为有效地址，记EA
分类（10种）
- 立即寻址
  - 操作数设在指令字内，A即操作数本身，称立即数
  - 访存一次：取指令1次访存+执行指令0次访存
  - 数据补码形式存放
  - 取出指令就可获得操作数，减少访存次数，但A的位数限制了立即数
  - 寻址特征位：#
    - 例：mov R0，#10H
    - 把二进制数10直接取出到R0中
- 直接寻址
  - 形式地址A就是操作数的真实地址EA，EA=A
  - 只一次访存，但A位数限制，且必须修改A的值，才能修改操作数的地址
  - 寻址特征位：无
    - 例：mov R0，10H
    - 把内存编号为 10 里的内容取出到R0中
- 隐含寻址
  - 操作数地址隐含在操作码或某个寄存器中
  - 少了一个地址，有利于缩短指令字长
  - Intel8086的乘法指令，被乘数存在AX（16位）或AL（8位）中
  - 字符串传送指令MOVS，源操作数存在SI寄存器中，目的操作数存在DI寄存器中
- 间接寻址
  - A指出操作数有效地址所在的存储单元，EA=(A)
  - 一次寻址和两次寻址
  - 优点
    - 扩大了寻址范围
    - 存储字长可与指令字长相等，若均为16位，A为8位，直接寻址范围就是2^8，一次间址的寻址范围2^16，多次寻址时，需要存储字的首位来标志间接寻址是否结束，1继续0结束，0时该存储字即为EA，寻址范围2^15
    - 方便完成子程序的返回
- 寄存器寻址
  - EA=Ri
  - 访存1次：取指令1次+执行指令0次（执行阶段不访问主存，只访问寄存器）
- 寄存器间接寻址
  - 寄存器Ri中给的不是一个操作数，是操作数所在主存单元的地址，EA=(Ri)
  - 两次访存：取指令1次+执行指令1次
- 基址寻址（-偏移寻址）
  - 以程序的起始存放地址作为“起点”，EA=(BR)+A
  - os中的重定位寄存器就是基址寄存器
  - 面向操作系统
- 变址寻址（-偏移寻址）
  - 程序自己决定从哪里作为起点，EA=(IX)+A
  - IX为变址寄存器，也可用通用寄存器作为变址寄存器
  - 面向用户
- 相对寻址（-偏移寻址）
  - 以程序计数器PC所指地址作为“起点”，EA=(PC)+A
- 堆栈寻址
  - 操作数存放在堆栈中，隐含使用堆栈指针（SP）作为操作数地址。

7.5 RISC

RISC精简指令系统计算机
- 选取使用频率较高的简单指令，并能组合成复杂的指令
- 指令长度固定，指令格式种类少，寻址方式种类少
- 只有load/store（存/取数操作）。其余指令的操作都在寄存器之间完成。
- CPU有多个通用寄存器（比CISC多很多）
- 采用流水线技术，一般在一个时钟周期内完成。
- 功耗小，成本低
- 代表：ARM指令构架，MIP指令构架
CISC复杂指令系统计算机
- 指令系统复杂庞大
- 指令长度不固定，指令格式多，寻址方式多
- 控制器大多采用微程序控制
- 代表：Intel公司的x86系列CPU是典型的CISC体系结构

7.5.2 RISC的主要特征

执行程序所需时间P=ICT

I是机器指令数，C是执行每条机器指令的平均机器周期，T是每个机器周期的执行时间 RISC指令简单，所以I比CISC多但RISC大多指令一个机器周期就能完成，所以C比CISC小 RISC简单，所以完成一个操作所经过的数据通路较短，T值大大下降

RISC II指令

39条指令寄存器-寄存器操作 12条取/存数指令 16条控制转移指令 6条其他 5条约定R0寄存器内容恒为0，加法指令可以替代寄存器间的传送指令 (Rs)+(R0) -> Rd 替代了 Rs -> Rd 加法指令替代清楚寄存器指令 (R0)+(R0) -> Rd 替代了 0 -> Rd 减法指令可替代取负数指令 (R0)-(Rs) -> Rd 替代了Rd寄存器内容取负

(Rs)+1 -> Rd 替代寄存器加一减一 (Rs)异或(1) -> Rd 替代 Rs求反码存到Rd 异或指令可替代求反码指令 1还是-1？？？

指令格式

RISC II指令格式有两种，短立即数格式和长立即数格式指令字长固定为32位，指令中每个字段都有固定位置 31-25位操作码OP 18-14位 rs1，存一个操作数 13位为0，另一个操作数在寄存器中（0-4位） 13位为1，另一个操作数是13位的立即数imm13（0-12位）运算结果存在DEST寄存器中（23-19位） DEST字段在条件转移指令中，22-19位作为转移条件，第23位无用第24位，S表示是否根据运算结果置状态位，S=1表示置状态位 RISC II机有4个状态位，零标志位Z，负标志位N，溢出标志位V，进位标志位C

长立即数指令格式主要用于相对转移指令

RISC指令系统的扩充

浮点指令特权指令读后置数指令读-修改-写，用于寄存器与存储单元交换数据等一些简单的专用指令

7.5.3 RISC和CISC的比较

RISC的优点

充分利用VLSI芯片的面积 RISC采用组合逻辑控制，其硬布线扩及只占CPU芯片面积的10%，用于增加大量的通用寄存器提高计算机运算速度 RISC的指令数、寻址方式和指令格式种类较少，指令编码有规律 RISC的通用寄存器多，减少了访存次数 RISC采用组合逻辑控制，比微程序控制的CISC延迟小，缩短了CPU的周期 RISC精简指令系统，适合于流水线工作，大多数指令在一个时钟周期内完成便于设计、降低成本、提高可靠性有效支持高级语言程序

csapp第三章-系统总线

Mon, 29 Mar 2021 00:00:00 +0000

第三章系统总线

分散连接

以运算器为中心，严重影响CPU的工作效率–>以存储器为中心，IO和主存之间交换信息可以不通过运算器，采用中断、DMA技术提高CPU效率

总线连接

某一时刻，只允许有一个部件向总线发送信息，而多个部件可以同时从总线上接收相同的信息

面向CPU的双总线结构

连接CPU和主存的叫存储总线（M总线）建立CPU和各IO之间交换信息的通道叫输入输出总线（I/O总线）这种结构IO设备与主存交换信息时还要占用CPU，影响效率

单总线结构

只有一组总线，出现争夺现象

以存储器为中心的双总线结构

在单总线基础上，单独开辟一条CPU与主存之间的通路，叫存储总线，速度高，只供主存和CPU之间传输信息

现在计算机大多采用该结构

1、片内总线

2、系统总线

按系统传输信息的不同，分为三类

数据总线

双向传输，数据总线的条数成为数据总线宽度，用以衡量系统性能

e.g如果数据总线宽度8位，指令字长16位，取指时，必须两次访问主存

地址总线

指出数据总线上源或目的数据的地址

单向传输

地址线的位数与存储单元的个数有关

e.g地址总线20根，对应的存储单元个数是2^20

控制总线

控制各部件在不同时刻占有总线使用权

对任一控制而言，传输是单向的，但对于控制总线总体来说，可认为是双向的

3、通信总线

串行通信总线

并行通信总线

机械特性、电气特性、功能特性、时间特性总线性能指标

总线结构

单总线结构

多总线结构

双总线结构的特点是将速度较低的IO设备从单总线上分离出来，形成主存总线与IO总线分开的结构
其中通道是一个具有特殊功能的处理器，CPU将一部分功能下放给通道，用于管理IO设备

三总线结构

主存总线用于CPU与主存之间的传输
IO总线供CPU与各类IO之间传递信息
DMA总线用于高速外设（磁盘、磁带等）与主存之间交换信息
注：任一时刻只能使用一种总线，主存总线和DMA总线不能同时对主存进行存取，IO总线只有在CPU执行IO指令时才用到

三总线的又一形式

CPU和Cache之间有一条局部总线，它将CPU与Cache或与更多的局部设备连接
Cache的控制机构不仅将Cache连到局部总线上，而且还直接连到系统总线上，这样Cache就可通过系统总线与主存传输信息

总线控制

总线判优控制

集中控制
分布控制

常见的集中控制有三种优先权仲裁方式

链式查询

 BS总线忙、BR总线请求、BG总线同意
BG是串行传递的，如果BG到达的接口有BR，BG就不往下传了，意味着该接口获得了总线使用权，并建立BS信号表示占用
特点：
查询链中，离总线控制部件最近的设备具有最高的优先级
只需要两根线，容易扩充设备、但对故障敏感

计数器定时查询

 与链式查询相比，多了一组设备地址线，少了一根总线同意线BG
控制部件接收到BR后，在总线未被占用的情况下（BS=0），计数器开始计数，向各设备发出一组地址信号，当某个有总线请求的设备地址与计数值一致时，获得总线使用权，终止计数查询
特点：
计数可以从0开始，此时设备的优先次序是固定的
计数也可以从终点开始，循环方法，所有设备优先级相等
计数初始值可以修改设置，故优先级次序可以改变
对电路故障不敏感，增加了主控制线，控制复杂
大致用log2n根线

独立请求方式

 每个设备都有一对BR和BG，总线控制部件中有一排队电路，可根据优先次序确定响应哪一个设备
特点：
响应速度快，优先次序控制灵活
控制线数量多，总线控制更复杂
需要2n根线

总线通信控制

总线在完成一次传输周期时，可分为四个阶段:
申请分配阶段
寻址阶段
传数阶段
结束阶段

通信双方如何协调如何配合

同步通信

 通信双方由统一时标控制数据传送，时标通常是CPU总线控制部件发出的，保持同步
一般用于总线长度较短，各部件存取时间比较一致的场合

异步通信

 采用应答模式
可以分为不互锁、半互锁、全互锁
不互锁
通信双方无依赖关系
半互锁
主模块发出请求等待从模块回答后，再撤销请求，而从模块发出应答后，不等待主模块，一段时间后撤销回答信号
全互锁
主模块发出请求，待从模块回答后撤销请求；从模块应答后，待主模块获知后，再撤销应答

半同步通信

 保留了同步通信的基本特点，发出时间严格按照系统时钟的某个前沿开始，接收方都采用系统时钟后沿时刻进行判断识别
又像异步通信那样，允许不通速度的模块和谐工作，为此增设了WAIT响应信号线
一般用于系统工作速度不高，但各设备之间速度差异大的简单系统
分离式通信
讲一个总线周期分解成两个子周期，在第一个子周期中，主模块A获得总线使用权后将信息和该主模块的编号发到系统总线上，发完就放弃总线使用权
B模块从总线上接收到了A发来的命令，读取等一系列操作后准备好A需要的数据，B就申请总线使用权，一旦获准，B就把A的编号、B的地址、A需要的数据发到总线上，供A接收
上述两个周期只有单方向的信息流，每个模块都变成了主模块
特点：
1234

csapp第十章-控制单元的设计

Mon, 29 Mar 2021 00:00:00 +0000

第十章控制单元的设计

10.1 组合逻辑设计

存放在IR的n位操作码经过一个译码电路产生2^n个输出，每对应一种操作码都有一个输出送到CU

控制单元的时钟输入，使CU能按一定节拍T发出控制信号，经过节拍发生器，产生一个与时钟周期等宽的节拍序列

0.1.2 微操作的节拍安排

原则一：注意微操作的先后顺序

原则二：凡是被控制对象不同的微操作，能在一个节拍内执行，就在一个节拍内完成

原则三：有些微操作所占时间不长，应该安排在一个节拍内完成

每个机器周期含3个节拍

取指周期的安排

T0，PC->MAR，1->R T1，M(MAR)->MDR，(PC)+1->PC T2，MDR->IR

间址周期的安排

T0，Ad(IR)->MAR，1->R T1，M(MAR)->MDR T2，MDR->Ad(IR)

执行周期

非访存指令清除累加器指令CLA 累加器取反指令COM 算术右移位移一位指令SHR 循环左移一位指令CSL 停机指令STP 访存指令

csapp第四章-存储器

Mon, 29 Mar 2021 00:00:00 +0000

第四章存储器

主存储器和cache

4.1 概述

存储器分类

存储介质分类
- 半导体存储器(主要)
  - TTL：集成度低，功耗高，速度快
  - MOS：集成度高、功耗低
  - 半导体大部分易失、以下三种非易失
- 磁表面存储器
  - 磁层磁化的方向表示01，有磁头、磁载体
- 磁芯存储器
  - 硬磁材料做成的环状元件，磁心中有驱动线和读出线。一个磁芯两根导线，NS表示01。xy两根线用于寻址。
- 光盘存储器
  - 激光
存取方式分类
- 随机存储器RAM 存取时间与存取单元的物理位置无关又分
- 只读存储器ROM 存取时间与物理地址有关又分
作用分类

4.2 主存储器

4.2.1 主存储器的基本组成

MAR必须经过译码器才能选定指定的存储单元
MDR保存了数据，要通过读写电路和控制电路决定是读还是写，控制方向

主存与CPU的联系，三种类型的信号

数据总线直接连MDR寄存器上，双向
地址总线连在MAR寄存器，单向的，从CPU送到主存
控制总线单向，由CPU送到主存

主存中存储单元的地址分配

24位地址总线，字长32位，按字节寻址16MB，按字寻址4MW；字长16位，按字节寻址16MB，按字寻址8MW
高位字节存放在低地址，低位字节存放在高地址。高位字节的地址作为存储字的地址。–大端
- 12345678 字地址12
低位字节存放在低地址，高位字节存放在高地址。低位字节的地址作为存储字的地址。–小端
- 78563412 字地址78
- x86机器

主存的技术指标

存储容量
- 存储容量=存储单元个数*存储字长
存储速度
- 存取时间Memory Access Time
  - 从存储器给出地址开始，直到得到稳定的输出或输入
- 存储周期Memory Cycle Time
  - 连续两次独立的存储器操作所需最小间隔时间
- 一般存储周期比存储时间长！
与Momory Cycle Time相关指标存储器的带宽
- 若存储器的数据总线宽度为 32 位，存取周期为 200ns ，则存储器的带宽是多少
  - 1MHz=10^6Hz
  - 1/200ns = 5*10^6Hz = 5MHz 主频时钟=1/存取周期
  - 带宽 = 5MHz*32bit = 160Mb/s = 20MB/s 带宽=主频*总线宽度
- 提高存储器带宽：
  - 缩短存取周期Memory Cycle Time
  - 增加存储字长，每个周期访问更多的二进制位
  - 增加存储体

4.2.2 半导体存储器芯片

基本结构

存储矩阵、读写矩阵、译码驱动
地址线单向输入，经过译码驱动
数据线双向
地址线和数据线的位数共同反映存储芯片的容量，计算：地址线10根，数据线4根，芯片容量2^10 * 4 = 4K
控制线：读写控制线和片选线两种
- 片选线
  - 就是芯片选择线，决定访问哪个芯片
  - 低电平有效
  - 两种标识方式:CS、CE 一横标识低电平有效
  - 片选信号
    - 用16K*1的芯片组成满足CPU 64K*8的要求的存储器
    - 需要一组八个芯片，布置四组 = 32 个芯片
- 读写控制线
  - 可以一根，可以两根
  - 两种标识：
    - 一根 WE 低电平写，高电平读
    - 两根 OE 允许读 WE允许写

译码驱动方式

线选法
- 1M*8 20根地址线，有一个译码器译码，地址译码后有1M条线
重合法
- 行地址只能有一条线有效，列地址也是
- 行0列0，经过译码后，只有X0、Y0有效，打开两个开关，信号畅通，可以输出
- 20根地址线，10*10，xy方向各1K条，总计2K条，比线选法少，芯片集成度更高

4.2.3 随机存取存储器RAM

静态RAM（SRAM）（cache用的SRAM）

保存01方式
- 利用双稳态触发器，4个管子，T1-T4组成的电路 T5、T6对存储原件进行读写，开关，受行地址选择控制 T7、T8是该列所有存储元件共有的开关，叫做列开关，受列地址选择控制先用T5T6选择行，然后只有列地址选择线有效，信号才会通过T8输出
- 静态RAM基本电路读操作六管静态RAM 给出行选信号，打开T5T6 给出列选信号，打开T7T8 读有效，MOS导通，存放在A中数据通过T6送出去，T8导通，送到数据总线上
- 静态RAM写操作行选择列选择 ……
单元电路结构 2114RAM结构行地址6个0，列地址4个0，第0行行选择信号有效，第0列列开关打开，交叉点上第一二三四组的第0行都会被选择 WE信号有效，CS信号有效，数据通过IO1-IO4写入第一二三四组的第0列，数据可以写到对应单元

动态RAM（DRAM）

保存01的方式
- 静态RAM双稳态触发器，动态使用电容，饱和是1，没有被充电就是0 两种动态RAM的单元电路三管：T123是控制管，读选择线和写选择线 T4是预充电管单管动态RAM
基本单元电路构成
- 三管 intel1103 刷新放大器三角形电容存储电荷的原理存储信息，电容会漏电，刷新放大器对电容保存的信息进行刷新行地址11111，第31行被选中（行地址00000，第0行被选中）…
- 单管 intel4116 16K*1的存储芯片，地址线只有7根 7位行7位列分别存在行地址缓冲器和列地址缓冲器中数据输入寄存器和数据输出驱动 RAS、CAS、WE产生行列写时钟读放大器的左侧电容有电0无电1，右侧相反，有电1无电0（跷跷板电路）
读出和写入
动态RAM结构
动态RAM如何读出和写入
刷新
- 电容容易漏电，如果不再生电容信息，就会丢失
- 刷新只和行地址有关，每次刷新一行所有的基本单元电路，每次刷新一行的数据
- 三种方法
  - 集中式刷新
    - 存取周期0.5微秒，刷新周期2毫秒，128行128列矩阵
      - 2ms，4000个存取周期，刷新128行，前3872个周期供读出、写入，后128个周期专用于芯片的刷新操作，无法进行信息交换，死区，0.5微秒*128行
      - 死区动态RAM不能用，CPU和IO只能等待，集中刷新的问题
    - 设对128 x 128矩阵的存储芯片进行刷新，若存取周期为0.5us，刷新周期为2ms，采用集中刷新的方式，那么对128行集中刷新，一共需要（）us？死时间率为（）%？
      - 刷新一遍的时间=存储周期*行数=0.5微秒*128=64微秒
      - 死时间率=死时间/刷新周期=64微秒/2ms=64/200=0.32
  - 分散刷新
    - 存取周期1微秒，128行128列的芯片
    - 每个读写操作后面绑定一个刷新操作，对每行存储单元的刷新分布到每个存取周期内完成
    - tm是原来的读写周期0.5微秒，tr是用于某一行的刷新0.5微秒，所以存取周期tc变成原来的两倍（tc=tm+tr）
    - 本来2毫秒刷新128行，现在128微秒就刷新完了128行，而且不存在死时间
    - 过度刷新，不需要这么频繁的刷新，性能下降
  - 异步刷新
    - 2毫秒刷新128行，每经过15.6微秒（刷新周期/总行数）刷新一行，每行刷新的时间仍为0.5微秒，刷新时间仍为2ms，死区缩短成了0.5微秒，每行每隔2ms刷新一次
    - 间隔=刷新周期/总行数=2ms/128=15.6ms
    - 设对128 x 128矩阵的存储芯片进行刷新，若存取周期为0.5us，刷新周期为2ms，采用异步刷新的方式，那么对128行异步刷新，一共需要（）us？死时间率为（）%？
      - 刷新时间仍为2ms；一共4000个存取周期（2ms/0.5us=2000/0.5=4000），死时间率为1/4000

静态RAM和动态RAM的比较

存储原理
- 动态DRAM–电容，静态SRAM–触发器存储01
DRAM集成度高，与SDRAM相比，DRAM所用的mos管少，占硅面积小，因而功耗小，集成度高
DRAM芯片的引脚数少，封装体积小
SRAM价格贵（cache），速度快，不会分行地址和列地址，所以引脚数更多，结构更复杂
DRAM功耗小，只是对电容充放电和刷新，SRAM功耗大
通常DRAM用于做主存，SRAM用于cache，小容量高速度

4.2.4 只读存储器ROM

一般用于保存系统程序和配置信息
PROM、EPROM、EEPROM
- PROM：可编程只读存储器，Programmable Red-Only Memory
- EPROM：可擦写可编程只读存储器，Erasable Programmable Read-Only Memory
- EEPROM：电可擦除可编程只读存储器，Electrically Erasable Programmable Read-Only Memory
- Flash memory：非易失性的内存
半导体ROM，基本器件

4.2.5 存储器和CPU的连接 *

CPU地址线多，寻址空间范围较大，需要多个芯片

存储器容量的扩展

位扩展

增加存储字长 1K*4芯片构成1K*8位的存储器两个1K*4位的芯片，采用相同的片选，同时被选中，每个读写四位，合在一起八位需要两片，地址线10条，数据线8条，片选连在一起 intel2114芯片注意看图

字扩展

增加存储器字的数量 1K*8的芯片构成2K*8 即存储字增加了一倍两个芯片，地址输入均为10条，数据线0-7提供八位数据,注意两个芯片不能同时进行工作，否则数据线上会混乱 2K*8 11条地址线 A10是片选信号，A10=0选第一个，A10=1选第二个芯片

字、位扩展

1K*4的芯片组成4K*8的存储器？芯片数量的计算，32K位/4K位 = 8片连接方式两个1K*4 = 1K*8 需要4组构成 4K*8 A0-A11：12根地址线 8根数据线 A0-A9 –> 1K*8 剩余两根地址线作为片选信号，A10-A11，有4K的地址，分给四组 00 0000000000/11111111111 第一组 01 0000000000/11111111111 第二组 10 0000000000/11111111111 第三组 11 0000000000/11111111111 第四组

存储器与CPU的连接

地址线的连接

地址连接的时候，地址的低位作为地址，高位作为芯片选择信号

数据线的连接

使存储器输出输入的数据满足CPU的要求

片选线的连接

确认CPU访问存储器不是IO 每个内存芯片都有自己的地址范围，必须满足CPU的要求，每一根地址线都要用到

合理选择存储芯片

实例1

CPU有16根地址线，8根数据线，（寻址范围64K，读写8位），MREQ作访存控制信号

RAM：1K*4、4K*8、8K*8 ROM：2K*8、4K*8、8K*8 6000H~~67FFH系统程序区 6800H~~6BFFH用户程序区 0110 0000 0000 0000 0110 0111 1111 1111 2^11=2K * 8 0110 1000 0000 0000 0110 1011 1111 1111 2^10=1K * 8 系统程序区选ROM 一片2K*8 用户程序区用RAM 两片1K*4，片选信号连在一起组成地址线的分配 A0-A10 11根地址线 A0-A9 10根地址线

138译码器的结构和功能 * CBA输入端… *

实例2

条件同上要求最小的4K是系统程序区，相邻的8K是用户程序区 0000 0000 0000 0000 0000 1111 1111 1111 0001 1111 1111 1111 8K*8 ……

4.2.6 存储器的校验

000-111 –> 001

0101 n-4 k-3

124 3567 0101

1 2 4

4.2.7 提高访存速度

单体多字系统

每次可以读取多个字
单体四字4*W，按地址可在一个存取周期内读出4*W位的指令或数据，将主存带宽提高到4倍
前提是数据和指令在主存内是连续存放的，遇到转移指令则效果不明显

多体并行系统

多体模块，每个模块相同容量和存取速度，各模块有独立的地址寄存器、地址译码器、驱动电路和读写电路
高位交叉编址
- 高位地址表示体号
- 数据和指令连续时，用一个存储体，效率低
低位交叉编址
- 模M编址（M等于模块数，M取2的方幂较为简单，为了减少存储器冲突，采用质数个模块）
- 模4交叉编址
- 低位地址表示体号，高位位体内地址
地址表最低两位地址 M0 0、4、8、12、4i+0 00 M1 1、5、9、13、4i+1 01 M2 2、6、10、14、4i+2 10 M3 3、7、11、15、4i+3 11
多体模块的存储器采用交叉编址后，可以在不改变每个模块存取周期的前提下，提高存储器的带宽

存储器控制部件（存控）

排队器、控制线路、节拍发生器以及标记触发器排队器易丢失的请求源，优先级最高严重影响CPU工作，次高级优先级写请求>读数，读数请求>读指令写书 > 读数优先级>读指令存控标记触发器Cm 接收排队器的输出信号，一旦响应，置1，以便启动节拍发生器节拍发生器产生固定节拍，与机器主脉冲同步，使控制线路按时序发出信号控制线路将排队器发出的信号和节拍发生器提供的节拍信号配合，向存储器各部件发出控制信号

Cache

主存块号m位，块内地址b位，m+b=n位 B=2^b，反应了块的大小，B为块长

Cache块号c位，块内地址b位，c+b 缓存块设一个标记，表示当前存放的是哪一个主存块

所需数已在缓存中，可直接访问cache，cache命中缓存的块数C远小于主存的块数M CPU读信息时，要将主存地址的高m位（或其中一位），与缓存块的标记进行比较，以判断

影响cache的效率

cache的容量和块长 80386的主存最大容量4GB，与其配套的cache容量为16KB或32KB，命中率可达95%以上块长从增长，起初由于局部性原理，已被访问字的附近，近期也可能被访问，而块长增加，导致缓存中块数的减少，新装入的块覆盖旧块，会导致少量块刚被装入又被覆盖，命中率反而下降一般每块取4-8个可编址单位（字或字节）较好，也可选择一个主存周期所能调出主存的信息长度 CRAY-1主存16个体交叉，每个体单字宽，存放指令的cache块长为16个字 IBM 370/168机主存是4体交叉，每个体宽64位（8个字节），cache块长32个字节

cache的基本结构

cache存储体
地址映像变换机构
- 将CPU送来的主存地址转换为cache地址，由于主存与cache的块大小相同，块内地址是偏移，即低位地址相同，因此地址变换主要是高位地址（块号）
- 主存与cache间的块号转换
  - 命中CPU就可以直接访问cache存储体
  - 不命中，不仅取出该字，将它所在的主存快一并调入cache，供cpu使用
  - 如果cache未满，可以调入，cache满了，需要替换策略
替换机构
- 替换算法
- cache对用户是透明的，用户编程时所用的地址是主存地址，用户不知道这些主存块是否已经在cache中，引入主存块调入cache是机器硬件完成的
cache的读写操作
- cache如何与主存内容保持一致
- 写直达法（通过式写Write-through、通过式存Store-through）
  - 随时保持主存与cache一致，但可能会增加访存次数
- 写回法（Write-back）（又称标志交换式Flang-Swap）
  - cache和主存的数据可能不一致
  - 暂时写入cache，并用标志（dirty bit）将该块加以注明，直到该块从cache替换出，才写入主存。每个cache line只有一个dirty bit，表示是否被修改过
  - 速度快，因主存中的字块未经随时修改，可能失效

cache的改进

增加cache的级数
- 单一缓存（与CPU在一个芯片内，片内缓存，片载缓存）提高外部总线的利用率 intel 80486 片内有8K字节的片内缓存
- 两级缓存主存与片内缓存之间，加一级缓存，片外缓存比主存动态RAM和ROM存取速度更快的静态RAM组成
将统一的cache分开
- 统一缓存指令和数据都存放在一起
- 分开缓存指令cache、数据cache
- 与主存结构一致
- 与机器对指令的控制方式有关采用超前控制或流水线控制方式时，一般分开缓存超前控制（超前取指、指令预取）流水线多条指令同时执行强调指令的预取和指令的并行执行，必须把cache分开，否则会导致取指和执行过程对统一缓存的争用
- 简化的pentium处理器框图 64bit总线接口指令cache8K，只读存储器，直接送到预取指令缓冲区 256bit 数据cache8K，有两个32位端口，与两个可并行的整数ALU相连，也可以合起来与64位浮点单元相连数据cache支持整数ALU和浮点操作 pentium处理器支持外部二级缓存，达256K或512K PowerPC 620处理器 128bit的总线接口两个cache 32K 32K 64bit的三个可执行操作的整数ALU和一个浮点运算部件

4.3.2 Cache-主存地址映像

直接映像
- 主存高m位，低b位
- 主存块号m位，字块内地址b位
- 主存地址m位，包含主存字块标记t和cache字块地址c，m=t+c
- 映射关系式 i=j mod C 或 i=j mod 2^C
  - i是缓存块号，j是主存块号，C是缓存块数
- 缺点
  - 每个主存块只能固定对应某个缓存块
  - 缓存空间浪费
  - 重复访问同一缓存位置的不同主存块，需要不停替换，降低命中率
全相联映像
- 允许主存中每一字块映像到cache的任一位置上
- 命中率高，缩小块冲突率
- 主存字块标记从t位变成t+c位，cache标记的位数增多
- 访问cache时需要和cache的全部标记位进行比较，才能做出判断，比较由按内容寻址的相联存储器来完成
组相联映像
- 把cache分为Q组，每组有R块
- i=j mod Q
  - i是缓存的组号，j是主存的块号
- 主存字块标记一共m=t+c位，主存字块地址s=t+r位，组地址q=c-r位
- 与直接映像相比
  - cache字块地址由c位变成了q位，q=c-r
  - 2^c表示cache的总块数
  - 2^q表示cache的分组个数
  - 2^r表示组内包含的块数
- 假设c=5，q=4，则r=c-q=1
  - cache共有2^c = 32个字块，共分为2^4 = 16个组
  - r=c-q=5-4=1，2^1 = 2 即为每组内含有2个块
  - 主存的某一字块可以摸16映像到cache某组的任一字块中
    - 0、16、32…可以分到第0组2个字块中的任一字块
    - 15、31、47… 第15组
  - 【r=0】主存i块可以分组到cache的j组内，是直接映像关系
  - 【r=c】？主存的第j块可以映像到第i组内中的任一块，是全相联映像关系
段相联映像
- 主存和cache都分成若干段，且使它们每段包含的块数都相等
- 段之间采用全相联，段内块采用直接映像
  - 段数与cache块数相等时，每段只包含一块，全相联映像
  - 段数是1，直接映像
一个四路组相连缓存实例问题
- 32 KB大小4路组相连cache，cache line大小是32 Bytes。请思考以下2个问题：
- 1.多少个组？
- 2.假设地址宽度是48 bits，index、offset以及tag分别占用几个bit？
- 总共4路，因此每路大小是8 KB。cache line size是32 Bytes，因此一共有256组（8 KB / 32 Bytes）。由于cache line size是32 Bytes，所以offset需要5位。一共256组，所以index需要8位，剩下的就是tag部分，占用35位。

4.3.3 替换算法

FIFO 最先调入cache的字块替换出来 LRU（近期最少使用）需要记录cache中各个字块的使用情况 LRU的平均命中率比FIFO高，分组容量加大时更能提高LRU的命中率

4.4 辅助存储器

外存，速度慢、价格低、可脱机保存信息、非易失性

磁表面存储器的主要技术指标

记录密度单位长度内存储的二进制信息量磁盘存储器道密度和位密度道密度：磁盘沿半径方向单位长度的磁道数为道密度道/英寸 Track Per Inch TPI 道/毫米 TPM 道密度Dt是道距P的倒数 DP=1 磁带存储器位密度位密度或线密度 bpi或bpm bits per inch 800bpi、1600bpi、6250bpi 一般位密度指的是最内圈磁道的位密度，即最大位密度存储容量二进制信息总数 C=n*k*s n是盘面数，k是每个盘面的磁道数，s是每条磁道上记录的二进制代码数格式化容量和非格式化容量格式化容量是按某种特定的记录格式所能存储信息的总量，一般占非格式化的60%-70% 平均寻址时间磁盘采用直接存取方式，找道时间ts，等待预读写的磁道区段旋转到磁头下方的等待时间tw，平均时间Ta 硬磁盘<软磁盘磁带存储器顺序存取，磁头不动磁带移动，不需要找磁道，考虑等待时间数据传输率 Dt是单位时间内磁表面存储器向主机传送数据的位数或字节数 Dt = D*V 记录密度D，记录介质的运动速度V 误码率出错位数和读出的总信息位数之比循环冗余码

4.4.2 磁记录原理和记录方式

4.4.6 循环冗余校验码（CRC码）

模2运算，不考虑进位和借位规律模2加和模2减结果相同 ……

csapp第五章-输入输出系统

Mon, 29 Mar 2021 00:00:00 +0000

第五章输入输出系统

发展

早期串行 DMA（Direct Memory Access） IO和主存之间有一条直接数据通路通道通道指令，受CPU的IO指令控制 IBM/360系统一个通道可以连8个设备控制器，一个设备控制器可以连8个设备 IO处理机外围处理机PPU

按照IO设备工作速度的不同，分三种联络方式

立即响应方式异步工作采用应答信号联络异步并行 IO接口向IO设备发送Ready信号后，立即从接口中取出数据 IO设备向IO接口发Strobe信号，并让接口转告CPU，接口中的数据已经被取走串行传送同步工作采用同步时标联络要求IO设备和CPU的工作速度完全同步

IO设备和主机的连接方式

辐射式要求每台IO设备都有一套控制线路和一组信号线，初期总线式一组总线（包括地址线、数据线、控制线等）

5.1.4 IO和主机信息传送的控制方式

五种控制方式

程序查询方式* CPU和IO串行工作程序中断方式* CPU启动IO设备后，对设备是否已准备就绪不过问，继续执行自身程序，需要IO设备准备就绪向CPU发出中断请求直接存储器存取方式DMA* IO设备能直接与主存交换信息而不占用CPU DMA方式中，主存与IO设备之间有一条数据通路，无需中断，就可以交换信息 DMA占用的存取周期–窃取周期或挪用周期，此时CPU还能继续内部操作 IO通道方式 IO处理机方式

外部设备

设备控制器，机、电磁、光部等外部设备

其他外部设备

5.3 IO接口

总线连接方式的IO接口电路

IO总线包括数据线、设备选择线、命令线和状态线

主机侧
- 通过I/O总线与内存、CPU相连。
- 主机侧有数据线、地址线、控制线
  - 地址线用于给出要访问的I/O接口中寄存器地址，与读写控制信号一起送到I/O控制逻辑部件
设备侧
- 通过接口电缆连接外设，设备侧的数据双向传输，状态寄存器外传内，控制寄存器内传外。
I/O控制逻辑
- 对控制寄存器中命令字进行译码，得到控制信号通过外设洁面控制逻辑送到外设
- 同时负责数据缓冲寄存器和外设之间的双向数据传输
- 还要收集外设状态到内部状态寄存器
数据缓冲寄存器
状态/控制寄存器
外设界面控制逻辑
I/O指令是特权指令

接口的功能和组成

选址功能传送命令传送数据接口中通常设有数据缓冲寄存器DBR，暂存反映IO设备工作状态完成触发器D和工作触发器B标志状态 D0 B0，暂停 D1 B0，准备就绪 D0 B1，设备处于准备状态中断技术，接口电路中一般还设有中断请求触发器INTR，为1时，表示该IO设备正向CPU发送中断请求，接口内还有屏蔽触发器MASK，与中断请求触发器配合使用，完成屏蔽功能 8.4节*

IO接口组成框图

1、设备选择电路 2、命令寄存器和命令译码器 3、数据缓冲寄存器DBR 4、设备状态标记需要通过控制逻辑电路协调时序接口一端连接CPU，一端连接外部设备数据线双向，地址线单向状态线把IO接口状态，外部设备的状态，传输给CPU

5.3.3 接口类型

按数据传送方式分类

并行 Intel 8255
串行 Intel 8251

功能选择的灵活性分类

可编程和不可编程

通用性分类（按主机访问I/O设备的控制方式）

程序查询接口
- 较慢的IO
DMA式接口
- 高速IO
中断接口

I/O端口及其编址

若干端口加上对应的控制逻辑电路组成接口

数据端口，cpu能读写
状态端口，cpu只能读
控制端口，cpu只能写

I/O端口的编址方式

统一编址（存储器映射方式）
- 只用统一访存指令即可，不需要I/O指令
- I/O端口占用存储器地址，内存容量变小
独立编址
- I/O地址空间和主存地址空间独立，无法从地址码上区分，需要I/O指令

5.4 程序查询方式

CPU不断查询IO设备状态，直到就绪，传送一次数据，修改地址和计数器

200 程序查询方式流程测试指令检查设备时候准备就绪传送指令转移指令接口电路

5.5 程序中断方式

外设准备就绪，就主动向CPU发出中断请求，请求CPU为自己服务

中断请求
- 中断请求标记触发器，（1表示中断源有请求）
- INTR线发出的是可屏蔽中断，优先级最低
- NMI线发出的是不可屏蔽中断，优先级最高
中断请求判优
- 响应优先级是固定的，处理优先级可以利用中断屏蔽技术动态调整
CPU响应中断条件
- CPU内部的中断屏蔽触发器开放
- 外设有中断请求时，中断请求触发器必须是1，保持中断请求信号
- 外设中断允许触发器必须为1，才能将外设中断请求送到CPU
- 满足以上三个条件，CPU在现行指令结束的最后一个状态周期响应中断
中断响应过程
- 中断响应优先级一般固定，不可改变
- 中断隐指令
  - 保存断点，异常指令保存的是当前指令的位置，中断指令保存的是下一条指令的地址
中断向量
- 中断识别：向量中断和非向量中断（软件查询法）（chap5？）
- 中断-中断类型号-中断服务程序-入口地址（中断向量）
- 中断向量表
中断处理过程
- 中断处理优先级可以由中断屏蔽字来改变，屏蔽位为0，对新中断开放
多重中断和中断屏蔽
- 中断优先级DACB，屏蔽字
- 执行轨迹

5.6 DMA方式

外设和内存之间有一条“直接数据通道”

特点

主存既可被CPU访问，又可被外设访问
主存地址确定、传送数据计数直接由硬件电路实现
内存中专有缓冲区
DMA速度快，CPU和外设并行
DMA传送前预处理，结束后中断方式后处理

组成

I/O设备通过DMA控制器（DMA接口）向CPU提出请求，CPU响应后让出系统总线，由DMA控制器接管总线。

传送方式

停止CPU访存
周期挪用（周期窃取）
DMA和CPU交替访存

DMA和中断的区别

中断是程序切换，DMA不占用CPU
中断的响应只在指令执行结束后，DMA的响应可以在每个机器周期结束时（取址、间址、执行）
DMA传送不需要CPU，高速有效
DMA请求优先级高于中断请求
中断可以处理异常，DMA仅有I/O操作
中断是程序传送，DMA是硬件传送数据

csapp第一章-计算机系统概论

Mon, 29 Mar 2021 00:00:00 +0000

第一章计算机系统概论

典型的冯诺依曼计算机是以运算器为中心的，现代的计算机已转化为以存储器为中心。

五大部件：输入设备、输出设备、存储器、运算器、控制器

运算器和控制器–>CPU

M.M主存储器

CPU内部

ALU：算术逻辑单元

CU：控制单元（CU控制AU，IO设备也受CU控制）

设某机的指令字长为16位，操作码6位，地址码10位

运算器包括三个寄存器（往往有寄存器组）和一个ALU

ACC（累加器）、MQ（乘商寄存器）、X（操作数寄存器）

为了实现按地址访问的方式，主存中还必须配置两个寄存器MAR和MDR

MAR：Memory Adress Register存储器地址寄存器

用来存放欲访问的存储单元的地址，其位数对应存储单元的个数

MAR为10位，则有1024个存储单元，记为1K

MDR：Memory Data Register存储器数据存储器

位数欲存储字长相等

早期计算机的存储字长一般和机器的指令字长与数据字长相等，访问一次主存可以取一条指令或一个数据

为了指令和数据字长的可变性，长度由字节的个数来表示。

控制器

程序计数器PC

用来存放当前欲执行指令的地址，他与主存的MAR之间有一条直接通路，具有自动加1的功能，可以自动形成下一条指令的地址

指令寄存器IR

用来存放当前的指令，内容来自贮存的MDR

OP（IR）-> CU ：IR中的操作码送至CU，用来分析指令

Ad（IR）-> MAR：地址码作为操作数的地址送至存储器的MAR

控制单元CU

用来分析当前指令所需完成的操作，并发出各种微操作命令序列

存储容量

存储容量=存储单元个数*存储字长

MAR16位，有2^16=65536个存储单元

MDR32位，有65536*32=2^21=2M位=2^18B=256KB

1M=2^20

1G=1KM=2^30

运算速度

吉普森Gibson法

综合考虑每条指令的执行之间以及他们在全部操作中所占的百分比

MIPS（Million Instruction Per Second）作为计量单位，每秒执行百万条指令

2MIPS：某机器每秒能执行200万条指令

CPI（Cycle Per Instruction）执行一条指令所需的时钟周期（主频的倒数）数

FLOPS(Floating Point Operation Per Second)每秒浮点运算次数来衡量运算速度

第二章计算机的发展及应用

约瑟夫问题

Mon, 30 Mar 2020 00:00:00 +0000

约瑟夫问题

Question

N个人围成一圈，从第一个人开始报数，报到M的人出圈，剩下的人继续从1开始报数，报到M的人出圈；如此往复，直到所有人出圈。（模拟此过程，输出出圈的人的序号）

Answer

解法一：假设有n个人，从1到n，放入一个ArrayList中。设置开始的编号k(设为0，为第一个人），加上需要报的数减1，即得到需要出列人的索引。要注意要出列的人是不是最后一个人，要特殊处理。当ArrayList为空，则完成。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Solution {

 public static void Josephus(int totalNum, int countNum) {
 List<Integer> start = new ArrayList<Integer>();
 for(int i=1; i<=totalNum; i++) {
 //初始化人数
 start.add(i);
 }

 int k = 0;
 while(start.size() != 0) {
 k = k+countNum;
 k = k%(start.size())-1; //得到第m人的索引位置，所以要-1

 if(k == -1) {
 //到队尾
 System.out.println(start.get(start.size()-1));
 start.remove(start.size()-1);
 k = 0;
 }else {
 System.out.println(start.get(k));
 start.remove(k);
 }
 }
 }


 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Scanner scanner = new Scanner(System.in);
 int totalNum = scanner.nextInt();
 int countNum = scanner.nextInt();
 Josephus(totalNum, countNum);
 scanner.close();
 }
}

//input：10 3
//output：3 6 9 2 7 1 8 5 10 4

解法二：用队列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Solution {

 public static void countQueue(int totalNum, int countNum) {
 Queue<Integer> queue = new LinkedList<Integer>();
 for(int i=1; i<=totalNum; i++) {
 queue.add(i);
 }

 int count = 0; //计数器
 while(!queue.isEmpty()) {
 int person = 0;
 person = queue.poll(); //出队列
 count++;
 if(count % countNum == 0) {
 //是，出队
 System.out.println(person);
 }else {
 //不是，继续入队列
 queue.add(person);
 }
 }
 }

 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Scanner scanner = new Scanner(System.in);
 int totalNum = scanner.nextInt();
 int countNum = scanner.nextInt();
 countQueue(totalNum, countNum);
 scanner.close();
 }

}

leetcode25.K个一组翻转链表

Mon, 16 Mar 2020 00:00:00 +0000

leetcode25.K个一组翻转链表

Question

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

说明：

你的算法只能使用常数的额外空间。你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/reverse-nodes-in-k-group 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

解法一

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


public class Solution {
 public ListNode reverseKGroup(ListNode head, int k) {
 ListNode dummyNode = new ListNode(0);
 dummyNode.next = head;

 //开始时pre和end都在dummyNode处
 ListNode pre = dummyNode; //待翻转链表的前驱
 ListNode end = dummyNode; //待翻转链表的末尾

 while(end.next != null) {
 for(int i = 0; i < k && end != null; i++) {
 end = end.next; //end指针后移，看是否足够翻转
 }
 if(end == null) break; //不够k个就跳出

 ListNode start = pre.next;
 ListNode next = end.next; //next记录待翻转的结点
 end.next = null; //从end往后断开，准备翻转【start，end】区间

 pre.next = reverse(start); //更新pre
 start.next = next; //将翻转后的部分与后面未翻转部分连起来

 pre = start; //重置pre指针
 end = pre; //重置end指针
 }
 return dummyNode.next;
 }

 private ListNode reverse(ListNode head) {
 //单链表的翻转操作，遍历实现
 ListNode pre = null;
 ListNode curr = head;
 ListNode temp = null;
 while(curr != null) {
 temp = curr.next;
 curr.next = pre;

 pre = curr;
 curr = temp;
 }
 return pre;
 }
}

解法二

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


import java.util.ArrayDeque;
import java.util.Deque;

public class Solution {
 public ListNode reverseKGroup(ListNode head, int k) {
 Deque<ListNode> stack = new ArrayDeque<ListNode>();
 ListNode dummyNode = new ListNode(0);
 ListNode p = dummyNode; //p用于生成新的链表，dummyNode记住头结点
 while(true) {
 int count = 0;
 ListNode tmp = head; //临时结点tmp
 while(tmp != null && count < k) {
 stack.add(tmp); //往栈里头加
 tmp = tmp.next;
 count++;
 }
 if(count != k) {
 //不够k个不翻转
 p.next = head;
 break;
 }
 while(!stack.isEmpty()) {
 p.next = stack.pollLast(); //取出来
 p = p.next;
 }
 p.next = tmp;
 head = tmp;
 }
 return dummyNode.next;
 }
}

Attention

解法一（常数空间）：

题解转载自王小二

链表分区为已翻转部分+待翻转部分+未翻转部分
每次翻转前，要确定翻转链表的范围，这个必须通过 k 次循环来确定
需记录翻转链表前驱和后继，方便翻转完成后把已翻转部分和未翻转部分连接起来
初始需要两个变量 pre 和 end，pre 代表待翻转链表的前驱，end 代表待翻转链表的末尾
经过k此循环，end 到达末尾，记录待翻转链表的后继 next = end.next
翻转链表，然后将三部分链表连接起来，然后重置 pre 和 end 指针，然后进入下一次循环
特殊情况，当翻转部分长度不足 k 时，在定位 end 完成后，end==null，已经到达末尾，说明题目已完成，直接返回即可
时间复杂度为 O(n*K) ，最好的情况为 O(n) ，最差的情况未 O(n^2)
空间复杂度为 O(1) ，除了几个必须的节点指针外，我们并没有占用其他空间

单链表的翻转

Mon, 16 Mar 2020 00:00:00 +0000

单链表的翻转

遍历法

pre：上一个结点 curr：当前结点 temp：临时结点，用于保存当前结点的指针域

基本思路：从前往后修改每个结点的指针。在curr != null的while循环中，先将当前结点curr的下一个结点存到temp即临时结点中，修改当前结点的指针curr.next = pre，然后指针后移，pre = curr curr = temp。最后把原链表的头结点head置为null。返回pre。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class ListNode {
 int val;
 ListNode next;
 ListNode (int x){ val = x; }
}

private ListNode reverse(ListNode head) {
 ListNode pre = null;
 ListNode curr = head;
 ListNode temp = null;
 while(curr != null) {
 temp = curr.next;
 curr.next = pre;

 pre = curr;
 curr = temp;
 }
 return pre;

 }

递归翻转

基本思路：在翻转当前结点时，先翻转后续结点。即从尾结点开始，逆向反转各个结点的指针。把head当作是前一结点，为空链或者当前只有一个结点直接返回head。

1
2
3
4
5
6
7


private ListNode reverse(ListNode head) {
 if(head == null || head.next == null) {return head;}
 ListNode reHead = reverse(head.next); //先翻转后续结点
 head.next.next = head; //将当前结点的指针域指向前一结点
 head.next = null; //前一结点的指针域置为null
 return reHead; //返回翻转后新链表的头结点
 }

二分求函数零点

Mon, 16 Mar 2020 00:00:00 +0000

二分求函数零点

Question

有函数：

f(x) = x5 - 15 * x4+ 85 * x3- 225 * x2+ 274 * x - 121

已知 f(1.5) > 0 , f(2.4) < 0 且方程 f(x) = 0 在区间 [1.5,2.4] 有且只有一个根，请用二分法求出该根

输出该方程在区间[1.5,2.4]中的根。要求四舍五入到小数点后6位。

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <cstdio>

//f(x) = x5 - 15 * x4+ 85 * x3- 225 * x2+ 274 * x - 121
//已知 f(1.5) > 0 , f(2.4) < 0 且方程 f(x) = 0 在区间 [1.5,2.4] 有且只有一个根，请用二分法求出该根
//output:1.849016

double f(double x);

void ok(double a, double b);

int main()
{
 ok(1.5, 2.4);
 return 0;
}

double f(double x){
 return x*x*x*x*x - 15*x*x*x*x+ 85*x*x*x- 225*x*x+ 274*x - 121;
}

void ok(double a, double b){
 double mid,result;
 mid = a + (b-a)/2;
 result = f(mid);
 if (result > 0.000001)
 {
 ok(mid,b); //到右半边去找
 }
 else if (result < -0.000001)
 {
 ok(a,mid); //到左半边去找
 }else{
 printf("%.6lf\n", mid);
 }
}

用两个栈实现队列

Mon, 16 Mar 2020 00:00:00 +0000

用两个栈实现队列

Question

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package queuebystack;

import java.util.Stack;

public class QueueByStack {

 Stack<Integer> stack1 = new Stack<>();
 Stack<Integer> stack2 = new Stack<>();

 private void move(Stack<Integer> source, Stack<Integer> target) {
 while(!source.isEmpty()) {
 target.push(source.pop());
 }
 }

 public void enqueue(int node) {
 if(stack1.isEmpty()) {
 move(stack2, stack1);
 }
 stack1.push(node);
 }

 public int dequeue() {
 if(stack2.isEmpty()) {
 move(stack1, stack2);
 }
 return stack2.pop();
 }


 public static void main(String[] args) {
 // TODO Auto-generated method stub
 QueueByStack obj = new QueueByStack();
 obj.enqueue(1);
 obj.enqueue(2);
 obj.enqueue(3);
 obj.enqueue(4);
 obj.enqueue(5);
 System.out.println(obj.dequeue());
 System.out.println(obj.dequeue());
 System.out.println(obj.dequeue());
 System.out.println(obj.dequeue());
 }

}

求二叉树的深度（递归和非递归）

Mon, 09 Mar 2020 00:00:00 +0000

求二叉树的深度（递归和非递归）

Question

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

Answer

二叉树结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


public class TreeNode {
 int val = 0;
 TreeNode left = null;
 TreeNode right = null;

 public TreeNode(int val) {
 this.val = val;

 }
 }

TreeDepth_1递归实现、TreeDepth_2非递归实现（Java描述）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package treedepth;

import java.util.LinkedList;

public class TreeDepth {

 public int TreeDepth_1(TreeNode root) {
 if(root == null) return 0;
 int num1 = TreeDepth_1(root.left);
 int num2 = TreeDepth_1(root.right);
 return 1 + (num1 > num2 ? num1 : num2);
 }

 public int TreeDepth_2(TreeNode root) {
 //level存放树的深度，LinkedList存放node结点
 int level = 0;
 LinkedList<TreeNode> q = new LinkedList<TreeNode>();
 if(root == null) return 0;
 q.offer(root); //放入根结点
 int len = 0;
 int cur; //记录本层已经记录的结点个数
 while(!q.isEmpty()) {
 len = q.size();
 cur = 0;
 while(cur < len) {
 //出队
 TreeNode current = q.poll();
 cur++;
 //如果当前左右子树还有结点，则将左右子树存放到链表中
 if(current.left != null) {
 q.offer(current.left);
 }
 if(current.right != null) {
 q.offer(current.right);
 }
 }
 //遍历存完一层的结点后level++
 level++;
 }
 return level;
 }


 public static void main(String[] args) {
 // TODO Auto-generated method stub

 }

}

Java基础知识

Sun, 08 Mar 2020 00:00:00 +0000

Java基础知识

面向对象与面向过程

面向过程性能比面向对象高，因为类的调用需要实例化，开销大
Java性能差的根本原因是因为半编译语言，最终的执行代码不是可以直接被CPU执行的二进制码

Java特点

Java虚拟机实现平台无关性
支持多线程
- C++11开始（2011年的时候）,C++就引入了多线程库，在windows、linux、macos都可以使用std::thread和std::async来创建线程
编译与解释共存

##关于JVM、JDK和JRE

Java虚拟机（JVM）

JVM运行Java字节码
- 字节码（扩展名为.class的文件）
- .class–>机器码，在这一步JVM类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢

JDK和JRE

JDK是功能齐全的Java SDK，拥有JRE的一切，JRE是Java运行时环境
JDK能够创建和编译程序，JRE不能创建新程序

Java与C++

都是OOP，支持封装、继承和多态
Java不提供指针直接访问内存
C++支持多重继承，Java单继承，但Java接口可多继承
Java有自动内存管理机制，不需要手动释放无用内存
C语言中‘、0’表示结束符，Java无

字符型常量和字符串常量的区别?

字符常量相当于一个整型值( ASCII 值),可以参加表达式运算
字符串常量代表一个地址值(该字符串在内存中存放位置)
字符常量只占2个字节
字符串常量占若干个字节 (注意： char在Java中占两个字节)

构造器 Constructor 是否可被 override?

Constructor可以被overload，不可override

重载和重写的区别

overload重载
- 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同
override重写
- 重写是子类对父类的允许访问的方法的实现过程进行重新编写，发生在子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类
- 如果父类方法访问修饰符为 private 则子类就不能重写该方法
- 也就是说方法提供的行为改变，而方法的外貌并没有改变

Java 面向对象编程三大特性: 封装继承多态

封装
- 把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法
继承
- 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类无法访问，只是拥有
- 子类可以对父类进行扩展
- 子类可以用自己的方法实现父类的方法
多态
- 程序中定义的引用变量所指向的具体类型和通过该应用变量发出的方法调用在编程时并不确定，直到程序运行期间才确定。即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，运行时决定。
- 实现多态的两种形式：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）

String StringBuffer 和 StringBuilder

String 类中使用final关键字修饰字符数组来保存字符串，private　final　char　value[]，所以 String 对象是不可变的
StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类
在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]value 但是没有用 final 关键字修饰，所以StringBuilder 与 StringBuffer都是可变的。
String中对象不可变，线程安全
AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，定义了一些字符串的基本操作，如 expandCapacity、append、insert、indexOf 等公共方法
- StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的
- StringBuilder 并没有对方法进行加同步锁，所以是非线程安全的
StringBuilder 比 StringBuffer 性能略高

自动装箱与拆箱

装箱：将基本类型用它们对应的引用类型包装起来
拆箱：将包装类型转换成基本数据类型

import java和javax有什么区别？

接口和抽象类的区别是什么？

成员变量与局部变量的区别有哪些？

从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰
从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
成员变量如果没有被赋初值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值

创建一个对象用什么运算符?对象实体与对象引用有何不同?

new 运算符
new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）
一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。

构造方法

构造方法有哪些特性？

名字与类名相同
没有返回值，但不能用void声明构造函数
生成类的对象时自动执行，无需调用。

在 Java 中定义一个不做事且没有参数的构造方法的作用

Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”
如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误

一个类的构造方法的作用是什么? 若一个类没有声明构造方法，该程序能正确执行吗? 为什么？

静态方法和实例方法

实例方法只能通过对象.方法名的方式调用
静态方法还可以通过类名.方法名调用，无需创建对象
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法

在一个静态方法内调用一个非静态成员为什么是非法的?

静态方法可以不通过对象进行调用
在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员

== 与 equals

==的作用是判断两个对象的地址是不是相等
- 判断两个对象是不是同一个对象
- 基本数据类型==比较的是值
- 引用数据类型==比较的是内存地址
equals()的作用也是判断两个对象是否相等

hashCode 与 equals (重要)

hashCode() 的作用是获取哈希码，也称为散列码；它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函数。
HashSet 如何检查重复
- 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对象加入的位置，同时也会与该位置其他已经加入的对象的 hashcode 值作比较，如果没有相符的 hashcode，HashSet 会假设对象没有重复出现。
- 但是如果发现有相同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。
- 这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。
hashCode（）与 equals（）的相关规定
- 如果两个对象相等，则 hashcode 一定也是相同的
- 两个对象相等,对两个对象分别调用 equals 方法都返回 true
- 两个对象有相同的 hashcode 值，它们也不一定是相等的
- 因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖
- hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）

简述线程、程序、进程的基本概念。以及他们之间关系是什么?

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。
进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU 时间，内存空间，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。线程是进程划分成的更小的运行单位。
线程和进程最大的不同在于基本上各进程是独立的，而各线程则不一定，因为同一进程中的线程极有可能会相互影响。从另一角度来说，进程属于操作系统的范畴，主要是同一段时间内，可以同时执行一个以上的程序，而线程则是在同一程序内几乎同时执行一个以上的程序段。

线程有哪些基本状态?

线程创建之后它将处于 NEW（新建）状态，调用 start()方法后开始运行，线程这时候处于 READY（可运行）状态。
可运行状态的线程获得了 cpu 时间片（timeslice）后就处于 RUNNING（运行）状态。
当线程执行 wait()方法之后，线程进入 WAITING（等待）状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 TIME_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将 Java 线程置于 TIMED WAITING 状态。
当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 BLOCKED（阻塞）状态。线程在执行 Runnable 的run()方法之后将会进入到 TERMINATED（终止）状态。

关于final关键字

对于一个 final 变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
当用 final 修饰一个类时，表明这个类不能被继承。final 类中的所有成员方法都会被隐式地指定为 final 方法。
使用 final 方法的原因有两个。
- 第一个原因是把方法锁定，以防任何继承类修改它的含义；
- 第二个原因是效率。在早期的 Java 实现版本中，会将 final 方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升（现在的 Java 版本已经不需要使用 final 方法进行这些优化了）。类中所有的 private 方法都隐式地指定为 final。

Java中的异常处理

Java异常类

java.lang 包中的 Throwable 类
Throwable中有两个重要的子类：Exception（异常） 和 Error（错误） ，二者都是 Java 异常处理的重要子类，各自都包含大量子类。
Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。
- 例如，Java 虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。
- 这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如 Java 虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。
- 这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
Exception（异常）:是程序本身可以处理的异常。Exception 类有一个重要的子类 RuntimeException。RuntimeException 异常由 Java 虚拟机抛出。
- NullPointerException（要访问的变量没有引用任何对象时，抛出该异常）
- ArithmeticException（算术运算异常，一个整数除以 0 时，抛出该异常）
- ArrayIndexOutOfBoundsException （下标越界异常）
注意：异常和错误的区别：异常能被程序本身处理，错误是无法处理。

Throwable类常用方法

public string getMessage():返回异常发生时的简要描述
public string toString():返回异常发生时的详细信息
public string getLocalizedMessage():返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage（）返回的结果相同
public void printStackTrace():在控制台上打印 Throwable 对象封装的异常信息

异常处理总结

try 块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
catch 块：用于处理 try 捕获到的异常。
finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。
在以下 4 种特殊情况下，finally 块不会被执行：
1. 在 finally 语句块第一行发生了异常。因为在其他行，finally 块还是会得到执行
2. 在前面的代码中用了 System.exit(int)已退出程序。 exit 是带参函数；若该语句在异常语句之后，finally 会执行
3. 程序所在的线程死亡。
4. 关闭 CPU。

获取用键盘输入常用的两种方法

Scanner

1
2
3


Scanner input = new Scanner(System.in);
String s = input.nextLine();
input.close();

BufferedReader

1
2


BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String s = input.readLine();

Java中的IO流

Java中的IO流分为几种

按照流的流向分，可以分为输入流和输出流
按照操作单元划分，可以划分为字节流和字符流
按照流的角色划分为节点流和处理流
四个抽象类基类
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。

I/O 流操作要分为字节流操作和字符流操作

不管是文件读写还是网络发送接收，信息的最小存储单元都是字节，那为什么 I/O 流操作要分为字节流操作和字符流操作呢？
- 字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还算是非常耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。
- 所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。

BIO,NIO,AIO 有什么区别?

BIO (Blocking I/O): 同步阻塞 I/O 模式，数据的读取写入必须阻塞在一个线程内等待其完成。
- 在活动连接数不是特别高（小于单机 1000）的情况下，这种模型是比较不错的，可以让每一个连接专注于自己的 I/O 并且编程模型简单，也不用过多考虑系统的过载、限流等问题。
- 线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。
- 但是，当面对十万甚至百万级连接的时候，传统的 BIO 模型是无能为力的。因此，我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
NIO (New I/O): NIO 是一种同步非阻塞的 I/O 模型.
- 在 Java 1.4 中引入了 NIO 框架，对应 java.nio 包，提供了 Channel , Selector，Buffer 等抽象。
- NIO 中的 N 可以理解为 Non-blocking，不单纯是 New。它支持面向缓冲的，基于通道的 I/O 操作方法。
- NIO 提供了与传统 BIO 模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。
- 对于低负载、低并发的应用程序，可以使用同步阻塞 I/O 来提升开发速率和更好的维护性；对于高负载、高并发的（网络）应用，应使用 NIO 的非阻塞模式来开发
AIO (Asynchronous I/O): AIO 也就是 NIO 2。
- 在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的 IO 模型。
- 异步 IO是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。
- AIO 是异步 IO 的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO 操作本身是同步的。

以上转载自JavaGuide

Java集合框架

Sun, 08 Mar 2020 00:00:00 +0000

Java集合框架

List,Set,Map三者的区别

List：List接口存储一组不唯一（可以有多个元素引用相同的对象）、有序的对象
Set：不允许重复的集合。不会有多个元素引用相同的对象
Map：使用键值对存储。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象

Arraylist 与 LinkedList 区别

是否保证线程安全：
- ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全
底层数据结构：
- Arraylist 底层使用的是 Object 数组
- LinkedList 底层使用的是 双向链表 数据结构（JDK1.6之前为循环链表，JDK1.7取消了循环）
插入和删除是否受元素位置的影响：
- ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响
- 执行add(E e) 方法的时候， ArrayList 会默认在将指定的元素追加到此列表的末尾，这种情况时间复杂度就是O(1)。但是如果要在指定位置 i 插入和删除元素的话（add(int index, E element) ）时间复杂度就为 O(n-i)。因为在进行上述操作的时候集合中第 i 和第 i 个元素之后的**(n-i)个元素都要执行向后位/向前移一位的操作**
- LinkedList 采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O（1），如果是要在指定位置i插入和删除元素的话（(add(int index, E element)） 时间复杂度近似为o(n))因为需要先移动到指定位置再插入
是否支持快速随机访问：
- LinkedList 不支持高效的随机元素访问
- ArrayList 支持。快速随机访问就是通过元素的序号快速获取元素对象(对应于get(int index) 方法)
内存空间占用：
- ArrayList的空间浪费主要体现在在list列表的结尾会预留一定的容量空间
- LinkedList的空间花费则体现在它的每一个元素都需要消耗比ArrayList更多的空间（因为要存放直接后继和直接前驱以及数据）

ArrayList 与 Vector 区别，为什么要用Arraylist取代Vector

Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象，但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间
Arraylist不是同步的，所以在不需要保证线程安全时建议使用Arraylist

HashMap 和 Hashtable 的区别

线程是否安全：
- HashMap 是非线程安全的，HashTable 是线程安全的
- HashTable 内部的方法基本都经过 synchronized 修饰（保证线程安全就使用ConcurrentHashMap）
效率：
- 因为线程安全的问题，HashMap 要比 HashTable 效率高一点
- 另外，HashTable 基本被淘汰，不要在代码中使用它
对Null key 和Null value的支持：
- HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null
- 但是在 HashTable 中 put 进的键值只要有一个 null，直接抛出 NullPointerException
初始容量大小和每次扩充容量大小的不同：
- 创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1
- HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍
- 创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小，也就是说 HashMap 总是使用2的幂作为哈希表的大小
底层数据结构：
- JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8）时，将链表转化为红黑树，以减少搜索时间

HashMap 和 HashSet区别

HashMap	HashSet
实现了Map接口	实现Set接口
存储键值对	仅存储对象
put()方法向map中添加元素	add()方法向Set中添加元素
使用key计算HashCode	使用成员对象来计算HashCode

对于两个对象来说HashCode可能相同，所以equals()方法用来判断对象是否相等。

HashMap 的长度为什么是2的幂次方

这个数组下标的计算方法是(n - 1) & hash
取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 **hash%length==hash&(length-1)**的前提是 length 是2的 n 次方）
采用二进制位操作&，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方

ConcurrentHashMap 和 Hashtable 的区别

ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

底层数据结构：
- JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟 HashMap1.8 的结构一样，数组+链表/红黑二叉树
- Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的
实现线程安全的方式（重要）：
- 在JDK1.7的时候，ConcurrentHashMap（分段锁）对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树 的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。（JDK1.6以后对 synchronized锁做了很多优化）整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本
- **Hashtable(同一把锁) **:使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低

HashMap 、 Hashtable 和 ConcurrentHashMap 的区别

HashMap是线程不安全的，并发环境下危险
HashTable和HashMap的实现原理几乎一样
- HashTable不允许key和value为null
- HashTable是线程安全的，但是HashTable线程安全的策略实现代价却太大了。get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。
如果容器中有多把锁，每一把锁锁一段数据，这样在多线程访问时不同段的数据时，就不会存在锁竞争了，这样便可以有效地提高并发效率，这就是ConcurrentHashMap所采用的**“分段锁”**思想

以上转载自JavaGuide

Java集合类：HashMap（基于JDK1.8）

Sun, 08 Mar 2020 00:00:00 +0000

散列函数

散列函数处理冲突的方法

开放地址法

所谓开放地址法，即可存放新表项的空闲地址既向他的同义词表项开放，又向他的非同义词表项开放。

取定某一增量序列后，处理方法是确定的。

线性探测法
- d=0，1，2，···，m-1
- 线性查看下一个单元，容易导致聚集
平方探测法
- d=0^2,1^2,-1^2,2^2,-2^2,···，k^2,-k^2,
- 又称二次探测法
- 缺点是不能探测到散列表上的所有单元，但至少能探测到一半单元
再散列法
伪随机序列法

在开放定址的情形下，不能随便物理删除表中已有元素，因为若删除元素就会阶段其他具有相同散列地址的元素的查找地址。若要删除一个元素，给他做一个删除标记，进行逻辑删除。副作用是在执行多次删除后，表面上看起来散列表很满，实际上有很多的位置没有利用，因此需要定期维护散列表，要把删除标记的元素的物理删除。

拉链法（chaining）

为了避免非同义词发生冲突，可以把所有的同义词存储在一个线性链表中，这个线性链表由其散列地址唯一标识。拉链法适用于经常进行插入和删除的情况。

散列性能分析

散列表的查找效率取决于三个因素：散列函数、处理冲突的方法和装填因子。

装填因子定义为一个表的装满程度

a = 表中记录数n / 散列表长度m

Java中的HashMap

以下转载自美团技术团队——Java 8系列之重新认识HashMap

JDK1.8对HashMap底层的实现进行了优化，例如引入红黑树的数据结构和扩容的优化。
Java中的接口java.util.Map，有四个常用的实现类，HashMap、Hashtable、LinkedHashMap和TreeMap。
HashMao非线程安全，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致，如果需要满足线程安全，可以用Collections的synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap。
HashMap就是使用哈希表来存储的。哈希表为解决冲突，可以采用开放地址法和链地址法等来解决问题，Java中HashMap采用了链地址法。

存储结构-字段

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


static class Node<K,V> implements Map.Entry<K,V> {
 final int hash; //用来定位数组索引位置
 final K key;
 V value;
 Node<K,V> next; //链表的下一个node

 Node(int hash, K key, V value, Node<K,V> next) { ... }
 public final K getKey(){ ... }
 public final V getValue() { ... }
 public final String toString() { ... }
 public final int hashCode() { ... }
 public final V setValue(V newValue) { ... }
 public final boolean equals(Object o) { ... }
}

Node[] table，即哈希桶数组，明显它是一个Node的数组。Node是HashMap的一个内部类，实现了Map.Entry接口。

HashMap的几个字段：从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：

1
2
3
4


int threshold; // 所能容纳的key-value对极限 
final float loadFactor; // 负载因子
int modCount;
int size;

首先，Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。

结合负载因子的定义公式可知，threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目，超过这个数目就重新resize(扩容)，扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个平衡选择，建议大家不要修改，除非在时间和空间比较特殊的情况下。

如果内存空间很多而又对时间效率要求很高，可以降低负载因子Load factor的值
相反，如果内存空间紧张而对时间效率要求不高，可以增加负载因子loadFactor的值，这个值可以大于1

size这个字段其实很好理解，就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳最大键值对数量threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数，主要用于迭代的快速失败。强调一点，内部结构发生变化指的是结构发生变化，例如put新键值对，但是某个key对应的value值被覆盖不属于结构变化。

在HashMap中，哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数，具体证明可以参考http://blog.csdn.net/liuqiyao_01/article/details/14475159，Hashtable 初始化桶大小为11，就是桶大小设计为素数的应用（Hashtable扩容后不能保证还是素数）。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。

这里存在一个问题，即使负载因子和Hash算法设计的再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响HashMap的性能。于是，在JDK1.8版本中，对数据结构做了进一步的优化，引入了红黑树。而当链表长度太长（默认超过8）时，链表就转换为红黑树，利用红黑树快速增删改查的特点提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。本文不再对红黑树展开讨论，想了解更多红黑树数据结构的工作原理可以参考http://blog.csdn.net/v_july_v/article/details/6105630 。

功能实现-方法

根据key获取哈希桶数组索引位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


方法一：
static final int hash(Object key) { //jdk1.8 & jdk1.7
 int h;
 // h = key.hashCode() 为第一步 取hashCode值
 // h ^ (h >>> 16) 为第二步 高位参与运算
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
 return h & (length-1); //第三步 取模运算
}

这里的Hash算法本质上就是三步：取key的hashCode值、高位运算、取模运算。

对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用方法一所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用方法二来计算该对象应该保存在table数组的哪个索引处。

这个方法非常巧妙，它通过h & (table.length -1)来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，这是HashMap在速度上的优化。当length总是2的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。 （由于位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。）

在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h »> 16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。

下面举例说明下，n为table的长度。

put方法的详细执行

判断键值对数组table[i]是否为空，否则执行resize()进行扩容
根据key计算hash值的插入的数组索引i，如果table[i]==null，直接新建节点添加，转向4，如果不为空，转向3
判断table[i]的首个元素是否和key一样，相同则直接覆盖value，否则转向4
判断table[i]是否为treeNode，即table[i]是否是红黑树，如果是红黑树，直接插入键值对，否则转向5
遍历table[i]，判断链表长度是否大于8，大于8则将链表转换为红黑树，在红黑树中插入，否则进行链表的插入；遍历过程中如果发现key已经存在直接覆盖value
插入成功后，判断实际存在的键值对数量size是否超出了最大容量threshold，超出则resize()

JDK1.8 HashMap的put方法源码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


public V put(K key, V value) {
 // 对key的hashCode()做hash
 return putVal(hash(key), key, value, false, true);
 }

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 boolean evict) {
 Node<K,V>[] tab; Node<K,V> p; int n, i;
 // 步骤①：tab为空则创建
 if ((tab = table) == null || (n = tab.length) == 0)
 n = (tab = resize()).length;
 // 步骤②：计算index，并对null做处理 
 if ((p = tab[i = (n - 1) & hash]) == null)
 tab[i] = newNode(hash, key, value, null);
 else {
 Node<K,V> e; K k;
 // 步骤③：节点key存在，直接覆盖value
 if (p.hash == hash &&
 ((k = p.key) == key || (key != null && key.equals(k))))
 e = p;
 // 步骤④：判断该链为红黑树
 else if (p instanceof TreeNode)
 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
 // 步骤⑤：该链为链表
 else {
 for (int binCount = 0; ; ++binCount) {
 if ((e = p.next) == null) {
 p.next = newNode(hash, key,value,null);
 //链表长度大于8转换为红黑树进行处理
 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 
 treeifyBin(tab, hash);
 break;
 }
 // key已经存在直接覆盖value
 if (e.hash == hash &&
 ((k = e.key) == key || (key != null && key.equals(k)))) break;
 p = e;
 }
 }

 if (e != null) { // existing mapping for key
 V oldValue = e.value;
 if (!onlyIfAbsent || oldValue == null)
 e.value = value;
 afterNodeAccess(e);
 return oldValue;
 }
 }

 ++modCount;
 // 步骤⑥：超过最大容量 就扩容
 if (++size > threshold)
 resize();
 afterNodeInsertion(evict);
 return null;
 }

扩容过程

扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。

resize源码（JDK1.7）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


 void resize(int newCapacity) { //传入新的容量
 Entry[] oldTable = table; //引用扩容前的Entry数组
 int oldCapacity = oldTable.length;
 if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
 threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
 return;
 }

 Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
 transfer(newTable); //！！将数据转移到新的Entry数组里
 table = newTable; //HashMap的table属性引用新的Entry数组
 threshold = (int)(newCapacity * loadFactor);//修改阈值
 }

transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void transfer(Entry[] newTable) {
 Entry[] src = table; //src引用了旧的Entry数组
 int newCapacity = newTable.length;
 for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
 Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素
 if (e != null) {
 src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
 do {
 Entry<K,V> next = e.next;
 int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
 e.next = newTable[i]; //标记[1]
 newTable[i] = e; //将元素放在数组上
 e = next; //访问下一个Entry链上的元素
 } while (e != null);
 }
 }
 }

newTable[i]的引用赋给了e.next，也就是使用了单链表的头插入方式，同一位置上新元素总会被放在链表的头部位置；这样先放在一个索引上的元素终会被放到Entry链的尾部(如果发生了hash冲突的话），这一点和Jdk1.8有区别。在旧数组中同一条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

JDK1.7

下面举个例子说明下扩容过程。假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。其中的哈希桶数组table的size=2，所以key = 3、7、5，put顺序依次为 5、7、3。在mod 2以后都冲突在table[1]这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过程。

JDK1.8做的优化

我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。

n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。

元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：

因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：

这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。

线程安全性

在多线程使用场景中，应该尽量避免使用线程不安全的HashMap，而使用线程安全的ConcurrentHashMap。下面举例子说明在并发的多线程使用场景中使用HashMap可能造成死循环。代码例子如下(便于理解，仍然使用JDK1.7的环境)：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class HashMapInfiniteLoop {

 private static HashMap<Integer,String> map = new HashMap<Integer,String>(2，0.75f);
 public static void main(String[] args) {
 map.put(5， "C");

 new Thread("Thread1") {
 public void run() {
 map.put(7, "B");
 System.out.println(map);
 };
 }.start();
 new Thread("Thread2") {
 public void run() {
 map.put(3, "A);
 System.out.println(map);
 };
 }.start();
 }
}

其中，map初始化为一个长度为2的数组，loadFactor=0.75，threshold=2*0.75=1，也就是说当put第二个key的时候，map就需要进行resize。

通过设置断点让线程1和线程2同时debug到transfer方法的首行。注意此时两个线程已经成功添加数据。放开thread1的断点至transfer方法的“Entry next = e.next;” 这一行；然后放开线程2的的断点，让线程2进行resize。结果如下图。

注意，Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。

线程一被调度回来执行，先是执行 newTalbe[i] = e，然后是e = next，导致了e指向了key(7)，而下一次循环的next = e.next导致了next指向了key(3)。

e.next = newTable[i] 导致 key(3).next 指向了 key(7)。注意：此时的key(7).next 已经指向了key(3)， 环形链表就这样出现了。

于是，当我们用**线程一调用map.get(11)**时，悲剧就出现了——Infinite Loop。

小结

扩容是一个特别耗性能的操作，所以当程序员在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容。
负载因子是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况非常特殊。
HashMap是线程不安全的，不要在并发的环境中同时操作HashMap，建议使用ConcurrentHashMap。
JDK1.8引入红黑树大程度优化了HashMap的性能。

leetcode15.三数之和.16.最接近的三数之和

Sat, 07 Mar 2020 00:00:00 +0000

Question-15

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

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

示例：

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

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

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/3sum 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer-15

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


package pid15;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
 public List<List<Integer>> threeSum(int[] nums) {
 List<List<Integer>> ans = new ArrayList<>();
 Arrays.sort(nums);
 int len = nums.length;
 for(int k=0; k<len-1; k++) {
 if(nums[k] > 0) break;
 if(k>0 && nums[k]==nums[k-1]) continue;
 int i = k+1;
 int j = len-1;
 while(i < j) {
 int sum = nums[k] + nums[i] + nums[j];
 if(sum < 0) {
 ++i;
 }else if(sum > 0) {
 --j;
 }else {
 ans.add(new ArrayList<Integer>(Arrays.asList(nums[k], nums[i], nums[j])));
 while((i<j) && nums[i+1] == nums[i]) ++i;
 while((i<j) && nums[j-1] == nums[j]) --j;
 ++i;
 --j;
 }
 }
 }
 return ans;

 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


/*
 * 15三数之和
 * nums = [0,0,0]
 * [[0,0,0]]
 * nums = [-1,0,1,2,-1,-4]
 * [[-1,-1,2],[-1,0,1]]
 * 和为0且不重复的三元组
 * vector<int> vec01 = {34,55,79,28,46,33,2,48,31,-3,84,71,52,-3,93,15,21,-43,57,-6,86,56,94,74,83,-14,28,-66,46,-49,62,-11,43,65,77,12,47,61,26,1,13,29,55,-82,76,26,15,-29,36,-29,10,-70,69,17,49};
 * 测试结果:[[-82,-11,93],[-82,13,69],[-82,17,65],[-82,21,61],[-82,26,56],[-82,33,49],[-82,34,48],[-82,36,46],[-70,-14,84],[-70,-6,76],[-70,1,69],[-70,13,57],[-70,15,55],[-70,21,49],[-70,34,36],[-66,-11,77],[-66,-3,69],[-66,1,65],[-66,10,56],[-66,17,49],[-49,-6,55],[-49,-3,52],[-49,1,48],[-49,2,47],[-49,13,36],[-49,15,34],[-49,21,28],[-43,-14,57],[-43,-6,49],[-43,-3,46],[-43,10,33],[-43,12,31],[-43,15,28],[-43,17,26],[-29,-14,43],[-29,1,28],[-29,12,17]]
 * 期望结果:[[-82,-11,93],[-82,13,69],[-82,17,65],[-82,21,61],[-82,26,56],[-82,33,49],[-82,34,48],[-82,36,46],[-70,-14,84],[-70,-6,76],[-70,1,69],[-70,13,57],[-70,15,55],[-70,21,49],[-70,34,36],[-66,-11,77],[-66,-3,69],[-66,1,65],[-66,10,56],[-66,17,49],[-49,-6,55],[-49,-3,52],[-49,1,48],[-49,2,47],[-49,13,36],[-49,15,34],[-49,21,28],[-43,-14,57],[-43,-6,49],[-43,-3,46],[-43,10,33],[-43,12,31],[-43,15,28],[-43,17,26],[-29,-14,43],[-29,1,28],[-29,12,17],[-14,-3,17],[-14,1,13],[-14,2,12],[-11,-6,17],[-11,1,10],[-3,1,2]]
 */

vector<vector<int>> threeSum(vector<int>& nums) {
 vector<vector<int>> res;
 vector<int> tmp;
 sort(nums.begin(), nums.end());
 cout << nums.size() << endl;
 for (int i = 0; i < nums.size(); ++i) {
 int l = i + 1, r = nums.size() - 1;
 if (nums[i] > 0) continue;
 if (i > 0 && nums[i] == nums[i-1]) continue; //跳过相同元素，去重，使用continue不使用break
 while (l < r) {
 if (nums[i] + nums[l] + nums[r] > 0) {
 r--;
 } else if (nums[i] + nums[l] + nums[r] < 0) {
 l++;
 } else {
 tmp.clear();
 tmp.push_back(nums[i]);
 tmp.push_back(nums[l]);
 tmp.push_back(nums[r]);
 res.push_back(tmp);
 while (l < r && nums[l] == nums[l+1]) ++l;//去重
 while (l < r && nums[r] == nums[r-1]) --r;
 ++l;
 --r;
 }
 }
 }
 return res;
}

Attention

暴力法三重循环会超时
先对数组排序，然后双指针移动
排序后固定指针k在最左边
初始化i=k+1``j=len-1，在while(i<j)的循环内
- 如果sum>0，大了则是j指针需要左移
- 如果sum<0，小了则是i指针需要由移
- 如果sum=0，用Arrays类的asList方法将数组加入到ans中，并且修改指针，i右移，j左移动
如何去重？
- 可以先判断nums[k]，如果>0，不用比较了，k右移动
- 在i和j指针移动的过程中，如果nums[i]或nums[j]的值相同且连续，可以让指针直接跳过
Arrays类的静态方法sort()可直接对数组进行升序排序

Question-16-最接近的三数之和

给你一个长度为 n 的整数数组 nums 和一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

示例 1：

输入：nums = [-1,2,1,-4], target = 1 输出：2 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

示例 2：

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

提示：

3 <= nums.length <= 1000 -1000 <= nums[i] <= 1000 -10⁴ <= target <= 10⁴

Related Topics 数组双指针排序 👍 1347 👎 0

Answer-16

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


/*
 * 16最接近的三数之和
 * nums = [-1,2,1,-4], target = 1, return 2
 * 与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
 */
int threeSumClosest(vector<int>& nums, int target) {
 int closestDif = INT_MAX;
 int flag = 0;
 sort(nums.begin(), nums.end());
 for (int i = 0; i < nums.size(); ++i) {
 int l = i + 1, r = nums.size() - 1;
 while (l < r) {
// printf("i[%d], l[%d], r[%d]\n", nums[i], nums[l], nums[r]);
 if (nums[i] + nums[l] + nums[r] > target) {
// closestDif = min(closestDif, nums[i] + nums[l] + nums[r] - target);
 if (nums[i] + nums[l] + nums[r] - target < closestDif) {
 closestDif = nums[i] + nums[l] + nums[r] - target;
 flag = 1; //满足条件修改flag，否则用例2,3,8,9,10-16，返回17，正确15
 }
 r--;
 } else if (nums[i] + nums[l] + nums[r] < target) {
// closestDif = min(closestDif, target - nums[i] - nums[l] - nums[r]);
 if (target - nums[i] - nums[l] - nums[r] < closestDif) {
 closestDif = target - nums[i] - nums[l] - nums[r];
 flag = -1;
 }
 l++;
 } else {
 return target;
 }
 }
 }
// printf("closestDif[%d], flag[%d]\n", closestDif, flag);
 return target + flag * closestDif;
}

leetcode18.四数之和

Sat, 07 Mar 2020 00:00:00 +0000

leetcode18.四数之和

Question

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

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

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/4sum 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
 public List<List<Integer>> fourSum(int[] nums, int target){
 List<List<Integer>> ans = new ArrayList<>();
 Arrays.sort(nums);
 int len = nums.length;
 for(int a=0; a<len-1; a++) {
 //此步k要跟0比
 if((a>0) && nums[a] == nums[a-1]) continue;
 for(int k=a+1; k<len-1; k++) {
 //注意此处k指针只能右移，此步去重
 if((k>a+1) && nums[k] == nums[k-1]) continue;
 int i = k+1;
 int j = len-1;
 while(i < j) {
 int sum = nums[a] + nums[k] + nums[i] + nums[j];
 if(sum < target) {
 ++i;
 }else if(sum > target) {
 --j;
 }else {
 ans.add(new ArrayList<Integer>(Arrays.asList(nums[a],nums[k], nums[i], nums[j])));
 while((i<j) && nums[i+1] == nums[i]) ++i;
 while((i<j) && nums[j-1] == nums[j]) --j;
 ++i;
 --j;
 }
 }
 }
 }
 return ans;
 }
}

Attention

在三数之和的 O(N^2) 的外面加一层循环，即可实现。
时间复杂度a遍历O(N)里嵌套k遍历O(N)再嵌套i,j双指针O(N)--> O(N^3)

leetcode35.搜索插入位置

Fri, 06 Mar 2020 00:00:00 +0000

leetcode35.搜索插入位置

Question

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

示例 1: 输入: [1,3,5,6], 5 输出: 2

示例 2: 输入: [1,3,5,6], 2 输出: 1

示例 3: 输入: [1,3,5,6], 7 输出: 4

示例 4: 输入: [1,3,5,6], 0 输出: 0

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/search-insert-position 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class Solution {
 public int searchInsert(int[] nums, int target) {
 int left = 0, right = nums.length-1;
 while(left <= right) {
 int pivot = left + (right - left)/2;
 if(nums[pivot] == target) {
 return pivot;
 }else if(nums[pivot] < target) {
 left = pivot + 1;
 }else {
 right = pivot -1;
 }
 }
 return left;
 }
}

Attention

二分法注意边界条件

Anaconda、conda、pip、virtualenv的区别

Tue, 03 Mar 2020 00:00:00 +0000

Anaconda、conda、pip、virtualenv的区别

Anaconda

Anaconda是一个包含180+的科学包及其依赖项的发行版本。其包含的科学包包括：conda, numpy, scipy, ipython notebook等。

conda

conda是包及其依赖项和环境的管理工具。 
适用语言：Python, R, Ruby, Lua, Scala, Java, JavaScript, C/C++, FORTRAN。 
适用平台：Windows, macOS, Linux 
用途：
- 快速安装、运行和升级包及其依赖项。
- 在计算机中便捷地创建、保存、加载和切换环境。
如果你需要的包要求不同版本的Python，你无需切换到不同的环境，因为conda同样是一个环境管理器。仅需要几条命令，你可以创建一个完全独立的环境来运行不同的Python版本，同时继续在你常规的环境中使用你常用的Python版本。——conda官方网站
- conda为Python项目而创造，但可适用于上述的多种语言。
- conda包和环境管理器包含于Anaconda的所有版本当中。

pip

pip是用于安装和管理软件包的包管理器。 
- pip编写语言：Python。 
- Python中默认安装的版本：
  - Python 2.7.9及后续版本：默认安装，命令为pip
  - Python 3.4及后续版本：默认安装，命令为pip3
- pip名称的由来：pip采用的是递归缩写进行命名的。其名字被普遍认为来源于2处：
  - “Pip installs Packages”（“pip安装包”）
  - “Pip installs Python”（“pip安装Python”）

virtualenv

virtualenv：用于创建一个独立的Python环境的工具。 
解决问题：
- 当一个程序需要使用Python 2.7版本，而另一个程序需要使用Python 3.6版本，如何同时使用这两个程序？ 
- 如果将所有程序都安装在系统下的默认路径，如：/usr/lib/python2.7/site-packages，当不小心升级了本不该升级的程序时，将会对其他的程序造成影响。 
- 如果想要安装程序并在程序运行时对其库或库的版本进行修改，都会导致程序的中断。 
- 在共享主机时，无法在全局site-packages目录中安装包。 
virtualenv将会为它自己的安装目录创建一个环境，这并不与其他virtualenv环境共享库；同时也可以选择性地不连接已安装的全局库。

pip 与 conda 比较

依赖项检查

pip：
- 不一定会展示所需其他依赖包。
- 安装包时或许会直接忽略依赖项而安装，仅在结果中提示错误。
conda：
- 列出所需其他依赖包。
- 安装包时自动安装其依赖项。
- 可以便捷地在包的不同版本中自由切换。

环境管理

pip：维护多个环境难度较大。
conda：比较方便地在不同环境之间进行切换，环境管理较为简单。

对系统自带Python的影响

pip：在系统自带Python中包的**更新/回退版本/卸载将影响其他程序。
conda：不会影响系统自带Python。

适用语言

pip：仅适用于Python。
conda：适用于Python, R, Ruby, Lua, Scala, Java, JavaScript, C/C++, FORTRAN。

conda与pip、virtualenv的关系

conda结合了pip和virtualenv的功能。

以上内容转载自Raxxie

用virtualenv创建一个独立的python环境的基本用法
- 用pip安装virtualenv pip install virtualenv --upgrade
- 安装后创建一个工作目录，比如home下建一个tensorflow文件夹virtualenv --system-site-packages ~/tensorflow
- 然后进入该目录cd ~/tensorflow
- 激活沙箱source bin/activate
- 在里面用pip安装tensorflowpip install tensorflow

更换pip源到国内镜像

Tue, 03 Mar 2020 00:00:00 +0000

更换pip源到国内镜像

修改 pip.conf 文件

路径$HOME/.config/pip/pip.conf

没有该文件自己创建一个

常用命令

ls -a 显示所有文件（包括隐藏文件）

mkdir 创建文件夹

touch pip.conf 创建文件

vi pip.conf

pip.conf修改成

1
2
3
4


[global]
timeout = 6000
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
trusted-host = pypi.tuna.tsinghua.edu.cn

国内的其他镜像源

清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/ 阿里云 http://mirrors.aliyun.com/pypi/simple/ 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/ 豆瓣(douban) http://pypi.douban.com/simple/ 中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

Eclipse debug打断点无效

Mon, 02 Mar 2020 00:00:00 +0000

打了断点后debug无效，因为开启了 Run–>Skip All Breakpoints (忽略所有的断点)

开启后

正常情况下

GitHub Desktop无法log in的问题

Mon, 02 Mar 2020 00:00:00 +0000

错误提示

GitHub Desktop was unable to store the account token in the keychain. Please check you have unlocked access to the ’login’ keychain.

解决方法

https://github.com/desktop/desktop/blob/development/docs/known-issues.md#the-username-or-passphrase-you-entered-is-not-correct-error-after-signing-into-account---3263

锁定钥匙串，再解锁，之后输入密码，再次尝试登陆GitHub Desktop

leetcode21.合并两个有序链表

Mon, 02 Mar 2020 00:00:00 +0000

leetcode21.合并两个有序链表

Question

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/merge-two-sorted-lists 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

Java

1
2
3
4
5


public class ListNode {
 int val;
 ListNode next;
 ListNode(int x) { val = x; }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


package test001;

public class Test001 {

 public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
 if (l1 == null) {
 return l2;
 }
 else if (l2 == null) {
 return l1;
 }
 else if (l1.val < l2.val) {
 l1.next = mergeTwoLists(l1.next, l2);
 return l1;
 }
 else {
 l2.next = mergeTwoLists(l1, l2.next);
 return l2;
 }

 }

 public static void main(String[] args) {
 // TODO Auto-generated method stub
// ListNode l1 = new ListNode(1);
// l1.next = new ListNode(2);
// l1.next.next = new ListNode(4);
// 
// ListNode l2 = new ListNode(1);
// l2.next = new ListNode(3);
// l2.next.next = new ListNode(4);
// 
// Test001 test = new Test001();
// 
// 
// ListNode l3 = test.mergeTwoLists(l1, l2);
// while( l3.next!=null ) {
// System.out.println(l3.val);
// l3 = l3.next;
// }
// 
 }
}

CPP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


/**
 * Definition for singly-linked list.
 * struct ListNode {
 * int val;
 * ListNode *next;
 * ListNode() : val(0), next(nullptr) {}
 * ListNode(int x) : val(x), next(nullptr) {}
 * ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
 ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
 if (l1 == nullptr) {
 return l2;
 }

 if (l2 == nullptr) {
 return l1;
 }

 ListNode *mergeHead = nullptr;
 if (l1->val < l2->val) {
 mergeHead = l1;
 mergeHead->next = mergeTwoLists(l1->next, l2);
 } else {
 mergeHead = l2;
 mergeHead->next = mergeTwoLists(l1, l2->next);
 }

 return mergeHead;
 }
};

Attention

递归函数

两个链表头部较小的一个与剩下元素的 merge 操作结果合并

选取l1和l2中较小的一个结点，如果l1<l2, 选取l1第一个结点，并递归的调用l1第二个元素开始和l2所有剩下结点的merge操作。

如果 l1 或者 l2 一开始就是 null ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个的头元素更小，然后递归地决定下一个添加到结果里的值。如果两个链表都是空的，那么过程终止，所以递归过程最终一定会终止。

Ubuntu16.04更换软件源

Mon, 02 Mar 2020 00:00:00 +0000

Ubuntu16.04更换软件源

默认使用的官方源访问速度太慢，更换为国内的源。

阿里云源 http://mirrors.aliyun.com/ubuntu/

查看Ubuntu版本信息

lsb_release -a

Codename后即为Ubuntu代号

修改源文件 sources.list

sudo gedit /etc/apt/sources.list

sources.list原内容：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


# deb cdrom:[Ubuntu 16.04.3 LTS _Xenial Xerus_ - Release amd64 (20170801)]/ xenial main restricted

# See http://help.ubuntu.com/community/UpgradeNotes for how to upgrade to
# newer versions of the distribution.
deb http://us.archive.ubuntu.com/ubuntu/ xenial main
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial main restricted

## Major bug fix updates produced after the final release of the
## distribution.
deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates main
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates main restricted

## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
## team. Also, please note that software in universe WILL NOT receive any
## review or updates from the Ubuntu security team.
deb http://us.archive.ubuntu.com/ubuntu/ xenial universe
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial universe
deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe

## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
## team, and may not be under a free licence. Please satisfy yourself as to
## your rights to use the software. Also, please note that software in
## multiverse WILL NOT receive any review or updates from the Ubuntu
## security team.
deb http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse

## N.B. software from this repository may not have been tested as
## extensively as that contained in the main release, although it includes
## newer versions of some applications which may provide useful features.
## Also, please note that software in backports WILL NOT receive any review
## or updates from the Ubuntu security team.
deb http://us.archive.ubuntu.com/ubuntu/ xenial-backports main universe multiverse
# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse

## Uncomment the following two lines to add software from Canonical's
## 'partner' repository.
## This software is not part of Ubuntu, but is offered by Canonical and the
## respective vendors as a service to Ubuntu users.
# deb http://archive.canonical.com/ubuntu xenial partner
# deb-src http://archive.canonical.com/ubuntu xenial partner

deb http://security.ubuntu.com/ubuntu xenial-security main
# deb-src http://security.ubuntu.com/ubuntu xenial-security main restricted
deb http://security.ubuntu.com/ubuntu xenial-security universe
# deb-src http://security.ubuntu.com/ubuntu xenial-security universe
deb http://security.ubuntu.com/ubuntu xenial-security multiverse
# deb-src http://security.ubuntu.com/ubuntu xenial-security multiverse

清除后更换成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


deb http://mirrors.aliyun.com/ubuntu/ xenial main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-security main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-proposed main restricted universe multiverse
deb http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ xenial-backports main restricted universe multiverse

保存退出后更新软件列表

sudo apt-get update

进行软件更新

sudo apt-get upgrade

git-clone遇到的错误

Wed, 19 Feb 2020 00:00:00 +0000

error: RPC failed; curl transfer closed with outstanding read data remaining

慢速网络连接获取大的仓库时遇到错误,连接关闭,整个克隆被取消.解决方案是先做一个表层克隆,然后用其历史记录更新存储库,无需切换至SSH也可解决问题.

1
2
3
4
5
6
7


Cloning into 'large-repository'...
remote: Counting objects: 20248, done.
remote: Compressing objects: 100% (10204/10204), done.
error: RPC failed; curl 18 transfer closed with outstanding read data remaining
fatal: The remote end hung up unexpectedly
fatal: early EOF
fatal: index-pack failed

The idea is to do a shallow clone first and then update the repository with its history.

1
2
3


$ git clone http://github.com/large-repository --depth 1
$ cd large-repository
$ git fetch --unshallow

–depth 1的含义是复制深度为1，就是每个文件只取最近一次提交，不是整个历史版本。

leetcode12.整数转罗马数字

Wed, 19 Feb 2020 00:00:00 +0000

leetcode12.整数转罗马数字

Question

罗马数字包含以下七种字符： I， V， X， L，C，D 和 M。

字符数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。给定一个整数，将其转为罗马数字。输入确保在 1 到 3999 的范围内。

示例 1: 输入: 3 输出: “III”

示例 2: 输入: 4 输出: “IV”

示例 3: 输入: 9 输出: “IX”

示例 4: 输入: 58 输出: “LVIII” 解释: L = 50, V = 5, III = 3.

示例 5: 输入: 1994 输出: “MCMXCIV” 解释: M = 1000, CM = 900, XC = 90, IV = 4.

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/integer-to-roman 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


package test001;

public class Test001 {

 public String intToRoman(int num) {
 //由大到小降序,贪心思想
 int[] nums = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
 String[] romans = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};


 StringBuilder stringbuilder = new StringBuilder();
 int index = 0;
 while(index < 13){
 //数组下标0-12
 while(num >= nums[index]){
 //从大面值的开始
 stringbuilder.append(romans[index]);
 num = num - nums[index];
 }
 index++;
 }
 return stringbuilder.toString();
 }

 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Test001 a = new Test001();
 int b = 2;
 String c = a.intToRoman(b);
 System.out.print(c);
 }

}

Attention

我们总是希望写出来的“罗马数字”的个数越少越好，以方便表示，并且这种表示方式还应该是唯一的。贪心算法的规则是每一步都使用当前较大的罗马数字作为加法因子，最后得到罗马数字表示就是长度最少的，类似于用最少的纸币凑成一个整数。

String、StringBuffer和StringBuilder的区别

String类是不可变类，即一旦一个String对象被创建以后，包含在这个对象中的字符序列是不可改变的，直至这个对象被销毁。
StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。
StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。

在自己的方法中使用StringBuilder类: StringBuilder stringBuilder = new StringBuilder(); append()方法可扩展字符串 toString()方法可转化String类型

leetcode13.罗马数字转整数

Wed, 19 Feb 2020 00:00:00 +0000

leetcode13.罗马数字转整数

Question

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如，罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1: 输入: “III” 输出: 3

示例 2: 输入: “IV” 输出: 4

示例 3: 输入: “IX” 输出: 9

示例 4: 输入: “LVIII” 输出: 58 解释: L = 50, V= 5, III = 3.

示例 5: 输入: “MCMXCIV” 输出: 1994 解释: M = 1000, CM = 900, XC = 90, IV = 4.

来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/roman-to-integer 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

Answer

解法一:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


package test001;

import java.util.Map;
import java.util.HashMap;

public class Test001 {
 public int romanToInt(String s) {
 Map<String, Integer> map = new HashMap<>();
 map.put("I", 1);
 map.put("IV", 4);
 map.put("V", 5);
 map.put("IX", 9);
 map.put("X", 10);
 map.put("XL", 40);
 map.put("L", 50);
 map.put("XC", 90);
 map.put("C", 100);
 map.put("CD", 400);
 map.put("D", 500);
 map.put("CM", 900);
 map.put("M", 1000);

 int ans = 0;

 for(int i = 0;i < s.length();) {
 if(i + 1 < s.length() && map.containsKey(s.substring(i, i+2))) {
 //System.out.println(s.substring(i, i+2));
 //两个字符组成
 ans += map.get(s.substring(i, i+2));
 i += 2;
 } else {
 //System.out.println(s.substring(i, i+1));
 //一个字符组成
 ans += map.get(s.substring(i, i+1));
 i ++;
 }
 }
 return ans;
 }

 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Test001 a = new Test001();
 String s = "XXIV";
 System.out.println(a.romanToInt(s));
 }
}

解法二:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


package test001;

import java.util.*;

public class Test001 {
 public int romanToInt(String s) {
 int ans = 0;
 int prenum = getValue(s.charAt(0)); //记下第一位，当前位

 for(int i=1; i<s.length(); i++) {
 //从第二位开始，即往后看一位，后一位将决定当前位的符号
 int num = getValue(s.charAt(i));
 if(num > prenum) {
 //只有后一位大于当前位的时候，当前位符号为负
 ans -= prenum;
 }else{
 ans += prenum;
 }
 prenum = num; //更新当前位
 }
 ans += prenum; //只剩一个字符时直接加上
 return ans;
 }

 private int getValue(char charAt) {
 switch(charAt) {
 case'I': return 1;
 case'V': return 5;
 case'X': return 10;
 case'L': return 50;
 case'C': return 100;
 case'D': return 500;
 case'M': return 1000;
 default: return 0;
 }
 }

 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Test001 a = new Test001();
 String s = "XXIV";
 System.out.println(a.romanToInt(s));
 }
}

Attention

解法一将可能出现的一个字符或两个字符的组合存到哈希表中，分两个分支去哈希表中去找到数字累加。
解法二找到规律如下:
- VI为5+1=6，即小的数在大的数后面为加法
- IV为5-1=4，即小的数在大的数后面为减法，可以看作1的符号为负
解法二的思路是：先记录下第一位为当前位，从第二位开始到最后一位循环遍历。（注意charAt()方法下标从0开始）。往后看一位，当且仅当后一位大于当前位，当前位符号为负，注意ans加减的值为prenum即当前位。遍历完需要把最后一位num加到ans上再返回。

OOP

Tue, 18 Feb 2020 00:00:00 +0000

单选

违反了单一职责原则：greet行为和其他行为不是一个职责
违反了OCP原则：如果后续需要扩展新的类型如三角形，drawShape方法必须要修改，违反了对扩展开放对修改关闭的原则
违反了LSP原则 新增的USBDevice并没有修改已有代码，特殊进行了类型处理的Acuquire方法也是新增加的，没有违反OCP 新增加的Refresh接口并不是新的目标，没有违反SRP Acquire中，子类和父类已经处于不同的逻辑了，父类抛出异常（？？），但子类没有，违反了LSP
违反了LSP 答案说Person的id已经被Student放弃了，所以看上去二者的toString差不多，但二者的含义已经发生了变化，Student已经不能再以待Person
违反了借口可分离原则ISP，应该将Refresh方法从iDevice接口中分离出来，这样PICClient和NetworkClient就不再需要依赖于Refresh方法了 应该注意到子类继承后对Refresh方法do nothing，则Refresh可分离接口
违反了数据与行为相集中原则：当一个类的方法访问的是另一个类的数据，完全没有用到自己的数据的时候，该方法应该转移到另一个类中，不符合数据与行为相集中的原则

27题：组合优于继承原则，只是为了复用代码时，需要两个接口。Stack类包含一个LinkedList对象，然后把具体接口的实现委托给该LisnkedList对象

每次Button被presssed，根据状态调用灯Lamp.turnOn,turnOf，无法实现扩展。Lamp是具体类，需要扩展时无法满足OCP，应该建立Lamp的接口类。

尽管两个模块代码各自独立，相互之间没有导入导出，更没有互相调用。两个模块之间存在重复时，会产生重复耦合。

判断题

单一职责原则指的是一个类最好只有一个修改的原因，原因可能是承载需求，也可能是实现方面的可变更性

1
2
3
4
5
6
7
8


class A{
 private B b;
 //...
 public void f(){
 C c = b.getC();
 c.p(); //此处调用违反demeter法则
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class A{
 private B b;
 //...
 public void f(C c){
 fp();
 b.p();
 c.q();
 D d = new D();
 d.m();
 //此处包含了D的实例化，不违反demeter
 }
 private void fp(){}
}

简答题

有一个销售管理系统阶段性设计类图如下
报童辅助系统的部分设计图

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class PaperBoy{
 public void getPayment(){
 payment=2.00;
 Wallet theWallet=myCustomer.getWallet();
 if(theWallet.countMoney()>=payment){
 theWallet.subtractMoney(payment);
 }else{
 //come back later and get money
 }
 }
}

违反了迪米特法则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


class PaperBoy{
//无答案，不知道对不对
 Customer customer;
 public void getCustomer(){
 return customer.getWallet(payment);
 }

class Customer{
 Wallet wallet;
 public void getWallet(){
 return wallet.subtracMoney(payment);//调用subtractMoney方法
 }

class Wallet{
 public void countMoney(){}
 public void addMoney(){}
 public void subtractmoney(){}
}

设计图如下该方案违反了LSP原则，可以使用组合代替继承的改进方案 改进方案类图描述 class Duck has a «interface»FlyBehavior class Duck has a «interface»QuarkBehavior MallardDuck is a Duck RedHeadDuck is a Duck BubberDuck is a Duck class FlyWithWings implements «interface»FlyBehavior class FlyNoWay implements «interface»FlyBehavior class Quark implements«interface»QuarkBehavior class Squark implements«interface»QuarkBehavior 通过实现接口类中的公共方法fly()和quark()
金融系统的部分设计图 chequeAccount是信用账户，可以取款debit和还款credit mortgageAccount是按揭贷款账户，不能取款debit但是可以还款credit，还款credit需要计算利息calculateInterest 违反了LSP 修改后的设计
违反了接口分离原则 改进后
组合优于继承原则 在同时是多种子类型的情景下，继承机制是失灵的，但各种不同工作之间关于Person的功能部分又是需要复用的，这是典型的使用组合优于继承原则的场景解决方案是：新建类Job，Person聚合Job（基数0..3)，Job有三个子类Manager、Engineer和Salesman
违反了Do not repeat原则 改正方案如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


//Puzzle code
abstract class Puzzle{
 abstract int tile(int r, int c);
 //...
}
class IntPuzzle extends Puzzle{
 public int tile(int r, int c){}
 //...
}
class ArrayPuzzle extends Puzzle{
 public int tile(int r, int c){}
 //...
}

//Client code
public static void display(Puzzle p){
 for(int r=0; r<3; r++)
 for(int c=0; c<3; c++)
 system.out.printIn(p.tile(r, c));
}

IntPuzzle类和ArrayPuzzle类继承抽象类Puzzle，在Puzzle类中有一个抽象公共方法，在不同的子类中实现该方法即可实现多态

OO分析

Tue, 18 Feb 2020 00:00:00 +0000

OO分析

OO分析单选题

下面哪个符号表示异步消息
- 2

有简易顺序图如下
- 与此一致的类图是：
- 选C

有简易顺序图如下
- 与此一致的类图是：
- 选B

下图中哪一个符号表示正在处理中
- 1是对象、2是生命线、3是执行态
- 该图没有异步消息

一个company会做很多project，一个project由一个team执行，team内包括很多employee，这些employee是company的员工，哪一个类图最为合适

该图描述了一个领域
- 仅从图中的信息出发，对象A的类与对象C的类之间不应该存在关联
- vii的箭头表示返回消息
- 该图表达的交互是串行的
- viii的虚线表示对象B已被销毁
- ix和x所关联的柱状体表示对象B和C拥有控制权，正在执行中
- i所关联的元素ABC是三个类的对象
- ii、iii、iv所关联的箭头表示同步消息

依照类图

对象图如下

一些person会养animal作为pet，类图是？

给出对象图，类图是

* 第三个是正确的，别的是错的

基于以下类图，能否建立一个对象图以表达“翠花”一个girl喜欢“酸菜”boy

* 不可以

多态机制的一个好处是可以减少
- ~~关联类中的方法~~
- ~~分支和判断语句~~
- ~~需要完成同样功能的子类~~
- 整个系统的类之间的耦合

- ~~图里共有三个对象~~
- ~~图里共有四个对象~~
- ~~图里只有一个类~~
- 图里有一个匿名对象

有关类图如下，
有boy对象larry喜欢girl对象mindy，对象图如下
那么有没有可能boy对象john也喜欢girl对象mindy？
- 没有，关联的基数限定了只有一个girl对象只有一个boy对象会喜欢

参照下图，正确的是？
- CheckingAccount和SavingAccount没有关联
- CheckingAccount没有balance
- CheckingAccount不是implements BankAccount，而是继承关系
- SavingAccount无法processCheck

一个计划plan是一种特殊类型的文档

- 两个图信息一样，但下面更好。

小张和小吴分别是一个公司的财务和销售。现在该公司需要开发一个管理系统，需要登记两个人的姓名和联系方式。他们都可以登录系统处理各自业务，但因为财务比较关键，所以小张需要通过专门的授权验证才能使用系统。针对上面的描述，定义他们的抽象类。
- 用户、财务用户

设计一个动物游戏，鹦鹉parrot和企鹅penguin，他们都有相同的形状（头、身体、翅脚、尾巴），都会鸣叫，其中企鹅penguin不会飞。那么怎样建立抽象类？
- 鸟（不会飞）、鹦鹉，其中鹦鹉继承鸟，企鹅是鸟的实例对象
- ~~鸟（会飞）、企鹅，其中企鹅继承鸟，鹦鹉是鸟的实例对象~~

对现实世界进行建模时，理想的顺序是
- ~~抽象并使用类，需要的时候再列举对象~~
- 先寻找对象，再归纳类

矩形的定义class Rectangle{int width; int height}，正方形的定义class Square{int edgeSize}
- 正方形不是矩形的一种，所以可以归纳出两个无关的类，正方形square和矩形Rectangle

软件谷学院开设了java程序设计课程，王明老师进行授课，张三和李四两个学生选修了该课程。抽象出正确的类。
- 学院、课程、老师、学生

与下图一致的接口定义是？

1
2
3
4


class Order{
public OrderLine getLIneItems(Product aProduct);
public void addLineItem(Number amount, Product aProduct);
}

类图如下
- 一个人可以不被任何公司雇佣
- ~~可以有一个没有任何员工的公司~~
- 一个人可以自己雇佣自己

类图的内容包括
- 带有参数和结果的操作
- 属性及其性质
- 可见性信息
- 组成关系
- ~~事件和行为~~
- 导航信息

一个多边形有一些有序点组成，是哪种关系类型
- ~~继承（泛化Generalization）~~
- ~~关联（Association）~~
- 聚集（Aggregation）
- ~~组成（Composition）~~
一个类有许多属性
- 组成关系
一个人在一个项目上使用一种计算机语言
- 关联关系
一个文件包含很多记录
- 组成关系
一个吃饭的人拿一个叉子
- 关联
一个文件可以是普通文件或目录文件
- 继承关系
一个国家有一个首都
- 聚集关系

OO分析判断题

* ![](https://tva1.sinaimg.cn/large/0082zybpgy1gbybnjjnq2j30pn02kweo.jpg)
* 一个运动员要么属于NBA团队，要么属于NFL团队，但不能同时属于两个团队
* 组合关系决定了player只能属于一个团队

~~该类图说明至少会存在一个teenager对象和一个portable audio device对象~~
关联基数所描述的是指定一端类对象与另一端类对象的可能数量关系，但不能用于限定领域中可能存在的类对象数量

以下的类图表达了人可以拥有狗，为了进一步明确是人拥有狗而不是狗拥有人，作出修改
- 错误的是
- 这个箭头表示关联的方向
- 正确的是
- 这个箭头表达的是可见性

OO分析简答题

找出顺序图的错误并修正
- 如果需要返回消息，addStudent不应该是异步消息，应该是同步
- Queue只能返回给Section，Section再返回给Register
- 最终修改应该是addStudent和getSize都是同步消息，Queue给Section返回size，然后Section再向Register返回size

一个银行贷款申请的流程如下，建立系统顺序图描述。分析系统顺序图，说明该流程存在哪些问题，并一一修正。
1. 申请人通过互联网完成并向银行提交贷款申请
2. 该系统验证贷款申请的信息，检查是否正确和完整
3. 该系统将贷款请求转交外部信贷局，以获得申请人的信用报告
4. 该系统根据返回的信用报告计算申请人的信用评分
- 用户的刺激没有得到响应
- 验证正确和完整性后没有分支处理
- 计算信用评分后没有完成整个流程

下面是一个售货机的使用流程
1. 顾客输入商品码选择商品
2. 系统显示该商品是否有货
3. 顾客投币
4. 系统提示已投金额重复3-4步,直到所投费用超出商品价格
5. 顾客确认购买
6. 系统给顾客提供商品
7. 顾客检查商品,无误后离开
- 扩展流程
- 2a 如果商品无货
  - (1)系统通知管理员补货
  - (2)管理员确认得到消息
- 5a 顾客取消购买
  - (1)系统退还钱款
- 7a 商品有误
- (1)顾客联系管理员请求帮助
- (2)管理员告知登记码
- (3)顾客在系统中登记,等待后续人工处理

下面的图中存在哪些错误，请找出并改正

下面的顺序图存在错误，请找出并改正

操作系统知识点

Tue, 18 Feb 2020 00:00:00 +0000

死锁

死锁定义

操作系统中的死锁，指的是如果在一个进程集合中的每一个进程都在等待只能由该集合中的其他一个进程才能引发的事件，则称一组进程或系统此时发生死锁

死锁产生

死锁防止

破坏互斥条件

使资源可以同时访问而不是互斥访问

破坏占有和等待条件

静态分配

进程在执行中不再申请资源
实现简单，被许多操作系统使用的，但会严重的降低资源利用率

破坏不剥夺条件

采用剥夺式调度方法

当进程在申请资源未获得准许的情况下，如主动释放资源（一种剥夺式），然后才去等待

破坏循环等待条件

两种死锁防止方法

上述死锁防止的方法造成资源利用率和吞吐率低，两种实用的死锁防止方法

采用层次分配策略

资源被分成多个层次，当进程得到某一层的一个资源后，它只能再申请较高层次的资源
当进程要释放某层的一个资源时，必须先释放占有的较高层次的资源
当进程得到某一层的一个资源后，它想申请该层的另一个资源时，必须先释放该层中的已占资源

层次策略的变种——按序分配策略

死锁避免

银行家算法

死锁检测和解除

死锁定理

系统为死锁状态的充分条件是，当且仅当该状态的进程-资源分配图是不可完全简化的，该充分条件称为死锁定理

死锁的解除

结束所有进程的执行，重新启动操作系统
撤销陷于死锁的所有进程，接触死锁继续运行
逐个撤销陷于死锁的进程，回收其资源重新分派，直至死锁解除
剥夺陷于死锁的进程占用的资源，但不撤销他，直到死锁解除
根据系统保存的检查点，让所有进程回退，直到足以解除死锁
当检测到死锁时，如果存在某些未卷入死锁的进程，而随着这些进程执行到结束，又可能释放足够的资源来接触死锁

进程管理

进程通信

消息传递

消息传递提供了进程交互需要的同步和通信
典型的消息传递原语
- send发送消息的原语
- receive接收消息的原语
直接通信
- 对称直接寻址：发送进程和接收进程必须命名对方以便通信
- 非对称直接通信：只要发送者命名接收者，而接收者不需要命名发送者
间接通信
- 消息不是直接从发送者发送到接收者，而是发送到由4临时保存这些消息的队列组成的一个共享数据结构，这些队列通常称为信箱mailbox

管道和套接字

管道和套接字都是基于信箱的消息传递方式的一种变体

文件管理

文件系统

文件系统是操作系统中负责存取和管理信息的模块，它用统一的方式管理用户和系统信息的存储、检索、更新、共享和保护，并为用户提供一整套方便有效的文件使用和操作方法
文件的逻辑结构和物理结构
- 逻辑结构
  - 对于用户来说，可以按照需要并遵循文件系统的规则定义文件信息的逻辑结构，有文件系统提供“按名存取”来实现对文件信息的存储和检索
  - 对于系统来说，必须采用特定数据结构和有效算法，实现文件的逻辑结构到存储结构的映射，实现对文件存储空间和文件信息的管理，提供多种存取方法

文件

文件的概念
- 文件是由文件名字表示的一组信息的集合，文件名字是字母或数字组成的字母数字串，他的格式和长度因系统而异
目录文件
- 目录文件是由文件目录构成的用来维护文件系统结构的系统文件，普通文件的查找依赖于目录文件

文件的存取

顺序存取

对固定长记录的顺序文件采用随机访问
对可变长记录的顺序文件，分两步

直接存取

文件可看作由顺序编号的物理块组成，这些物理块划成等长，作为定位和存取的最小单位

索引存取

基于索引文件的索引存取方法

文件目录

Linux系统的FCB中的文件名和其他管理信息分开，其他信息单独组成一个数据结构，称为索引结点inode，此索引结点在磁盘上的位置由inode号标识
- 磁盘inode记录文件的属性和相关信息，在内存区开辟一张活动inode表，磁盘inode反映文件静态特性，活动inode反映文件动态特性

文件的存储

文件的逻辑结构

文件组织指文件中信息的配置和构造方式，应该从文件的逻辑结构和组织及文件的物理结构和组织两方面考虑
文件的逻辑结构和组织是从用户观点出发，研究用户概念中的信息组织方式，这是用户能观察到，可加以处理的数据集合

流式文件

流式文件指文件内的数据不再组成记录，只是一次的一串信息集合，称为字节流文件

记录式文件

记录式文件包含若干逻辑记录，逻辑记录式是文件中按信息在逻辑上的独立含义划分的信息单位
域field是基本数据单元
记录record是一组相关的域的集合，它可以看作是应用程序的一个单元
文件file是一组相似记录的集合
数据库database是一组相关的数据集合
- database自身是由一种或多种类型的文件组成的

记录式顺序文件

记录式索引文件

这种文件使用索引表，表项包含记录键和索引指针
提供的系统调用有getrecord()、putrecord()

成组和分解

成组操作
- 若干逻辑记录合并成一组
分解操作
- 当存储介质上的一个物理块读进系统输入缓冲区后，把逻辑记录从块中分离出来的操作
块因子：每块中的逻辑记录的个数

文件的物理结构

文件的物理结构和组织是指逻辑文件在物理存储空间中存放方法和组织关系
第一类计算法
- 设计映射算法，通常用线性计算法、杂凑法等，通过对记录键对计算转换成对应的物理地址，从而找到所需记录
- 直接寻址文件、计算寻址文件、顺序文件均属此类，计算法的存取效率高
第二类指针法
- 设置专门指针，指明相应记录的物理地址或表达各记录之间的关联
- 索引文件、索引顺序文件、连接文件均属此类

顺序文件（连接文件）

连接文件（串联文件）

直接文件（哈希文件）

设备管理

I/O控制方式

程序控制I/O（轮询方式）

处理器代表给I/O模块发送一个I/O命令，该进程进入忙式等待，等待操作的完成，然后才可以继续操作

中断驱动I/O

处理器代表进程向I/O模块发出一个I/O命令，然后继续执行后续指令，等I/O模块完成工作后，处理器被该模块中断
如果该进程不需要等待I/O完成，则后续指令可以仍是该进程中的指令，否则，该进程在这个中断上挂起，处理器执行其他操作

直接存储器访问DMA

一个DMA模块控制主存和I/O，模块之间的数据交换。为传送一块数据，处理器给DMA模块发送请求，只有当整个数据块传送结束后，处理器才被中断

通道方式

为获得CPU和外围设备更高的并行工作能力，引入通道
CPU在执行主程序时遇到I/O请求，它启动指定通道上选址的外围设备，一旦启动成功，通道开始控制外围设备进行操作。CPU就可执行其他任务并与通道并行工作，直到I/O操作的完成。通道发出操作结束中断，CPU才停止当前工作，转向处理I/O操作结束事件
CSW通道状态字
- 通道状态字是存放在内存固定单元的控制字，专门用于记录通道和设备执行操作的情况
CAW通道地址字
- 通道地址字是存放在内存固定单元的控制字，专门用于存放通道程序首地址

虚拟设备

虚拟设备
- 虚拟设备是使用一类物理设备模拟另一类物理设备的技术
- 通常是使用共享型外围设备模拟独占型外围设备

SPOOLing设备

井是用作缓冲的存储区域
预输入程序
- 操作系统将一批作业从输入设备上预先输入到磁盘的输入缓冲区中暂时保存，这称为“预输入”，此后，由作业调度作业执行，作业使用数据时不必再启动输入设备，只要从磁盘的输入缓冲区中读入
缓输出程序
- 作业执行中不必直接启动输出设备，只要将作业的输出数据暂时保存到磁盘的输出缓冲区，当作业执行完毕后，由操作系统组织信息成批输出
井管理程序

I/O设备管理的实现和层次

I/O软件

把软件组织成一种层次结构，底层软件用来屏蔽硬件的具体细节，高层软件则主要向用户提供一个简洁、规范的界面
解决的问题
- 设备无关性
- 出错处理
- 同步（阻塞）——异步（中断驱动）传输
- 独占型外围设备和共享型外围设备

I/O软件的层次

用户层I/O软件

进行I/O调用；格式化I/O；SPOOLing

与设备无关的操作系统I/O软件

命名；保护；阻塞；缓冲；分配

设备驱动程序

建立设备寄存器；检查状态

I/O中断处理程序（底层）

执行I/O操作

计算机网络知识点

Tue, 18 Feb 2020 00:00:00 +0000

概述

服务与协议
- 协议是水平的，即协议是控制对等实体之间通信的规则
- 服务是垂直的，即服务是下层向上层通过层间接口提供的。并非在一个层内完成的全部功能都称为服务，只有那些能够被高一层看得见的功能才能称之为“服务”
==服务的三种类型==
- 面向连接的服务和面向无连接的服务
  - 面向连接服务：当通信双方通信时，要事先建立一条通信线路，该线路包括建立连接、使用连接和释放三个过程
  - 面向无连接服务：通信双方不需要事先建立一条通信线路
- 可靠服务和不可靠服务
  - 可靠服务：提供纠错、检错、应答机制，能保证数据正确、可靠地传送到目的地
  - 不可靠服务：不能保证数据正确、可靠的传送到目的地
- 应答和无应答服务
SAP
- service access point/服务访问点
- 同一节点相邻两层交换信息的连接点
SDU
- 服务数据单元
- 为完成用户所要求的功能而应传送的数据
PCI
- 协议控制信息
- 控制协议操作的信息
PDU
- 协议数据单元Protocol DataUnit
- 指对等层次之间传递的数据单位
  - 物理层的PDU是数据位bit
  - 数据链路层的PDU是数据帧frame
  - 网络层的PDU是数据包packet
  - 传输层的PDU是数据段segment
  - 其他更高层次的PDU是报文message
==OSI七层模型==
开放系统互连OSI是网络中两个最终用户之间通信的标准参考模型，将整个网络按照功能分成七层，上面四层用于将信息传入主机。要传入主机的信息需要通过上面四层，要传入其他主机的信息不需要通过上面四层，而是传入另一个主机。
应用层、表示层、会话层、传输层为资源子网，网络层、数据链路层、物理层为通信子网
- 物理层
  - 在设备之间传输比特bit；定义电压、线速、针脚等物理规范
- 数据链路层
  - 把字节性质的包组成帧；根据MAC地址提供对传输介质的访问；实行错误检测，但不实行错误更正
- 网络层
  - 提供逻辑地址，用于routers的路径选择
- 传输层
  - 提供可靠和不可靠的数据传递；在错误数据重新传输前对其进行更正
- 会话层
  - 建立会话，分割不同应用程序的数据
- 表示层
  - 表述数据；对数据的操作诸如加密、压缩等
- 应用层
  - 提供用户接口
==TCP/IP四层模型==
- 网络接口层
- 网际层
- 传输层
- 应用层
  - 会话层+表示层+应用
==五层模型==
- 物理层
- 数据链路层
- 网络层
- 传输层
- 应用层
==层次模型的好处==
- 降低复杂度
- 灵活性好
- 易于实现和维护
- 促进标准化工作

物理层

==六种通信方式==
- 单工
  - 单向信号只可以在一个方向上传播（飞机）
- 半双工
  - 信道可以双向传播，但不能同时传播
- 全双工Full Duplex
  - 全双工通信是指数据可以同时沿相反的两个方向传送，因此又被称为双向同时通信
物理层四个特性（谢希仁38）
数字信号和模拟信号
常用编码方式
- 曼彻斯特编码
- 差分曼彻斯特编码
==物理层五种数据传输方式==
- 电路交换（面向连接）
- 报文交换
- 分组交换
报文和分组的区别
- 报文：要发送的完整数据
- 分组：将报文分割成较短的分组
面向连接的虚电路和无连接的数据报方式
物理层传输介质
- STP（屏蔽双绞线）
- 集线器：多端口中继器
- UTP（无屏蔽双绞线）：电磁干扰能力

数据链路层

LLC逻辑链路控制+MAC媒体访问控制子层
==数据链路层的功能==
- 为网络层提供服务
  - 无确认的无连接
  - 有确认的无连接
- 链路管理
- 帧定界
- 帧同步
- 组帧
- 透明传输
  - 无论数据是什么样的比特组合，都应该能在链路上传送
- 差错控制
  - 常见的差错控制方式
    - 奇偶校验吗
    - 通过接收方请求发送方重传出错的数据帧来恢复出错帧
- 流量控制
  - 停止-等待流量控制
  - 滑动窗口流量控制
- 可靠传输
  - AAQ（自动重传请求）
    - 停止协议
    - GFN
    - SEO
- 介质访问控制
  - 信道划分
    - FDM（频分多路复用）
    - STDM（统计时分多路复用）
    - WDM（波分多路复用）
    - CDM（码分多路复用）
    - TDM（时分多路复用）
  - 随机访问
    - 纯ALOHA协议
  - 轮询访问
==WAN（广域网）==
- 覆盖范围很广的长距链路层协议，应用于直接连接在两个节点的链路上，用来通过拨号或者专线方式建立点对点连接发送数据
==广播网相关协议==
- ==HDLC（高级数据链路控制协议）==
  - 面向比特的互连成的计算机网络，采用广播技术
- ==PPP（点对点协议）==
  - 面向字节，由具有存储转发功能的结点交换机和连接链路组成，采用交换技术
==LAN（局域网）==
==数据链路层设备及特点==
- 网桥
  - 用于连接多个以太网（局域网）
- 交换机
  - 多端口网桥
==STP生成树协议==
- 该协议可应用于在网络中建立树形拓扑，消除网络中的环路
- STP的基本原理
  - 通过在交换机之间传递一种特殊的协议报文，网桥协议数据单元BPDU（Bridge Protocol Data Unit），来确定网络的拓扑结构
==CSMA/CD==
- 带冲突检测的载波监听多路访问技术（载波监听多点接入/碰撞检测
- 先听后发，边听边发，冲突停止，随机重发
==BPUD网桥协议数据单元==
- 交换机之间使用BPDU来交换STP信息

网络层

IP地址
- A类地址0-127
- B类地址128-191
- C类地址192-223
==路由算法==
- 静态路由
  - 手动配置路由
- 动态路由
  - 通过路由交换的信息来构造路由表
==ARP地址解析协议==
- ARP用于解决同一个局域网上的主机或路由器的IP地址到MAC地址的映射问题
- RARP
  - 反向地址转换协议
  - 允许局域网的物理机器从网关服务器的ARP表或缓存上请求其IP地址
ICMP
IGMP
CIDR
==DHCP（动态主机配置协议）==
- 是一个局域网的网络协议，使用UDP协议工作，主要有两个用途：给内部网络或网络服务供应商自动分配IP地址，给用户或者内部网络管理员作为对所有计算机作中央管理的手段
RIP
==OSPF（开放式最短路径优先）==
- 是一个内部网关协议IGP（Interior GatewayProtocol），用于在单一自治系统AS内决策路由
VPN
NAT
NAPT
==避免路由环路的技术==
- 定义最大值
- 水平分割技术
- 路由中毒
- 反向路由中毒
- 控制更新时间
==两种解决距离矢量协议中回路问题的技术==
- 水平分割splithorizon
  - 是一种避免路由环路的出现和加快路由汇聚的技术
  - 由于路由器可能收到他自己发送的路由信息，而这种信息是无用的，水平分割技术不反向通告任何从终端收到的路由更新信息，而只通告那些不会由于计数到无穷而清除的路由
  - 原理：路由器从某个接口接收到的更新信息不允许再从这个接口发回去
  - 优点：能够阻止路由环路的产生
  - 减少路由器更新信息占用的链路带宽资源
- 毒性逆转Poisoned Reverse
  - 实际上是一种改进的水平分割
  - 原理：路由器从某个接口上接收到某个网段的路由信息后，并不是不往回发送信息了，而是发送，只不过是将这个网段的跳数设为无限大，再发送出去。收到此种的路由信息后，接受方会立刻抛弃该路由，而不是等待其老化时间到（Age Out），这样可以加速路由的收敛

传输层

socket
- 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket
==TCP流量控制==
- 链路层的流量控制和传输层的流量控制区别是什么
  - 链路层的流量是根据分配的带宽由路由器、交换机等网络设备控制的
  - 传输层的流量控制是用户电脑为了保证传输质量而由电脑操作系统控制的
  - 传输层流量受链路层流量的影响
==TCP的拥塞控制==
- 慢开始和拥塞避免
- 快重传
- 快恢复
- 随机早期检测RED
==TCP链接管理==
- 简述TCP链接建立过程
- 简述TCP链接释放过程

应用层

==DNS==
- Domain Name System域名系统
- 因特网上作为域名和IP地址相互映射的一个分布式数据库，能够使用户更方便的访问互联网，而不用去记住能够被机器直接读取的IP数串
==域名解析过程和具体步骤==
- 当客户机提出域名解析请求，并将该请求发送给本地的域名服务器
- 当本地的域名服务器收到请求后，先查询本地的缓存，如有该记录项，则本地的域名服务器就直接把查询的结果返回
- 如果本地的缓存中没有该记录，则本地域名服务器就直接把请求发给根域名服务器，然后根域名服务器再返回给本地域名服务器一个所查询域（根的子域）的主域名服务器的地址
- 本地服务器再向上一步返回的域名服务器发送请求，接受请求的服务器查询自己的缓存，如果没有该记录，则返回相关的下级的域名服务器的地址
- 重复第四步，直到找到正确的记录
- 本地域名服务器把返回的结果保存到缓存，以备下一次使用，同时还将结果返回给客户机

名词解释

TCP/IP
- 传输控制协议/因特网互联协议，又名网络通信协议，是internet最基本的协议、internet国际互联网的基础。由网络层的IP协议与传输层的TCP协议组成。
- TCP/IP定义了电子设备如何连入因特网，以及数据如何在他们之间传输的协议。TCP/IP是一个协议族，是因为TCP/IP包括了TCP、IP、UDP、ICMP、RIP、TELNETFTP、SMTP、ARP、TFTP等许多协议，这些协议一起称为TCP/IP协议
RIP 是一种内部网关协议IGP，是一种动态路由选择协议，用于自治系统内的路由信息的传递，RIP协议基于距离向量算法，使用“跳数”即metric来衡量到达目标地址的路由距离
NAT
- 网络地址转换，允许把一个整体机构以一个公用IP地址出现在因特网上。它是一种把内部私有网络地址转换成合法网络IP地址的技术
DNS
- Domain name system域名系统，万维网上作为域名和IP地址相互映射的一个分布式数据库，能够使用户更方便的访问互联网，而不用去记住能够被机器直接读取的IP数串
FTP
- 用于Internet上控制文件的双向传输。同时它也是个应用程序，基于不同的操作系统有不同的FTP程序，这些所有的应用程序都遵循同一种协议以传输文件
ICMP
- 网际控制报文协议，允许主机发送错误报告
SMTP
- 简单邮件传输协议，用于传输电子邮件，采用推方式
ARP
- 地址解析协议，从IP地址中映射MAC地址
TCP
- 传输控制协议，可靠的，面向连接的，基于字节的传输层控制层传输协议
HTTP
- 超文本传输协议，使用TCP进行可靠传输，万维网客户程序和服务程序之间必须严格遵守
Split horizon
RARP
Time division multiplexing
PPP
CSMA/CD

问答题

简述三次握手过程并说明为什么要进行第三次握手
- 第一次握手：建立连接时，客户端发送syn包（syn=j）到服务器，并进入SYN-SEND状态，等待服务器确认。SYN：同步序列编号
- 第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个syn包（syn=k），即SYN+ACK包，此时服务器进入SYN-RECV状态。
- 第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK（ack=k+1），此包发送完毕客户端和服务器进入ESTABLISHED状态，完成三次握手。
- 第三次握手是为了保证信息传达的准确性，确保信息没有丢失，之间的连接依然通畅。
比较RIP和OSPF的区别
- RIP是一种分布式的基于距离向量的路由选择协议
- OSPF是一种分布式的基于链路状态的路由选择协议
- RIP
  - 仅相邻的路由器交换状态；
  - 路由器交换的信息是当前路由器所知道的全部信息，即路由表；
  - 按照固定的时间间隔交换路由信息；
- OSPF
  - 向本自治系统的所有路由器发送信息，发送的信息是与本路由器相邻的所有路由器的链路状态，即本路由器周边的网络拓扑；
  - 只有当链路状态发生改变时，路由器才向所有的路由器用洪泛发发送信息
- RIP
  - 在RIP中，每个路由器只知道到所有路由器的距离以及下一跳路由器，不知道全网的拓扑结构，且由于所处位置不同，每个路由器的路由表不同；
  - 发生网络故障时，要经过较长时间才能将此信息传送给所有路由器，即“好消息传得快，坏消息传得慢”
- OSPF
  - 在OSPF中，由于交换的信息是相邻的路由器的链路状态，故每一个路由器都能建立起一个链路状态数据库（即全网的拓扑结构），该数据库在全网范围内是一致的（这称为“链路状态数据库的同步”）
  - OSPF中，链路数据库能较快的更新，故OSPF的更新过程收敛快
- RIP协议使用运输层的用户数据包UDP进行传送，OSPF直接使用IP数据报传送
- TCP/IP协议分为哪几层，各层分别有什么功能
  - 网络接口层
    - 从主机或结点上接受IP分组，并把它们发送到指定的物理网络上
  - 网络层
    - 处理数据路由，进行路由转发
  - 传输层
    - 为端到端通信提供可靠服务
  - 应用层
    - 提供用户与网络的界面，包含所有高层协议
- 试说明某些场景下使用静态路由协议
  - 静态路由是指网络管理人员手工配置的路由信息
  - 静态路由算法的优点是简便、可靠，在负荷稳定、拓扑变化不大的网络中运行的效果很好，故仍广泛应用于高密度安全性的军事系统和较小的商业网络
- 试描述单域OSPF的工作过程
  - OSPF开放式最短路径优先
    - 向自治系统内所有路由发送信息，使用洪泛法，此信息包含自身与相邻路由表
    - 当链路状态发生变化时，路由器使用洪泛法向所有路由发送信息
- 试述具有五层协议的网络体系各层的主要功能
  - 应用层
    - 直接为用户的应用程序提供服务
  - 传输层
    - 向上一层进行通信的两个进程之间提供一个可靠的端到端的服务，使他们看不见传输层以下的数据通信的细节
  - 网络层
    - 选择合适的路由，使发送站的传输层所传下来的数据报能够正确的按照地址找到目的站，并交付给目的站的传输层
  - 数据链路层
    - 在两个相邻结点的线路无差错的传送以帧为单位的数据，所有数据包括数据和必要的控制信息
  - 物理层
    - 透明的传输比特流，物理层还要确定电接电缆插头的定义

模块化

Tue, 18 Feb 2020 00:00:00 +0000

单选

Receiver.message和MyType.doSomethingForMe方法数据耦合
最好的内聚是功能内聚、信息内聚
- 通信内聚：可接受无法避免，与步骤有关且这些操作都在相同的数据上进行
最好的耦合是数据耦合
Process_customer_record与Calculate_sales_tax之间是数据耦合
valide_checkout——request和valid方法之间是控制耦合：一个模块给另一个模块传递控制信息
TightCoupling.showWelconMsg和TightCoupling2.TightCoupling2两个方法之间是控制耦合：GE不是实际的数据，是控制信号，所以是控制耦合，不是印记耦合，印记耦合是共享一个数据结构，但只用了其中一部分
Process_input_code与Choose_appropriate_Action方法之间是控制耦合
validate_checkout_request和valid_month 之间是印记耦合
WorkItem.notice与Emailer.sendEmail之间是印记耦合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


Class Employee{
 private int id;
 private String name;
 private String email;
 //...
}
Class WorkItem{
 private Employee leader;
 private String description;
 private Emailer email;
 //...
 public notice(){
 //...
 email.sendEmail(leader,description);
 //...
 }
}
Class Emailer{
//Emailer只使用了Employee传递的部分数据，所以是印记耦合
 public void sendEmail(Emoloyee e,String text){
 EmailerService.send(e.getName(),e.getEmail(),text);
 }
 //...
}

Log.notice与Email.sendEmail之间是数据耦合

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


Struct User{
 String name;
 String email;
}
Class Log{
 private User user;
 private Emailer email;
 //...
 public notice(){
 //...
 email.sendEmail(user,message);
 //...
 }
}
Class Emailer{
 public void sendEmail(user a, String text){
 EmailerService.send(u.name,u.email,text);
 }
 //...
}

印记耦合：传递的数值是三个数据，只用了两个
印记耦合：传递的list中，topTen只使用了前十个，其他都是多余数据，所以是印记耦合
公共耦合：不能接受，模块之间共享全局变量，这两个方法之间共享了数据checkout_data
公共耦合：两个方法共享了x变量，所以是公共耦合
公共耦合：共享了sales_tax变量
公共耦合：两个方法公共使用了同一个文件customer record
公共耦合：**两个类共享了同一个变量todaysDow **
内容耦合：Arch.slant访问了Vector3D的内部的xy，所以是内容耦合
内容耦合：一个类中的方法访问另一个类的内部
内容耦合：SneekyModifier访问了Person的内部成员变量，所以是内容耦合
内部类访问外部类的成员变量，是内容耦合。内部类一般都与外部类构成内容耦合，但是是一种受限和特殊标记的内容耦合
功能内聚的要求是一个模块只能有一个目标
通信内聚是可接受无法避免的，操作与步骤有关，且这些操作都在相同的数据上进行
计算total_purchases，再基于total_purchases计算sales_tax，再基于total_purchases和sales_tax计算amount_due，构成了明显的问题解决过程，所以是过程内聚。同时几个行为都使用了total_purchases，这种使用相同数据的行为是通信内聚。即是过程又是通信的，所以是顺序内聚
功能内聚
两种目的构成了处理的先后顺序，是过程内聚
再同一时间**（初始化时）执行了多个不同目的的活动，是时间内聚**
逻辑内聚：基于switch对参数的判定执行不同的功能路径是典型的逻辑内聚，这些不同路径之间是完全不同的事情，他们之前只是相似而已

1
2
3
4
5
6
7


Read_all_files(file_code)
 switch(file_code)
 case 1:
 case 2:
 case 3:
 ENDSWITCH
END

整个方法只有一个目标为功能内聚
通信内聚：都是为了处理error_flag、error_massage和error_report，所以是相同的数据，属于通信内聚
三个职责都使用相关的数据connection，所以是通信内聚。行为包括，获得get和释放release connection；得到connection的统计数据、持久化使用数据（requested、released）
过程内聚：该方法是典型的过程三段式：初始化、数据处理、输出（打印）
逻辑内聚：从代码上看，sample是把逻辑相似但目的不同的多个片段组合在了一起，然后通过flag选择实际的执行路径。典型的逻辑内聚
偶然内聚：电梯类如下，行为之间没有明显的绑定因素。
偶然内聚；顾客的四个行为：租借、付费、建立界面编辑顾客信息、保持数据
utils、tools等公用代码库往往是偶然内聚的，他们可能就是把多个独立函数封装在一起而已，这些函数之间没有什么联系

多选题

偶然内聚和逻辑内聚是非常不理想的，应该避免使用
方法Method、包Package、类Class都可以被看作是模块化中的模块，从而适用高内聚、低耦合设计思路。模块是代码段，包、类和方法都包含了一个代码段，语句块虽然也包括了代码段，但语句块是基于控制结构的，不适用内聚耦合思想。界面、数据库、网络节点等都不表现为代码段，所以不能算是模块。
哪些联系会产生耦合
- 类A继承B
- 类A访问B的成员变量
- 类A包含B
- 方法f调用方法q
- 方法f和方法q访问同一个公共数据
类A和类B都包含类C不产生耦合、方法f和方法q调用同一个方法m不产生耦合
高内聚低耦合的模块化方法是为了易修改、易理解、易复用
模块化追求的效果是
- 理解一个模块非常简单、清晰
- 一个模块显而易见的正确
- 修改一个模块不会对外产生连锁反应
模块性能优异、可靠性高；模块是黑盒、安全性高不是模块化追求的效果

判断题

模块化的本质是如何高质量的把一段复杂代码分割成多个简单片段
内聚服从于耦合，高内聚是为了实现低耦合
耦合是指两个模块之间存在着连接，体现为底层命令的指令地址转换、数据标识访问等
时间内聚基于相同的时间，过程内聚基于相同的问题，通信内聚基于相同的数据，所以他们之间的内聚强度没有本质上的差别，都是可以接受的
**功能分解的方式能够提升内聚，但并不一定能降低耦合。**高内聚要从属于低耦合，低耦合才是设计的第一准则，所以按照功能分解并不是最佳的设计方式
**区分控制耦合和数据耦合的关键是区分数据和控制信号。**数据是有实际意义的信息，控制信号是人为设置的标记。
flag标志是控制信号，但只有控制信号影响了被调用者执行路径分支选择的情况下，才是控制耦合。如果q只是简单加工flag标志，没有因为flag影响执行路径，就不构成控制耦合。
公共耦合是指共享了相同的外部环境，包括数据、文件、设备等，但第三方模块不属于公共环境。

软工知识点

Tue, 18 Feb 2020 00:00:00 +0000

SE概论

SE基础

SE定义

应用系统的、规范的、可量化的方法来开发、运行和维护软件，即将工程应用到软件
对1）中各种方法的研究

科学与工艺的区别

科学是运用范畴、定理、定律等思维形式反映现实世界各种现象的本质规律的知识体系。
- 它重在把握事物的规律性，并按照这些固定的规律指导活动顺利和正确进行
工艺是在科学王国之外依赖于人类天性和创造性的知识
- 没有什么固定的规律，但是人们在长期的实践活动中却可以发现和总结出一些经验，他们被称为实践方法或原则

软件开发活动

主要活动包括：需求开发、软件设计、软件构造、软件测试、软件交付与维护

需求开发

主要制品：
- 软件需求规格说明书SRS
- 需求分析模型

软件设计

主要制品：
- 软件设计描述SDD文档
- 软件设计模型

软件构造

软件测试

软件交付与维护

软件开发过程

####过程模型

重量级过程方法RUP（Rational Unified Process）
- RUP的思想是在一个基本的过程框架下组织和使用最佳实践方法，强调在基本过程框架和最佳实践方法的基础上进行过程定制与裁剪，RUP还拥有全程的软件过程工具支持
轻量级过程方法
- 极限编程XP
- 特征驱动开发
- 敏捷agile方法

过程改进

为了在评价一个企业软件能力成熟度的基础之上，指导企业改进软件过程，提升过程管理能力，CMU SEI将SW-CMM改进为CMMI
五个等级

能力成熟度模型CMM

CMM有助于建立一个有规律的、成熟的软件过程，CMM策略力图改进软件过程的管理，而在技术上的改进是其必然的结果
CMM为软件的过程能力提供了一个阶梯式的框架，它基于以往的软件工程的经验教训，提供了一个基于过程改进的框架图
CMMI
- CMM模型在软件开发中的应用有时会出现问题，形成能力成熟度模型集成CMMI项目是为了解决使用多个模型进行软件开发过程的问题，因此CMMI模型已经取代了CMM模型
成熟度的五个等级
- 初始级Initial
  - 无序的、甚至是混乱的
- 管理级（可重复级）Repeatable
  - 有纪律的
- 定义级Defined
  - 标准、一致的过程
- 定量管理级Managed
  - 度量的和可预测的
- 优化级Optimizing
  - 预防过程和产品缺陷，关注于过程持续改进

软件开发过程模型

软件开发的典型阶段

软件开发的典型阶段有
- 软件需求工程
- 软件设计
- 软件构造
- 软件测试
- 软件交付与软件维护
软件需求工程可以进一步划分为两个阶段
- 系统需求开发
  - 系统需求开发是为了获得整个系统的期望目标（即完成业务需求处理），整个系统包括软件系统、硬件系统和人力配置
- 软件需求开发
  - 软件需求开发是以承载的系统需求为出发点，建立软件系统的解决方案，使其满足系统的需求

软件生命周期模型

典型的软件生命周期模型是 * 需求工程、软件设计、软件实现、软件测试、软件交付、软件维护

软件过程模型

与简略的软件生命周期模型不同，软件过程模型可以被看作是网络化的活动组织
软件过程模型是对软件生命周期模型更详细哼准确的描述

构建-修复模型

特点
- 没有考虑最基本的生命周期
- 没有对需求真实性、设计结构重量、代码组织质量、质量保障等软件开发的复杂因素进行关注点分解处理

瀑布模型

瀑布模型按照软件生命周期模型将软件开发活动组织为需求开发、软件设计、软件实现、软件测试、软件交付和软件维护等基本活动，并规定它们自上而下、相互衔接的次序，按照“从一个阶段到另一个阶段的有序的转换序列”的方式来组织开发活动
允许活动出现反复和迭代
特点
- 要求每个活动的结果必须要进行验证
- 重视模型与文档
- 文档驱动
局限性
- 对文档的期望过高
- 对开发互动的线性顺序假设
- 客户、用户参与不够
- 里程碑粒度过粗
  - 要求一个阶段完成之后才进行验证
特定情况下使用瀑布模型
- 需求成熟稳定，没有不确定的内容，也不会变化
- 所需技术成熟可靠，没有不确定的技术难点
- 复杂度适中，不至于产生太大的文档负担和过粗的里程碑

增量迭代模型

迭代式、渐进交付和并行开发共同促使了增量迭代模型的产生和普及
增量迭代模型在项目开始时，通过系统需求开发和核心体系结构设计活动完成项目对前景和范围的界定，然后再将后续开发活动组织多个迭代、并行的瀑布式开发活动
实际开发中，第一个迭代完成的是产品的核心部分，满足基本需求，但是很多附带特性需要后续迭代完成
需求驱动的

演化模型

与增量迭代模型相比
- 相同点是它们都使用迭代式组织开发活动并且都适合大规模软件开发
- 不同点是增量迭代模型适用于比较成熟、稳定的领域，而演化模型主要用在需求变更比较频繁或不确定性较多的领域
初始开发迭代中，主要任务是澄清和明确系统的核心需求，建立和交付核心系统
需求驱动的
特点
- 使用了迭代式开发
- 并行开发
- 渐进交付

原型模型

螺旋模型

基本思想是尽早解决比较高的风险
风险驱动的
风险解决的基本思路是：
- 确定目标、解决方案和约束
- 评估方案、发现风险
- 寻找风险解决方法
- 落实风险解决方案
螺旋模型是风险解决迭代和瀑布模型的综合
特点
- 可以降低风险，减少项目因风险造成的损失
- 缺点是由于原型自身带来的风险

Rational统一过程

RUP（Rational Unified Process）
二维坐标描述
- 横轴是时间，是过程展开的生命周期特征，体现开发过程的动态结构
- 纵轴是内容，自然的逻辑活动，体现开发过程的静态结构
RUP没有使用经典的软件生命周期，而是把软件开发的生命周期定义为
- 初始
  - 初始阶段定义项目前景、范围和业务用例
- 细化
  - 细化阶段设计软件体系结构、构建核心体系结构原型
- 构造
  - 构造阶段完成软件系统的详细设计和实现
- 交付
  - 交付阶段将软件产品交付给用户
- 核心实践方法——体现了RUP的基础思想
  - 迭代式开发
  - 管理需求
  - 基于组件
  - 可视化建模
  - 验证软件质量
  - 控制软件变更
- RUP是重量级过程

敏捷过程

敏捷思想——价值观
- 个体和互动高于流程和工具
- 工作的软件高于详尽的文档
- 客户合作高于合同谈判
- 响应变化高于遵循计划
敏捷开发以用户的需求进化为核心，采用迭代、循序渐进的方法进行软件开发
- 在敏捷开发中，软件项目在构建初期被切分成多个子项目，各个子项目的成果都经过测试，具备可视、可集成和可运行使用的特征。
- 换言之，就是把一个大项目划分成多个相互联系，但也可独立运行的小项目，并分别完成，在此过程中软件一直处于可使用状态

项目启动

项目管理基础

软件项目管理

软件项目管理包括项目启动、项目计划、项目执行、项目跟踪与控制、项目收尾5个过程组

团队组织与管理

团队定义

为了一致的目的、绩效标准、方法而共担责任并且技能互补的少数人
特点
- 有共同的目标
- 共担责任
- 技能互补
- 小规模团体
- 有明确的结构

几种典型的团队结构

主程序员团队
民主团队
- 敏捷开发
开放团队
- 黑箱管理方式

团队建设

建立团队章程
持续成功
和谐沟通
避免团队杀手

软件质量保障

软件质量

质量属性

人们通常会使用选用系统的某些质量要素进行量化处理，建立质量特征，这些特征被称为质量属性
为了根据质量属性描述和评价系统的整体质量，人们从很多质量属性的定义中选择一些能够相互配合，相互联系的特征集，被称为质量模型
常见的质量模型
- 功能性
  - 完备性、正确性、安全性、兼容性、互操作性
- 可靠性
  - 无缺陷性、容错性、可用性
- 易用性
  - 可理解性、易学习性、可操作性、通信性
- 效率
  - 时间经济型、资源经济性
- 可维护性
  - 可修正性、扩展性、可测试性
- 可移植性
  - 硬件独立性、软件独立性、可安装性、可复用性

质量保障

质量验证的方法：评审、测试和质量度量三种
主要质量保障活动

里程碑	质量保障活动
需求开发	需求评审、需求度量
体系结构	体系结构评审、集成测试
详细设计	详细设计评审、设计度量、集成测试
实现（构造）	代码评审、代码度量
测试	测试、测试度量

软件配置管理

配置管理定义
- 用技术的和管理的指导和监督方法，来标识和说明配置项的功能和物理特征，控制对这些特征的变更记录和报告变更处理及其实现状态，并验证与需求规格的一致性
- 配置管理通过将软件开发的重要制品及其变更纳入管理和监控，保证了在不影响开发活动协同的情况下有效处理变更
配置项
- 需要配置管理的软件开发制品，包括最终制品和中间制品，都成为配置项
基线
- 经过了评审和验证，可以作为后续开发工作基础而进入协同工作过程，需要纳入配置管理和执行变更控制的制品称为该配置项的基线
- 基线的建立意味着一个里程碑，标志着生产基线制品活动的成功结束和后续协同开发活动的开始
- IEEE定义：已经经过正式评审的规格说明或制品，可以作为进一步开发的基础，并且只有通过正式的变更控制过程才能变更
配置管理活动
- 标识配置项
- 版本管理
- 变更控制
- 配置审计
- 状态报告
- 软件发布管理

需求开发阶段

需求工程基础

需求工程定义
- 需求工程就是所有需求处理活动的总和，它收集信息、分析问题、整合观点、记录需求并验证其正确性、最终描述出软件被应用后与其环境互动形成的期望效应

需求工程活动

需求开发过程模型

需求获取

目标分析
用户需求获取
- 面谈
- 集体获取方法
- 头脑风暴
- 原型

需求分析

边界分析
- 系统的用例图和上下文图通常用来定义系统的边界
需求建模

需求规格说明

定制文档模版
编写文档

需求验证

需求规格说明文档至少要满足以下几个标准
- 文档内每条需求都正确、准确的反映了用户的意图
- 文档记录的需求集在整体上具有完整性和一致性
- 文档的组织方式和需求的书写方式具有可读性和可修改性

需求基础

需求定义

需求就是用户的一种期望，软件系统通过满足用户的期望来解决用户的问题。
IEEE定义
- 用户为了解决问题或达到某些目标所需要的条件或能力
- 系统或系统部件为了满足合同、标准、规范或其他正式文档所规定的要求而需要具备的条件或能力
- 对1）或2）中的一个条件或一种能力的文档话表述

需求的层次性

业务需求
- 系统建立的战略出发点，表达为高层次的目标，它描述了组织为什么要开发系统
用户需求
- 执行实际工作的用户对系统所能完成的具体任务的期望，描述了系统能够帮助用户做些什么
系统级需求
- 用户对系统行为的期望，每个系统级需求反映了一次外界与系统的交互行为，或系统的一个实现细节
- 一系列的系统级需求联系起来可以满足一个用户需求，帮助用户完成任务从而满足业务需求
- 将用户需求转换成系统级需求的过程就是需求工程中最为重要的需求分析活动

区分需求、问题域与规格说明

需求是一种期望，源于现实又高于现实
问题域是对现实世界运行规律的一种反映
规格说明是软件产品的方案描述，他不是需求但是实现需求，不是问题域但是要与问题域互动

软件需求分类

功能需求
性能需求
- 速度
- 容量
- 吞吐量
- 负载
- 实时性
质量属性
- 可靠性
- 可用性
- 安全性
- 可维护性
- 可移植性
- 易用性
对外接口
- 包括用户界面、硬件接口、软件接口、网络通信接口
约束
- 编程语言、硬件设施等
- 常见的约束有三类
  - 系统开发及运行的环境
  - 问题域内的相关标准
  - 商业规则
数据需求
- 数据需求是需求在数据库、文件或者其他介质中存储的数据描述

软件过程

软件设计

设计基础

软件设计的核心思想

分解——在横向上把系统分割成几个简单的子系统
抽象——纵向上聚焦子系统的接口，抽象可以分离接口和实现

软件设计的方法

结构化设计
面向对象设计
数据结构为中心设计
基于构件的设计
形式化设计方法

软件设计的模型

静态模型：类图、对象图、构件图、部署图
动态模型：交互图（顺序图和通信图）、状态图、活动图

软件设计描述

设计视图——基于软件视角
- 逻辑设计视角
- 组合设计视角
- 信息视角
- 接口视角
- 结构视角
- 依赖视角
常见的设计视角——上下文、组合、逻辑、依赖、信息、模式、接口、结构、交互等

体系结构视图（视角）

4+1视图模型
- 逻辑视图
  - 显示了系统中对象和对象类的一些主要抽象
  - 通过这些逻辑视图，将系统需求和实体关联起来应该是可能的
- 进程视图
  - 显示了运行时系统是如何组织为一组交互的进程
  - 这种视图对非功能系统特征的判断是非常有效的，比如性能和可用性
- 开发视图
  - 显示了软件是如何为了开发而被分解的，即将软件分解成可以由单独的开发人员或开发团队实现的组件
  - 这种视图对软件的管理者和程序员有用
- 物理视图
  - 它显示了系统硬件和系统中软件组织是如何分布在处理器上的
  - 这种视图对系统工程师规划系统部署是非常有用的
- 4+1模型从逻辑、开发、过程、物理和场景5个不同的视角来描述软件体系结构的全部内容
  - 逻辑视角
    - 描述系统的功能需求及他们之间的相互关系
  - 过程视角
    - 过程角度侧重于系统的运行性
    - 从系统的行为出发，考察各个构件之间的协作/交互/通讯关系，反映系统的行为结构
    - 该视图给予系统的需求场景，同时遵循框架视图的制约，是系统核心结构之一
  - 开发视角
    - 开发角度负责软件模块的组织和管理
    - 该视图以构件为着眼点，是系统开发的核心结构之一，是框架视图的设计模式，是对框架视图的细化
  - 物理视角
    - 物理角度解决系统的拓扑结构、系统安装及通信问题等
    - 描述系统的软件和硬件之间的映射关系并反映其分布特性，展示软件在生命周期的不同阶段中所必须的物理环境或硬件配置以及分布状况
  - 场景
    - 场景则对应于用户需求或系统功能实例的抽象，设计者通过分析如何满足每个场景所要求的约束来分析软件的体系结构
    - 场景是整个体系结构设计的依据

体系结构基础

体系结构

定义：部件、连接件、配置；一个软件系统的体系结构规定了系统的计算部件和部件之的交互
- 部件——承载系统的主要功能
- 连接件——定义了部件间的交互
- 配置——定义了部件以及连接件之间的关联方式

体系结构风格

主程序/子程序

主要实现机制是模块实现，类似于结构化但基于部件与连接件建立的高层结构
模块粒度更粗，在模块内部可以结构化也可面向对象
优点
- 结构清晰、易于理解
- 强控制性
缺点
- 强耦合，非常依赖于交互方的接口规格，系统难以修改和复用
- 程序调用的连接方式限制了各部件之间的数据交互

面向对象

将系统组织为多个独立的对象，每个对象封装内部数据，并基于数据对外提供服务
主要实现机制是模块实现
优点
- 内部实现的可修改性
- 易开发、易理解、易复用
缺点
- 无法消除接口的耦合性
- 无法消除标识（identity）的耦合性，即一个对象要与其他对象交互，必须知道其他对象的标识
- 副作用：难以实现正确性

分层风格

约束
- 从最底层到最高层，上层调用下层
- 层次间遵守交互协议
- 跨层次连接禁止
- 逆向连接禁止
通常是不限粒度的模块实现
优点
- 设计机制清晰、易于理解
- 支持并行开发
- 更好的可复用性和内部修改性
缺点
- 交互协议难以修改
- 性能损失：禁止跨层调用
- 难以确定层次数量和粒度

MVC

模型-视图-控制
优点
- 易开发
- 视图和控制的可修改性
- 网络系统开发
缺点
- 复杂性
- 模型修改困难

体系结构设计过程

主要流程

分析关键需求和项目约束
- 概要功能性需求
- 非功能性需求
  - 质量
  - 性能
  - 约束
  - 接口
选择体系结构风格
进行软件体系结构逻辑（抽象）设计
依赖逻辑设计进行软件体系结构物理（实现）设计
- 逻辑设计从开发（开发包、物理模块）、发布（进程）、部署（网络部署）三个角度实现
- 包设计原则
  - Data层置于服务器端，Logic层无法依赖Data层
    - RMI技术：将Data层开发包分解置于客户端dataservice接口包和置于服务器端的Data层开发包
    - socket通信传递数据
  - 分层风格的典型设计中，不希望高层直接依赖于低层，而是为底层建立接口包，依赖倒置原则
  - 消除循环依赖现象，可使用依赖倒置原则将循环依赖变为单向依赖
完善体系结构设计
定义构件接口
迭代3-6

体系结构集成与测试

常见集成策略

大爆炸式——适用于一个维护型项目或被测试系统较小的情况
增量式
- 自顶向下——适用于控制结构清晰稳定、高层接口变化较小、底层接口未定义或经常可能被修改、控制组件有较大的技术风险的软件系统
  - 对分层次的架构，先集成和测试上层的模块，下层的模块使用stub，不断加入下层模块
  - 优点
    - 按DFS可以首先实现和验证一个完整的功能需求
    - 只需要最顶端的一个驱动driver
    - 利于故障定位
  - 缺点
    - stub开发量大
    - 底层验证被推迟，且底层组件测试不充分
- 自底向上——适用于底层接口较稳定、高层接口变化频繁、底层组件较早被完成
  - 从最底层的模块集成测试起，测试的时候上层的模块使用伪装的相同接口的驱动driver来替换
  - 优点
    - 底层组件较早验证
    - 底层组件开发可以并行
    - stub工作量少
    - 利于故障定位
  - 缺点
    - driver工作量大
    - 高层的验证被推迟，高层错误不能被及时发现
- 三明治式
- 持续集成
  - 提倡尽早集成和频繁集成

详细设计基础

结构化设计

面向对象设计

面向对象的设计过程

设计模型建立
- 通过职责建立静态设计模型
  - 抽象类的职责
  - 抽象类之间的关系
  - 添加辅助类
- 通过协作建立动态设计模型
  - 抽象对象之间协作
  - 明确对象的创建
  - 选择合适的控制风格
设计模型重构
- 根据模块化思想重构，目标为高内聚、低耦合
- 根据信息隐藏的思想重构，目标为隐藏职责与变更
- 利用设计模式重构

通过职责建立静态模型

通过协作建立动态模型

详细设计中的模块化与信息隐藏

模块化

KWIC系统的例子

系统完成四个步骤：输入、循环位移、字母排序、输出
按算法分解——5个模块
- 主体控制模块Master control
- 输入模块Input
- 循环移位模块Circular shift
- 排序模块Alphabetizer
- 输出模块Output
数据是全局变量，共享给所有的模块

1
2
3
4
5


public void circularShift(){
 ArrayList word_indices = new ArranList();
 ArrayList line_indices = new ArrayList():
 //...
 }

结构化设计中的耦合

耦合

类型	耦合性	解释	例子
内容耦合	最高	一个模块直接修改或者依赖于另一个模块	goto语句
公共耦合	不能接受	模块之间共享全局变量	全局变量
重复耦合	不能接受	模块之间有同样逻辑的重复代码	逻辑代码被复制到两个地方
控制耦合	可以接受	一个模块给另一个模块传递控制信息	传递“显示星期天”。传递模块和接收模块必须共享一个共同的内部结构和逻辑
印记耦合	可以接受	共享一个数据结构，但只用了其中一部分	传递了整个记录，但另一个模块只需要一个字段
数据耦合	最低	两个模块的所有参数是同类型的数据项	传递一个整数给一个计算平方根的函数

内聚

类型	内聚性	解释	例子
偶然内聚	最低	不相关操作
逻辑内聚	不能接受	一系列相关	开车去、坐火车去、坐飞机去
时间内聚	可接受无法避免	初始化时	起床、刷牙、洗脸、吃早餐
过程内聚	可接受无法避免	与步骤顺序有关
通信内聚	可接受无法避免	与步骤有关，且这些操作都在相同的数据上进行	查书名、查书的作者、查书的出版商
功能内聚	好	只执行一个操作或达到一个单一目的	下列内容作为独立模块：计算平方根、决定最短路径、压缩数据
信息内聚	最高	模块有许多操作，各有各的入口点，每个操作的代码相对独立，所有操作在相同的数据结构上完成	数据结构中的栈，包含相应的数据和操作，所有的操作都是针对相同的数据结构

信息隐藏

KWIC系统的第二种设计方案

Lines模块隐藏的决策是字母和行的存储
Input模块隐藏的决策是输入源及格式
CircularShift模块隐藏的决策时位移的算法和位移后字符的存储
Alphabetizer模块隐藏的决策时字母排序的算法
Output模块隐藏的决策是输出目的地及其格式
MasterControl模块隐藏的决策是整个任务的执行顺序

信息与隐藏

信息是什么

模块的秘密，对模块来说容易变化的地方，分为两类
- 一是根据需求分配的职责
- 二是内部实现机制

模块说明

模块说明中主要记录两个方面的四个主题：
- 内部角度说明模块所隐藏的秘密
  - 来自需求的主要秘密
  - 源于现实的次要秘密
- 外部角度说明模块承担的角色role和提供的接口facility

详细设计中面向对象方法下的模块化

面向对象中的模块

类之间的关系

除了结构化中的耦合关系，面向对象方法中还有其他复杂关系
关联——访问耦合
- 如果某个类关联另一个类，那么他就持有另一个类的引用，则这个类所有的对象都具有向另一个类的对象发送消息的能力
继承——继承耦合
- 子类可以访问父类的成员方法和成员变量

访问耦合

如果类A拥有对类B的引用，则A可以访问B

类型	耦合性	解释	例子
隐式访问	最高	B既没有出现在A的规格中，也没在实现中出现	CascadingMessage
实现中访问		B的引用是A方法中的局部变量	通过引入局部变量，避免Cascading Message；方法中创建一个对象，将其饮用赋予方法的局部变量，并使用
成员变量访问		B的引用是A的成员变量	类的规格中包含所有需接口和供接口（需要特殊语言机制）
参数变量访问		B的引用是A的方法的参数变量	类的规格中包含所有需接口和供接口（需要特殊语言机制）
无访问	最低	理论最优

Cascading Message指在Client类中出现连续的方法调用“a.methodA.mehodB()”

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


Class A{
 public B methodA(){
 }
}
Class B{
 public void methodB(){
 }
}
Class Client{
 public static void main(String args){
 A a = new A();
 a.methodA.methodB();
 //B b = a.methodA;
 //b.methodB();
 }
}

降低访问耦合的方法

针对接口编程
- 契约式设计
  - 前置条件：方法调用前，校验传入参数的正确性，正确才能执行
  - 后置条件：一旦通过前置条件，方法必须执行，并确保执行结果符合契约，称为后置条件
  - 不变式：对象本身有一套对自身状态进行校验的检查条件，以确保该对象的本质不发生改变，称为不变式
接口最小化/接口分离原则
访问耦合的合理范围/迪米特法则
- 每个单元对于其他的单元只能拥有有限的知识，只是与当前单元紧密联系的单元
- 每个单元只能和他的朋友交谈，不能喝陌生单元交谈
- 只和自己直接的朋友交谈
- 具体来说，对象O有一个方法M，M只能调用下列对象的方法
  - O自己
  - M中的参数对象
  - 任何在M中创建的对象
  - O的成员变量
  - 例子：在连锁商店销售系统中，我们要获知每个已购买商品的价格，为此可以在sale类的方法中调用——违反了迪米特法则 salesList.getSalesLineItem().getCommodity().getPrice();

继承耦合

继承耦合分为
- 修改
  - 修改规格——子类任意修改从父类继承回来的方法的接口
  - 修改实现——子类任意修改从父类继承回来的方法的实现
- 精化
  - 精化规格——子类只根据已经定义好的规则（语义）来修改父类的方法，但至少有一个方法的接口被改动
  - 精化实现——子类只根据已经定义好的规则来修改父类的方法，但只改动了方法的实现
- 扩展——子类只是增加新的方法和成员变量，不对从父类继承回来的任何成员进行更改
修改规格、修改实现、精化规格不可接受，精化实现可以接受，扩展是最好的继承耦合

降低继承耦合的方法

Liskov替换原则
- 子类型必须能够替换掉基类型而起到同样的作用
  - 按照契约式设计，为满足LSP
    - 子类方法的前置条件必须与超类方法的前置条件相同或者要求更少
    - 子类方法的后置条件必须与超类方法的后置条件相同或者要求更多
使用组合替代继承
- 组合关系代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Backend{
 public int method(){
 }
}
class Frontend{
 public Backend back = new Backend();
 public int method(){
 back.method();
 }
}
class Client{
 public static void main(String[] args){
 Frontend front = new Frontend();
 int i = front.method();
 }
}

内聚

衡量标准
- 方法和属性是否一致
- 属性之间是否体现一个职责
- 属性之间可否抽象

1
2
3
4
5
6
7
8
9


内聚低的例子：小计每一购物项金额的方法放在Sales类中
class Scales{
 HashMap<Integer, SalesLineItem>map;
 getSubtotal(int CommodityID){
 1)根据CommodityID找到Commodity的价格
 2)根据CommodityID找到SalesLineItem，再找到商品购买的数量
 3)计算小计
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


内聚高的例子：小计每一购物项金额的方法放在SaleLineItem中，计算总额的类放在Sales类中
class Sales{
 HashMap<Integer, SalesLineItem>map;
 getTotal(){
 total = item.getSubtotal();
 }
}
class SalesLineItem{
 Commodity commodity;
 Int quantity;
 getSubtotal():
}

1
2
3
4
5
6
7
8


内聚低：学号、姓名、成绩、课程编号、课程名在一个类里面
class SCORE{
 int studentID;
 String name;
 int score;
 int courseID;
 String courseName;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


内聚高：学生、课程、成绩在成绩类中
class Student{
 int studentID;
 String name;
}
class Course{
 int courseID;
 String courseName;
}
class SCORE{
 Student student;
 Course course;
 int score;
}

1
2
3
4
5
6
7
8
9


内聚低：生产年份、月份、日期，进货年份、月份、日期在一个类里
class Product{
 int yearOfProduction;
 int mothOfProduction;
 int dayOfProduction;
 int yearOfImport;
 int monthOfImport;
 int dayOfImport;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


内聚高：抽象出日期类包括年月日三个属性，类里面只有日期类的生产日期和进货日期两个变量
class Date{
 int year;
 int month;
 int day;
}
class Product{
 Data productionDate;
 Date importDate;
}

提高内聚的方法

集中信息与行为：GPS定位系统的例子

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Position
{
 public double latitude;
 public double longtitude;

 public double calculateDistance(Position pos){
 //计算当前点到pos点的距离
 }
 public double calculateDirection(Position pos){
 //计算当前点到pos点的方向
 }
}

单一职责原则SRP
- 信息和行为除了要集中外，还要联合起来表达一个内聚的概念，而不是简单的堆砌

耦合与内聚的度量

耦合的度量

方法调用耦合
- CBO （coupling between objects）越小越好
访问耦合
- DAC（data abstraction coupling）越小越好
继承耦合
- NOC（number of children）
- DIT（depth of the inheritance tree）

内聚的度量

详细设计中面向对象方法下的信息隐藏

封装类的职责

为变更而设计

详细设计的设计模式

设计模式基础

可修改性和基本实现机制

通过接口和接口的实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


public class Client{
 public static void main(String [] args){
 //创建
 Interface_A a = new Class_A1();
 Interface_A a = new Class_A2();
 //多态

 //调用
 a.method_A();
 }
}
public interface Interface_A{
 //接口
 public void method_A();
}
public class Class_A1 implements Interface_A{
 public void method_A(){
 //实现
 System.out.printIn("Class_A1's method_A()!")
 }
}
public class Class_A2 implements Interface_A{
 public void method_A(){
 //扩展新的实现类
 }
}

通过子类继承父类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


public class Client{
 public static void main(String [] args){
 Super_A a = new Sub_A();
 Super_A a = new Sub_B();
 //多态
 a.method_A();
 }
}
public class Super_A{
 public void method_A(){
 System.out.printIn("Super_A's method_A()!")
 }
}
public class Sub_A extends Super_A{
 public void method_A(){
 Syetem.out.printIn("Sub_A's method_A()!")
 }
}
public class Sub_B extends Super_A{
 public void method_A(){
 //新的子类
 }
}

组合关系中的前端类和后端类例子

前端和后端接口上不具有耦合性，后端接口改变时不会影响到Client的代码

后端类的实现可以动态创建、动态配置、动态销毁，非常灵活

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


 class Backend{
 public int method_2(){
 }
 }
 class Frontend{
 //组合关系，Frontend类中包含Backend类的实例化
 public Backend back = new Backend();
 public int method_2(){
 back.method_2();
 }
 }
 class Client{
 //Client类中无需关心Backend类
 public static void main(String [] args){
 Frontend front = new Frontend();
 int i = front.method_2();
 }
 }

策略模式

策略模式的优点
- 提高代码的可扩展性，符合面向接口编程原则
- 策略模式提供了可以替换继承关系的办法
- 使用策略模式可以避免使用多重条件转移语句
策略模式的缺点
- 客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须理解这些算法的区别，以便适时选择恰当的算法类
- 策略模式造成很多的策略类，每一个具体策略类都会产生一个新类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98


//Client:TestDriver类
public class TestDriver{
 public static void main(String [] args){
 Employee tom = new Employee("tome",0);
 Employee jack = new Employee("jack",1);
 Employee kevin = new Employee("kevin",2);

 HourlyClassfication hc = new HourlyClassfication(10,40);
 CommissionedClassfication cc = new CommissionClassfication(0.01,1000000);
 SalariedClassification sc = new SalariedClassfication(3000);

 WeeklySchedule ws = new WeeklySchedule(2019, Calendar.FEBRUARY,22);
 BiweeklySchedule bs = new BiweelySchedule(2019, Calendar.FEBRUARY,22);
 MonthlySchedule ms = new MonthlySchedule(21);

 //配置Employee对象，也可通过带参数的构造方法来配置
 tom.setPaymentClassification(hc);
 tom.setPaymentSchedule(ws);
 //...

 //Employee对象的使用
 while(i.hasNext()){
 Employee e = i.next();
 if(e.isPayDay()){
 e.getPayment();
 }
 }
 //...
 }
}



//Context:Employee类
public class Employee{
 String name;
 int ID;
 PaymentClassification pc;
 PaymentSchedule ps;
 //在Employee类中加入两个实例变量，声明为接口类型而不是具体类实现类型
 //实例对象在运行时持有特定行为的引用

 public Employee(String s, int id){
 //构造器
 name = s;
 ID = id;
 }
 public void getPayment(){
 //支付方式
 double payment = 0;
 payment = pc.calculatePayment();
 System.out.printIn(name + "get" + payment + " dollars!");
 }
 public booleam isPayDay(){
 //使用支付策略
 boolean isPay = false;
 isPay = ps.isPayDay();
 if(isPay){
 //...
 }
 return isPay;
 }

 //setter方法设置策略，而不是在Employee构造器内实例化，可随时调用改变行为
 //setter方法持有对行为设定的引用即可实现 
 public void setPaymenyClassification(PaymentClassification paymentClassification){
 pc = paymentClassification;
 }
 public void setPaymentSchedule(PaymentSchedule paymentSchedule){
 ps = paymentSchedule;
 }
}



//Strategy:策略接口
public interface PaymentClassification{
 public double calculatePayment();
}



//ConcreteStrategy:HourlyClassification类，实现PaymentClassification接口的具体策略类
public class HourlyClassification implements PaymentClassification{
 int hourlyRate;
 int hours;

 public HourlyClassification(int rate,int h){
 hourlyRate = rate;
 hours = h;
 }
 public double calculatePayment(){
 //策略接口方法的实现
 int sum = 0;
 sum = hourlyRate * hours;
 return sum;
 }
 }

抽象工厂模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


//可通过多态的形式体现不同的行为实现，但构造方法无法多态
class Client{
 public void dosomething1(int type){
 if(type == 1){
 Class a = new ClassA1();
 }else{
 Class a = new ClassA2();
 }
 a.method1();
 }
 public void dosomething2(int type){
 if(type == 1){
 Class a = new ClassA1();
 }else{
 Class a = new ClassA2();
 }
 a.method2();
 }
}

class ClassA{}
class ClassA1 extends ClassA{}
class ClassA2 extends ClassA{}

//工厂模式就是为对象的创建提供一个接口，将具体创建的实现封装在接口之下，这样具体创建的改变不会影响Client代码
//工厂模式代码如下
class Client1 extends Client{
 public ClassA createClassA(){
 if(type == 1){
 Class a = new ClassA1();
 }else{
 Class a = new ClassA2();
 }
 return a;
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


public interface DatabaseFactory{
 public CommodityDatabaseService getCommodityDatabase();
 public UserDatabaseService getUserDatabase();
 public MemberDatabaseService getMemberbase();
 public SalesDatabaseService getSalesbase();
}

public class DatabaseFactoryMysqlImpl implements DatabaseFactory{
 UserDatabaseService userDatabase = new UserDatabaseServiceMySqlImpl();
 //...
 SalesDatabaseService salesDatabase = new SalesDatabaseServiceMySqlImpl();

 //构造函数
 public DatabaseFactoryMySqlImpl() throws RemoteException{}

 public UserDatabaseService getUserDatabase(){
 return UserDatabase;
 }
 //...
 public SalesDayabaseService getSalesDatabase(){
 return SalesDatabase;
 }
}

public class UserDatabaseServiceMysqlImpl implements UserDataService{
 //用组合代替继承
}

单件模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


//数据库抽象工厂的具体工厂应该只有一个实现，根据它我们可以得到不同数据库表的不同实现
public class DatabaseFactoryTxtFileImpl implements DatabaseFactory{
 //单件
 //UML类图中private是减号，public是加号
 private static DatabaseFactoryTxtFileImpl databaseFactoryTxtFile = null;
 //databaseFactoryTxtFile是静态类型的单件类型的引用变量
 private DatabaseFactoryTxtFileImpl(){
 }
 //类的构造方法要私有！！

 public static DatabaseFactory getInstance(){
 //通过静态方法获得对象的引用
 if(datdabaseFactoryTxtFile == null)
 //如果是null就是首次创建，通过new创建单件对象
 databaseFactoryTxtFile = new DatabaseFactoryTxtFileImpl();
 return databaseFactoryTxtFile;
 //返回单件类型的引用
 }
}

单件模式使用的设计原则：职责抽象，即隐藏单件创建的实现
为了实现只创建一个对象，首先要让类的构造方法私有，然后只能通过静态的getInstance方法获得单件类型的对象的引用
这就要求类的成员变量中拥有一个静态类型的单件类型的引用变量uniqueInstance
getInstance方法返回引用变量uniqueInstance
如果uniqueInstance是null说明是首次创建，通过new创建单件对象，并且将该对象的引用变量赋值给uniqueInstance；否则说明不是首次创建，正常返回

迭代器模式

软件测试

测试相关概念

集成测试
- 也叫组装测试或者联合测试。在单元测试的基础上，将所有模块按照设计要求（如根据结构图）组装称为子系统或系统，进行集成测试
回归测试
- 指修改了旧代码后，重新进行测试以确认没有引入新的错误或导致其他代码产生错误
Alpha测试
- 是由一个用户在开关环境下进行的测试，也可以是公司内部的用户在模拟实际操作环境下进行的受控测试，Alpha测试通常不能由测试员完成
Beta测试
- 是软件的多个用户的实际使用环境下的测试。开发者通常不在测试现场，Beta测试不能由程序员或测试员完成

验证与确认

V&V

验证

检查开发者是否正确的使用技术建立系统，确保系统能够在预期的环境中按照技术要求建立系统，确保系统能够在预期的环境中按照技术要求正确地运行

确认

检查开发者是否建立了正确的系统，确保最终产品符合规格。
例如：对需求文档内容是否反映用户真实意图，设计是否能跟踪到需求，测试是否覆盖需求，代码是否按照需求与设计的要求编写

测试技术

随机测试

基于规格的技术——黑盒测试

早期的黑盒测试主要使用等价类划分、边界值分析等简单方法，后来为形式化模型、UML等各种规格手段都建立了相应的测试方法

等价类划分

等价类划分就是把所有可能的输入数据，即程序的输入域划分成若干子集，然后从每一个子集中选取少数具有代表性的数据作为测试用例
可分为两种情况
- 有效等价类
- 无效等价类

边界值分析

边界值分析方法是对等价类划分方法的补充

决策表

决策表是为复杂逻辑判断设计测试用例的技术
决策表是由条件声明、行动声明、规则选项和行动选项四个象限组成的表格

状态转换

基于代码的技术——白盒测试

语句覆盖

确保被测试对象的每一行程序代码都至少执行一次
相比于条件覆盖和路径覆盖，语句覆盖是一种比较弱的代码覆盖技术，不能覆盖所有的执行路径

路径覆盖

确保程序中每个判断的每个结果都至少满足一次
条件覆盖保证判断中的每个条件都被覆盖了
条件覆盖的覆盖程度比语句覆盖强

分支覆盖

路径覆盖测试用例的标准就是确保程序中每条独立的执行路径都至少执行一次

测试活动

典型活动包括：测试计划、测试设计、测试执行和测试评价

测试度量

软件有效性验证

通常被称为检验和有效性验证（V&V）
测试过程中的阶段包括
- 组件测试（单元测试）：组件可以是简单的实体
- 系统测试：集成组件形成完整的系统，关注无法预测的组件交互和组件界面问题引发的错误
- 接收测试：在系统接受并运行之前进行的最后阶段测试，使用客户提供的真实数据测试系统
  - V开发模型：把测试和开发活动联系起来
    - 接收测试又是被称为alpha测试——针对定制系统
    - beta测试——将系统交付给愿意使用该系统的潜在用户，能够暴露开发者无法预见的错误

人机交互设计

人机交互的目标

易用性的维度

易学性
效率
易记性
出错率
主观满意度

人机交互设计的人类因素

精神模型
差异性

一些人机交互设计原则

简洁设计
- 常见要求是不要使用太大的菜单、不要在一个窗口中表现过多的信息类别、不要在一个表单中使用太多的颜色和字体作为线索
一致性设计
低出错率设计
- 出错信息应该遵循以下四个原则
  - 应当使用清晰的语言来描述
  - 使用的语言应该精炼准确，不空泛模糊
  - 应该对用户解决问题提供建设性的帮助
  - 出错信息应该友好，不要威胁或责备用户
易记性设计
- 减少短期记忆负担
- 使用逐层递进的方式展示信息
- 快捷方式
- 设置有意义的默认值

人机交互设计过程

需求开发
- 需求收集、场景分析
软件设计
- 导航设计、界面设计、界面原型化、界面评估与修正
构造、测试与维护
- 构造、测试与维护

代码设计

设计可靠的代码

契约式设计

契约式设计又称断言式设计，基本思想是：如果一个函数或方法，在前置条件满足的条件下开始执行，完成后能够满足后置条件那么这个函数或方法就是正确、可靠的

异常方式

在契约式设计的异常方式就是在代码开始执行时，检查前置条件是否满足，不满足就抛出异常。在代码执行完后，再检查后置条件是否满足，不满足也抛出异常
Sales类的getChange方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


public class Sales extends DomainObject{
...
 public double getChange(double payment)throws PreException, PostException{
 //前置条件检查
 if(payment<=0)||(payment<total){
 throw new PreException(“Sales.getChange: Payment” + String.valueOf(payment) + “; Total” + String.valueOf(total));
 }
 ...
 //返回result之前进行后置条件检查
 if(result != (payment-total)){
 throw new PostException(“Sales.getChange: Payment” + String.valueOf(payment) + “; Total” + String.valueOf(total));
 }
 return result;
 }
}

断言方式

Sales.getChange()方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class Sales extends DomainObject{
 ...
 public double getChange(double payment)throws AssertionError{
 //前置条件检查
 assert((payment>0) && (payment>=total)):
 (“Sales.getChange:Payment” + String.valueOf(payment) + “; Total” + String.valueOf(total));
 ...
 //返回result之前进行后置条件检查
 assert(result == (payment-total)):
 (“Sales,getChange:Payment” + String.valueOf(payment) + “; Total” + String.valueOf(total));
 return result;
 }
}

比较

虽然断言方式实现起来简单，但不推荐在复杂系统中使用断言方式，因为断言方式只能抛出AssertionError异常，不利于故障诊断
最好在Public方法中使用异常方式，在Protected、Private方法中使用断言

防御式编程

基本思想：在一个方法和其他方法、操作系统、硬件等外界条件交互时，不能确保外界都是正确的，所以要在外界发生错误时，保护内部方法不受损害
与契约式设计的共同点是：他们都要检查输入参数的有效
差异点是：防御式编程将所有与外界的交互（不仅仅是前置条件所包含的）都纳入防御范围，例如用户输入的有效性、待读写文件的有效性、调用的其他方法返回值的有效性
防御式编程不检查输出和后置条件，因为他们的使用者会自行检查

设计模式

Tue, 18 Feb 2020 00:00:00 +0000

单选题

开发与新硬件交互的软件，并急于根据实际硬件进行测试。硬件制造商说设备驱动程序的接口可能会在后续日期发生变化。设备驱动程序会在整个代码中到处使用，如果担心后期这些接口发生修改会带来很大的风险，采用哪个设计模式？
- ~~Bridge~~
- ~~Strategy~~
- ~~Mediator~~
- ==Adapter==
- ~~Decorator~~
- 适配器模式所针对的就是接口兼容和变化问题
下面哪个模式很好的体现了“组合优于继承的”面向对象设计原则？
- ==Adapter==
- “组合优于继承”针对的是复用，composite、decorator使用组合是为了组织复合结构，bridge是为了匹配接口和实现
- Factory Method完全没有使用组合关系，只是普通关联
- Adapter的目的是复用Adaptee，采用了组合的方式，而不是直接继承Adatee
“隐藏类的构造函数，并提供静态方法代替构造函数的作用，这样客户就可以在不知道对象如何被构造的情况下使用对象”
- 只有Singleton会使用隐藏构造函数，代之以静态方法
建立日志是对象创建功能，只有Singleton和Abstract Factory合适。但抽象工厂适用场景是建立产品组合，单件模式是控制构造对象数量不超过1。
遍历一些学生，应该使用Iterator模式

简答题

什么是迭代器？ Iterator接口提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素。

现在对武器的使用有约定：Queen使用Knife，Troll使用BowAndArrow，King使用Sword，Knight使用Axe，setWeapon方法应该如何处理，给出实现方案 在setWeapon()方法中加一个检查方法，如果为false，返回异常

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


void setWeapon(WeaponBehavior w) throws Exception{
 if isValid(w){
 this.weapon = w;
 }else{
 throw new Exception("weapontype error");
 }
}
abstract boolean isValid(WeaponBehavior w){}
boolean isValid(WeaponBehavior w)::Queen{
 if(w instanceof KnifeWeaponBehavior){
 //instance关键字判断一个对象是否是某个类型的实例
 return true;
 }else{
 return false;
 }
}

图片编辑系统，图书有五种格式，每一种的保存方法都不一样，因此Image实现了五种方法，使用设计模式修改 策略模式 抽象出一个«interface»为ImageSaver，拥有一个公共方法save(image)，分别用class JpegSaver, class BmpSaver, class TiffSaver实现该接口，Image类use a IamgeSaver。是为了扩展更多的行为而使用策略模式

Image使用CreateThumbnail方法动态创建了Thumbnail，是典型的抽象工厂模式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


public class FactoryChoice{
 static public IChoice getChoiceObj(string cChoice){
 IChoice objChoice = null;
 if(cChoice == "car"){
 objChoice = new Car();
 }else if(cChoice == "bike"){
 objChoice = new Bike();
 }else{
 objChoice = new InvalidChoice();
 }
 return objChoice;
 }
}
public class Store{
 public void purchase(){
 string choice = getUserChoice(); //获取用户的选择
 IChoice ichoice = FactoryChoice.getChoiceObj(choice);
 ichoice.buy();
 }
}

FactoryChoice使用getChoiceObj方法动态创建了IChoice

需求基础

Tue, 18 Feb 2020 00:00:00 +0000

需求基础

需求基础单选题

需求定义
- 用户为了解决问题或达到某些目标需要具备的条件和能力
- 系统和系统部件为了满足合同、标准、规范或其他正式文档所规定的要求而需要具备的条件和能力
- 1）或者2）
常见的需求表达方式——系统应该…
业务需求反映了用户的战略目标
用户需求反映了用户的日常任务
在项目管理者请求分配任务时，系统将选中的需求开发任务分配给选中的开发人员——系统级（功能）需求
该软件管理工具必须帮助项目管理者进行开发管理工作，以通过CMMI-4的评估——用户需求
软件规格说明书的一个片段：收文管理应该包括…——用户需求
软件规格说明书：开发意图：减少人力成本、提高办公效率、成本统计查询、历史信息查询、支持web操作等——业务需求、存在问题，定义太模糊
软件规格说明书：实现工作流程合理化、高效化、决策支持科学化、准确化——业务需求、定义太模糊
需求属于哪种类型：系统需要帮助项目管理者安排项目计划，具体包括资源估算、进度安排、里程碑规划、跟踪计划、质量管理计划、风险管理计划等——用户需求
同上
需求属于哪种类型：系统能够为用户提供库存分析报告、商品/利润报告和过期产品报告——用户需求
需求类型：产品在发布一年以后，必须在出版的ABC三个产品评论刊物中被评为最可靠的产品——业务需求
可以不做明确量化，带有一些多逻辑混杂的需求类型是——用户需求
需要经过技术加工才能产生的需求类型是——系统级（功能需求）
需要配合现实世界知识才能更好地理解的需求类型是——用户需求
需要使用解决方案、功能特征来满足的需求类型是——业务需求
哪一种类型的需求反映了用户与系统的交互细节——系统级（功能）需求
经过十天培训的收银员就能够熟练使用系统——软件需求
- 这属于软件需求类别下的质量需求（易用性）
- 因其描述重点不是需要什么样的人，而是系统应该易于使用，10天培训即可。
- 如果需求是“系统使用之前，需要对用户进行十天的专门培训”，就属于其他（人力）需求了
系统开发的成本不超过10万RMB——项目需求
- 跟项目计划相关的都是项目需求
- 资源（时间、人力、金钱）估算是项目计划范围
系统开发必须在六个月内完成——项目需求
该软件管理工具的开发过程自身必须符合CMMI-4标准——过程需求
项目需要招聘并培训专职的系统管理员，以让其维护系统的运行与使用——其他需求（包括硬件需求、人力需求等）
开发团队必须给出SRS文档——过程需求
- 过程的管理规范、开发方法、开发工具选择、制品产出等都属于软件过程的内容
顾客使用信用卡付款时，系统必须使用银联专用刷卡设备与银行交易——其他需求
软件规格说明书的片段：验收投标方需提供以下文档：软件需求分析报告、软件总体设计报告、软件操作手册、软件配置手册等——过程需求
软件规格说明书的片段：
- 培训要求：
- 投标人必须提供相应的应用软件技术和系统操作等方面的培训。
- 投标人应提供面向系统管理员的应用软件系统结构、日常维护等方面的培训。
- 以上培训内容的培训费用均包含在投标报价内，项目采购人不再另行支付
- 其他需求（包括硬件需求、人力需求等）
- 培训的要求是对人力的要求
一个从未使用过atm的新顾客，也能顺利使用系统完成自助取款——质量需求
- 易用性的一种维度，表示易学习性
使用扫描仪扫描文件，传递回的数据为pdf格式文件——对外接口
当订单数量大于现有数量时，系统必须通知操作员——功能需求
订单数量不能大于现有库存数量——约束
- 商业规则，是约束的一种
系统每小时能够处理3000次呼叫——性能需求
商品的标识由0～24位字母、数字组成的字符串——数据需求
当存储设备发生故障时，系统要在10秒内发现——质量需求
- 可靠性需求，强调是故障处理。
- 需要注意的是，发生故障不是正常的功能，所以考察的不是cpu的计算能力，不算是性能需求
数据库与服务器之间的通信必须是加密的——质量需求
系统必须能够与oracle数据库交互——约束
- oracle数据库是系统运行的基本环境，而不是普通的其他软件系统，所以是约束而不是对外接口
商品的标识类型要能够在0.5个月内改为长整型——质量需求

用例描述

用例描述单选题

参与者与用例之间的关系实质是——交互
主参与者与辅助参与者之间的关系是——主参与者拥有目标，发起一个用例，辅助参与者参与用例，帮助主参与者完成目标
包含是用例图的关系
- 聚合是类图的关系
- 依赖是组件图的关系
- 前导和后续在各种图中都不支持
搜索用例和按照名称搜索和按照日期搜索这两个用例之间的关系是——继承
现金付款支付和代金券付款、刷卡付款这两个用例之间的关系是——扩展
atm机取款、存款、转账这三个用例和查看账户余额用例之间的关系是——包含
用例建模的主要目的是——捕获功能需求
定位找猫的用例图，主参与者是人，辅助参与者是定位设备

用例描述多选题

哪些内容可以建模为用例：
1. 一次数据库读取
2. 一次用户与系统的交互
3. 一次事件处理过程
4. 一个复杂的计算
5. 一个报表展示界面
6. 一个用户任务
7. 答案为3、6，可能2粒度太小
下面哪些可能被建模为actor
1. 其他软件系统
2. 特殊硬件
3. 网络
4. 用户
5. 答案为1、2、4
下面用例间关系正确的是
1. 面试继承招聘用例
2. 考试用例包含身份验证用例
3. 开卷考试用例继承考试用例
4. 退货用例扩展送货用例
5. 退货用例拓展销售用例
6. 用户管理用例包含新用户注册用例 7.答案为2、3
粒度恰当的用例具有下列哪些特点
1. 同一类用户发起和参与
2. 同一段时间内发生
3. 同一个地点发生
4. 完成业务增值
5. 答案为1、2、4

用例描述判断题

Actor并非就是系统的用户
用例之间的空心菱形关系可以避免不同用例之间出面描述文本重复
真正让用例变得有用的是用例文本描述，而不是用例图。用例文本描述是需求内容，所以很重要
extend关系可以将一个非常复杂难以描述的用例合理分解为多个不同用例
在开发后期扩展前期用例时，extend关系可以让前期用例文本保持不变
复杂用例关系如include、extend、继承等容易让用例模型变得难以理解，考虑到用例文本描述才是更重要的内容，所以应该尽量限制这些复杂关系的使用
搜索与按电话号码搜索、按作者搜索、按题目搜索应该是继承关系，不是扩展（extend）。扩展是主流程中发生了新的分支

Brexit

Fri, 01 Mar 2019 00:00:00 +0000

Economy could be 9% weaker under no-deal Brexit, government says

Latest no-deal notice forecasts Northern Ireland to be hit hard and food prices likely to rise

The government has issued a bleak warning over a no-deal Brexit, estimating the UK economy could be 9% weaker in the long run, businesses in Northern Ireland might go bust and food prices will increase.

In an official document only published after repeated demands by the former Conservative MP Anna Soubry, the government also revealed it was behind on contingency planning for a third of “critical projects” in relation to business and trade.

The latest no-deal notice states:

The economy would be 6%-9% smaller over the next 15 years than it otherwise might have been, in the event of no deal, in line with Bank of England forecasts.

The flow of goods through Dover would be “very significantly reduced for months”.

With 30% of food coming from the EU, prices are likely to increase and there is a risk that panic buying might create shortages.

Only six of the 40 planned international trade agreements have been signed.

The document was published just hours after Theresa May was forced to promise two key votes, allowing MPs the option to reject no deal and to potentially delay Brexit for a short period, following pressure from remain-minded cabinet ministers.

The prime minister set out a timetable that includes a vote on her Brexit deal by 12 March; if that fails, a vote the following day to support no deal, and if that also fails, a vote on 14 March on extending article 50. The delay is likely to further agitate the Tory party’s Eurosceptics, with Brexiter ministers including Andrea Leadsom and Liz Truss expressing their frustration over the issue in cabinet on Tuesday morning.

Speaking in the House of Commons on Tuesday, May did not specify the length of any delay, saying only that she would prefer it to be the shortest possible. An extension beyond the end of June would involve the UK taking part in the European parliament elections. Cabinet ministers are keen for May to use any delay to try to force a cross-party consensus.

The no-deal notice said customs checks alone could cost businesses £13bn a year and that it was impossible to predict the impact of new tariffs. It said this was partly because the government’s communications to businesses and individuals about the need to prepare for no deal had not been effective.

It said small- to medium-sized businesses were not making basic preparations despite government advice to do so.

Only 40,000 of 240,000 businesses that had no experience of customs or tariffs had registered for an economic operator registration and identification number.

The government said that while it might wave hauliers through British ports, “they would be stopped if taking goods into France without the right paperwork”. This amounts to the most robust rebuttal yet of Brexiter claims that there would be no delays because the British would be taking a loose approach to checks and controls.

Evidence suggested the public had not been heeding no-deal warnings either, with no “noticeable behaviour change” witnessed on a “significant scale” over the need to renew passports, and get international driving permits and green cards for insurance for driving in the EU, it said.

The EU, which would treat the UK as a third country in the event of no deal, could impose tariffs of 70% on beef exports, 45% on lamb and 10% on cars, it said. “This would be compounded by the challenges of even modest reductions in flow at the border.”

The impact on the economy would vary across the UK, with Wales and Scotland’s economies estimated to be about 8% smaller under a no deal scenario over the next 15 years, when compared to today’s arrangements. In the Northern Ireland, the economy would be 9% smaller and in the north-east of England 10.5% smaller.

It added: “Overall, the cumulative impact from a no-deal scenario is expected to be more severe in Northern Ireland than in Great Britain, and to last for longer.” This was because of expected disruption in the “closely interwoven supply chains and increasing costs that would affect the viability of many businesses across Northern Ireland. There is a risk that businesses in Northern Ireland will not have sufficient time to prepare. This could result in business failure.” Scottish fishing would be badly hit as would Welsh sheep farming, with 92% of its lamb being exported to the EU, confirming the sector’s previous warnings that it could be “wiped out” by no deal.

The notice said the impact on the food and drink sector would be most pronounced in Wales, Scotland and particularly Northern Ireland, where the sector comprises 5.07% of the economy, compared to 1.38% for England.

It said fewer than one in 10 items would be affected by delays on the channel crossings but, because of the timing of a potential no-deal Brexit, supplies of fresh fruit and vegetables could be hit hardest.

“In the absence of other action from government, some food prices are likely to increase, and there is a risk that consumer behaviour could exacerbate, or create, shortages in this scenario” it said.

The government revealed there were significant delays to critical projects being undertaken in preparation for no deal.

“In February, departments reported being on track for just under 85% of no-deal projects but, within that, on track for just over two thirds of the most critical projects” it said.

The document confirmed that the Treasury had made more than £4bn available for no-deal planning, £2bn of which was allocated in December to support preparations for the 2019-20 financial year.

Article Source: The Guardian

Data: February 27,2019

Posts on SERRINI — AI Engineer

精读Navigating the Digital World as Humans Do：UNIVERSAL VISUAL GROUNDING FOR GUI AGENTS

introduction

method

Overview：

Data construction（简单的数据合成策略）

小标题：常见的RE类型（[[RE]] is “referring expressions” ）

小标题：来自Web的混合RE合成

小标题：补充数据

总结一下：

Model design

experiments

GUI VISUAL GROUNDING

OFFLINE AGENT EVALUATION

ONLINE AGENT EVALUATION

ERROR ANALYSIS

conclusions and limitations

结论：

局限

未来工作方向

关键意义

精读SeeClick：Harnessing GUI Grounding for Advanced Visual GUI Agents

Introduction

Related work

第一段：

早期研究：

LLM驱动的范式转变

第二段（LVLMs）：

Approach（方法）

GUI grounding for LVLMs

Data Construction（数据建设）

Training Details

ScreenSpot: A Grounding Benchmark

Exprements

GUI Grounding on ScreenSpot

Compared LVLMs & Evaluation

Visual GUI Agent Tasks

Conclusion

Limitations

A Details of SeekClick Pre-training

A.1 Pre-training Tasks

A.2 Training Configurations

B ScreenSpot Annotation & Evaluation

B.1 Human Annotation

B.2 Sample Showcase

B.3 Evaluation Detail

B.4 SeekClick Case Study & Error Analysis

Downstream Agent Tasks

C.1 Formulation of SeekClick as Visual GUI Agent

C.2 MiniWob

C.3 AITW

C.4 Mind2Web

Agent 工具接入

Agent 工具接入方式

工具调用时的Agent与模型交互通信全流程

第一回合：用户提问

第二回合：模型下达指令 (The Tool Call)

Agent 本地执行

第三回合：回填结果与最终响应

Model 最终返回给 Agent 的 Response

代码核心链路

定义

注册与绑定

决策是否调用

执行

简单循环

工具并发调用

Function Calling实现

使用Pydantic定义输入，描述清楚Description

实现工具内部逻辑

注册工具

基于 LangGraph 的高并发 Multi-Agent 流式系统设计

同步阻塞式流式响应

使用 Server-Sent Events (SSE) 实现的流式 API 接口

SSE通信机制

SSE数据格式

API端分析

Multi-Agent执行流程

子agent服务端实现

pipeline设计模式的通信流程