balanced trees avl trees red-black trees 2-3 trees 2-3-4 trees
TRANSCRIPT
Balanced TreesBalanced Trees
AVL TreesRed-Black Trees2-3 Trees2-3-4 Trees
AVL TreesAVL TreesThe earliest form of balanced tree,
originally proposed in 1962.Conceptually easy to understand, but
difficult to code.Based on the concept, that for every sub-
tree of a BST, if the difference in height of the two branches is 0 or 1, that sub-tree is balanced. If more than 1, it is unbalanced, and a rotation has to be performed to balance the tree.
AVL TreesAVL Trees
Every time a node is inserted, the sub-tree it's in must be checked for balance.
The problem is adding a node might not unbalance the sub-tree it's in, it might unbalance a higher level sub-tree.
Every time a node is added, every sub-tree up to the root has to be checked and rebalanced, if necessary.
Balancing an AVL TreeBalancing an AVL Tree
30
20
10
30
20
10
Balancing an AVL TreeBalancing an AVL Tree
40
20
10
30 50
60
40
20
10
50
60
30
A Double RotationA Double Rotation
40
20
10 30
50
60
25 35
22
40
20
10
30 50
60
25
35
22
A Double RotationA Double Rotation
30
10
20 40
50
22
25
60
35
40
20
10
30 50
60
25
35
22
Inserting into an AVL TreeInserting into an AVL Tree
Insert the new node as you would into a normal BST.
Starting from the parent of the new node:◦Get the depth of the left branch.◦Get the depth of the right branch.◦If abs(right – left) is > 1, rotate.◦Recurse up to the next parent.
AVLNode
- data : Object
- left : AVLNode
- right : AVLNode
- parent: AVLNode
+ createAVLNode()
+ getData()
+ setData()
+ getLeft()
+ setLeft()
+ getRight()
+ setRight()
+ getParent()
+ setParent()
Red Black TreesRed Black Trees
Originally invented in 1972 and called "Symmetric Binary B-trees".
Acquired its modern name in 1978 to make it easier to understand and to code.
Red Black Tree RulesRed Black Tree Rules
Every node is either red or blackAt the end of every branch is a black NULL
nodeIf a node is red, both of its children are
black (Can't have two red nodes in a row.)Every path from a node to a descendant
leaf must have the same number of black nodes.
RBBTNode
- data : Object
- left : RBBTNode
- right : RBBTNode
- color : char
+ createRBBTNode()
+ getData() : Object
+ setData()
+ getLeft() : RBBTNode
+ setLeft()
+ getRight() : RBBTNode
+ setRight()
+ getColor() : char
+ setColor()
2-3 Trees2-3 Trees
2-3 Trees2-3 TreesA 2-3 Tree is always height balanced.A 2-3 Tree has 2-Nodes and 3-Nodes
◦A 2-Node has 1 data item and 2 children.◦A 3-Node has 2 data items and 3 children.
New values are always added at the leaf level.
The only time the height of the tree changes is when the root node has too many values in it, and has to be split.
2-3 Node Pictorially2-3 Node Pictorially
leftValue rightValue
firstChild thirdChildsecondChild
When Used as a 2-NodeWhen Used as a 2-Node
leftValue rightValue
firstChild thirdChildsecondChild
< LV > LV
When Used as a 3-NodeWhen Used as a 3-Node
leftValue rightValue
firstChild thirdChildsecondChild
< LV > RV> LV && < RV
A Node for a 2-3 TreeA Node for a 2-3 Tree
Node23
- leftValue : Object
- rightValue : Object
- firstChild : Node23
- secondChild : Node23
- thirdChild : Node23
- parent : Node23
- type : int
+ getType : int
+ setType : void
(Accessors and Mutators
for all fields of instance data)
Inserting into a 2-3 TreeInserting into a 2-3 Tree
Insert 39
Insert 38
Inserting into a 2-3 Tree (con'd)Inserting into a 2-3 Tree (con'd)
Insert 37 Insert 36
Insert 33, 35, 34
Inserting into a 2-3 Tree (con'd)Inserting into a 2-3 Tree (con'd)
Inserting 32
Searching a 2-3 TreeSearching a 2-3 Tree
Searching is similar to searching a BST, except you may have 2 values to compare, and 3 possible paths to take.
If you're sitting on a 2-Node, it's exactly the same as a BST.
Searching a 2-3 TreeSearching a 2-3 Tree
if node is a 2-Node if key == node value return current node if key < node value traverse to the left else traverse to the rightelse (node is a 3-node) if key == left value return current node if key < left value traverse to the left else if key == right value return current node if key > right value traverse to the right else traverse to the middle
Inserting into a 2-3 TreeInserting into a 2-3 Tree
if the node to insert into is a 2-Node if the new value is less than the value in the node push the old value into the rightValue assign the new value to the leftValue else (new value is greater than old value) assign new value to rightValueelse ( it's a 3-Node ) The middle value of current left, current right and new value is going to get pushed up to the parent. The lowest of the 3 values is going to get pushed into its own node to the left. The highest of the 3 values is going to get pushed into a new node on the right. Now, recursively, does pushing the middle value up to the parent cause a split up there? If I'm splitting the root node (parent == null), the middle value will be pushed into a new root node.
2-3-4 Trees2-3-4 Trees
Always perfectly balanced, every leaf has the same depth.
Not a binary tree, nodes may contain◦1 data value and 2 children (2-Node)◦2 data values and 3 children (3-Node)◦3 data values and 4 children (4-Node)
Node234
- leftValue : Object
- middleValue : Object
- rightValue : Object
- firstChild : Node234
- secondChild : Node234
- thirdChild : Node234
- fourthChild : Node234
- parent : Node234
- type : int
+ getType : int
+ setType : void
(Accessors and Mutators
for all fields of instance data)
leftValue middleValue rightValue
firstChild thirdChild fourthChildsecondChild
Used as a 2-NodeUsed as a 2-Node
leftValue middleValue rightValue
firstChild thirdChild fourthChildsecondChild
< MV > MV
Used as a 3-NodeUsed as a 3-Node
leftValue middleValue rightValue
firstChild thirdChild fourthChildsecondChild
< LV > LV && < RV > RV
Used as a 4-NodeUsed as a 4-Node
leftValue middleValue rightValue
firstChild thirdChild fourthChildsecondChild
< LV > LV && < MV > RV> MV && < RV
Insertion into a 2-3-4 TreeInsertion into a 2-3-4 Tree
New values get inserted to leaves only.As you're looking for the node to insert
into, split any 4-Nodes you run into.By splitting any 4-Node we run into, we
always have room to insert the new value when we find out where it belongs.
Inserting and splitting never changes the height of the tree, unless the root node is being split.
6 Cases for Splitting a 4-Node6 Cases for Splitting a 4-Node
The 4-Node is the rootThe 4-Node is the child of a 2-Node
◦The 4-Node is the left (first) child◦The 4-Node is the right (fourth) child
The 4-Node is the child of a 3-Node◦The 4-Node is the first child◦The 4-Node is the second child◦The 4-Node is the fourth child
Case 1: 4-Node is the rootCase 1: 4-Node is the root
Cases 2,3: Parent is a 2-NodeCases 2,3: Parent is a 2-Node
Cases 4,5,6: Parent is a 3-NodeCases 4,5,6: Parent is a 3-Node
Cases 4,5,6: Parent is a 3-NodeCases 4,5,6: Parent is a 3-Node
2-3-4 Tree Search Algorithm2-3-4 Tree Search AlgorithmIF this node is null, return null
IF this is a 2-Node
IF key == middle value
return this;
ELSE IF key < middle value
recurse down the left subtree
ELSE
recurse down the right subtree
ELSE IF this is a 3-Node
IF key == left value
return this;
ELSE IF key < left value
recurse down left subtree
ELSE IF key == right value
return this;
ELSE IF key < right value
recurse down the middle subtree
ELSE recurse down the right subtree continued…
2-3-4 Tree Search Algorithm (con'd)2-3-4 Tree Search Algorithm (con'd)
ELSE (this is a 4-Node)
IF key == left value
return this;
ELSE IF key < left value
recurse down first subtree
ELSE IF key == middle value
return this;
ELSE IF key < middle value
recurse down second subtree
ELSE IF key == right value
return this;
ELSE IF key < right value
recurse down third subtree
ELSE
recurse down fourth subtree
ExampleExample
Example ContinuedExample Continued
Example ContinuedExample Continued
Deletion from a 2-3-4 TreeDeletion from a 2-3-4 Tree
Similar to deletion from a Binary Search Tree:◦Find the highest value in the left subtree (will
always be in a leaf node)◦Swap the values in the two nodes◦Remove the value from the leaf node◦Problems arise when the value to be deleted is
in a 2-Node.
Deletion (con'd)Deletion (con'd)
Leaf nodes cannot simply be removed.2-Nodes with value to be deleted must be
MERGED into other nodes (the opposite of splitting), and then, the value removed.
Just like there are 6 split cases, they are MANY merge cases, depending on what types of node the brothers are, and what type of node the parent is.
We're not going to cover it here.