二叉树遍历的三种方法的非递归版本

二叉树遍历的三种方法的非递归版本

二叉树遍历虽然是一个老生常谈的问题，但在面试中经常遇见，最近在刷leetcode的时候碰到了用前序，中序和后序遍历二叉树，遂来总结一下思路。

前序遍历

题目参考leetcode 144 Binary Tree Preorder Traversal

从根节点出发，按照根->左子树->右子树的顺序递归访问整个二叉树。

例如：输入 [1,2,3,null,4,5,null]，输出 [1,2,4,3,5]（可自行画图体会）

递归版本

代码十分好写，思路就是在递归访问左右子树之前先访问根节点

// 定义树节点
struct TreeNode{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x):val(x),left(NULL),right(NULL){}
};

// 递归函数，将前序遍历的结果放入result中
void preorderCore(TreeNode* pNode,vector& result){
    if(pNode == NULL){
        return;
    }
    result.push_back(pNode->val);
    preorderCore(pNode->left, result);
    preorderCore(pNode->right, result);
}

// 主函数
vector preorderTraversal(TreeNode* root) {
    if(root == NULL){
        return {};
    }
    vector result;
    preorderCore(root, result);
    return result;
}

非递归版本

实际上前序遍历的非递归代码是三种遍历方式中最好写的一个。

思路：使用一个栈保存待访问的节点，使用pCur保存当前正在访问的节点，大致思路和DFS遍历很类似，就是一路沿左子树向下，直到左子节点为空再通过栈进行回退操作，直到栈为空，详细代码如下：

vector preorderTraversal(TreeNode* root) {
    if(root == NULL){
        return {};
    }
    vector result;
    stack nodes;
    TreeNode* pCur = root;
    while(!nodes.empty() || pCur != NULL){
        if(pCur != NULL){
            nodes.push(pCur);
            result.push_back(pCur->val);
            pCur = pCur->left;
        }
        else{
            TreeNode* tmp = nodes.top();
            nodes.pop();
            pCur = tmp->right;
        }
    }
    return result;
}

上面的代码是我认为最简洁的代码，而且这个利用DFS遍历二叉树的模板套路只要略加修改就可以应用到剩下的两个遍历中。

中序遍历

题目参考leetcode 94 Binary Tree Inorder Traversal

从根节点出发，按左子树->父节点->右子树的顺序递归访问。

例如：输入 [1,2,3,null,4,5,null]，输出 [2,4,1,5,3]（可自行画图体会）

递归版本

同样非常好写，把握访问顺序即可，代码如下：

// 树节点定义如前序遍历中定义的一样
void inorderCore(TreeNode* pNode,vector& result){
    if(pNode == NULL){
        return;
    }
    inorderCore(pNode->left, result);
    result.push_back(pNode->val);
    inorderCore(pNode->right, result);
}

vector inorderTraversal(TreeNode* root) {
    vector result;
    if(root == NULL){
        return result;
    }
    inorderCore(root, result);
    return result;
}

非递归版本

如上面所说，可以把前序遍历的非递归代码略加修改应用到这里即可，实际上就是修改了将节点加入结果数组的顺序，代码如下：

vector inorderTraversal(TreeNode* root) {
    vector result;
    if(root == NULL){
        return result;
    }
    stack nodes;
    TreeNode* pCur = root;
    while(!nodes.empty() || pCur != NULL){
        if(pCur != NULL){
            nodes.push(pCur);
            pCur = pCur->left;
        }
        else{
            TreeNode* tmp = nodes.top();
            result.push_back(tmp->val);
            nodes.pop();
            pCur = tmp->right;
        }
    }
    return result;
}

后序遍历

题目参考leetcode 145 Binary Tree Postorder Traversal

从根节点出发，按左子树->右子树->父节点的顺序递归访问。

例如：输入 [1,2,3,null,4,5,null]，输出 [4,2,5,3,1]（可自行画图体会）

递归版本

同样按照访问顺序直接写即可：

// 树节点定义同上
void postorderCore(TreeNode* pNode,vector& result){
    if(pNode == NULL){
        return;
    }
    postorderCore(pNode->left, result);
    postorderCore(pNode->right, result);
    result.push_back(pNode->val);
}

vector postorderTraversal(TreeNode* root) {
    if(root == NULL){
        return {};
    }
    vector result;
    postorderCore(root, result);
    return result;
}

非递归版本

可以说后序遍历的非递归代码是三个里面最难的一个，不过按照上面的套路来其实也不难。

注意坑点：由于父节点需要最后一个弹出，所以如果照搬前面的思路是会出现死循环的，即重复访问父节点和它的子树，当栈顶元素是某个父节点时我们并不知道它的孩子没有没有被访问过，会重复的将它的孩子们压入栈弹出栈，重复访问，解决办法为使用一个指针lastVisited记录最后访问的节点，当栈顶元素为父节点时，判断lastVisited是否是它的右节点，如果是，则代表它的孩子们已经遍历过，直接弹出该父节点即可，具体代码如下：

vector postorderTraversal(TreeNode* root) {
    if(root == NULL){
        return {};
    }
    vector result;
    stack nodes;
    TreeNode* pCur = root;
    TreeNode* lastVisited = NULL;
    while(!nodes.empty() || pCur != NULL){
        if(pCur != NULL){
            nodes.push(pCur);
            pCur = pCur->left;
        }
        else{
            TreeNode* tmp = nodes.top();
            if(tmp->right != NULL && lastVisited != tmp->right){
                pCur = tmp->right;
            }
            else{
                result.push_back(tmp->val);
                nodes.pop();
                lastVisited = tmp;
            }
        }
    }
    return result;
}

不得不提一下，很多人用前序遍历的结果reverse一下作为后序遍历的答案，虽然结果是正确的，但是这其实是一种欺骗做法，并没有按照后序遍历应用的顺序访问节点啊，摊手。

总结

实际上这三种遍历方式的非递归算法都遵循了某一规律，只要熟悉了遍历顺序，写出代码也不是很难~希望看完这篇文章能对大家理解二叉树的遍历有一点帮助。