zoukankan      html  css  js  c++  java
  • 42: Binary Tree Postorder Traversal

    /************************************************************************/
                /*       42:  Binary Tree Postorder Traversal                               */
                /************************************************************************/
                /*
                 * Given a binary tree, return the postorder traversal of its nodes' values.

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

       1
       
         2
        /
       3

    return [3,2,1].
                 * */
                
                /****后序遍历 PostOrder tree  递归复杂度****Time: O(n), Space: O(n).****************************************************************/
                /*
                 * 应用1:
                 * 计算文件夹所占的磁盘容量时,先要计算根节点下的所有文件夹的大小,然后层层网上
                 *
                 * TODO
                 * */

      public List<Integer> postorderTraversal(TreeNode root) 
                {
                    List<Integer> source=new ArrayList<Integer>();
                    postorderTree(root,source);
                    return source;
                }
            
            
                private void postorderTree(TreeNode node,List<Integer> nodes)
                {
                        if(node==null)
                        {
                            return;
                        }
                        System.out.println("pre root-->"+node.val);
                        postorderTree(node.left,nodes);
                        postorderTree(node.right,nodes);
                        nodes.add(node.val);
                        System.out.println("-->"+node.val);
                } 
                
                /****后序遍历 PostOrder tree  Time: O(n), Space: O(n) 栈迭代方法实现的********************************************************************/
                //实现的有点繁琐好像,有没有其他办法呢? 改进版本见 :postorderTraversal3
                public List<Integer>postorderTraversal2(TreeNode root)
                {
                    List<Integer> results=new ArrayList<Integer>();
                    Stack<Map<TreeNode, Boolean> > stack=new Stack<Map<TreeNode, Boolean> >();
                    TreeNode node=null;
                    node=root;
                    while(node!=null||!stack.isEmpty())
                    {
                        if(node!=null)
                        {
                            Map<TreeNode, Boolean> temp=new HashMap<TreeNode, Boolean>();
                            temp.put(node, false);
                            stack.push(temp);
                            node=node.left;
                        }
                        else
                        {
                            Map<TreeNode, Boolean> tempnode= stack.pop();
                            for (Map.Entry<TreeNode, Boolean> entry :tempnode.entrySet())
                            {
                                if(entry.getKey().left==null&&entry.getKey().right==null&&entry.getValue()==false) // 弹出叶子节点,按照左节点到右节点的弹出顺序
                                {
                                    results.add(entry.getKey().val);
                                    //System.out.println(entry.getKey().val);
                                    node=entry.getKey();
                                    node=node.right;
                                }
                                else if(entry.getKey().right!=null&&entry.getValue()==false)// 中间路径上的根节点第一遍时不弹出,设置已访问过
                                {
                                    entry.setValue(true);
                                    stack.push(tempnode);
                                    node=entry.getKey();
                                    node=node.right;
                                }
                            else   // 中间路径上的根节点第二遍时弹出
                                {
                                    results.add(entry.getKey().val);
                                    //System.out.println(entry.getKey().val);
                                    node=null;
                                }
                            }
                        }
                    }
                    return results;
                    
                }
                
                /****后序遍历 PostOrder tree 简洁版本1  Time: O(n), Space: O(n) 栈迭代方法实现的********************************************************************/
                /*
                 *
                 * 算法思路: 对应函数:  postorderTraversal3,postorderTraversal4
                 * 
                 * pre-order traversal is root-left-right, and post order is left-right-root. 
                 * modify the code for pre-order to make it root-right-left, 
                 * and then reverse the output so that we can get left-right-root .
    
        Create an empty stack, Push root node to the stack.
    
        Do following while stack is not empty.
    
        2.1. pop an item from the stack and print it.
    
        2.2. push the left child of popped item to stack.
    
        2.3. push the right child of popped item to stack.
    
        reverse the ouput.
    
                 * */
                public List<Integer>postorderTraversal3(TreeNode root)
                {
                    List<Integer> results=new ArrayList<Integer>();
                    Stack<TreeNode> stack=new Stack<TreeNode>();
                    TreeNode node=null;
                    node=root;
                    while(node!=null||!stack.isEmpty())
                    {
                        if(node!=null)
                        {
                            //System.out.println("-->"+node.val);
                            results.add(node.val);
                            stack.push(node);
                            node=node.right;
                        }
                        else
                        {
                            node= stack.pop();
                            node=node.left;
                        }
                    }
                    Collections.reverse(results);
                    return results;
                }
                
                
                public List<Integer>postorderTraversal4(TreeNode root)
                {
                    List<Integer> results=new ArrayList<Integer>();
                    Stack<TreeNode> stack=new Stack<TreeNode>();
                    stack.push(root);
                    TreeNode node=null;
                    while(!stack.isEmpty())
                    {
                        node=stack.pop();
                        results.add(node.val);
                        if(node.left!=null)
                        {
                            stack.push(node.left);
                        }
                        if(node.right!=null)
                        {
                            stack.push(node.right);
                        }
                    }
                    Collections.reverse(results);
                    return results;
                }
  • 相关阅读:
    错误解决Caused by: org.hibernate.MappingException: Repeated column in mapping for entity: pers.zhb.domain.Student column: classno (should be mapped with insert="false" update="false")
    Hibernate(级联保存、级联删除)
    文件搜索命令——grep
    文件搜索命令(命令搜索)which、whereis
    文件搜索命令locate
    批量查询:原生sql查询(查询所有、条件查询、分页查询)
    批量查询Criteria(查询所有、条件、分页、统计(聚合函数)、排序、Criteria 和与DetachedCriteria)
    批量查询HQL(查询所有、条件查询、占位符、分页、排序、统计、投影)
    Hibernate的事务(封锁、隔离级别、事务处理)
    Hibernate(一级缓存、快照)
  • 原文地址:https://www.cnblogs.com/theonemars/p/4254332.html
Copyright © 2011-2022 走看看