二叉树的前中后序遍历（利用自定义栈）

原创已于 2022-08-22 16:53:37 修改 · 195 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #leetcode #算法

于 2021-03-13 20:31:22 首次发布

刷题专栏收录该内容

51 篇文章

订阅专栏

本文介绍了使用Python和Java实现二叉树的前序、中序及后序遍历算法。通过栈结构辅助完成非递归方式的遍历，详细展示了每种遍历方式的具体实现过程。

1. 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 inorderTraversal(self, root: TreeNode) -> List[int]:
        
        res = []
        if root is None:
            return res;
        stack = []
        
        while root is not None or stack: # 或写成stack != []
            while root is not None:
                stack.append(root);
                root = root.left;
            
            root = stack.pop();
            res.append(root.val);
            root = root.right;
        

        return res;

2. java写法

前序（中左右）：是先左后右，左之前遍历，左时压栈，当左无路可走（root == null）时弹出，走右。
后序（左右中，反向就是中右左，和中左右类似）：是先右后左，右之前遍历，右时压栈，当右无路可走（root == null）时弹出，走左。然后把遍历得到的列表res反向输出。
中序（左中右）：是先左后右，左时压栈，当左无路可走（root == null）时弹出，遍历，走右。

前序：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                res.add(root.val);
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            root = root.right;
        }

        return res;

    }
}

中序：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            res.add(root.val);
            root = root.right;
        }

        return res;

    }
}

后序：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) return res;
        Stack<TreeNode> stack = new Stack<>();
        
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                res.add(root.val);
                stack.push(root);
                root = root.right;
            }
            root = stack.pop();
            root = root.left;
        }

        Collections.reverse(res);
        return res;

    }
}