【labuladong算法之JavaScript代码】手把手刷二叉树算法：思路篇、构造篇、

东哥带你刷二叉树（思路篇）

226. 翻转二叉树

//力扣 226 翻转二叉树
//遍历思维
function traverse(root){
    if(root == null) return null;
    let tmp = root.left
    root.left = root.right
    root.right = tmp
    
    traverse(root.left)
    traverse(root.right)
}
var invertTree = function(root) {
    traverse(root)
    return root
};

//分解问题思维
var invertTree = function(root) {
    if(root == null) return null;

    let left = invertTree(root.left)
    let right = invertTree(root.right)

    root.left = right
    root.right = left
    return root
};

116. 填充每个节点的下一个右侧节点指针

 function traverse(node1,node2){
     if (node1 == null || node2 == null) return null;
      // 将传入的两个节点穿起来
     node1.next = node2
     // 连接相同父节点的两个子节点
     traverse(node1.left,node1.right)
     traverse(node2.left,node2.right)

     // 连接跨越父节点的两个子节点
     traverse(node1.right,node2.left)

 }
var connect = function(root) {
    if (root == null) return null;
    traverse(root.left,root.right)
    return root
};

114. 二叉树展开为链表

• 注意 flatten 函数的签名，返回类型为 void，也就是说题目希望我们在原地把二叉树拉平成链表，无法通过遍历解决

 // 定义：将以 root 为根的树拉平为链表
var flatten = function(root) {
    if(root == null ) return null;

    flatten(root.left)
    flatten(root.right)
    /**** 后序遍历位置 ****/
    // 1、左右子树已经被拉平成一条链表
    let left = root.left
    let right = root.right
    // 2、将左子树作为右子树
    root.left = null
    root.right = left
    
    // 3、将原先的右子树接到当前右子树的末端
    let p = root
    while (p.right !== null){
        p = p.right
    }
    p.right = right
    
};

东哥带你刷二叉树（构造篇）

654. 最大二叉树

var constructMaximumBinaryTree = function (nums) {
    const BuildTree = (arr, left, right) => {
        if (left > right)
            return null;
        let maxValue = -1;
        let maxIndex = -1;
        for (let i = left; i <= right; ++i) {
            if (arr[i] > maxValue) {
                maxValue = arr[i];
                maxIndex = i;
            }
        }
        let root = new TreeNode(maxValue);
        root.left = BuildTree(arr, left, maxIndex - 1);
        root.right = BuildTree(arr, maxIndex + 1, right);
        return root;
    }
    let root = BuildTree(nums, 0, nums.length - 1);
    return root;
}

105. 从前序与中序遍历序列构造二叉树

• 获取数组中某个树的索引

let index = inorder.findIndex(number => number === root.val)

var buildTree = function(preorder, inorder) {
    if(!preorder.length)
        return null;
    let root = new TreeNode(preorder[0]);
    let mid = inorder.findIndex((number) => number === root.val);
    root.left = buildTree(preorder.slice(1, mid + 1), inorder.slice(0, mid));
    root.right = buildTree(preorder.slice(mid + 1, preorder.length), inorder.slice(mid + 1, inorder.length));
    return root;
};

106. 从中序与后序遍历序列构造二叉树

var buildTree = function(inorder, postorder) {
    if (!postorder.length) return null
    
    let root = new TreeNode(postorder[postorder.length - 1])
    
    let index = inorder.findIndex(number => number === root.val)
    
    root.left = buildTree(inorder.slice(0, index), postorder.slice(0, index))
    root.right = buildTree(inorder.slice(index + 1, inorder.length), postorder.slice(index, postorder.length - 1))
    
    return root
};

889. 根据前序和后序遍历构造二叉树

• indexOf():返回数组特定某数值的索引

var constructFromPrePost = function(pre, post) {

    if(pre.length == 0){
        return null;
    };

    let tmp = pre[0];
    let index = post.indexOf(pre[1]);
    let root = new TreeNode(tmp);
    root.left = constructFromPrePost(pre.slice(1,index+2),post.slice(0,index+1)); //index+2为选定2个节点
    root.right = constructFromPrePost(pre.slice(index+2),post.slice(index+1,post.length-1));
    return root;
};