## Data Structures — A Quick Comparison (Part 2)

5 stars based on
50 reviews

Most operations on a BST take time proportional to the height of the tree, so it is desirable to keep the height small. Self-balancing binary trees solve this problem by performing transformations on binary search pros and cons tree at key times, in order to reduce the height. Although a certain overhead is involved, it is justified in the long run by ensuring fast execution of later operations.

Balanced BSTs are not always so precisely balanced, since it can be expensive to keep a tree at minimum height at all times; instead, most algorithms keep the height within a constant factor of this lower bound. There are four cases, choosing which one depends on different types of unbalanced relations. In the following cases, assume Root is the initial parent before a rotation and Pivot is the child to take the root's place. Overall, the time required is O log n for lookup, plus a maximum of O log n rotations on the way back to the root, so the deletion can be completed in O log n time.

Because of the height-balancing of the tree, a lookup takes O log n time. Please take a look at the following slides for AVL tree insertion and deletion animation use the slide show mode. In addition to the ordinary requirements imposed on BSTs, the following additional requirements apply to RB-trees:.

To see why these properties guarantee this, it suffices to note that no path can have two red nodes in a row, due to property 4. The shortest possible path has all black nodes, and the longest possible path alternates between red and black nodes. Since all maximal paths have the same number of black nodes, by property 5, this shows that no path is more than twice as long as any other path. Insertion begins by adding the node as any BST insertion does and by coloring it red.

It's a red inner node with two black leaves. Back To Lectures Notes. A self-balancing binary search tree or height-balanced binary search tree is a binary search tree BST that attempts to keep its height, or the number of levels of nodes beneath the root, as small as possible at all times, automatically. What is the major disadvantage of an ordinary BST?

The height must binary search pros and cons be at most the ceiling of log 2 n. Operation Big-O time Lookup. Properties of an AVL tree: In an AVL tree, the heights of the two child subtrees of any node differ by at most one; therefore, it is also said to be height-balanced.

Lookup, insertion, and deletion all take O log n time in both the average and worst cases, where n is the number of nodes in the tree. Insertions and deletions may require the tree to be rebalanced by one or more tree rotations. The balance factor of a node is the height of its right subtree minus the height of its left subtree and a node with a balance factor 1, 0, or -1 is considered balanced.

After inserting a node, it is necessary to check each of the node's ancestors for consistency with the Binary search pros and cons rules. For each node checked, if the balance factor remains 1, 0, or -1 then no rotations are necessary. After each insertion, at binary search pros and cons two tree rotations are needed to restore the entire tree. If a node is a leaf, remove it. If the node is not a leaf, replace it with either the largest in its left subtree rightmost or the smallest in its right subtree leftmostand remove that node.

The node that was found as replacement has at most one subtree. After deletion, retrace the path from parent of the replacement to the root, adjusting the balance factors as needed. More complicated rules for stopping. If the balance factor becomes 0 then the height of the subtree has decreased by one and the retracing needs to continue. This is in contrast to an insertion where a rotation resulting in a balance factor of 0 indicated that the subtree's height has remained unchanged.

Build an AVL tree with the following values: Remove 24 and 20 from the above tree. Compare binary search trees with hash tables. Find pros and cons of each data structure. Time complexity of operations Space complexity of data structure Handling varying input sizes Traversal Other supported operations?

It is complex, but has a good worst-case running time for its operations and is efficient in practice: In RB-trees, the leaf nodes are not relevant and do not contain data.

A null child pointer can encode the fact that this child is a leaf. The search time on a RB-tree results in O log n time. In addition to the ordinary binary search pros and cons imposed on BSTs, the following additional requirements apply to RB-trees: A binary search pros and cons is either red or black. The root is black. All leaves are black.

Both children of every red node are black. Every simple path from a given node to any of its descendant leaves contains the same number of black nodes.

The above constraints enforce a critical property of RB-trees: The longest path from the root to any leaf is no more than twice as long as the shortest path from the root to any other leaf in that tree. The result is that the tree is roughly balanced. Insertion, deletion, and search require worst-case time proportional to the height of the tree, the theoretical upper bound on the height allows RB-trees to be **binary search pros and cons** in the worst case.

Insertions and removals are quite complex in a RB-tree in order to keep the properties. Property 3 all binary search pros and cons are black always holds. Property 4 both children of every red node are black is threatened only by adding a red node, repainting a black node red, or a rotation. Property 5 all paths have same number of black nodes is threatened only by adding a black node, repainting a red node black or vice versaor a rotation.

It's repainted black to satisfy property 2. Property 4 children of red are black is not violated. Property 5 holds since N has two black leaf children, but N is binary search pros and cons. Perform left rotation on P. Then go to Case 5. Repaint G and P. For deletion on a RB-Tree, please see the Wikipedia link for details. Let's try it out with the following sequence of values: