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;

note/026/README.md

@@ -19,7 +19,7 @@ Your function should return length = `2`, with the first two elements of *nums*
 题意是让你从一个有序的数组中移除重复的元素，并返回之后数组的长度。我的思路是判断长度小于等于1的话直接返回原长度即可，否则的话遍历一遍数组，用一个`tail`变量指向尾部，如果后面的元素和前面的元素不同，就让`tail`变量加一，最后返回`tail`即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int removeDuplicates(int[] nums) {
         int len = nums.length;
         if (len <= 1) return len;

note/027/README.md

@@ -22,7 +22,7 @@ Your function should return length = 2, with the first two elements of *nums* be
 题意是移除数组中值等于`val`的元素，并返回之后数组的长度，并且题目中指定空间复杂度为O(1)，我的思路是用`tail`标记尾部，遍历该数组时当索引元素不等于`val`时，`tail`加一，尾部指向当前元素，最后返回`tail`即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int removeElement(int[] nums, int val) {
         int tail = 0;
         for (int i = 0, len = nums.length; i < len; ++i) {

note/028/README.md

@@ -14,7 +14,7 @@ Returns the index of the first occurrence of needle in haystack, or -1 if needle
 题意是从主串中找到子串的索引，如果找不到则返回-1，我们只需要遍历主串长度减子串长度即可，利用substring比较即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int strStr(String haystack, String needle) {
         int l1 = haystack.length(), l2 = needle.length(), l3 = l1 - l2;
         for (int i = 0; i <= l3; ++i) {

note/035/README.md

@@ -21,7 +21,7 @@ Here are few examples.
 题意是让你从一个没有重复元素的已排序数组中找到插入位置的索引。因为数组已排序，所以我们可以想到二分查找法，因为查找到的条件是找到第一个等于或者大于`target`的元素的位置，所以二分法略作变动即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int searchInsert(int[] nums, int target) {
         int left = 0, right = nums.length - 1, mid = (right + left) >> 1;
         while (left <= right) {

note/038/README.md

@@ -24,7 +24,7 @@ Note: The sequence of integers will be represented as a string.
 题意是数和说，根据如下序列`1, 11, 21, 1211, 111221, ...`，求第n个数，规则很简单,就是数和说，数就是数这个数数字有几个，说就是说这个数，所以`1`就是1个1：`11`,`11`就是有2个1：`21`，`21`就是1个2、1个1：`1211`，可想而知后面就是`111221`，思路的话就是按这个逻辑模拟出来即可。
 
 ``` java
-public class Solution {
+class Solution {
     public String countAndSay(int n) {
         String str = "1";
         while (--n > 0) {

note/053/README.md

@@ -19,7 +19,7 @@ If you have figured out the O(*n*) solution, try coding another solution using t
 题意是求数组中子数组的最大和，这种最优问题一般第一时间想到的就是动态规划，我们可以这样想，当部分序列和大于零的话就一直加下一个元素即可，并和当前最大值进行比较，如果出现部分序列小于零的情况，那肯定就是从当前元素算起。其转移方程就是`dp[i] = nums[i] + (dp[i - 1] > 0 ? dp[i - 1] : 0);`，由于我们不需要保留dp状态，故可以优化空间复杂度为1，即`dp = nums[i] + (dp > 0 ? dp : 0);`。
 
 ``` java
-public class Solution {
+class Solution {
     public int maxSubArray(int[] nums) {
         int len = nums.length, dp = nums[0], max = dp;
         for (int i = 1; i < len; ++i) {
@@ -36,7 +36,7 @@ public class Solution {
 题目也给了我们另一种思路，就是分治，所谓分治就是把问题分割成更小的，最后再合并即可，我们把`nums`一分为二先，那么就有两种情况，一种最大序列包括中间的值，一种就是不包括，也就是在左边或者右边；当最大序列在中间的时候那我们就把它两侧的最大和算出即可；当在两侧的话就继续分治即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int maxSubArray(int[] nums) {
         return helper(nums, 0, nums.length - 1);
     }

note/058/README.md

@@ -22,7 +22,7 @@ return `5`.
 题意是让你从一个只包含大小字母和空格字符的字符串中得到最后一个单词的长度，很简单，我们倒序遍历，先得到最后一个非空格字符的索引，然后再得到它前面的空格字符索引，两者相减即可。当然，我们使用API来完成这件事更加方便，只需一行代码`return s.trim().length() - s.trim().lastIndexOf(" ") - 1;`，但我相信作者出这道题的目的肯定不是考你API的使用，所以我们还是用自己的思路来实现。
 
 ``` java
-public class Solution {
+class Solution {
     public int lengthOfLastWord(String s) {
         int p = s.length() - 1;
         while (p >= 0 && s.charAt(p) == ' ') p--;

note/066/README.md

@@ -16,7 +16,7 @@ The digits are stored such that the most significant digit is at the head of the
 题意是给你一个数字数组，高位在前，并且首位不为0除非这个数组就是`[0]`，让你给该数组低位加一求其结果，那么我们就模拟小学数学那样进位去算即可，如果一直进位到首位，这种情况也就是都是由9组成的数组，此时我们只要new出一个多一个长度的数组即可，并把第0个元素赋1即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int[] plusOne(int[] digits) {
         int p = digits.length - 1;
         if (digits[p] < 9) {

note/067/README.md

@@ -17,7 +17,7 @@ Return `"100"`.
 题意是给你两个二进制串，求其和的二进制串。我们就按照小学算数那么来做，用`carry`表示进位，从后往前算，依次往前，每算出一位就插入到最前面即可，直到把两个二进制串都遍历完即可。
 
 ``` java
-public class Solution {
+class Solution {
     public String addBinary(String a, String b) {
         StringBuilder sb = new StringBuilder();
         int carry = 0, p1 = a.length() - 1, p2 = b.length() - 1;

note/069/README.md

@@ -14,7 +14,7 @@ Compute and return the square root of x.
 题意是求平方根，参考[牛顿迭代法求平方根](https://wenku.baidu.com/view/6b74c622bcd126fff7050bfe.html)，然后再参考维基百科的[Integer square root](https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division)即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int mySqrt(int x) {
         long n = x;
         while (n * n > x) {

note/070/README.md

@@ -16,7 +16,7 @@ Each time you can either climb 1 or 2 steps. In how many distinct ways can you c
 题意是爬楼梯，每次你只能爬一步或者两步，问到顶层共有多少种方案。我们假设到顶层共有`f(n)`种，那么`f(n) = f(n - 1) + f(n - 2)`肯定是成立的，意思就是我们迈向顶层的最后一步是在倒数第一级台阶或者在倒数第二级台阶。算法我对空间复杂度进行了优化，因为在迭代过程中只需要两个变量即可。
 
 ``` java
-public class Solution {
+class Solution {
     public int climbStairs(int n) {
         int a = 1, b = 1;
         while (--n > 0) {

note/083/README.md

@@ -24,7 +24,7 @@ Given `1->1->2->3->3`, return `1->2->3`.
  *     ListNode(int x) { val = x; }
  * }
  */
-public class Solution {
+class Solution {
     public ListNode deleteDuplicates(ListNode head) {
         if (head == null || head.next == null) return head;
         ListNode curr = head;

note/088/README.md

@@ -15,7 +15,7 @@ You may assume that *nums1* has enough space (size that is greater or equal to *
 题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用`nums1`自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
 
 ``` java
-public class Solution {
+class Solution {
     public void merge(int[] nums1, int m, int[] nums2, int n) {
         int p = m-- + n-- - 1;
         while (m >= 0 && n >= 0)

note/100/README.md

@@ -1,27 +1,36 @@
-# [Merge Sorted Array][title]
+# [Same Tree][title]
 
 ## Description
 
-Given two sorted integer arrays *nums1* and *nums2*, merge *nums2* into *nums1* as one sorted array.
+Given two binary trees, write a function to check if they are equal or not.
 
-**Note:**
-You may assume that *nums1* has enough space (size that is greater or equal to *m* + *n*) to hold additional elements from *nums2*. The number of elements initialized in *nums1* and *nums2* are *m* and *n* respectively.
+Two binary trees are considered equal if they are structurally identical and the nodes have the same value.
 
-**Tags:** Array, Two Pointers
+**Tags:** Tree, Depth-first Search
 
 
 ## 思路
 
-题意是给两个已排序的数组`nums1`和`nums2`，合并`nums2`到`nums1`中，两数组元素个数分别为`m`和`n`，而且`nums1`数组的长度足够容纳`m + n`个元素，如果我们按顺序排下去，那肯定要开辟一个新数组来保存元素，如果我们选择逆序，这样利用`nums1`自身空间足矣，不会出现覆盖的情况，依次把大的元素插入到`nums1`的末尾，确保`nums2`中的元素全部插入到`nums1`即可。
+题意是
 
 ``` java
-public class Solution {
-    public void merge(int[] nums1, int m, int[] nums2, int n) {
-        int p = m-- + n-- - 1;
-        while (m >= 0 && n >= 0)
-            nums1[p--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
-        while (n >= 0)
-            nums1[p--] = nums2[n--];
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == null && q == null) return true;
+        if (p == null || q == null) return false;
+        if (p.val == q.val) {
+            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+        }
+        return false;
     }
 }
 ```
@@ -33,5 +42,5 @@ public class Solution {
 
 
 
-[title]: https://leetcode.com/problems/merge-sorted-array
+[title]: https://leetcode.com/problems/same-tree
 [ajl]: https://github.com/Blankj/awesome-java-leetcode