feat 二叉树

pom.xml

@@ -22,6 +22,12 @@
             <version>1.0-SNAPSHOT</version>
         </dependency>
 
+        <dependency>
+            <groupId>org.skyscreamer</groupId>
+            <artifactId>jsonassert</artifactId>
+            <version>1.5.1</version>
+        </dependency>
+
         <!-- https://mvnrepository.com/artifact/cglib/cglib -->
         <dependency>
             <groupId>cglib</groupId>

src/main/java/algorithm_practice/LeetCode/code000/E035_搜索插入位置.java

@@ -12,7 +12,7 @@
 输入: [1,3,5,6], 5
 输出: 2
 
-示例 2:
+示例 2:
 输入: [1,3,5,6], 2
 输出: 1
 

src/main/java/algorithm_practice/LeetCode/code000/E069_x的平方根.java

@@ -4,9 +4,9 @@
 import org.junit.Test;
 
 /*
-实现 int sqrt(int x) 函数。
+实现 int sqrt(int x) 函数。
 
-计算并返回 x 的平方根，其中 x 是非负整数。
+计算并返回 x 的平方根，其中 x 是非负整数。
 
 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
 
@@ -18,7 +18,7 @@
 输入: 8
 输出: 2
 说明: 8 的平方根是 2.82842...,
-     由于返回类型是整数，小数部分将被舍去。
+     由于返回类型是整数，小数部分将被舍去。
 
 来源：力扣（LeetCode）
 链接：https://leetcode-cn.com/problems/sqrtx

src/main/java/algorithm_practice/LeetCode/code000/E083_删除排序链表中的重复元素.java

@@ -9,11 +9,11 @@
 /*
 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
 
-示例 1:
+示例 1:
 输入: 1->1->2
 输出: 1->2
 
-示例 2:
+示例 2:
 输入: 1->1->2->3->3
 输出: 1->2->3
 

src/main/java/algorithm_practice/LeetCode/code000/H051_N皇后.java

@@ -9,7 +9,7 @@
 import java.util.List;
 
 /*
-n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
+n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
 
  [".Q..",
   "...Q",
@@ -18,11 +18,11 @@
 
 上图为 8 皇后问题的一种解法。
 
-给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
+给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。
 
-每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
+每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。
 
- 
+ 
 
 示例：
 
@@ -39,7 +39,7 @@
   ".Q.."]
 ]
 解释: 4 皇后问题存在两个不同的解法。
- 
+ 
 
 提示：
 

src/main/java/algorithm_practice/LeetCode/code000/H057_插入区间.java

@@ -11,17 +11,17 @@
 
 在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
 
- 
+ 
 
-示例 1：
+示例 1：
 
 输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
 输出：[[1,5],[6,9]]
-示例 2：
+示例 2：
 
 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
 输出：[[1,2],[3,10],[12,16]]
-解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
 
 
 来源：力扣（LeetCode）

src/main/java/algorithm_practice/LeetCode/code000/H072_编辑距离.java

@@ -4,24 +4,24 @@
 import org.junit.Test;
 
 /*
-给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
+给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。
 
 你可以对一个单词进行如下三种操作：
 
 插入一个字符
 删除一个字符
 替换一个字符
- 
+ 
 
-示例 1：
+示例 1：
 
 输入：word1 = "horse", word2 = "ros"
 输出：3
 解释：
 horse -> rorse (将 'h' 替换为 'r')
 rorse -> rose (删除 'r')
 rose -> ros (删除 'e')
-示例 2：
+示例 2：
 
 输入：word1 = "intention", word2 = "execution"
 输出：5

src/main/java/algorithm_practice/LeetCode/code000/M011_盛最多水的容器.java

@@ -4,8 +4,8 @@
 import org.junit.Test;
 
 /*
-给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
-说明：你不能倾斜容器，且 n 的值至少为 2。
+给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+说明：你不能倾斜容器，且 n 的值至少为 2。
 
 示例:
 输入: [1,8,6,2,5,4,8,3,7]

src/main/java/algorithm_practice/LeetCode/code000/M015_三数之和.java

@@ -10,7 +10,7 @@
 import java.util.List;
 
 /*
-给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
+给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。
 
 注意：答案中不可以包含重复的三元组。
 

src/main/java/algorithm_practice/LeetCode/code000/M016_最接近的三数之和.java

@@ -6,7 +6,7 @@
 import java.util.Arrays;
 
 /*
-给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
+给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
 
 例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).

src/main/java/algorithm_practice/LeetCode/code000/M019_删除链表的倒数第N个节点.java

@@ -7,15 +7,15 @@
 import org.junit.Test;
 
 /*
-给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
+给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
 
 示例：
 给定一个链表: 1->2->3->4->5, 和 n = 2.
 
 当删除了倒数第二个节点后，链表变为 1->2->3->5.
 
 说明：
-给定的 n 保证是有效的。
+给定的 n 保证是有效的。
 
 进阶：
 你能尝试使用一趟扫描实现吗？

src/main/java/algorithm_practice/LeetCode/code000/M033_搜索旋转排序数组.java

@@ -7,19 +7,19 @@
 /*
 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
 
-( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
+( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。
 
-搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
+搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。
 
 你可以假设数组中不存在重复的元素。
 
-你的算法时间复杂度必须是 O(log n) 级别。
+你的算法时间复杂度必须是 O(log n) 级别。
 
 示例 1:
 
 输入: nums = [4,5,6,7,0,1,2], target = 0
 输出: 4
-示例 2:
+示例 2:
 
 输入: nums = [4,5,6,7,0,1,2], target = 3
 输出: -1

src/main/java/algorithm_practice/LeetCode/code000/M034_在排序数组中查找元素的第一个和最后一个位置.java

@@ -6,14 +6,14 @@
 
 /*
 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。
-你的算法时间复杂度必须是 O(log n) 级别。
-如果数组中不存在目标值，返回 [-1, -1]。
+你的算法时间复杂度必须是 O(log n) 级别。
+如果数组中不存在目标值，返回 [-1, -1]。
 
 示例 1:
 输入: nums = [5,7,7,8,8,10], target = 8
 输出: [3,4]
 
-示例 2:
+示例 2:
 输入: nums = [5,7,7,8,8,10], target = 6
 输出: [-1,-1]
 

src/main/java/algorithm_practice/LeetCode/code000/M039_组合总和.java

@@ -7,32 +7,32 @@
 import java.util.*;
 
 /*
-给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 
-candidates 中的数字可以无限制重复被选取。
+candidates 中的数字可以无限制重复被选取。
 
 说明：
 
-所有数字（包括 target）都是正整数。
-解集不能包含重复的组合。 
-示例 1：
+所有数字（包括 target）都是正整数。
+解集不能包含重复的组合。 
+示例 1：
 
 输入：candidates = [2,3,6,7], target = 7,
 所求解集为：
 [
   [7],
   [2,2,3]
 ]
-示例 2：
+示例 2：
 
 输入：candidates = [2,3,5], target = 8,
 所求解集为：
 [
-  [2,2,2,2],
-  [2,3,3],
-  [3,5]
+  [2,2,2,2],
+  [2,3,3],
+  [3,5]
 ]
- 
+ 
 
 提示：
 

src/main/java/algorithm_practice/LeetCode/code000/M040_组合总和2.java

@@ -8,31 +8,31 @@
 import java.util.stream.Collectors;
 
 /*
-给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
 
-candidates 中的每个数字在每个组合中只能使用一次。
+candidates 中的每个数字在每个组合中只能使用一次。
 
 说明：
 
 所有数字（包括目标数）都是正整数。
-解集不能包含重复的组合。 
-示例 1:
+解集不能包含重复的组合。 
+示例 1:
 
-输入: candidates = [10,1,2,7,6,1,5], target = 8,
+输入: candidates = [10,1,2,7,6,1,5], target = 8,
 所求解集为:
 [
   [1, 7],
   [1, 2, 5],
   [2, 6],
   [1, 1, 6]
 ]
-示例 2:
+示例 2:
 
-输入: candidates = [2,5,2,1,2], target = 5,
+输入: candidates = [2,5,2,1,2], target = 5,
 所求解集为:
 [
-  [1,2,2],
-  [5]
+  [1,2,2],
+  [5]
 ]
 
 

src/main/java/algorithm_practice/LeetCode/code000/M056_合并区间.java

@@ -14,7 +14,7 @@
 输出: [[1,6],[8,10],[15,18]]
 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
 
-示例 2:
+示例 2:
 输入: [[1,4],[4,5]]
 输出: [[1,5]]
 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

src/main/java/algorithm_practice/LeetCode/code000/M060_第k个排列.java

@@ -5,27 +5,27 @@
 import org.junit.Test;
 
 /*
-给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。
+给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。
 
-按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
+按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
 
 "123"
 "132"
 "213"
 "231"
 "312"
 "321"
-给定 n 和 k，返回第 k 个排列。
+给定 n 和 k，返回第 k 个排列。
 
 说明：
 
-给定 n 的范围是 [1, 9]。
-给定 k 的范围是[1,  n!]。
-示例 1:
+给定 n 的范围是 [1, 9]。
+给定 k 的范围是[1,  n!]。
+示例 1:
 
 输入: n = 3, k = 3
 输出: "213"
-示例 2:
+示例 2:
 
 输入: n = 4, k = 9
 输出: "2314"

src/main/java/algorithm_practice/LeetCode/code000/M061_旋转链表.java

@@ -7,23 +7,23 @@
 import org.junit.Test;
 
 /*
-给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
+给定一个链表，旋转链表，将链表每个节点向右移动 k 个位置，其中 k 是非负数。
 
-示例 1:
+示例 1:
 输入: 1->2->3->4->5->NULL, k = 2
 输出: 4->5->1->2->3->NULL
 解释:
 向右旋转 1 步: 5->1->2->3->4->NULL
 向右旋转 2 步: 4->5->1->2->3->NULL
 
-示例 2:
+示例 2:
 输入: 0->1->2->NULL, k = 4
 输出: 2->0->1->NULL
 解释:
 向右旋转 1 步: 2->0->1->NULL
 向右旋转 2 步: 1->2->0->NULL
-向右旋转 3 步: 0->1->2->NULL
-向右旋转 4 步: 2->0->1->NULL
+向右旋转 3 步: 0->1->2->NULL
+向右旋转 4 步: 2->0->1->NULL
 
 来源：力扣（LeetCode）
 链接：https://leetcode-cn.com/problems/rotate-list