二叉树的遍历

二叉树

前言

二叉树是一种典型的树状数据结构，本篇文章，包含以下内容：
* 前序遍历
* 中序遍历
* 后序遍历
* 二叉树的还原构造
** 通过中序与后序遍历序列构造二叉树
** 通过前序与中序遍历序列构造二叉树

默认定义二叉树节点结构如下：

function TreeNode(val) {
    this.val = val;
    this.left = this.right = null;
}

前序遍历

前序遍历首先访问根节点，然后遍历左子树，最后遍历右子树，传送门

递归解法

var preorderTraversal = function(root) {
    var ans = []; // 返回遍历之后的节点数组

    dfs(root, ans);
    return ans;
};
// 递归函数
var dfs = function(node, ans) {
    if(!node) return;

    ans.push(node.val); // 先访问根节点

    dfs(node.left, ans); // 再递归遍历左节点
    dfs(node.right, ans); // 最后递归遍历右节点
}

迭代解法

迭代和递归的区别是，递归是函数自己调用自己，使用递归的方式比较简单；迭代是将输出作为输入，再次进行处理；

var preorderTraversal = function(root) {
    var ans = [];
    var stack = []; // 采用栈的辅助空间

    if(!root) return ans;
    stack.push(root); // 首先把根节点押入栈

    while(stack.length > 0) {
        var node = stack.pop();
        ans.push(node.val);

        if(node.right) { // 先把右节点先于左节点压入栈，因为栈是后入先出的结构。
            stack.push(node.right);
        }
        if(node.left) {
            stack.push(node.left);
        }
    }

    return ans;
};

中序遍历

中序遍历是先遍历左子树，然后访问根节点，然后遍历右子树，传送门

递归解法

var inorderTraversal = function(root) {
    var ans = [];

    if(!root) return ans;

    dfs(root, ans);

    return ans;
};
// 递归函数
var dfs = function(node, ans) {
    if(!node) return;

    dfs(node.left, ans); // 先递归遍历左节点
    ans.push(node.val);  // 再访问根节点
    dfs(node.right, ans); // 最后递归遍历右节点
}

迭代解法

var inorderTraversal = function(root) {
    var ans = [];
    var stack = []; // 采用栈的辅助空间
    if(!root) return ans;

    while(true) { 
        if(root != null) { // 先从左节点开始遍历，如果左节点不为空，把它压入栈，继续判断左节点的左节点
            stack.push(root);
            root = root.left; // 这样子保证了左节点一直是后于它的根节点压入栈
        } else {
            if(stack.length === 0) break;
            root = stack.pop(); // 根据上面的判断，如果左节点为空了，那么把栈顶元素（根节点）推出栈
            ans.push(root.val);
            root = root.right; // 然后判断它的右节点是否存在，存在则是上面的判断，继续压入栈，寻找这个右节点的左节点，不断循环这个过程
        }
    }

    return ans;
};

后序遍历

后序遍历是先遍历左子树，然后遍历右子树，最后访问树的根节点，传送门

递归解法

var postorderTraversal = function(root) {
    var ans = [];

    if(!root) return ans;

    dfs(root, ans);

    return ans;
};
// 递归函数
var dfs = function(node, ans) {
    if(!node) return;

    dfs(node.left, ans); // 先递归遍历左节点
    dfs(node.right, ans); // 再递归遍历右节点
    ans.push(node.val); // 最后访问根节点
}

迭代解法

后序遍历反过来就是，先遍历根节点，再遍历右节点，最后遍历左节点，类似前序遍历，只是左右节点遍历顺序不同

var postorderTraversal = function(root) {
    var ans = [];
    var stack = [];

    if(!root) return ans;

    stack.push(root);
    while(stack.length > 0) {
        var node = stack.pop();
        ans.push(node.val);

        if(node.left) {  // 这里和前序遍历不一样，先把左节点压入栈，再把右节点压入栈
            stack.push(node.left);
        }
        if(node.right) {
            stack.push(node.right);
        }
    }

    return ans.reverse(); // 最后把数组反转一下
};

二叉树的还原构造

前面我们知道了二叉树的三种遍历方式，通过两种组合：中序与后序遍历序列、前序与中序遍历序列 我们也可以把二叉树的构造还原。

通过中序与后序遍历序列构造二叉树

传送门
分析如下：

输入如下：
中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]

根据后序遍历数组得知，最后一个元素 [3] 肯定是整个二叉树根节点
所以中序数组中[9] 是 [3] 的左子树，[15,20,7] 是 [3] 的右子树
[9] 只有一个元素，它是叶节点
[15,20,7] 在后序遍历数组中表现为[15,7,20],可以得知 [20] 是根节点，中序遍历中 [15] 在 [20] 左边为左子树，[7]在右边为右子树
[15]、[7] 都只有一个元素，是叶节点
最后二叉树如下：
     3
    / \
   9  20
     /  \
    15   7

代码如下：

/**
 * @param {number[]} inorder
 * @param {number[]} postorder
 * @return {TreeNode}
 */
var buildTree = function(inorder, postorder) {
    if(inorder.length <= 0 || postorder.length <= 0 || inorder.length != postorder.length) return null;

    var hash = {};
    for(var i = 0; i < inorder.length; i++) {
        hash[inorder[i]] = i; // 保存中序数组的索引，以便查找在后序遍历数组中找到的根节点在中序数组中的位置
    }
    return dfs(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1, hash);
};

var dfs = function(inorder, iL, iH, postorder, pL, pH, hash) {
    if(iL > iH || pL > pH) return null;

    var root = new TreeNode(postorder[pH]);
    var pos = hash[postorder[pH]];
    root.left = dfs(inorder, iL, pos, postorder, pL, pos - iL - 1 + pL, hash); // 重点把pos iL iH pL pH 关系建立
    root.right = dfs(inorder, pos + 1, iH, postorder, pos - iL + pL, pH - 1, hash);

    return root;
}

通过前序与中序遍历序列构造二叉树

传送门
分析如下：

输入如下：
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]

根据前序遍历数组得知，第一个元素 [3] 肯定是整个二叉树根节点
所以中序数组中[9] 是 [3] 的左子树，[15,20,7] 是 [3] 的右子树
[9] 只有一个元素，它是叶节点
[15,20,7] 在前序遍历数组中表现为[20,15,7],可以得知 [20] 是根节点，中序遍历中 [15] 在 [20] 左边为左子树，[7]在右边为右子树
[15]、[7] 都只有一个元素，是叶节点
最后二叉树如下：
     3
    / \
   9  20
     /  \
    15   7

代码如下：

/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function(preorder, inorder) {
    if(preorder.length <=0 || inorder.length <=0 || preorder.length != inorder.length) return null;

    var hash = {}
    for(var i = 0; i < inorder.length; i++) {
        hash[inorder[i]] = i; // 保存中序数组的索引，以便查找在后序遍历数组中找到的根节点在中序数组中的位置
    }

    return dfs(inorder, 0, inorder.length - 1, preorder, 0, preorder.length - 1, hash);
};

var dfs = function(inorder, iL, iH, preorder, pL, pH, hash) {
    if(iL > iH || pL > pH) return null;
    var root = new TreeNode(preorder[pL]);
    var pos = hash[preorder[pL]];

    root.left = dfs(inorder, iL, pos, preorder, pL + 1, pL + pos - iL, hash);
    root.right = dfs(inorder, pos + 1, iH, preorder, pL + pos - iL + 1, pH, hash);

    return root;
}

总结

通过这几种遍历方式，掌握递归和迭代方法的区别，对树的理解也深一点。