zoukankan      html  css  js  c++  java
  • 二叉树的递归

    1.Minimum Depth of Binary Tree

        // 递归版,时间复杂度O(n),空间复杂度O(logn)
    	private static int minDepth(TreeNode root) {
    		if (root == null)   return 0;  
    		return Math.min(minDepth(root.left), minDepth(root.right))+1;
    	}
    

    2.Maximum Depth of Binary Tree

    同上,递归版,// 时间复杂度O(n),空间复杂度O(logn)
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
    

    3.Path Sum

    return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22
    // 时间复杂度O(n),空间复杂度O(logn)
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) return false;
        if (root.left == null && root.right == null) // leaf
            return sum == root.val;
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
    

    4.Path Sum II

            同上,返回路径  // 时间复杂度O(n),空间复杂度O(logn)
    	public List<List<Integer>> pathSum(TreeNode root, int sum) {
    		List<List<Integer>> result = new ArrayList<>();
    		ArrayList<Integer> cur = new ArrayList<>(); // 中间结果
    		pathSum(root, sum, cur, result);
    		return result;
    	}
    
    	private static void pathSum(TreeNode root, int gap, ArrayList<Integer> cur, List<List<Integer>> result) {
    		if (root == null)  return;
    		cur.add(root.val);
    		if (root.left == null && root.right == null) {
    			if (gap == root.val) {  result.add(new ArrayList<>(cur)); }
    		}
    		pathSum(root.left, gap - root.val, cur, result);
    		pathSum(root.right, gap - root.val, cur, result);
    		cur.remove(cur.size() - 1);   //添加的删除了
    	}
    

    5.Binary Tree Maximum Path Sum

        // 时间复杂度O(n),空间复杂度O(logn)
        private int max_sum;
    	private int dfs(TreeNode root) {
    		if (root == null) return 0;
    
    		int l = dfs(root.left);
    		int r = dfs(root.right);
    
    		int sum = root.val;
    		if (l > 0) sum += l;
    		if (r > 0) sum += r;
    
    		max_sum = Math.max(sum, max_sum);
    		return Math.max(l, r) > 0 ? Math.max(l, r) + root.val : root.val;
    	}
    

     6、给一棵二叉树, 找到和为最小的子树, 返回其根节点。

    public class Solution {
        private TreeNode subtree = null;
        private int subtreeSum = Integer.MAX_VALUE;
    
        public TreeNode findSubtree(TreeNode root) {
            helper(root);
            return subtree;
        }
        
        private int helper(TreeNode root) {
            if (root == null) {
                return 0;
            }
            
            int sum = helper(root.left) + helper(root.right) + root.val;
            if (sum <= subtreeSum) {
                subtreeSum = sum;
                subtree = root;
            }
            return sum;
        }
    }
    

    7、求从根(root)到叶(leaf)的所有路径

    Input:{1,2,3,#,5}
    Output:["1->2->5","1->3"]
    Explanation:
    1
    /
    2 3

    5

    public class Solution {
    
        public List<String> binaryTreePaths(TreeNode root) {
            List<String> paths = new ArrayList<>();
            if (root == null) {
                return paths;
            }
            
            List<String> leftPaths = binaryTreePaths(root.left);
            List<String> rightPaths = binaryTreePaths(root.right);
            for (String path : leftPaths) {
                paths.add(root.val + "->" + path);
            }
            for (String path : rightPaths) {
                paths.add(root.val + "->" + path);
            }
            
            // root is a leaf
            if (paths.size() == 0) {
                paths.add("" + root.val);
            }
            
            return paths;
        }
    }
    

      

    8、给定一棵二叉树,找到两个节点的最近公共父节点(LCA)。

    最近公共祖先是两个节点的公共的祖先节点且具有最大深度。

    public class Solution {
        // 在root为根的二叉树中找A,B的LCA:
        // 如果找到了就返回这个LCA
        // 如果只碰到A,就返回A
        // 如果只碰到B,就返回B
        // 如果都没有,就返回null
        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode node1, TreeNode node2) {
            if (root == null || root == node1 || root == node2) {
                return root;
            }
            
            // Divide
            TreeNode left = lowestCommonAncestor(root.left, node1, node2);
            TreeNode right = lowestCommonAncestor(root.right, node1, node2);
            
            // Conquer
            if (left != null && right != null) {
                return root;
            } 
            if (left != null) {
                return left;
            }
            if (right != null) {
                return right;
            }
            return null;
        }
    }

    参考:九章算法

    https://www.jiuzhang.com/

    https://www.jiuzhang.com/solutions/minimum-subtree/

    https://www.jiuzhang.com/solutions/binary-tree-paths/

  • 相关阅读:
    第十二章学习笔记
    UVa OJ 107 The Cat in the Hat (戴帽子的猫)
    UVa OJ 123 Searching Quickly (快速查找)
    UVa OJ 119 Greedy Gift Givers (贪婪的送礼者)
    UVa OJ 113 Power of Cryptography (密文的乘方)
    UVa OJ 112 Tree Summing (树的求和)
    UVa OJ 641 Do the Untwist (解密工作)
    UVa OJ 105 The Skyline Problem (地平线问题)
    UVa OJ 100 The 3n + 1 problem (3n + 1问题)
    UVa OJ 121 Pipe Fitters (装管子)
  • 原文地址:https://www.cnblogs.com/rnanprince/p/11595176.html
Copyright © 2011-2022 走看看