feat: add 100 and fix code

Author: Blankj

README.md

@@ -26,6 +26,7 @@
 |70|[Climbing Stairs][070]|Dynamic Programming|
 |83|[Remove Duplicates from Sorted List][083]|Linked List|
 |88|[Merge Sorted Array][088]|Array, Two Pointers|
+|100|[Same Tree][100]|Tree, Depth-first Search|
 
 
 ## Medium
@@ -69,6 +70,7 @@
 [070]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/070/README.md
 [083]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/083/README.md
 [088]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/088/README.md
+[100]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/100/README.md
 
 [008]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/008/README.md
 [019]: https://github.com/Blankj/awesome-java-leetcode/blob/master/note/019/README.md

note/001/README.md

@@ -23,7 +23,7 @@ return [0, 1].
 题意是让你从给定的数组中找到两个元素的和为指定值的两个索引，最容易的当然是循环两次，复杂度为`O(n^2)`，首次提交居然是2ms，打败了100%的提交，谜一样的结果，之后再次提交就再也没跑到过2ms了。
 
 ``` java
-public class Solution {
+class Solution {
  public int[] twoSum(int[] nums, int target) {
  int st = 0, end = nums.length;
  for (int i = 0; i < end; ++i) {

note/007/README.md

@@ -32,7 +32,7 @@ The input is assumed to be a 32-bit signed integer. Your function should **retur
 题意是给你一个整型数，求它的逆序整型数，而且有个小坑点，当它的逆序整型数溢出的话，那么就返回0，用我们代码表示的话可以求得结果保存在long中，最后把结果和整型的两个范围比较即可。
 
 ``` java
-public class Solution {
+class Solution {
  public int reverse(int x) {
  long res = 0;
  for (; x != 0; x /= 10)

note/008/README.md

@@ -28,7 +28,7 @@ If no valid conversion could be performed, a zero value is returned. If the corr
 题意是把一个字符串转为整型，但要注意所给的要求，先去除最前面的空格，然后判断正负数，注意正数可能包含`+`，如果之后存在非数字或全为空则返回`0`，而如果合法的值超过int表示的最大范围，则根据正负号返回`INT_MAX`或`INT_MIN`。
 
 ``` java
-public class Solution {
+class Solution {
  public int myAtoi(String str) {
  int i = 0, ans = 0, sign = 1, len = str.length();
  while (i < len && str.charAt(i) == ' ') ++i;

note/009/README.md

@@ -24,7 +24,7 @@ There is a more generic way of solving this problem.
 题意是判断一个有符号整型数是否是回文，也就是逆序过来的整数和原整数相同，首先负数肯定不是，接下来我们分析一下最普通的解法，就是直接算出他的回文数，然后和给定值比较即可。
 
 ``` java
-public class Solution {
+class Solution {
  public boolean isPalindrome(int x) {
  if (x < 0) return false;
  int copyX = x, reverse = 0;

note/013/README.md

@@ -20,7 +20,7 @@ Input is guaranteed to be within the range from 1 to 3999.
 那么我们可以利用map来完成罗马数字的7个数字符号：I、V、X、L、C、D、M和整数的映射关系，然后根据上面的解释来模拟完成即可。
 
 ``` java
-public class Solution {
+class Solution {
  public int romanToInt(String s) {
  Map<Character, Integer> map = new HashMap<>();
  map.put('I', 1);

note/014/README.md

@@ -12,7 +12,7 @@ Write a function to find the longest common prefix string amongst an array of st
 题意是让你从字符串数组中找出公共前缀，我的想法是找出最短的那个字符串的长度`minLen`，然后在`0...minLen`的范围比较所有字符串，如果比较到有不同的字符，那么直接返回当前索引长度的字符串即可，否则最后返回最短的字符串即可。
 
 ``` java
-public class Solution {
+class Solution {
  public String longestCommonPrefix(String[] strs) {
  int len = strs.length;
  if (len == 0) return "";

note/019/README.md

@@ -34,7 +34,7 @@ Try to do this in one pass.
  * ListNode(int x) { val = x; }
  * }
  */
-public class Solution {
+class Solution {
  public ListNode removeNthFromEnd(ListNode head, int n) {
  ListNode pre = head;
  ListNode afterPreN = head;

note/020/README.md

@@ -14,7 +14,7 @@ The brackets must close in the correct order, `"()"` and `"()[]{}"` are all vali
 题意是判断括号匹配是否正确，很明显，我们可以用栈来解决这个问题，当出现左括号的时候入栈，当遇到右括号时，判断栈顶的左括号是否何其匹配，不匹配的话直接返回`false`即可，最终判断是否空栈即可，这里我们可以用数组模拟栈的操作使其操作更快，有个细节注意下`top = 1;`，从而省去了之后判空的操作和`top - 1`导致数组越界的错误。
 
 ``` java
-public class Solution {
+class Solution {
  public boolean isValid(String s) {
  int len = s.length();
  char[] stack = new char[len + 1];

note/021/README.md

@@ -27,7 +27,7 @@ Your function should return length = `2`, with the first two elements of *nums*
  * ListNode(int x) { val = x; }
  * }
  */
-public class Solution {
+class Solution {
  public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
  ListNode head = new ListNode(0);
  ListNode temp = head;