update basic traversal algorithm

Author: ligecarryme

数据结构篇/二叉树.md

@@ -25,9 +25,11 @@ const buildTreeByArray = function (array, index) {
     let tn = null;
     if (index < array.length) {
         const value = array[index];
-        tn = new TreeNode(value);
-        tn.left = buildTreeByArray(array, 2 * index + 1);
-        tn.right = buildTreeByArray(array, 2 * index + 2);
+        if (value !== null) {
+            tn = new TreeNode(value);
+            tn.left = buildTreeByArray(array, 2 * index + 1);
+            tn.right = buildTreeByArray(array, 2 * index + 2);
+        }
         return tn;
     }
     return tn;
@@ -45,7 +47,7 @@ let root = binaryTree(arr);
 
 ```js
 function preOrder(root) {
-    if(root === null || root.val === null){
+    if(root === null){
         return null;
     }
     console.log(root.val);
@@ -57,16 +59,32 @@ function preOrder(root) {
 ##### 前序非递归
 
 ```js
-
+var preOrderTraversal = function (root) {
+    if(root === null){
+        return [];
+    }
+    let res = [];
+    let stack = [];
+    stack.push(root);
+    while(stack.length !== 0){
+        let node = stack.pop();
+        res.push(node.val);
+        if (node.right !== null) {
+            stack.push(node.right);
+        }
+        if (node.left !== null) {
+            stack.push(node.left);
+        }
+    }
+    return res;
+}
 ```
 
-
-
 ##### 中序递归
 
 ```js
 function inOrder(root){
-    if(root === null || root.val === null){
+    if(root === null){
         return null;
     }
     inOrder(root.left);
@@ -75,11 +93,34 @@ function inOrder(root){
 }
 ```
 
+##### 中序非递归
+
+```js
+var inOrderTraversal = function(root){
+    if (root === null) {
+        return [];
+    }
+    let res = [];
+    let stack = [];
+    let node = root;
+    while(stack.length!==0 || node!==null){
+        while(node !== null){
+            stack.push(node);
+            node = node.left;
+        }
+        node = stack.pop();
+        res.push(node.val);
+        node = node.right;
+    }
+    return res;
+}
+```
+
 ##### 后序递归
 
 ```js
 function postOrder(root){
-    if(root === null || root.val === null){
+    if(root === null){
         return null;
     }
     postOrder(root.left);
@@ -88,7 +129,90 @@ function postOrder(root){
 }
 ```
 
+##### 后序非递归
+
+```js
+var postOrderTraversal = function(root){  //翻转非递归 后序遍历
+    if (root === null) {
+        return [];
+    }
+    let res = [];
+    let stack = [];
+    stack.push(root);
+    while(stack.length !== 0){
+        let node = stack.pop();
+        res.push(node.val);
+        if (node.left !== null) {
+            stack.push(node.left);
+        }
+        if (node.right !== null) {
+            stack.push(node.right);
+        }
+    }
+    return res.reverse();
+}
+```
 
+##### 深度遍历
+
+```js
+var dfsUpToDown = function(root){  //递归，从上到下
+    let res = [];
+    dfs(root, res);
+    return res;
+}
+
+var dfs = function(node, res){
+    if (node === null) {
+        return null;
+    }
+    res.push(node.val);
+    dfs(node.left, res);
+    dfs(node.right, res);
+}
+
+var dfsDownToUp = function(root){ //从下到上
+    return divideAndConquer(root);
+}
+
+var divideAndConquer = function(node){ // 分治法
+    let res = [];
+    if (node === null) {
+        return null;
+    }
+    let left = divideAndConquer(node.left);
+    let right = divideAndConquer(node.right);
+    res.push(node.val);
+    if (left !== null) {
+        res = res.concat(left.flat());
+    }
+    if (right !== null) {
+        res = res.concat(right.flat());
+    }
+    return res;
+}
+```
+
+##### 广度遍历
+
+```js
+var bfs = function(root){
+    let res = [];
+    let queue = [];
+    queue.push(root);
+    while(queue.length !== 0){
+        let node = queue.shift();
+        res.push(node.val);
+        if (node.left !== null) {
+            queue.push(node.left);
+        }
+        if (node.right !== null) {
+            queue.push(node.right);
+        }
+    }
+    return res;
+}
+```
 
 ##### 104.二叉树的最大深度[二叉树的最大深度](https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/)
 
@@ -109,7 +233,7 @@ var maxDepth = function(root) {   //递归
     if(root === null){
         return 0;
     }
-    return Math.max(maxDepth(root.left), 				maxDepth(root.right))+1;
+    return Math.max(maxDepth(root.left), 								maxDepth(root.right))+1;
 };
 ```