更新题解

Author: muyids

README.md

@@ -10,7 +10,8 @@ collect some good articles about data structure and algorithm.
 
 ## 简介
 
-力扣常见考察的知识点大概有十几种，包括：**二分，滑动窗口，双指针，单调栈（单调队列），链表，二叉树，字符串处理，dfs + 回溯，并查集，动态规划，贪心，位运算，数论（质数、约数、欧拉函数、欧几里得算法、中国剩余定理、简单博弈论等），图论（dfs、bfs、flood fill、拓扑排序、二分染色、最短路、最小生成树等）**
+力扣常见考察的知识点大概有十几种，包括：**二分，滑动窗口，双指针，单调栈（单调队列），链表，二叉树，字符串处理，dfs + 回溯，并查集，动态规划，贪心，位运算，
+数论（质数、约数、欧拉函数、欧几里得算法、中国剩余定理、简单博弈论等），图论（dfs、bfs、flood fill、拓扑排序、二分染色、最短路、最小生成树等）**
 
 系统性地学习算法会有事半功倍的效果，于是我归纳了一些基础算法的知识点，并对力扣上的相关题目进行了整理
 
@@ -20,7 +21,7 @@ collect some good articles about data structure and algorithm.
 
 [我的力扣主页](https://leetcode-cn.com/u/muyids/)
 
-访问[我的电子书《从零开始学算法》](http://muyids.com/alg/)，获取更好的阅读体验
+访问[我的电子书《从零开始学算法》](https://muyids.github.io/alg/)，获取更好的阅读体验
 
 ## ♨️ 导图
 
@@ -49,17 +50,16 @@ collect some good articles about data structure and algorithm.
 └── TOC-By-Tag.md -- 按分类查看目录
 ```
 
- 
-
+## 工具
 
-## 🔐 Problems & Solutions
 
-完成进度（[834](./TOC-By-ID.md)🔑/ [1770](https://leetcode-cn.com/problemset/all/)🔒) 
+ 
 
+## 🔐 Problems & Solutions
 
+完成进度（[886](./TOC-By-ID.md)🔑/ [2385](https://leetcode-cn.com/problemset/all/)🔒) 
 
 - 🔗 [标签查找](./TOC-By-Tag.md)
 
 - 🔗 [题号查找](./TOC-By-ID.md)
 
-

TOC-By-ID.md

@@ -1,13 +1,10 @@
+## 解题思路
 
+两种二分模板的选择
 
-### 解题思路
+[l, mid-1], [mid, r] 和 [l, mid], [mid+1, r]
 
-二分模板
-
-[l, mid -1], [mid, r]
-
-
-### 代码
+## 代码
 
 ```cpp
 class Solution {

TOC-By-Tag.md

@@ -1,3 +1,5 @@
+
+
 编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
 
 每行中的整数从左到右按升序排列。

algorithms/1-100/69.sqrtx.md

@@ -1,124 +1,46 @@
-
-## 深度优先搜索
-
-分析
-
-递归所有节点满足，二叉树的左孩子 < 根, 右孩子 > 根
-
-代码
-
-```javascript
-var isValidBST = function(root) {
-
- function dfs(root){
- if (root == null){
- return true
- }
- if (root.left){
- if (root.left.val >= root.val) return false
- }
- if (root.right){
- if (root.right.val <= root.val) return false
+## 中序遍历-非递归
+
+
+```java
+class Solution {
+ long tmp = Long.MIN_VALUE;
+ public boolean isValidBST(TreeNode p) {
+ if (null == p) return true;
+ Deque<TreeNode> stk = new LinkedList<>();
+ while (p != null || !stk.isEmpty()){ 
+ while (p != null) { // 先把左子树的左孩子依次进栈
+ stk.addLast(p);
+ p = p.left;
+ }
+ p = stk.removeLast(); // 访问根节点
+ if (p.val <=tmp) return false;
+ tmp = p.val;
+ p = p.right; // 下一轮右孩子的左边孩子依次入栈
  }
-
- return dfs(root.left) && dfs(root.right)
+ return true;
  }
-
- return dfs(root)
-};
+}
 ```
 
-但是这样也不一定正确，如下面的case就不通过
+## 中序遍历-递归
 
-[10,5,15,null,null,6,20] 返回true,期望false
+```java
+class Solution {
+ long tmp = Long.MIN_VALUE;
 
-实际上BST，需要整个右子树都大于根，整个左子树都小于根
-
-前面已经判断了，右孩子一定大于根，左孩子一定小于根；
-
-需要再附加条件：**任意节点的值必须大于其左子树的最右节点；同时小于右子树的最左节点。从根节点开始检查，一旦发现不满足则返回false。**
-
-整理代码
-
-```javascript
-var isValidBST = function(root) {
-
- function dfs(root){
- if (root == null ){
- return true
- }
- if (root.left){
- if (root.left.val >= root.val) return false
- let rightest = getRightest(root.left)
- if (rightest && root.val <= rightest.val) return false
-
- }
- if (root.right){
- if (root.right.val <= root.val) return false
- let leftest = getLeftest(root.right)
- if (leftest && root.val >= leftest.val) return false
- }
-
- return dfs(root.left) && dfs(root.right)
- }
-
- function getRightest(node){
- while (node && node.right) node = node.right
- return node
- }
-
- function getLeftest(node){
- while (node && node.left) node = node.left
- return node
- }
-
- return dfs(root)
-};
-```
-
-自上往下递归，传入当前子树所有值应该在的区间
-
-x [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]
-y	z
-m	n	p	q
-
-y取值 [Number.MIN_SAFE_INTEGER, x-1]
-z取值 [x+1, Number.MAX_SAFE_INTEGER]
-依次递推
-
-```javascript
-var isValidBST = function(root) {
- function dfs(root, low, high){
- if (root == null) return true
- if (root.left && root.left.val >= root.val)return false
- if (root.right && root.right.val <= root.val)return false
- if (root.left && root.left.val < low) return false
- if (root.right && root.right.val > high) return false
- return dfs(root.left, low, root.val-1) && dfs(root.right, root.val+1, high)
+ public boolean isValidBST(TreeNode p) {
+ if (null == p) return true;
+ boolean left = isValidBST(p.left);
+ if (p.val <= tmp) return false;
+ tmp = p.val;
+ boolean right = isValidBST(p.right);
+ return left && right;
  }
- return dfs(root, Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER)
-};
-
+}
 ```
 
-### 中序遍历
+## 二叉搜索树的性质
 
-```javascript
-var isValidBST = function(root) {
- var queue = []
- function dfs(root){
- if (!root) return
- if (root.left) dfs(root.left)
- if (root) queue.push(root.val)
- if (root.right) dfs(root.right)
- }
+二叉搜索树的性质是： 左子树最右节点 < 根 < 右子树的最左节点
 
- dfs(root)
-
- for (let i =0; i< queue.length-1; i++){
- if (queue[i] >= queue[i+1]) return false
- }
-
- return true
-};
-```
+缺点：两次遍历，性能差

algorithms/1-100/74.search-a-2d-matrix.md

@@ -21,6 +21,36 @@
 
 ### bfs
 
+
+
+java
+
+```java
+class Solution {
+ public int minDepth(TreeNode root) {
+ if (root == null) return 0;
+ Queue<TreeNode> q = new ArrayDeque<>();
+ int floor = 0;
+ q.add(root);
+ while (!q.isEmpty()) {
+ floor++;
+ int k = q.size();
+ while (k-- > 0) {
+ TreeNode top = q.poll();
+ if (top.left == null && top.right == null) return floor;
+ if (top.left != null) q.add(top.left);
+ if (top.right!=null) q.add(top.right);
+ }
+ }
+ return -1;
+ }
+}
+```
+
+
+
+c++
+
 ```cpp
 class Solution {
 public:
@@ -48,6 +78,24 @@ public:
 
 ### dfs
 
+Java
+
+```java
+class Solution {
+ public int minDepth(TreeNode root) {
+ if (root== null) return 0;
+ int left = minDepth(root.left);
+ int right = minDepth(root.right);
+ if (left == 0 || right == 0) return left+right + 1;
+ return Math.min(left, right) + 1;
+ }
+}
+```
+
+
+
+c++
+
 ```cpp
 class Solution {
 public: