LeetCode 110.Balanced Binary Tree (平衡二叉树)

小鱼儿 2022-05-09 04:56 216阅读 0赞

题目描述:

给定一个二叉树,判断它是否是高度平衡的二叉树。

本题中,一棵高度平衡二叉树定义为:

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

  1. 3
  2. / \
  3. 9 20
  4. / \
  5. 15 7

返回 true

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

  1. 1
  2. / \
  3. 2 2
  4. / \
  5. 3 3
  6. / \
  7. 4 4

返回 false

AC C++ Solution:
递归法:

对每个节点调用depth()求每个节点的高度,再比较左右节点。

  1. /**
  2. * Definition for a binary tree node.
  3. * struct TreeNode {
  4. * int val;
  5. * TreeNode *left;
  6. * TreeNode *right;
  7. * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  8. * };
  9. */
  10. class Solution {
  11. public:
  12. int depth(TreeNode *root) {
  13. if (root == NULL) return 0;
  14. return max(depth(root->left),depth(root->right)) + 1;
  15. }
  16. bool isBalanced(TreeNode* root) {
  17. if (root == NULL) return true;
  18. int left = depth(root->left);
  19. int right = depth(root->right);
  20. return abs(left-right) <= 1 && isBalanced(root->left) && isBalanced(root->right);
  21. }
  22. };

DFS解法:

我们不是为每个子节点显式调用depth(),而是在DFS递归中返回当前节点的高度。当当前节点(包括)的子树平衡时,函数dfsHeight()返回非负值作为高度。否则返回-1。根据两个孩子的leftHeight和rightHeight,父节点可以检查子树是否平衡,并确定其返回值。

  1. /**
  2. * Definition for a binary tree node.
  3. * struct TreeNode {
  4. * int val;
  5. * TreeNode *left;
  6. * TreeNode *right;
  7. * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  8. * };
  9. */
  10. //解题链接:https://leetcode.com/problems/balanced-binary-tree/discuss/35691/The-bottom-up-O(N)-solution-would-be-better
  11. class Solution {
  12. public:
  13. int dfsHeight(TreeNode *root) { //深度优先搜索
  14. if(root == NULL) return 0;
  15. int leftHeight = dfsHeight(root->left);
  16. if (leftHeight == -1) return -1;
  17. int rightHeight = dfsHeight(root->right);
  18. if (rightHeight == -1) return -1;
  19. if(abs(leftHeight - rightHeight) > 1) return -1; //每个节点都要判断是否是平衡的
  20. return max(leftHeight,rightHeight) + 1;
  21. }
  22. bool isBalanced(TreeNode* root) {
  23. return dfsHeight(root) != -1;
  24. }
  25. };

在这种自下而上的方法中,树中的每个节点只需要访问一次。因此,时间复杂度为O(N),优于第一种解决方案。

发表评论

表情:
评论列表 (有 0 条评论,216人围观)

还没有评论,来说两句吧...

相关阅读