算法基础锚点添加 +

Author: ningfeng

docs/08.md

@@ -1,4 +1,16 @@
-# 1 二叉树的递归套路
+
+- [1 二叉树的递归套路](#1)
+  * [1.1 二叉树的递归套路深度实践](#11)
+    + [1.1.1 例一：判断二叉树平衡与否](#111)
+    + [1.1.2 例二：返回二叉树任意两个节点最大值](#112)
+    + [1.1.3 例三：返回二叉树中的最大二叉搜索树Size](#113)
+    + [1.1.4 例四：派对最大快乐值](#114)
+    + [1.1.5 例五：判断二叉树是否是满二叉树](#115)
+    + [1.1.6 例六：二叉搜索树的头结点](#116)
+    + [1.1.7 例子七：是否是完全二叉树](#117)
+    + [1.1.8 例子八：最低公共祖先](#118)
+
+<h1 id='1'>1 二叉树的递归套路</h1>
 
 1、 可以解决面试中的绝大部分二叉树(95%以上)的问题，尤其是树形dp问题
 
@@ -14,9 +26,9 @@
 5. 递归函数都返回S，每颗子树都这么要求
 6. 写代码，在代码中考虑如何把左树信息和右树信息整合出整棵树的信息
 
-## 1.1 二叉树的递归套路深度实践
+<h2 id='11'>1.1 二叉树的递归套路深度实践</h2>
 
-### 1.1.1 例一：判断二叉树平衡与否
+<h3 id='111'>1.1.1 例一：判断二叉树平衡与否</h3>
 
 给定一棵二叉树的头结点head，返回这颗二叉树是不是平衡二叉树
 
@@ -134,7 +146,7 @@ public class Code01_IsBalanced {
 
 ```
 
-### .1.2 例二：返回二叉树任意两个节点最大值
+<h2 id='112'>1.1.2 例二：返回二叉树任意两个节点最大值</h2>
 
 给定一棵二叉树的头结点head，任何两个节点之间都存在距离，返回整棵二叉树的最大距离
 
@@ -307,7 +319,7 @@ public class Code08_MaxDistance {
 }
 ```
 
-### 1.1.3 例三：返回二叉树中的最大二叉搜索树Size
+<h3 id='113'>1.1.3 例三：返回二叉树中的最大二叉搜索树Size</h3>
 
 给定一颗二叉树的头结点head，返回这颗二叉树中最大的二叉搜索树的Size
 
@@ -522,7 +534,7 @@ public class Code04_MaxSubBSTSize {
 }
 ```
 
-### 1.1.4 例四：派对最大快乐值
+<h3 id='114'>1.1.4 例四：派对最大快乐值</h3>
 
 排队最大快乐值问题，员工信息定义如下，多叉树结构：
 
@@ -682,7 +694,7 @@ public class Code09_MaxHappy {
 
 ```
 
-### 1.1.5 例五：判断二叉树是否是满二叉树
+<h3 id='115'>1.1.5 例五：判断二叉树是否是满二叉树</h3>
 
 给定一棵二叉树的头结点head，返回这颗二叉树是不是满二叉树。
 
@@ -793,7 +805,7 @@ public class Code02_IsFull {
 
 ```
 
-### 1.1.6 例六：二叉搜索树的头结点
+<h3 id='116'>1.1.6 例六：二叉搜索树的头结点</h3>
 
 给定一棵二叉树的头结点head，返回这颗二叉树中最大的二叉搜索子树的头节点
 
@@ -937,8 +949,7 @@ public class Code05_MaxSubBSTHead {
 
 }
 ```
-
-### 1.1.7 例子七：是否是完全二叉树
+<h3 id='117'>1.1.7 例子七：是否是完全二叉树</h3>
 
 给定一棵二叉树的头结点head，返回这颗二叉树是不是完全二叉树
 
@@ -1124,7 +1135,7 @@ public class Code06_IsCBT {
 
 ```
 
-### 1.1.8 例子八：最低公共祖先
+<h3 id='118'>1.1.8 例子八：最低公共祖先</h3>
 
 给次那个一颗二叉树的头结点head，和另外两个节点a和b。返回a和b的最低公共祖先
 

docs/09.md

@@ -1,6 +1,20 @@
-# 1 贪心算法
 
-## 1.1 基本概念
+- [1 贪心算法](#1)
+  * [1.1 基本概念](#11)
+    + [1.2.1 贪心算法解释](#121)
+    + [1.2.2 贪心算法的证明问题](#122)
+  * [1.2 贪心算法求解思路](#12)
+    + [1.2.1 标准求解过程](#121)
+    + [1.2.2 贪心算法解题套路](#122)
+  * [1.3 贪心算法套路解题实战](#13)
+    + [1.3.1 例一：会议日程安排问题](#131)
+    + [1.3.2 例二：居民楼路灯问题](#132)
+    + [1.3.3 例三：哈夫曼树问题](#133)
+    + [1.3.4 例四：项目花费和利润问题](#134)
+
+<h1 id='1'>1 贪心算法</h1>
+
+<h2 id='11'>1.1 基本概念</h2>
 
 1、最自然智慧的算法
 
@@ -10,15 +24,15 @@
 
 4、对于贪心算法的学习主要是以增加阅历和经验为主
 
-### 1.2.1 贪心算法解释
+<h3 id='121'>1.2.1 贪心算法解释</h3>
 
 正例：通过一个例子来解释，假设一个数组中N个正数，第一个挑选出来的数乘以1，第二个挑选出来的数乘以2，同理，第N次挑选出来的数乘以N，总的加起来是我们的分数。怎么挑选数字使我们达到最大分数？
 
 > 数组按从小到大的顺序排序，我们按顺序依次挑选，最终结果就是最大的。本质思想是因子随着挑选次数的增加会增大，我们尽量让大数去结合大的因子。
 
 ==贪心算法有时是无效的，后面会贪心算法无效的例子==
 
-### 1.2.2 贪心算法的证明问题
+<h3 id='122'>1.2.2 贪心算法的证明问题</h3> 
 
 如何证明贪心算法的有效性？
 
@@ -207,17 +221,17 @@ public class Code01_LowestLexicography {
 
 ==贪心策略算法，尽量不要陷入复杂的证明==
 
-## 1.2 贪心算法求解思路
+<h2 id='12'>1.2 贪心算法求解思路</h2>
 
-### 1.2.1 标准求解过程
+<h3 id='121'>1.2.1 标准求解过程</h3>
 
 1、分析业务
 
 2、根据业务逻辑找到不同的贪心策略
 
 3、对于能举出反例的策略，直接跳过，不能举出反例的策略要证明有效性，这往往是比较困难的，要求数学能力很高且不具有统一的技巧性
 
-### 1.2.2 贪心算法解题套路
+<h3 id='122'>1.2.2 贪心算法解题套路</h3>
 
 1、实现一个不依靠贪心策略的解法X,可以用暴力尝试
 
@@ -229,9 +243,9 @@ public class Code01_LowestLexicography {
 
 > 贪心类的题目在笔试中，出现的概率高达6到7成，而面试中出现贪心的概率不到2成。因为笔试要的是淘汰率，面试要的是区分度。由于贪心的解决完全取决于贪心策略有没有想对，有很高的淘汰率但是没有很好的区分度
 
-## 1.3 贪心算法套路解题实战
+<h2 id='13'>1.3 贪心算法套路解题实战</h2>
 
-### 1.3.1 例一：会议日程安排问题
+<h3 id='131'>1.3.1 例一：会议日程安排问题</h3>
 
 一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目宣讲。给你每个项目的开始时间和结束时间，你来安排宣讲的日程，要求会议室进行宣讲的场数最多。
 
@@ -360,7 +374,7 @@ public class Code04_BestArrange {
 
 ```
 
-### 1.3.2 例二：居民楼路灯问题
+<h3 id='132'>1.3.2 例二：居民楼路灯问题</h3>
 
 给定一个字符串str，只由‘X’和‘.’两中国字符构成。
 
@@ -475,7 +489,7 @@ public class Code02_Light {
 
 ```
 
-### 1.3.3 例三：哈夫曼树问题
+<h3 id='133'>1.3.3 例三：哈夫曼树问题</h3>
 
 一根金条切成两半，是需要花费和长度值一样的铜板的。
 
@@ -575,7 +589,7 @@ public class Code03_LessMoneySplitGold {
 }
 ```
 
-### 1.3.4 例四：项目花费和利润问题
+<h3 id='134'>1.3.4 例四：项目花费和利润问题</h3>
 
 输入：正数数组costs，正数数组profits,正数K,正数M
 

docs/10.md

@@ -1,8 +1,29 @@
-# 1 并查集、图相关算法
 
-## 1.1 并查集
-
-### 1.1.1 并查集基本结构和操作
+- [1 并查集、图相关算法](#1)
+  * [1.1 并查集](#11)
+    + [1.1.1 并查集基本结构和操作](#111)
+    + [1.1.2 例题](#112)
+  * [1.2 图相关算法](#12)
+    + [1.2.1 图的概念](#121)
+    + [1.2.2 图的表示方法](#122)
+      - [1.2.2.1 邻接表表示法](#1221)
+      - [1.2.2.2 邻接矩阵表示法](#1222)
+    + [1.2.3 图的遍历](#123)
+      - [1.2.3.1 宽度优先遍历](#1231)
+      - [1.2.3.2 深度优先遍历](#1232)
+    + [1.2.4 图的拓扑排序](#124)
+    + [1.2.5 图的最小生成树算法](#125)
+      - [1.2.5.1 Kruskal（克鲁斯卡尔）算法](#1251)
+      - [1.2.5.2 Prim算法](#1252)
+    + [1.2.6 图的最短路径算法](#126)
+      - [1.2.6.1 Dijkstra(迪杰特斯拉)算法](#1261)
+      - [1.2.6.2 floyd算法](#1262)
+
+<h1 id='1'>1 并查集、图相关算法</h1>
+
+<h2 id='11'>1.1 并查集</h2>
+
+<h3 id='111'>1.1.1 并查集基本结构和操作</h3>
 
 1、有若干个样本a、b、c、d...类型假设是V
 
@@ -129,7 +150,7 @@ public class Code01_UnionFind {
 ```
 ==并查集用来处理连通性的问题特别方便==
 
-### 1.1.2 例题
+<h3 id='112'>1.1.2 例题</h3>
 
 学生实例有三个属性，身份证信息，B站ID,Github的Id。我们认为，任何两个学生实例，只要身份证一样，或者B站ID一样，或者Github的Id一样，我们都算一个人。给定一打拼学生实例，输出有实质有几个人？
 
@@ -257,16 +278,17 @@ public class Code07_MergeUsers {
 }
 ```
 
-## 1.2 图相关算法
-### 1.2.1 图的概念
+<h2 id='12'>1.2 图相关算法</h2>
+
+<h3 id='121'>1.2.1 图的概念</h3>
 
 1、由点的集合和边的集合构成
 
 2、虽然存在有向图和无向图的概念，但实际上都可以用有向图来表达，无向图可以理解为两个联通点互相指向
 
 3、边上可能带有权值
 
-### 1.2.2 图的表示方法
+<h3 id='122'>1.2.2 图的表示方法</h3>
 
 对于下面一张无向图，可以改为有向图：
 
@@ -282,7 +304,7 @@ D-->A
 A-->D
 ```
 
-#### 1.2.2.1 邻接表表示法
+<h4 id='1221'>1.2.2.1 邻接表表示法</h4>
 
 记录某个节点，直接到达的邻居节点：
 
@@ -296,8 +318,7 @@ D:  B,A
 
 如果是带有权重的边，可以封装我们的结构，例如A到C的权重是3,那么我们可以表示为A: C(3),D
 
-
-#### 1.2.2.2 邻接矩阵表示法
+<h4 id='1222'>1.2.2.2 邻接矩阵表示法</h4>
 
 我们把不存在路径的用正无穷表示，这里用'-'表示，例如A到C的边权重是3，可把上图表示为：
 
@@ -442,7 +463,7 @@ public class GraphGenerator {
 }
 ```
 
-### 1.2.3 图的遍历
+<h3 id='123'>1.2.3 图的遍历</h3>
 
 例如该图：
 
@@ -459,7 +480,7 @@ C-->D
 C-->E
 ```
 
-#### 1.2.3.1 宽度优先遍历
+<h4 id='1231'>1.2.3.1 宽度优先遍历</h4>
 
 1、利用队列实现
 
@@ -519,7 +540,7 @@ public class Code02_BFS {
 }
 ```
 
-#### 1.2.3.2 深度优先遍历
+<h4 id='1232'>1.2.3.2 深度优先遍历</h4>
 
 1、利用栈实现
 
@@ -584,7 +605,7 @@ public class Code02_DFS {
 }
 ```
 
-### 1.2.4 图的拓扑排序
+<h3 id='124'>1.2.4 图的拓扑排序</h3>
 
 1、在图中找到所有入度为0的点输出
 
@@ -666,11 +687,11 @@ public class Code03_TopologySort {
 }
 ```
 
-### 1.2.5 图的最小生成树算法
+<h3 id='125'>1.2.5 图的最小生成树算法</h3>
 
 > 最小生成树解释，就是在不破坏原有图点与点的连通性基础上，让连通的边的整体权值最小。返回最小权值或者边的集合
 
-#### 1.2.5.1 Kruskal（克鲁斯卡尔）算法
+<h4 id='1251'>1.2.5.1 Kruskal（克鲁斯卡尔）算法</h4>
 
 > 连通性借助并查集实现
 
@@ -800,7 +821,7 @@ public class Code04_Kruskal {
 ```
 > K算法求无向图的最小生成树，求权值是没问题的，如果纠结最小生成树的连通结构，实质是少了一侧，即A指向B, B指向A只会保留其一。可以手动补齐
 
-#### 1.2.5.2 Prim算法
+<h4 id='1252'>1.2.5.2 Prim算法</h4>
 
 > P算法无需并查集结构，普通set即可满足
 
@@ -925,9 +946,9 @@ public class Code05_Prim {
 }
 ```
 
-### 1.2.6 图的最短路径算法
+<h3 id='126'>1.2.6 图的最短路径算法</h3>
 
-#### 1.2.6.1 Dijkstra(迪杰特斯拉)算法
+<h4 id='1261'>1.2.6.1 Dijkstra(迪杰特斯拉)算法</h4>
 
 > Dijkstra算法必须要求边的权值不为负，且必须指定出发点。则可以求出发点到所有节点的最短距离是多少。如果到达不了，为正无穷
 
@@ -1159,7 +1180,6 @@ public class Code06_Dijkstra {
 
 }
 ```
-
-#### 1.2.6.2 floyd算法
+<h4 id='1262'>1.2.6.2 floyd算法</h4>
 
 > 图节点的最短路径，处理权值可能为负的情况。三层for循环，比较简单