Question

True or False questions:

1. A balanced, unsorted tree is more efficient than a sorted, unbalanced tree.

2. You should build a tree first, adding all the required elements before applying a balancing algorithm over the structure.

Answer 1

Answer;-

1. A balanced, unsorted tree is more efficient than a sorted, unbalanced tree.

ans: true

expalnation:-

A binary tree doesn't inherently have to be sorted. In this case you'd use the 0th index to create the root, the first to create the left branch, the second to create the right branch, and so forth and so on proceeding left to right or right to left as you prefer down the depth of the tree until your input runs out of numbers.

You could do that, and recently in an interview I was asked a similar question. I ended the interview when the interviewer couldn't provide a satisfactory answer as to why the hell the tree wasn't sorted in the first place, since a significant part of the value of having a binary tree is to use it for sorting values when they are added in a minimal number of computations.

A binary tree doesn't necessarily needs to be sorted, so you can follow any pattern you want and choose a root point and start building the tree through iteration or recursion of the array.

However, if you want a binary search tree (in which for every node, left child is smaller and right child is bigger in value), you can use different tree construction algorithms. The most simple one would be to sort the array and choose the mid-point to be the root, and start constructing the tree by continuously dividing the array into two parts and choosing the mid-point to be the root. In the end, you'll have a tree, which is made up of smaller trees and the roots of each tree were the mid-points of the continuously divided arrays, and where each node is bigger in value than it's left child, while smaller in value than the right child

You should build a tree first, adding all the required elements before applying a balancing algorithm over the structure.

ans:true

explanation:-

AVL tree is a self-balancing Binary Search Tree (BST) where the difference between heights of left and right subtrees cannot be more than one for all nodes.

An Example Tree that is an AVL Tree

The above tree is AVL because differences between heights of left and right subtrees for every node is less than or equal to 1.

An Example Tree that is NOT an AVL Tree

The above tree is not AVL because differences between heights of left and right subtrees for 8 and 18 is greater than 1.

Why AVL Trees?
Most of the BST operations (e.g., search, max, min, insert, delete.. etc) take O(h) time where h is the height of the BST. The cost of these operations may become O(n) for a skewed Binary tree. If we make sure that height of the tree remains O(Logn) after every insertion and deletion, then we can guarantee an upper bound of O(Logn) for all these operations. The height of an AVL tree is always O(Logn) where n is the number of nodes in the tree (See this video lecture for proof).

Insertion
To make sure that the given tree remains AVL after every insertion, we must augment the standard BST insert operation to perform some re-balancing. Following are two basic operations that can be performed to re-balance a BST without violating the BST property (keys(left) < key(root) < keys(right)).
1) Left Rotation
2) Right Rotation

T1, T2 and T3 are subtrees of the tree 
rooted with y (on the left side) or x (on 
the right side)           
     y                               x
    / \     Right Rotation          /  \
   x   T3   - - - - - - - >        T1   y 
  / \       < - - - - - - -            / \
 T1  T2     Left Rotation            T2  T3
Keys in both of the above trees follow the 
following order 
 keys(T1) < key(x) < keys(T2) < key(y) < keys(T3)
So BST property is not violated anywhere.

Steps to follow for insertion
Let the newly inserted node be w
1) Perform standard BST insert for w.
2) Starting from w, travel up and find the first unbalanced node. Let z be the first unbalanced node, y be the child of z that comes on the path from w to z and x be the grandchild of z that comes on the path from w to z.
3) Re-balance the tree by performing appropriate rotations on the subtree rooted with z. There can be 4 possible cases that needs to be handled as x, y and z can be arranged in 4 ways. Following are the possible 4 arrangements:
a) y is left child of z and x is left child of y (Left Left Case)
b) y is left child of z and x is right child of y (Left Right Case)
c) y is right child of z and x is right child of y (Right Right Case)
d) y is right child of z and x is left child of y (Right Left Case)

Following are the operations to be performed in above mentioned 4 cases. In all of the cases, we only need to re-balance the subtree rooted with z and the complete tree becomes balanced as the height of subtree (After appropriate rotations) rooted with z becomes same as it was before insertion. (See this video lecture for proof)