Java 中序遍历 后序遍历 求前序遍历 前序遍历js

1、二叉树的前序遍历

前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。

在遍历左、右子树时，仍然先访问根结点，然后遍历左子树，最后遍历右子树。

若二叉树为空则结束返回，否则：

（1）访问根结点。

（2）前序遍历左子树。

（3）前序遍历右子树 。

需要注意的是：遍历左右子树时仍然采用前序遍历方法。

如图

前序遍历结果：ABCDEFGHI

已知后序遍历和中序遍历，就能确定前序遍历。

// 非递归实现，迭代实现
var preorderTraversal = function(root) {
    if(!root) return []
    let res = []
    let queue = [root]
    while(queue.length){
        let temp = queue.pop()
        res.push(temp.val)
        if(temp.right) queue.push(temp.right)  //  因为栈先进后出所以将right放前
        if(temp.left) queue.push(temp.left)
    }
    return res
};

// 递归实现
var preorderTraversal = function(root,res=[]) {
    if(!root) return []
    res.push(root.val)
    preorderTraversal(root.left,res)
    preorderTraversal(root.right,res)
    return res
};

2、二叉树的中序遍历

中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则：

（1）中序遍历左子树

（2）访问根结点

（3）中序遍历右子树

如图所示二叉树，中序遍历结果：CBDAGFHEI

// 非递归实现
var inorderTraversal = function(root) {
    if(!root) return []
    let res = []
    let stack = []
    while(stack.length || root){
        //  循环遍历左节点
        while(root){
            stack.push(root)
            root = root.left
        }
        let temp = stack.pop()
        res.push(temp.val)
        root = temp.right
    }
    return res
};

//递归实现
var inorderTraversal = function(root,res = []) {
    if(!root) return []
    if(root.left) inorderTraversal(root.left,res)
    res.push(root.val)
    if(root.right) inorderTraversal(root.right,res)
    return res
};

3、 二叉树的后序遍历

后序遍历首先遍历左子树，然后遍历右子树，最后访问根结点，在遍历左、右子树时，仍然先遍历左子树，然后遍历右子树，最后遍历根结点。即：
若二叉树为空则结束返回，
否则：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根结点
如图所示二叉树
后序遍历结果：CDBGHFIEA
已知前序遍历和中序遍历，就能确定后序遍历。

// 非递归实现，前序遍历是根左右，后序为左右根，将前序实现为根右左，再将数组反转即得后序遍历，左右根
var postorderTraversal = function(root) {
    if(!root) return []
    let res = []
    let stack = [root]
    while(stack.length){
        let temp = stack.pop()
        if(temp.left) stack.push(temp.left)  //  前序根左右调换为，根右左
        if(temp.right) stack.push(temp.right)
        res.push(temp.val)
    }
    return res.reverse()  //  将结果反转即为后序
};

4、二叉树的层序遍历

层序遍历所要解决的问题很好理解，就是按二叉树从上到下，从左到右依次打印每个节点中存储的数据。如下图：

层序遍历的结果为：

[ [3] --- [9 20] --- [15 7] ]

var levelOrder = function(root) {
    if(!root) return []
    let res = []
    let stack = [root]
    let count = 0  //  记录当前层级
    while(stack.length){
        res[count] = [] //  初始化当前层级
        let countNum = stack.length  //  当前层级的节点数
        while(countNum--){  //  遍历当前层级的节点数
        let temp = stack.shift()  // 从前开始取当前层级的节点
        res[count].push(temp.val)  //  推入每层的节点值
        if(temp.left) stack.push(temp.left)  
        if(temp.right) stack.push(temp.right)
        }
        count++   //  层级+1
    }
    return res
};