二叉树的先中后序遍历 -- 递归实现、非递归的栈实现

二叉树的遍历

// 树节点对象
class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = this.right = null;
    }
}

先中后序遍历（递归）

// 先序遍历
let preOrder = function(root){
    if(!root)
        return [];
    return [root.val].concat(preOrder(root.left), preOrder(root.right));
}

// 中序遍历
let midOrder = function(root){
    if (!root)
        return [];
    return midOrder(root.left).concat([root.val], midOrder(root.right));
}

// 后序遍历
let afterOrder = function(root) {
    if (!root)
        return [];
    return afterOrder(root.left).concat(afterOrder(root.right), [root.val]);
}

先中后序遍历（非递归，通过栈实现）

// 先序遍历
let preOrder = function(root){
    let p = root,
        stack = [],
        res = [];
    while (p != null || stack.length) {
        while (p != null) {
            stack.push(p);
            res.push(p.val);
            p = p.left;
        }
        p = stack.pop();
        p = p.right;
    }
    return res;
}

// 中序遍历
let midOrder = function(root){
    let p = root,
        stack = [],
        res = [];
    while (p != null || stack.length) {
        while (p != null) {
            stack.push(p);
            p = p.left;
        }
        p = stack.pop();
        res.push(p.val);
        p = p.right;
    }
    return res;
}

// 后序遍历
let afterOrder = function(root) {
    let p = root,
        stack = [],
        res = [],
        last = null;
    while (p != null || stack.length) {
        while (p != null) {
            stack.push(p);
            p = p.left;
        }
        p = stack[stack.length - 1];
        if (p.right && last != p.right)
            p = p.right;
        else if (p.right == null || p.right == last) {
            res.push(p.val);
            last = p;
            stack.pop();
            p = null;
        }
    }
    return res;
}