LintCode 1172: Binary Tree Tilt (二叉树好题)

1172. Binary Tree Tilt

Given a binary tree, return the tilt of the whole tree.

The tilt of a tree node is defined as the absolute difference between the sum of all left subtree node values and the sum of all right subtree node values. Null node has tilt 0.

The tilt of the whole tree is defined as the sum of all nodes' tilt.

Example

Example 1:

Input: 
{1,2,3}
Output: 1

Explanation: 
         1
       /   \
      2     3
Tilt of node 2 : 0
Tilt of node 3 : 0
Tilt of node 1 : |2-3| = 1
Tilt of binary tree : 0 + 0 + 1 = 1

**Example 2: **

Input：
{1,1,#,2,3}
Output：
7

Explanation：
        1
      /
    1
   /  \
2     3

Notice

1.The sum of node values in any subtree won't exceed the range of 32-bit integer.
2.All the tilt values won't exceed the range of 32-bit integer.

Input test data (one parameter per line)How to understand a testcase?

解法1：
思路就是递归求节点的sum，附带着把tilt给求了。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: the root
     * @return: the tilt of the whole tree
     */
    int findTilt(TreeNode * root) {
        getSum(root);
        return tilt_sum;
    }

private:
    int getSum(TreeNode *root) {
        if (!root) return 0;
        if (!root->left && !root->right) {
            return root->val;
        }
        if (!root->left) {
            int ret = getSum(root->right);
            tilt_sum += abs(ret);
            return ret + root->val;
        }
        if (!root->right) {
            int ret = getSum(root->left);   
            tilt_sum += abs(ret);
            return ret + root->val;
        }
        int left_sum = getSum(root->left);
        int right_sum = getSum(root->right);
        tilt_sum += abs(left_sum - right_sum);
        return  left_sum + right_sum + root->val; 
    }

    int tilt_sum = 0;
};

解法2：
解法1的精简版。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */

class Solution {
public:
    /**
     * @param root: the root
     * @return: the tilt of the whole tree
     */
    int findTilt(TreeNode * root) {
        int tilt = 0;
        dfs(root, tilt);
        return tilt;
    }

private:
    int dfs(TreeNode *root, int &tilt) {
        if (!root) return 0;
        
        int left_sum = dfs(root->left, tilt);
        int right_sum = dfs(root->right, tilt);
        tilt += abs(left_sum - right_sum);
        return  left_sum + right_sum + root->val; 
    }
};