二叉树遍历方式总结

二叉树结构

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};

void creat_tree(TreeNode* &T)//创建二叉树
{
    T->val = 12;
    T->left = new TreeNode(65, new TreeNode(81,NULL,new TreeNode(77)), new TreeNode(1));
    T->right = new TreeNode(14, new TreeNode(33, new TreeNode(99), NULL), new TreeNode(18));

}

前序遍历

12 65 81 77 1 14 33 99 18

递归

//前序遍历 递归
void preorderTraversal(TreeNode* cur, vector<int> &sum)
{
    if (cur == nullptr) return ;
    sum.push_back(cur->val);
    preorderTraversal(cur->left, sum);
    preorderTraversal(cur->right, sum);
}

迭代

/前序遍历 迭代
void preorderTraversal2(TreeNode* root, vector<int>& sum)
{
    stack<TreeNode*> stk;
    stk.push(root);
    while (!stk.empty())
    {
        TreeNode* tmp = stk.top();
        sum.push_back(tmp->val);
        stk.pop();
        if (tmp->right) stk.push(tmp->right);
        if (tmp->left) stk.push(tmp->left);
    }
}

//前序遍历 迭代2
void preorderTraversal3(TreeNode* root, vector<int>& sum)
{
    stack<TreeNode*> stk;
    TreeNode* pNode = root;
    while (pNode || !stk.empty())
    {
        if (pNode)
        {
            stk.push(pNode);
            sum.push_back(pNode->val);
            pNode = pNode->left;
        }
        else
        {
            pNode = stk.top();
            stk.pop();
            pNode = pNode->right;
        }
    }
}

中序遍历

81 77 65 1 12 99 33 14 18

递归

//中序遍历 递归
void inorderTraversal(TreeNode* cur, vector<int>& sum)
{
    if (cur == nullptr) return;
    inorderTraversal(cur->left, sum);
    sum.push_back(cur->val);
    inorderTraversal(cur->right, sum);
}

迭代

//中序遍历 迭代
void inorderTraversal2(TreeNode* root, vector<int>& sum)
{
    stack<TreeNode*> stk;
    TreeNode* pNode = root;
    while (pNode || !stk.empty())
    {
        if (pNode)
        {
            stk.push(pNode);
            pNode = pNode->left;
        }
        else
        {
            pNode = stk.top();
            sum.push_back(pNode->val);
            stk.pop();
            pNode = pNode->right;
        }
    }
}

Morris遍历(空间复杂度O(1))

vector<int> inorderTraversal(TreeNode* root) {
        //https://leetcode.cn/problems/binary-tree-inorder-traversal/solutions/412886/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/
        //morris 遍历
        TreeNode *prev = nullptr;
        vector<int> ans;
        while(root)
        {
            if(root->left)
            {
                // prev 节点就是当前 root 节点向左走一步，然后一直向右走至无法走为止
                prev = root->left;
                while(prev->right && prev->right != root)
                {
                    prev = prev->right;
                }

                if(prev->right)
                {
                    //表示左子树遍历完成
                    ans.push_back(root->val);
                    prev->right = nullptr;
                    root = root->right;
                }
                else
                {
                    // 让 prev 的右指针指向 root，继续遍历左子树
                    prev->right = root;
                    root = root->left;
                }
            }
            else
            {
                // 如果没有左孩子，则直接访问右孩子
                ans.push_back(root->val);
                root = root->right;
            }
        }
        return ans;
    }

后序遍历

77 81 1 65 99 33 18 14 12

递归

//后序遍历 递归
void postorderTraversal(TreeNode* root, vector<int>& sum)
{
    if (!root) return;
    postorderTraversal(root->left,sum);
    postorderTraversal(root->right,sum);
    sum.emplace_back(root->val);
}

迭代

//后序遍历 迭代1
void postorderTraversal(TreeNode* root, vector<int>& sum)
{
    if (!root) return;
    stack<TreeNode*> stk;
    stk.emplace(root);
    TreeNode* lastpopNode = root;
    while (!stk.empty())
    {
        root = stk.top();
        if (root->left && root->left != lastpopNode && root->right != lastpopNode)
        {
            stk.emplace(root->left);
        }
        else if (root->right && root->right != lastpopNode)
        {
            stk.emplace(root->right);
        }
        else
        {
            sum.emplace_back(root->val);
            stk.pop();
            lastpopNode = root;
        }
    }
}

//后序遍历 迭代2
void postorderTraversal2(TreeNode* root, vector<int>& sum) {
    
    if (root == nullptr) {
        return ;
    }

    stack<TreeNode*> stk;
    TreeNode* prev = nullptr;
    while (root != nullptr || !stk.empty()) {
        while (root != nullptr) {
            stk.emplace(root);
            root = root->left;
        }
        root = stk.top();
        stk.pop();
        if (root->right == nullptr || root->right == prev) {
            sum.emplace_back(root->val);
            prev = root;
            root = nullptr;
        }
        else {
            stk.emplace(root);
            root = root->right;
        }
    }
}

参考：

• 二叉树的各种遍历方法（C++版）
• 二叉树的后序遍历
• 代码随想录