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

最新推荐文章于 2022-10-27 19:02:37 发布

原创最新推荐文章于 2022-10-27 19:02:37 发布 · 240 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文介绍如何使用递归方法计算二叉树的整体倾斜，通过DFS遍历每个节点，同时计算其左右子树节点值之差的绝对值，最后返回所有节点倾斜值之和。

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; 
    }
};