Merge branch 'youngyangyang04:master' into master

problems/0005.最长回文子串.md

@@ -363,6 +363,34 @@ class Solution:
 Go：
 
 ```go
+func longestPalindrome(s string) string {
+    maxLen := 0
+    left := 0
+    length := 0
+    dp := make([][]bool, len(s))
+    for i := 0; i < len(s); i++ {
+        dp[i] = make([]bool,len(s))
+    }
+    for i := len(s)-1; i >= 0; i-- {
+        for j := i; j < len(s); j++ {
+            if s[i] == s[j]{
+                if j-i <= 1{ // 情况一和情况二
+                    length = j-i
+                    dp[i][j]=true
+                }else if dp[i+1][j-1]{ // 情况三
+                    length = j-i
+                    dp[i][j] = true
+                }
+            }
+        }
+        if length > maxLen {
+            maxLen = length
+            left = i
+        }
+    }
+    return s[left: left+maxLen+1]
+}
+
 
 ```
 

problems/0054.螺旋矩阵.md

@@ -133,5 +133,73 @@ public:
 
 ## 其他语言版本
 
+### Java
+
+```java
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        //存放数组的数
+        List<Integer> ans = new ArrayList<>();
+        //列数
+        int columns = matrix[0].length;
+        //行数
+        int rows = matrix.length;
+        //遍历起点
+        int start = 0;
+        //循环的次数 行数和列数中的最小值除以二
+        int loop = Math.min(rows,columns) / 2;
+        //未遍历的中间列（行）的列（行）下标
+        int mid = loop;
+        //终止条件
+        int offSet = 1;
+        int i,j;
+        while(loop-- > 0) {
+            //初始化起点
+            i = j = start;
+            
+            //从左往右
+            for(; j < columns - offSet; j++)
+                ans.add(matrix[i][j]);
+
+            //从上往下
+            for(; i < rows - offSet; i++)
+                ans.add(matrix[i][j]);
+
+            //从右往左
+            for(; j > start; j--)
+                ans.add(matrix[i][j]);
+            
+            //从下往上
+            for(; i > start; i--)
+                ans.add(matrix[i][j]);
+
+            //每循环一次 改变起点位置
+            start++;
+            //终止条件改变
+            offSet++;
+        }
+
+        //如果行和列中的最小值是奇数 则会产生中间行或者中间列没有遍历
+        if(Math.min(rows,columns) % 2 != 0) {
+            //行大于列则产生中间列
+            if(rows > columns) {
+                //中间列的行的最大下标的下一位的下标为mid + rows - columns + 1
+                for(int k = mid; k < mid + rows - columns + 1; k++) {
+                    ans.add(matrix[k][mid]);
+                }
+            }else {//列大于等于行则产生中间行
+                //中间行的列的最大下标的下一位的下标为mid + columns - rows + 1
+                for(int k = mid; k < mid + columns - rows + 1; k++) {
+                    ans.add(matrix[mid][k]);
+                }
+            }
+        }
+        return ans;
+    }
+}
+```
+
+
+
 -----------------------
 <div align="center"><img src=https://code-thinking.cdn.bcebos.com/pics/01二维码一.jpg width=500> </img></div>

problems/0100.相同的树.md

@@ -237,6 +237,26 @@ class Solution:
         return True
 ```
 Go：
+> 递归法
+```go
+func isSameTree(p *TreeNode, q *TreeNode) bool {
+    if p != nil && q == nil {
+        return false
+    }
+    if p == nil && q != nil {
+        return false
+    }
+    if p == nil && q == nil {
+        return true
+    }
+    if p.Val != q.Val {
+        return false
+    }
+    Left := isSameTree(p.Left, q.Left)
+    Right := isSameTree(p.Right, q.Right)
+    return Left && Right
+}
+```
 
 JavaScript：
 
@@ -253,6 +273,28 @@ var isSameTree = function (p, q) {
     return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
 };
 ```
+> 迭代法
+
+```javascript
+var isSameTree = (p, q) => {
+    const queue = [{ p, q }];
+    // 这是用{ } 解决了null的问题！
+    while (queue.length) {
+        const cur = queue.shift();
+        if (cur.p == null && cur.q == null) continue;
+        if (cur.p == null || cur.q == null) return false;
+        if (cur.p.val != cur.q.val) return false;
+        queue.push({
+            p: cur.p.left,
+            q: cur.q.left
+        }, {
+            p: cur.p.right,
+            q: cur.q.right
+        });
+    }
+    return true;
+};
+```
 
 TypeScript:
 

problems/0102.二叉树的层序遍历.md

@@ -810,33 +810,30 @@ go:
 199. 二叉树的右视图
  */
 func rightSideView(root *TreeNode) []int {
-    queue:=list.New()
+    if root == nil {
-    res:=[][]int{}
+        return nil
-    var finaRes []int
-    if root==nil{
-        return finaRes
     }
+    res := make([]int, 0)
+    queue := list.New()
     queue.PushBack(root)
-    for queue.Len()>0{
+
-        length:=queue.Len()
+    for queue.Len() > 0 {
-        tmp:=[]int{}
+        length := queue.Len()
-        for i:=0;i<length;i++{
+        for i := 0; i < length; i++ {
-            node:=queue.Remove(queue.Front()).(*TreeNode)
+            node := queue.Remove(queue.Front()).(*TreeNode)
-            if node.Left!=nil{
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmp=append(tmp,node.Val)
+            // 取每层的最后一个元素，添加到结果集中
+            if i == length-1 {
+                res = append(res, node.Val)
+            }
         }
-        res=append(res,tmp)
     }
-    //取每一层的最后一个元素
+    return res
-    for i:=0;i<len(res);i++{
-        finaRes=append(finaRes,res[i][len(res[i])-1])
-    }
-    return finaRes
 }
 ```
 
@@ -1054,40 +1051,34 @@ go:
 637. 二叉树的层平均值
  */
 func averageOfLevels(root *TreeNode) []float64 {
-    res:=[][]int{}
+    if root == nil {
-    var finRes []float64
+        // 防止为空
-    if root==nil{//防止为空
+        return nil
-        return finRes
     }
-    queue:=list.New()
+    res := make([]float64, 0)
+    queue := list.New()
     queue.PushBack(root)
-    var tmpArr []int
+
-    for queue.Len()>0 {
+    var sum int
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+    for queue.Len() > 0 {
-        for i:=0;i<length;i++{
+        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+        length := queue.Len()
-            if node.Left!=nil{
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
+            // 当前层元素求和
+            sum += node.Val
         }
-        res=append(res,tmpArr)//放入结果集
+        // 计算每层的平均值，将结果添加到响应结果中
-        tmpArr=[]int{}//清空层的数据
+        res = append(res, float64(sum)/float64(length))
+        sum = 0 // 清空该层的数据
     }
-    //计算每层的平均值
+    return res
-    length:=len(res)
-    for i:=0;i<length;i++{
-        var sum int
-        for j:=0;j<len(res[i]);j++{
-            sum+=res[i][j]
-        }
-        tmp:=float64(sum)/float64(len(res[i]))
-        finRes=append(finRes,tmp)//将平均值放入结果集合
-    }
-    return finRes
 }
 ```
 
@@ -1552,44 +1543,40 @@ go:
 515. 在每个树行中找最大值
  */
 func largestValues(root *TreeNode) []int {
-    res:=[][]int{}
+    if root == nil {
-    var finRes []int
+        //防止为空
-    if root==nil{//防止为空
+        return nil
-        return finRes
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
-    var tmpArr []int
+    ans := make([]int, 0)
-    //层次遍历
+    temp := math.MinInt64
-    for queue.Len()>0 {
+    // 层序遍历
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+    for queue.Len() > 0 {
-        for i:=0;i<length;i++{
+        //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-            node:=queue.Remove(queue.Front()).(*TreeNode)//出队列
+        length := queue.Len()
-            if node.Left!=nil{
+        for i := 0; i < length; i++ {
+            node := queue.Remove(queue.Front()).(*TreeNode)//出队列
+            // 比较当前层中的最大值和新遍历的元素大小，取两者中大值
+            temp = max(temp, node.Val)
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node.Val)//将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        ans = append(ans, temp)
-        tmpArr=[]int{}//清空层的数据
+        temp = math.MinInt64
     }
-    //找到每层的最大值
+    return ans
-    for i:=0;i<len(res);i++{
-        finRes=append(finRes,max(res[i]...))
-    }
-    return finRes
 }
-func max(vals...int) int {
+
-    max:=int(math.Inf(-1))//负无穷
+func max(x, y int) int {
-    for _, val := range vals {
+    if x > y {
-        if val > max {
+        return x
-            max = val
-        }
     }
-    return max
+    return y
 }
 ```
 
@@ -1891,36 +1878,35 @@ go:
  */
 
 func connect(root *Node) *Node {
-   res:=[][]*Node{}
+    if root == nil { //防止为空
-    if root==nil{//防止为空
         return root
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
-    var tmpArr []*Node
+    tmpArr := make([]*Node, 0)
-    for queue.Len()>0 {
+    for queue.Len() > 0 {
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i:=0;i<length;i++{
+        for i := 0; i < length; i++ {
-            node:=queue.Remove(queue.Front()).(*Node)//出队列
+            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left!=nil{
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node)//将值加入本层切片中
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        if len(tmpArr) > 1 {
-        tmpArr=[]*Node{}//清空层的数据
+            // 遍历每层元素,指定next
-    }
+            for i := 0; i < len(tmpArr)-1; i++ {
-    //遍历每层元素,指定next
+                tmpArr[i].Next = tmpArr[i+1]
-    for i:=0;i<len(res);i++{
+            }
-        for j:=0;j<len(res[i])-1;j++{
-            res[i][j].Next=res[i][j+1]
         }
+        tmpArr = []*Node{} //清空层的数据
     }
     return root
 }
+
 ```
 
 Swift：
@@ -2172,33 +2158,31 @@ go:
  */
 
 func connect(root *Node) *Node {
-   res:=[][]*Node{}
+    if root == nil { //防止为空
-    if root==nil{//防止为空
         return root
     }
-    queue:=list.New()
+    queue := list.New()
     queue.PushBack(root)
-    var tmpArr []*Node
+    tmpArr := make([]*Node, 0)
-    for queue.Len()>0 {
+    for queue.Len() > 0 {
-        length:=queue.Len()//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
+        length := queue.Len() //保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
-        for i:=0;i<length;i++{
+        for i := 0; i < length; i++ {
-            node:=queue.Remove(queue.Front()).(*Node)//出队列
+            node := queue.Remove(queue.Front()).(*Node) //出队列
-            if node.Left!=nil{
+            if node.Left != nil {
                 queue.PushBack(node.Left)
             }
-            if node.Right!=nil{
+            if node.Right != nil {
                 queue.PushBack(node.Right)
             }
-            tmpArr=append(tmpArr,node)//将值加入本层切片中
+            tmpArr = append(tmpArr, node) //将值加入本层切片中
         }
-        res=append(res,tmpArr)//放入结果集
+        if len(tmpArr) > 1 {
-        tmpArr=[]*Node{}//清空层的数据
+            // 遍历每层元素,指定next
-    }
+            for i := 0; i < len(tmpArr)-1; i++ {
-    //遍历每层元素,指定next
+                tmpArr[i].Next = tmpArr[i+1]
-    for i:=0;i<len(res);i++{
+            }
-        for j:=0;j<len(res[i])-1;j++{
-            res[i][j].Next=res[i][j+1]
         }
+        tmpArr = []*Node{} //清空层的数据
     }
     return root
 }

problems/0129.求根到叶子节点数字之和.md

@@ -250,22 +250,22 @@ Go：
 
 ```go
 func sumNumbers(root *TreeNode) int {
-	sum = 0
+    sum := 0
-	travel(root, root.Val)
+    dfs(root, root.Val, &sum)
-	return sum
+    return sum
 }
 
-func travel(root *TreeNode, tmpSum int) {
+func dfs(root *TreeNode, tmpSum int, sum *int) {
-	if root.Left == nil && root.Right == nil {
+    if root.Left == nil && root.Right == nil {
-		sum += tmpSum
+        *sum += tmpSum
-	} else {
+    } else {
-		if root.Left != nil {
+        if root.Left != nil {
-			travel(root.Left, tmpSum*10+root.Left.Val)
+            dfs(root.Left, tmpSum*10 + root.Left.Val, sum)
-		}
+        }
-		if root.Right != nil {
+        if root.Right != nil {
-			travel(root.Right, tmpSum*10+root.Right.Val)
+            dfs(root.Right, tmpSum*10 + root.Right.Val, sum)
-		}
+        }
-	}
+    }
 }
 ```
 

problems/0844.比较含退格的字符串.md

@@ -157,7 +157,7 @@ public:
 
 ## 其他语言版本
 
-### Java：
+### Java
 
 ```java
 // 普通方法（使用栈的思路）
@@ -214,7 +214,80 @@ public static boolean backspaceCompare(String s, String t) {
 }
 ```
 
+```java
+class Solution {
+    public static boolean backspaceCompare(String s, String t) {
+        return getStr(s).equals(getStr(t));
+    }
 
+    public static String getStr(String s) { //使用快慢双指针去除字符串中的#
+        int slowIndex;
+        int fastIndex = 0;
+        StringBuilder builder = new StringBuilder(s); //StringBuilder用于修改字符串
+        for(slowIndex = 0; fastIndex < s.length(); fastIndex++) {
+            if(builder.charAt(fastIndex) != '#') {
+                builder.setCharAt(slowIndex++,builder.charAt(fastIndex));
+            } else {
+                if(slowIndex > 0) {
+                    slowIndex--;
+                }
+            }
+        }
+        return builder.toString().substring(0,slowIndex); //截取有效字符串
+    }
+}
+```
+
+从后往前双指针：
+
+```java
+class Solution {
+    public static boolean backspaceCompare(String s, String t) {
+        int sSkipNum = 0; //记录s的#的个数
+        int tSkipNum = 0; //记录t的#的个数
+        int sIndex = s.length() - 1;
+        int tIndex = t.length() - 1;
+        while(true) {
+            while(sIndex >= 0) { //每次记录连续的#并跳过被删除的字符
+                if(s.charAt(sIndex) == '#') {
+                    sSkipNum++;
+                } else {
+                    if(sSkipNum > 0) {
+                        sSkipNum--;
+                    } else {
+                        break;
+                    }
+                }
+                sIndex--;
+            }
+            while(tIndex >= 0) { //每次记录连续的#并跳过被删除的字符
+                if(t.charAt(tIndex) == '#') {
+                    tSkipNum++;
+                } else {
+                    if(tSkipNum > 0) {
+                        tSkipNum--;
+                    } else {
+                        break;
+                    }
+                }
+                tIndex--;
+            }
+            if(sIndex < 0 || tIndex < 0) { //s 或者 t遍历完了
+                break;
+            }
+            if(s.charAt(sIndex) != t.charAt(tIndex)) { //当前下标的字符不相等
+                return false;
+            }
+            sIndex--;
+            tIndex--;
+        }
+        if(sIndex == -1 && tIndex == -1) { //同时遍历完 则相等
+            return true;
+        }
+        return false;
+    }
+}
+```
 
 ### python