zoukankan      html  css  js  c++  java
  • [LeetCode#144]Binary Tree Preorder Traversal

    The problem:

    Given a binary tree, return the preorder traversal of its nodes' values.

    For example:
    Given binary tree {1,#,2,3},

       1
        
         2
        /
       3
    

    return [1,2,3].

    The recursion solution:

    public class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            ArrayList<Integer> ret = new ArrayList<Integer>();
            
            if (root == null)
                return ret;
            
            helper(root, ret);
            return ret;
        }
        
        private void helper(TreeNode cur_root, ArrayList<Integer> ret) {
            
            if (cur_root == null)
                return;
            
            ret.add(cur_root.val);
            helper(cur_root.left, ret);
            helper(cur_root.right, ret);
        }
    }

    An iteration way:

    My analysis:

    The iteration way in traversaling a tree is very skillful and important. Even it differs a lot from the iteration methond we have used (usually over an array), we must master it and understand it!
    key skills:
    1. use a stack properly, cause we need to reuse the node we have already reached in any traversal methods.
    2. add the node properly into the final answer set, according to the preorder, inorder or postorder requirement.

    The detail in implementation:
    1. use a big while loop for the iteration.
    1.1 if the current node is not null, we could explore its children.
    1.2 if the current node is null, that means we have reached the leaf level. if the stack is not empty, it means we still have some possible right children to explore.
    thus, the while loop is:

    while (root != null || stack.empty() != true)

    2. then we need a "if" statement to distinguish between whether entering the loop is caused by current node is null or not.
    2.1 iff the current node is not null, we could push the current node into stack, and then explore the current node's left child.

    if (root != null) { //for later usage
        stack.push(root);
        root = root.left;
    }

    2.2 iff the current node is alreay null, we could retrace to its ancestor nodes by pop a node out from the stack, and then explore the node's right child.

    The important facts:
    1. once a node is in stack, its right child must have been explored.
    2. the stack is used for retracing the scanned root nodes.

    My solution:

    public class Solution {
        public List<Integer> preorderTraversal(TreeNode root) {
            
            ArrayList<Integer> ret = new ArrayList<Integer>();
            Stack<TreeNode> stack = new Stack<TreeNode>();
            
            while (root != null || stack.empty() != true) {
                
                if (root != null) {
                    ret.add(root.val);
                    stack.push(root);
                    root = root.left;
                } else{
                    root = stack.pop();
                    root = root.right;
                }
            }
            
            return ret;
        }
  • 相关阅读:
    电容
    IC行业常见用语
    MOSFET 的 I / V 特性曲线
    MOS 预夹断到底是什么
    [ Skill ] 如何 flatten 一个 list
    Metal 线宽如何选择
    [ Skill ] 如何读取一个文件并打印出来
    PHP 当前时间秒数+数值,然后再转换成时间。
    PHP HTTP GET POST
    做一个菜鸟,写一些自己自己编程错误的地方。个人所遇到的问题 保存处
  • 原文地址:https://www.cnblogs.com/airwindow/p/4216130.html
Copyright © 2011-2022 走看看