update 0101.对称二叉树: 更改错字，优化代码风格

problems/0101.对称二叉树.md

@@ -21,7 +21,7 @@
 
 对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了**其实我们要比较的是两个树（这两个树是根节点的左右子树）**，所以在递归遍历的过程中，也是要同时遍历两棵树。
 
-那么如果比较呢？
+那么如何比较呢？
 
 比较的是两个子树的里侧和外侧的元素是否相等。如图所示：
 
@@ -80,7 +80,7 @@ else if (left == NULL && right == NULL) return true;
 else if (left->val != right->val) return false; // 注意这里我没有使用else
 ```
 
-注意上面最后一种情况，我没有使用else，而是elseif， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。
+注意上面最后一种情况，我没有使用else，而是else if， 因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。
 
 3.  确定单层递归的逻辑
 
@@ -244,7 +244,7 @@ public:
 
 这次我们又深度剖析了一道二叉树的“简单题”，大家会发现，真正的把题目搞清楚其实并不简单，leetcode上accept了和真正掌握了还是有距离的。
 
-我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如果解题的。
+我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如何解题的。
 
 在迭代法中我们使用了队列，需要注意的是这不是层序遍历，而且仅仅通过一个容器来成对的存放我们要比较的元素，知道这一本质之后就发现，用队列，用栈，甚至用数组，都是可以的。
 
@@ -259,7 +259,7 @@ public:
 
 # 其他语言版本
 
-## Java
+Java
 
 ```Java
     /**
@@ -364,7 +364,7 @@ public:
 
 ```
 
-## Python
+Python
 
 递归法:
 ```python
@@ -464,8 +464,7 @@ class Solution:
         return True
 ```
 
-## Go
-
+Go
 ```go
 /**
  * Definition for a binary tree node.
@@ -488,10 +487,12 @@ func defs(left *TreeNode, right *TreeNode) bool {
     }
     return defs(left.Left, right.Right) && defs(right.Left, left.Right);
 }
+
 func isSymmetric(root *TreeNode) bool {
     return defs(root.Left, root.Right);
 }
 
+
 // 迭代
 func isSymmetric(root *TreeNode) bool {
     var queue []*TreeNode;
@@ -515,59 +516,60 @@ func isSymmetric(root *TreeNode) bool {
 ```
 
 
-## JavaScript
+JavaScript
 
 递归判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-    //使用递归遍历左右子树 递归三部曲
+    // 使用递归遍历左右子树 递归三部曲
     // 1. 确定递归的参数 root.left root.right和返回值true false 
-    const compareNode=function(left,right){
-        //2. 确定终止条件 空的情况
-        if(left===null&&right!==null||left!==null&&right===null){
+    const compareNode = function(left, right) {
+        // 2. 确定终止条件 空的情况
+        if(left === null && right !== null || left !== null && right === null) {
             return false;
-        }else if(left===null&&right===null){
+        } else if(left === null && right === null) {
             return true;
-        }else if(left.val!==right.val){
+        } else if(left.val !== right.val) {
             return false;
         }
-        //3. 确定单层递归逻辑
-        let outSide=compareNode(left.left,right.right);
-        let inSide=compareNode(left.right,right.left);
-        return outSide&&inSide;
+        // 3. 确定单层递归逻辑
+        let outSide = compareNode(left.left, right.right);
+        let inSide = compareNode(left.right, right.left);
+        return outSide && inSide;
     }
-    if(root===null){
+    if(root === null) {
         return true;
     }
-    return compareNode(root.left,root.right);
+    return compareNode(root.left, root.right);
 };
 ```
 
 队列实现迭代判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-  //迭代方法判断是否是对称二叉树
-  //首先判断root是否为空
-  if(root===null){
+  // 迭代方法判断是否是对称二叉树
+  // 首先判断root是否为空
+  if(root === null) {
       return true;
   }
-  let queue=[];
+  let queue = [];
   queue.push(root.left);
   queue.push(root.right);
-  while(queue.length){
-      let leftNode=queue.shift();//左节点
-      let rightNode=queue.shift();//右节点
-      if(leftNode===null&&rightNode===null){
+  while(queue.length) {
+      let leftNode = queue.shift();    //左节点
+      let rightNode = queue.shift();   //右节点
+      if(leftNode === null && rightNode === null) {
           continue;
       }
-      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+      if(leftNode === null || rightNode === null || leftNode.val !== rightNode.val) {
           return false;
       }
-      queue.push(leftNode.left);//左节点左孩子入队
-      queue.push(rightNode.right);//右节点右孩子入队
-      queue.push(leftNode.right);//左节点右孩子入队
-      queue.push(rightNode.left);//右节点左孩子入队
+      queue.push(leftNode.left);     //左节点左孩子入队
+      queue.push(rightNode.right);   //右节点右孩子入队
+      queue.push(leftNode.right);    //左节点右孩子入队
+      queue.push(rightNode.left);    //右节点左孩子入队
   }
+  
   return true;
 };
 ```
@@ -575,33 +577,34 @@ var isSymmetric = function(root) {
 栈实现迭代判断是否为对称二叉树：
 ```javascript
 var isSymmetric = function(root) {
-  //迭代方法判断是否是对称二叉树
-  //首先判断root是否为空
-  if(root===null){
+  // 迭代方法判断是否是对称二叉树
+  // 首先判断root是否为空
+  if(root === null) {
       return true;
   }
-  let stack=[];
+  let stack = [];
   stack.push(root.left);
   stack.push(root.right);
-  while(stack.length){
-      let rightNode=stack.pop();//左节点
-      let leftNode=stack.pop();//右节点
-      if(leftNode===null&&rightNode===null){
+  while(stack.length) {
+      let rightNode = stack.pop();    //左节点
+      let leftNode=stack.pop();       //右节点
+      if(leftNode === null && rightNode === null) {
           continue;
       }
-      if(leftNode===null||rightNode===null||leftNode.val!==rightNode.val){
+      if(leftNode === null || rightNode === null || leftNode.val !== rightNode.val) {
           return false;
       }
-      stack.push(leftNode.left);//左节点左孩子入队
-      stack.push(rightNode.right);//右节点右孩子入队
-      stack.push(leftNode.right);//左节点右孩子入队
-      stack.push(rightNode.left);//右节点左孩子入队
+      stack.push(leftNode.left);      //左节点左孩子入队
+      stack.push(rightNode.right);    //右节点右孩子入队
+      stack.push(leftNode.right);     //左节点右孩子入队
+      stack.push(rightNode.left);     //右节点左孩子入队
   }
+  
   return true;
 };
 ```
 
-## TypeScript：
+TypeScript：
 
 > 递归法
 
@@ -670,7 +673,7 @@ function isSymmetric(root: TreeNode | null): boolean {
 };
 ```
 
-## Swift:
+Swift:
 
 > 递归
 ```swift
@@ -752,7 +755,7 @@ func isSymmetric3(_ root: TreeNode?) -> Bool {
 }
 ```
 
-## Scala
+Scala
 
 > 递归：
 ```scala