Leetcode P0094"Binary Tree Inorder Traversal" 题解

2020/09/02 Leetcode

博文中会简要介绍Leetcode P0094题目分析及解题思路。

“Binary Tree Inorder Traversal”是一道比较基础的二叉树相关的题目。题目要求中序遍历一个二叉树,然后输出所有非null结点的值。

Given a binary tree, return the inorder traversal of its nodes’ values.

关于二叉树或者树的遍历,常见的有四种,分别如下:

  • 前序遍历,是指对于一个结点,先访问其本身的值(域),然后遍历其左子树,最后遍历其右子树。

  • 中序遍历,是指对于一个结点,先遍历其左子树,然后访问其本身的值(域),最后遍历其右子树。

  • 后序遍历,是指对于一个结点,先遍历其左子树,然后遍历其右子树,最后访问其本身的值(域)。

  • 层遍历,是指对于树的每一层,先遍历和其处在同一层的所有结点,最后再向下一层访问。

递归实现前序遍历思路十分直接,也相对容易。迭代实现则需要利用到栈,当前树指针不为null或栈不为空时,继续遍历,若当前树指针不为null,不断将其左结点压栈,直到树指针为null,将栈顶元素赋予树指针,并出栈,记录值,然后将树指针右结点压入栈中。

以下是Java的题解代码实现。

/**
 * 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> traversal = new ArrayList<>();
        
        // Iterative
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode curr = root;
        while (!stack.isEmpty() || curr != null) {
            while (curr != null) {
                stack.offerFirst(curr);
                curr = curr.left;
            }
            
            curr = stack.pollFirst();
            traversal.add(curr.val);
            curr = curr.right;
        }

        // Recursive
        // this.traverse(root, traversal);
        
        return traversal;
    }

    private void traverse(TreeNode curr, List<Integer> traversal) {
        if (curr == null)
            return;
        
        this.traverse(curr.left, traversal);
        traversal.add(curr.val);
        this.traverse(curr.right, traversal);
    }

}

以下是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:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> traversal;
        stack<TreeNode*> nodes;
        TreeNode *curr = root;
        // Iterative
        while (!nodes.empty() || curr != NULL) {
            while (curr != NULL) {
                nodes.push(curr);
                curr = curr->left;
            }
            
            curr = nodes.top();
            nodes.pop();
            traversal.push_back(curr->val);
            curr = curr->right;
        }
        
        return traversal;
    }
};

Search

    Table of Contents