利用二叉树前序和后序遍历序列的相似性质巧妙实现后序遍历迭代算法

• 前序遍历是后序遍历的准镜像算法。无论是从递归的角度看，还是迭代的角度看。都是！我们怎么定义准镜像算法？就是通过微调原来前序遍历的定义后，再进行镜像操作。

//看一下如下代码框架：
//递归前后序遍历

// 递归前序遍历
recursive(root) {
    if(root == null) {
        return ;
    }
    list.add(root.val);
    recursive(root.left);
    recursive(root.right);
}
输入[1234567]
输出[1245367]

// 递归后序遍历
recursive(root) {
    if(root == null) {
        return ;
    }
    recursive(root.left);
    recursive(root.right);
    list.add(root.val);
}
输入[1234567]
输出[4526731]

从数字上看不出所以然？
我们知道前序遍历的定义是： 先遍历根节点，后遍历左节点，然后遍历右节点。

而后序遍历的定义是：先遍历左节点，然后遍历右节点，再遍历根节点。

如果我们把前序遍历，改为“先遍历根节点，再遍历右节点，最后遍历左节点”，然后再把输出结果翻转就是后序遍历的结果了。
如下：
输入[1234567]
微调后的前序遍历：[1376254]
再翻转结果为：[4526731],恰好等于后序遍历。

利用这个性质，我们就可以把递归后序遍历算法写成：

recursive(root) {
    if(root == null) {
        return ;
    }
    list.add(root.val);
    recursive(root.right);
    recursive(root.left);
}
list.reverse();

// 这个算法的思想来源于序列的规律，但是不建议这样操作。
// 除非万不得已。

• 我们知道后序遍历的迭代算法比前序遍历迭代算法难写很多很多。
• 很多人利用前序遍历序列的和后序遍历序列相似的性质来，将前序遍历迭代算法改版。是一种比较巧妙的方法，有点类似“它山之石可以攻玉”。但是还是有点花里花俏，还是不建议使用。

这里写一下实现过程：

// 前序遍历迭代实现

preorderTree(root) {
    
    Stack<TreeNode> stack = new Stack<>(); 
    stack.push(root);
    while(stack.size() != 0) {
        cur = stack.pop();
        list.add(cur.val);
        if(cur.right != null) {
            stack.push(cur.right);
        }
        if(cur.left != null) {
            // 栈顶先遍历，左子节点
            stack.push(cur.left);
        }
    }
}

// 后序遍历迭代实现
preorderTree(root) {
    Stack<TreeNode> stack = new Stack<>(); 
    stack.push(root);
    while(stack.size() != 0) {
        cur = stack.pop();
        list.add(cur.val);
        if(cur.left != null) { 
            stack.push(cur.left);
        }
        if(cur.right != null) {
            // 栈顶先遍历，右子节点
            stack.push(cur.right);
        }
    }
    // 翻转序列
    stack.reverse();
}

总结：

• 这个方法有点骚，不过后序遍历确实比前序遍历算法和中序遍历算法难很多很多。

• 而这个性质犹如魔术般的数学公式，巧妙解答。先写出简单的前序遍历算法，然后稍微做一点点修改。

• 不过本文不建议用这个方法，因为研究二叉树的性质应该是针对“节点的同类指针”（或者叫，左右子节点指针）性质为出发点，进行研究。因为二叉树毕竟是一种数据存储工具，我们应该研究它怎么存储数据，而不是研究怎么实现二叉树迭代遍历。即便是研究“二叉树迭代遍历”也应该是利用节点形式来实现。而不是前后遍历序列定义的规律。

• 比如我们可以研究，怎么把二叉树看成带分叉的链表来实现迭代算法。

• 倒序迭代访问链表的代码框架如下：

    cur = head;
    Stack<Node> stack = new Stack<>();
    Node pre = new Node(-99999999);
    while(stack.size() || cur != null) {
        if(cur == null) {
            cur = stack.pop();
        }
        boolean isNoPreAccess = pre != cur.next;
        if(isPreAccess && cur.next != null) {
            // 递推时才访问
            stack.push(cur);
            cur = cur.next;
            continue;
        } 
        // 回溯时才访问
        print(cur.val);
        pre = cur;
        cur = null;
        
    }

总结：乍一看是个链表，再细看，其实就跟一颗没有右节点的二叉树后序遍历一毛一样。

• 下面来欣赏一下，利用节点性质，实现二叉树的后序迭代遍历。

    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    TreeNode pre = new TreeNode(-99999999);

    while(stack.size() != 0 || cur != null) {
        if(cur == null) {
            cur = stack.pop();
        } 
        boolean isNoPreAccessLeft = pre != cur.right && pre != cur.left;
        if(isNoPreAccessLeft && cur.left != null) {
             stack.push(cur);
             // 1.访问左子节点
             cur = cur.left;
             continue;
        }
        // 比链表在每一个节点都多了一个分叉。
        boolean isNoPreAccessRight = pre != cur.right;
        if(isNoPreAccessRight && cur.right != null) {
            stack.push(cur);
            // 2.访问右子节点
            cur = cur.right;
            continue;
        }
            
        // pre有可能是左节点，也有可能是右节点
        pre = cur;
        res.add(cur.val);
        cur = null;
  }

比链表在每个节点多了一个分叉。

链表的遍历对象是链表节点。
二叉树的遍历对象是二叉树节点。

二叉树节点比链表多一个分叉，所以，迭代对象也需要对分叉多一次处理，仅此而已。