How to determine if binary tree is balanced?
It\'s been a while from those school years. Got a job as IT specialist at a hospital. Trying to move to do some actual programming now. I\'m working on binary trees now, a
-
An empty tree is height-balanced. A non-empty binary tree T is balanced if:
1) Left subtree of T is balanced
2) Right subtree of T is balanced
3) The difference between heights of left subtree and right subtree is not more than 1.
/* program to check if a tree is height-balanced or not */ #include<stdio.h> #include<stdlib.h> #define bool int /* A binary tree node has data, pointer to left child and a pointer to right child */ struct node { int data; struct node* left; struct node* right; }; /* The function returns true if root is balanced else false The second parameter is to store the height of tree. Initially, we need to pass a pointer to a location with value as 0. We can also write a wrapper over this function */ bool isBalanced(struct node *root, int* height) { /* lh --> Height of left subtree rh --> Height of right subtree */ int lh = 0, rh = 0; /* l will be true if left subtree is balanced and r will be true if right subtree is balanced */ int l = 0, r = 0; if(root == NULL) { *height = 0; return 1; } /* Get the heights of left and right subtrees in lh and rh And store the returned values in l and r */ l = isBalanced(root->left, &lh); r = isBalanced(root->right,&rh); /* Height of current node is max of heights of left and right subtrees plus 1*/ *height = (lh > rh? lh: rh) + 1; /* If difference between heights of left and right subtrees is more than 2 then this node is not balanced so return 0 */ if((lh - rh >= 2) || (rh - lh >= 2)) return 0; /* If this node is balanced and left and right subtrees are balanced then return true */ else return l&&r; } /* UTILITY FUNCTIONS TO TEST isBalanced() FUNCTION */ /* Helper function that allocates a new node with the given data and NULL left and right pointers. */ struct node* newNode(int data) { struct node* node = (struct node*) malloc(sizeof(struct node)); node->data = data; node->left = NULL; node->right = NULL; return(node); } int main() { int height = 0; /* Constructed binary tree is 1 / \ 2 3 / \ / 4 5 6 / 7 */ struct node *root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->right->left = newNode(6); root->left->left->left = newNode(7); if(isBalanced(root, &height)) printf("Tree is balanced"); else printf("Tree is not balanced"); getchar(); return 0; }Time Complexity: O(n)
讨论(0) -
Wouldn't this work?
return ( ( Math.abs( size( root.left ) - size( root.right ) ) < 2 );Any unbalanced tree would always fail this.
讨论(0) -
Stumbled across this old question while searching for something else. I notice that you never did get a complete answer.
The way to solve this problem is to start by writing a specification for the function you are trying to write.
Specification: A well-formed binary tree is said to be "height-balanced" if (1) it is empty, or (2) its left and right children are height-balanced and the height of the left tree is within 1 of the height of the right tree.
Now that you have the specification, the code is trivial to write. Just follow the specification:
IsHeightBalanced(tree) return (tree is empty) or (IsHeightBalanced(tree.left) and IsHeightBalanced(tree.right) and abs(Height(tree.left) - Height(tree.right)) <= 1)Translating that into the programming language of your choice should be trivial.
Bonus exercise: this naive code sketch traverses the tree far too many times when computing the heights. Can you make it more efficient?
Super bonus exercise: suppose the tree is massively unbalanced. Like, a million nodes deep on one side and three deep on the other. Is there a scenario in which this algorithm blows the stack? Can you fix the implementation so that it never blows the stack, even when given a massively unbalanced tree?
UPDATE: Donal Fellows points out in his answer that there are different definitions of 'balanced' that one could choose. For example, one could take a stricter definition of "height balanced", and require that the path length to the nearest empty child is within one of the path to the farthest empty child. My definition is less strict than that, and therefore admits more trees.
One can also be less strict than my definition; one could say that a balanced tree is one in which the maximum path length to an empty tree on each branch differs by no more than two, or three, or some other constant. Or that the maximum path length is some fraction of the minimum path length, like a half or a quarter.
It really doesn't matter usually. The point of any tree-balancing algorithm is to ensure that you do not wind up in the situation where you have a million nodes on one side and three on the other. Donal's definition is fine in theory, but in practice it is a pain coming up with a tree-balancing algorithm that meets that level of strictness. The performance savings usually does not justify the implementation cost. You spend a lot of time doing unnecessary tree rearrangements in order to attain a level of balance that in practice makes little difference. Who cares if sometimes it takes forty branches to get to the farthest leaf in a million-node imperfectly-balanced tree when it could in theory take only twenty in a perfectly balanced tree? The point is that it doesn't ever take a million. Getting from a worst case of a million down to a worst case of forty is usually good enough; you don't have to go all the way to the optimal case.
讨论(0) -
Here is a version based on a generic depth-first traversal. Should be faster than the other correct answer and handle all the mentioned "challenges." Apologies for the style, I don't really know Java.
You can still make it much faster by returning early if max and min are both set and have a difference >1.
public boolean isBalanced( Node root ) { int curDepth = 0, maxLeaf = 0, minLeaf = INT_MAX; if ( root == null ) return true; while ( root != null ) { if ( root.left == null || root.right == null ) { maxLeaf = max( maxLeaf, curDepth ); minLeaf = min( minLeaf, curDepth ); } if ( root.left != null ) { curDepth += 1; root = root.left; } else { Node last = root; while ( root != null && ( root.right == null || root.right == last ) ) { curDepth -= 1; last = root; root = root.parent; } if ( root != null ) { curDepth += 1; root = root.right; } } } return ( maxLeaf - minLeaf <= 1 ); }讨论(0) -
What kind of tree are you talking about? There are self-balancing trees out there. Check their algorithms where they determine if they need to reorder the tree in order to maintain balance.
讨论(0) -
#include <iostream> #include <deque> #include <queue> struct node { int data; node *left; node *right; }; bool isBalanced(node *root) { if ( !root) { return true; } std::queue<node *> q1; std::queue<int> q2; int level = 0, last_level = -1, node_count = 0; q1.push(root); q2.push(level); while ( !q1.empty() ) { node *current = q1.front(); level = q2.front(); q1.pop(); q2.pop(); if ( level ) { ++node_count; } if ( current->left ) { q1.push(current->left); q2.push(level + 1); } if ( current->right ) { q1.push(current->right); q2.push(level + 1); } if ( level != last_level ) { std::cout << "Check: " << (node_count ? node_count - 1 : 1) << ", Level: " << level << ", Old level: " << last_level << std::endl; if ( level && (node_count - 1) != (1 << (level-1)) ) { return false; } last_level = q2.front(); if ( level ) node_count = 1; } } return true; } int main() { node tree[15]; tree[0].left = &tree[1]; tree[0].right = &tree[2]; tree[1].left = &tree[3]; tree[1].right = &tree[4]; tree[2].left = &tree[5]; tree[2].right = &tree[6]; tree[3].left = &tree[7]; tree[3].right = &tree[8]; tree[4].left = &tree[9]; // NULL; tree[4].right = &tree[10]; // NULL; tree[5].left = &tree[11]; // NULL; tree[5].right = &tree[12]; // NULL; tree[6].left = &tree[13]; tree[6].right = &tree[14]; tree[7].left = &tree[11]; tree[7].right = &tree[12]; tree[8].left = NULL; tree[8].right = &tree[10]; tree[9].left = NULL; tree[9].right = &tree[10]; tree[10].left = NULL; tree[10].right= NULL; tree[11].left = NULL; tree[11].right= NULL; tree[12].left = NULL; tree[12].right= NULL; tree[13].left = NULL; tree[13].right= NULL; tree[14].left = NULL; tree[14].right= NULL; std::cout << "Result: " << isBalanced(tree) << std::endl; return 0; }讨论(0)
加载中...
- 热议问题