LeetCode144二叉树的前序遍历,94二叉树的中序遍历,145二叉树的后序遍历

最新推荐文章于 2022-11-30 22:46:17 发布

物联世

最新推荐文章于 2022-11-30 22:46:17 发布

阅读量1k

点赞数

分类专栏： LeetCode Python 数据结构与算法文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/qq_35200479/article/details/127972719

版权

数据结构与算法同时被 3 个专栏收录

24 篇文章 0 订阅

订阅专栏

LeetCode

21 篇文章 0 订阅

订阅专栏

Python

9 篇文章 0 订阅

订阅专栏

文章目录

]

144二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。

示例1

输入：root = [1,null,2,3]
输出：[1,2,3]

示例2：

输入：root = []
输出：[]

示例3:

输入：root = [1]
输出：[1]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

**进阶：**递归算法很简单，你可以通过迭代算法完成吗？

c++ 代码实现

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */


// 递归实现
class Solution {
public:
    void traversalTree(TreeNode* root, vector<int> &ret) {
        if (root == nullptr) return;
        // 前序遍历，中左右,先插入中。
        ret.push_back(root->val); // 中
        traversalTree(root->left, ret); // 左
        traversalTree(root->right, ret); // 右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        traversalTree(root, ret);
        return ret;
    }
};


// 迭代实现
/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        if (root == nullptr) return ret;
        stack<TreeNode*> sta;
        
        sta.push(root); // 中
        while (!sta.empty()) {
            TreeNode * m = sta.top();
            sta.pop();
            ret.push_back(m->val); // 中
            // 栈，先压右，然后左， 弹出时就会 中左右 前序遍历
            if (m->right) sta.push(m->right);
            if (m->left) sta.push(m->left);
        }
        return ret;
    }
};

// 另一种方式迭代方式实现
class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> sta;
        while (root != nullptr || !sta.empty()) {
            while (root != nullptr) {
                // 中
                sta.emplace(root);
                ret.emplace_back(root->val);
                // 左
                root = root->left;
            }
            // 移出
            root = sta.top();
            sta.pop();
            // 右
            root = root->right;
        }
        return ret;
    }
};

python 代码实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

# 递归实现
class Solution:
    def reversalTree(self, root, ret):
        if root == None: 
            return
        ret.append(root.val)
        self.reversalTree(root.left, ret)
        self.reversalTree(root.right, ret)

    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = []
        self.reversalTree(root, ret)
        return ret
    
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

# 迭代实现
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = []
        if not root:
            return ret

        sta = [root]
        while sta:
            m = sta.pop()
            ret.append(m.val)
            if m.right: 
                sta.append(m.right)
            if m.left: 
                sta.append(m.left)
        return ret

94二叉树的中序遍历

题目：

给定一个二叉树的根节点 root ，返回 它的中序遍历 。

示例1：

输入：root = [1,null,2,3]
输出：[1,3,2]

示例2：

输入：root = []
输出：[]

示例3：

输入：root = [1]
输出：[1]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

进阶: 递归算法很简单，你可以通过迭代算法完成吗？

c++ 代码实现

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */

// 递归实现
class Solution {
public:
    void traversalTree(TreeNode *root, vector<int>& ret) {
        if (root == nullptr) return;
        // 中序遍历，左中右
        traversalTree(root->left, ret);  // 左
        ret.push_back(root->val);         // 中
        traversalTree(root->right, ret); // 右
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        traversalTree(root, ret);
        return ret;
    }
};

// 迭代实现
/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    // 中序遍历，左中右
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> sta;
        while (root != nullptr || !sta.empty()) {
            
            while (root != nullptr) {
                sta.emplace(root);
                // 左
                root = root->left;
            }
            // 中
            root = sta.top();
            sta.pop();
            ret.push_back(root->val);
            // 右
            root = root->right;
        }
        return ret;
    }
};

python 代码实现

#递归遍历
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    # 中序遍历，左中右
    def TraversalTree(self, root, ret):
        if root == None: return;
        # 左
        self.TraversalTree(root.left, ret)
        # 中
        ret.append(root.val)
        # 右
        self.TraversalTree(root.right, ret)
    
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = []
        self.TraversalTree(root, ret)
        return ret

# 迭代遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    # 中序遍历，左中右
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = list()
        sta = []
        while root or sta:
            while root:
                sta.append(root)
                # 左
                root = root.left
            root = sta.pop()
            # 中
            ret.append(root.val)
            # 右
            root = root.right
        return ret;

145二叉树的后序遍历

给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

示例1：

输入：root = [1,null,2,3]
输出：[3,2,1]

示例2：

输入：root = []
输出：[]

示例3：

输入：root = [1]
输出：[1]

提示：

树中节点的数目在范围 [0, 100] 内
-100 <= Node.val <= 100

**进阶：**递归算法很简单，你可以通过迭代算法完成吗？

c++ 代码实现

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    // 后序遍历，左右中
    void traversalTree(TreeNode * root, vector<int> & ret) {
        if (root == nullptr) return;
        traversalTree(root->left, ret);
        traversalTree(root->right, ret);
        ret.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        traversalTree(root, ret);
        return ret;
    }
};

// 迭代实现
/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    // 后序遍历，左-右-中 顺序
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> ret;
        stack<TreeNode*> sta;
        TreeNode * prev = nullptr;
        while ( root != nullptr || !sta.empty() ) {
            while (root != nullptr) {
                // 左
                sta.emplace(root);
                root = root->left;
            }
            // 弹出
            root = sta.top();
            sta.pop();
            // 右，判断是否为空。
            if (root->right == nullptr || root->right == prev) {
                // 中
                ret.emplace_back(root->val);
                prev = root;
                root = nullptr;
            }else{
                sta.emplace(root);
                root = root->right;
            }
        }
        return ret;
    }
};

python代码实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
#递归，后序 左右中
class Solution:
    def traversalTree(self, root, ret):
        if root == None: 
            return 
        self.traversalTree(root.left, ret)
        self.traversalTree(root.right, ret)
        ret.append(root.val)

    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = []
        self.traversalTree(root, ret)
        return ret



# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

# 迭代， 后序 左右中
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        ret = list()
        sta = []
        prev = None
        while root or sta:
            while root:
                sta.append(root)
                root = root.left
            
            root = sta.pop()
            if root.right == None or root.right == prev:
                ret.append(root.val)
                prev = root
                root = None
            else:
                sta.append(root)
                root = root.right
        return ret