【二叉求和树】

package od;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

public class 给出一个二叉树如图所示 {
   static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(int x) { val = x; }
    }

    public static class Main {

        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);

            String[] inorderStr = sc.nextLine().split(" ");
            String[] preorderStr = sc.nextLine().split(" ");

            int[] inorder = Arrays.stream(inorderStr).mapToInt(Integer::parseInt).toArray();
            int[] preorder = Arrays.stream(preorderStr).mapToInt(Integer::parseInt).toArray();

            TreeNode root = buildTree(preorder, inorder);
            buildSumTree(root);

            List<Integer> inorderResult = new ArrayList<>();
            inorderTraversal(root, inorderResult);

            for (int i = 0; i < inorderResult.size(); i++) {
                System.out.print(inorderResult.get(i));
                if (i < inorderResult.size() - 1) {
                    System.out.print(" ");
                }
            }
        }

        private static TreeNode buildTree(int[] preorder, int[] inorder) {
            if (preorder == null || inorder == null || preorder.length == 0 || inorder.length == 0) {
                return null;
            }
            return buildTreeHelper(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
        }

        private static TreeNode buildTreeHelper(int[] preorder, int preStart, int preEnd,
                                                int[] inorder, int inStart, int inEnd) {
            if (preStart > preEnd || inStart > inEnd) {
                return null;
            }

            TreeNode root = new TreeNode(preorder[preStart]);
            int rootIndex = 0;
            for (int i = inStart; i <= inEnd; i++) {
                if (inorder[i] == root.val) {
                    rootIndex = i;
                    break;
                }
            }

            int leftSize = rootIndex - inStart;

            root.left = buildTreeHelper(preorder, preStart + 1, preStart + leftSize,
                    inorder, inStart, rootIndex - 1);
            root.right = buildTreeHelper(preorder, preStart + leftSize + 1, preEnd,
                    inorder, rootIndex + 1, inEnd);

            return root;
        }

        private static int buildSumTree(TreeNode root) {
            if (root == null) {
                return 0;
            }

            int leftSum = buildSumTree(root.left);
            int rightSum = buildSumTree(root.right);

            int oldVal = root.val;
            root.val = leftSum + rightSum;

            return oldVal + root.val;
        }

        private static void inorderTraversal(TreeNode node, List<Integer> result) {
            if (node == null) {
                return;
            }
            inorderTraversal(node.left, result);
            result.add(node.val);
            inorderTraversal(node.right, result);
        }
    }
}