get (tree node val - (subtree val sum))

最新推荐文章于 2025-04-24 01:49:03 发布

sjphiChina

最新推荐文章于 2025-04-24 01:49:03 发布

阅读量414

点赞数

CC 4.0 BY-SA版权

分类专栏： strStr 队列

本文链接：https://blog.youkuaiyun.com/sjphiChina/article/details/52103321

strStr 同时被 2 个专栏收录

360 篇文章

订阅专栏

队列

63 篇文章

订阅专栏

本文介绍了一种算法，该算法通过递归及非递归方式计算给定树中每个节点的值与其左右子树之和的差值。递归实现简洁直观，而非递归方法使用栈和哈希映射进行高效计算。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给一个tree，返回每个点左右子树的和与自己值的差，用递归做，还问了不递归怎么做

package tree;

import java.util.*;

import z_dataStructure.TreeNode;

public class TreeNodeMinusSubtreeSum {

	public static void main(String[] args) {
		TreeNode root = new TreeNode(1);
		TreeNode node2 = new TreeNode(2);
		TreeNode node3 = new TreeNode(3);
		TreeNode node4 = new TreeNode(4);
		TreeNode node5 = new TreeNode(5);
		root.left = node2;
		root.right = node3;
		node3.left = node4;
		node3.right = node5;

		for (int subsum : treeNodeWithSubtreeSum(root)) {
			System.out.println(subsum);
		}
		ArrayList<Integer> res = new ArrayList<Integer>();
		treeNodeWithSubtreeSum1(root, res);
		for (int subsum : res) {
			System.out.println(subsum);
		}
	}
	
	public static int treeNodeWithSubtreeSum1(TreeNode root, ArrayList<Integer> res){
		if (root == null) {
			return 0;
		}
		int leftSubtree = treeNodeWithSubtreeSum1(root.left, res);
		int rightSubtree = treeNodeWithSubtreeSum1(root.right, res);
		int sum = root.val - leftSubtree - rightSubtree;
		res.add(sum);
		return root.val + leftSubtree + rightSubtree;
	}
	
	 public static ArrayList<Integer> treeNodeWithSubtreeSum(TreeNode root) {
         ArrayList<Integer> ret = new ArrayList<Integer>();
         if (root == null)
                 return ret;
         Stack<TreeNode> s = new Stack<TreeNode>();
         HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
         s.add(root);
         TreeNode pre = null;
         while (!s.isEmpty()) {
                 TreeNode cur = s.peek();
                 if (pre == null || pre.left == cur || pre.right == cur) {
                         if (cur.left != null) {
                                 s.push(cur.left);
                         } else if (cur.right != null) {
                                 s.push(cur.right);
                         } else {
                                 s.pop();
                                 map.put(cur.val, 0);
                                 ret.add(cur.val - map.get(cur.val));
                         }
                 } else if (cur.left == pre) {
                         if (cur.right != null) {
                                 map.put(cur.val, map.get(pre.val) + pre.val);
                                 s.push(cur.right);
                         } else {
                                 s.pop();
                                 map.put(cur.val, map.get(pre.val) + pre.val);
                                 ret.add(cur.val - map.get(cur.val));
                         }
                 } else if (cur.right == pre) {
                         s.pop();
                         int tmp = 0;
                         if (map.containsKey(cur.val))
                                 tmp = map.get(cur.val);
                         tmp += map.get(pre.val) + pre.val;
                         map.put(cur.val, tmp);
                         ret.add(cur.val - map.get(cur.val));
                 }
                 pre = cur;
         }
         return ret;
 }
}