12. Balanced Trees

advertisement
241-423 Advanced Data Structures
and Algorithms Semester 2, 2012-2013
12. Balanced Search
Trees
Objectives
– discuss various kinds of balanced search trees:
AVL trees, 2-3-4 trees, Red-Black trees,
ADSA: Balanced Trees/12
1
Contents
1.
2.
3.
4.
What is a Balanced Binary Search Tree?
AVL Trees
2-3-4 Trees
Red-Black Trees
ADSA: Balanced Trees/12
2
1.What is a Balanced Binary Search Tree?
• A balanced search tree is one where all the
branches from the root have almost the
same height.
balanced
unbalanced
ADSA: Balanced Trees/12
continued
3
• As a tree becomes more unbalanced, search
running time decreases from O(log n) to
O(n)
– because the tree shape turns into a list
• We want to keep the binary search tree
balanced as nodes are added/removed, so
searching/insertion remain fast.
ADSA: Balanced Trees/12
4
1.1. Balanced BSTs: AVL Trees
• An AVL tree maintains height balance
– for each node, the difference in height of its two
subtrees is in the range -1 to 1
ADSA: Balanced Trees/12
5
1.2. 2-3-4 Trees
o
o
A multiway tree where each node has at most 4
children, and a node can hold up to 3 values.
A 2-3-4- tree can be perfectly balanced
•
•
no difference in height between branches
requires complex nodes and links
ADSA: Balanced Trees/12
6
1.3. Red-Black Trees
o
A red-black tree is a binary version of a 2-3-4 tree
•
the nodes have a 'color' attribute: BLACK or RED
•
•
drawn in Ford and Topp (and here) in white and gray!!
the tree maintains a balance measure called
the BLACK height
BLACK
RED
ADSA: Balanced Trees/12
7
1.4. B-Trees
• A multiway tree where each node has at
most m children, and a node can hold up to
m-1 values
– a more general version of a 2-3-4 tree
• B-Trees are most commonly used in
databases and filesystems
– most nodes are stored in secondary storage such
as hard drives
ADSA: Balanced Trees/12
8
2. AVL Trees
• For each AVL tree node, the difference
between the heights of its left and right
subtrees is either -1, 0 or +1
– this is called the balance factor of a node
•
balanceFactor =
height(left subtree) - height(right subtree)
L-R
– if balanceFactor > 1 or < -1 then the tree is too
unbalanced, and needs 'rearranging' to make it
more balanced
ADSA: Balanced Trees/12
9
• Heaviness
– if the balanceFactor is positive, then the node is
"heavy on the left"
•
the height of the left subtree is greater than the
height of the right subtree
– a negative balanceFactor, means the node is
"heavy on the right"
ADSA: Balanced Trees/12
continued
10
L–R
= 0-1
root is
heavy on
the right,
but still
balanced
ADSA: Balanced Trees/12
L–R
= 2-1
root is
heavy on
the left,
but still
balanced
L–R
= 1-2
root is
heavy on
the right,
but still
balanced
11
2.1. The AVLTree Class
ADSA: Balanced Trees/12
12
Using AVLTree
String[] stateList = {"NV", "NY", "MA", "CA", "GA"};
AVLTree<String> avltreeA = new AVLTree<String>();
for (int i = 0; i < stateList.length; i++)
avltreeB.add(stateList[i]);
System.out.println("States: " + avltreeA);
int[] arr = {50, 95, 60, 90, 70, 80, 75, 78};
AVLTree<Integer> avltreeB = new AVLTree<Integer>();
for (int i = 0; i < arr.length; i++)
avltreeB.add(arr[i]);
// display the tree
System.out.println(avltreeB.displayTree(2));
avltreeB.drawTree(2);
ADSA: Balanced Trees/12
13
Execution
States: [CA, GA, MA, NV, NY]
70(-1)
60(1)
50(0)
90(1)
78(0)
75(0)
95(0)
80(0)
(-1)
(1)
ADSA: Balanced Trees/12
root is
heavy on
the right,
but still
balanced
14
The AVLTree Node
• An AVLNode contains the node's value,
references to the node's two subtrees, and the
node height.
height(node) = max ( height(node.left), height(node.right) ) + 1;
nodeValue
height
left
ADSA: Balanced Trees/12
AVTTreeNode
object
right
continued
15
nodeValue
height
private static class AVLNode<T>
{
public T nodeValue;
// node data
left
right
public int height;
// child links
public AVLNode<T> left, right;
public AVLNode (T item)
{ nodeValue = item;
height = 0;
left = null; right = null;
}
Use of public is bad;
the coding style is
due to Ford & Topp
}
ADSA: Balanced Trees/12
16
2.2. Adding a Node to the Tree
• The addition of a node may cause the tree to
go out of balance.
– addNode() adds a node and may reorder nodes as
it returns from the adding back to the root
•
reordering is the new idea in AVL trees
– the reordering is done using single and double
rotations
ADSA: Balanced Trees/12
17
2.2.1. Too Heavy on the Left
L – R = 3-1
left
25
12
Two cases
or
node P
(2)
left
30
12
30
left
5
node P
(2)
25
right
20
left or right branch
-- doesn't matter
11
outside grandchild
ADSA: Balanced Trees/12
5
20
branch
doesn't matter
22
inside grandchild
continued
18
• Inserting a node in the left subtree of P (e.g.
adding 11 or 22) may cause P to become
"too heavy on the left"
– balance factor == 2
• The new node can either be in the outside or
inside grandchild subtree:
– outside grandchild = left-left
– inside grandchild = left-right
ADSA: Balanced Trees/12
continued
19
ADSA: Balanced Trees/12
20
2.2.2. Too Heavy on the Right
L – R = 1-3
node P
(-2)
right
12
30
25
right
12
right
27
45
branch
doesn't matter
40
outside grandchild
ADSA: Balanced Trees/12
or
node P
(-2)
25
Two cases
30
left
27
branch
doesn't matter
45
29
inside grandchild
continued
21
• Inserting a node in the right subtree of P (e.g.
adding 29 or 40) may cause P to become "too
heavy on the right"
– balance factor == -2
• The new node can either be in the outside or
inside grandchild subtree:
– outside grandchild = right-right
– inside grandchild = right-left
ADSA: Balanced Trees/12
continued
22
ADSA: Balanced Trees/12
23
2.3. Single Rotations
• When a new item is added to the subtree for
an outside grandchild, the imbalance is fixed
with a single right or left rotation
• Two cases:
– left outside grandchild (left-left) -->
single right rotation
– right outside grandchild (right-right) -->
single left rotation
ADSA: Balanced Trees/12
24
2.3.1. Single Right Rotation
• A single right rotation occurs when a new
element is added to the subtree of the left
outside grandchild (left-left)
ADSA: Balanced Trees/12
continued
25
add
cut
cut
add
left outside grandchild (left-left)
ADSA: Balanced Trees/12
continued
26
• A single right rotation rotates the left child
(LC) to replace the parent
– the parent becomes the new right child
• The right subtree of LC (RGC) is attached as a
left child of P
– ok since the nodes in RGC are greater than LC but
less than P
ADSA: Balanced Trees/12
27
singleRotateRight()
// single right rotation on p
private static <T> AVLNode<T> singleRotateRight(
AVLNode<T> p)
{
AVLNode<T> lc = p.left;
p.left = lc.right;
lc.right = p;
// 1 & 4 on slide 26
// 2 & 3
p.height = max(height(p.left), height(p.right)) + 1;
lc.height = max(height(lc.left),
height(rc.right)) + 1;
return lc;
}
ADSA: Balanced Trees/12
28
private static <T> int height(AVLNode<T> t)
{
if (t == null)
return -1;
else
return t.height;
}
ADSA: Balanced Trees/12
29
2.3.2. Single Left Rotation
• A single left rotation occurs when a new
element is added to the subtree of the right
outside grandchild (right-right).
• The rotation exchanges the parent (P) and
right child (RC) nodes, and attaches the
subtree LGC as the right subtree of P.
ADSA: Balanced Trees/12
continued
30
cut
add
add
cut
right outside grandchild (right-right)
ADSA: Balanced Trees/12
31
singleRotateLeft()
// single left rotation on p
private static <T> AVLNode<T> singleRotateLeft(
AVLNode<T> p)
{
AVLNode<T> rc = p.right;
p.right = rc.left;
rc.left = p;
// 1 & 4 on slide 31
// 2 & 3
p.height = max(height(p.left),height(p.right)) + 1;
rc.height = max(height(rc.left),
height(rc.right)) + 1;
return rc;
}
ADSA: Balanced Trees/12
32
2.4. Double Rotations
• When a new item is added to the subtree for
an inside grandchild, the imbalance is fixed
with a double right or left rotation
– a double rotation is two single rotations
• Two cases:
– left inside grandchild (left-right) -->
double right rotation
– right inside grandchild (right-left) -->
double left rotation
ADSA: Balanced Trees/12
33
2.4.1. A Double Right Rotation
Single left rotation
about LC
left inside
grandchild
(left-right)
ADSA: Balanced Trees/12
Single right rotation
about P
Watch RGC
rise to the top
balanced
34
doubleRotateRight()
private static <T> AVLNode<T> doubleRotateRight(
AVLNode<T> p)
/* double right rotation on p is
left rotation, then right rotation */
{
p.left = singleRotateLeft(p.left);
return singleRotateRight(p);
}
ADSA: Balanced Trees/12
35
2.4.2. A Double Left Rotation
P
P
LGC
RC
LGC
LGC
LC
P
RC
LC
RC
A
RGC
A
B
A
B
Single right rotation
about RC
right inside
grandchild
(right-left)
ADSA: Balanced Trees/12
RGC
Single left rotation
about P
Watch LGC
rise to the top
B
LC
RGC
balanced
36
doubleRotateLeft()
private static <T> AVLNode<T> doubleRotateLeft(
AVLNode<T> p)
/* double left rotation on p is
right rotation, then left rotation */
{
p.right = singleRotateRight(p.right);
return singleRotateLeft(p);
}
ADSA: Balanced Trees/12
37
2.5. addNode()
• addNode() recurses down to the insertion point
and inserts the node.
• As it returns, it visits the nodes in reverse order,
fixing any imbalances using rotations.
• It must handle four cases:
– balance height == 2: left-left, left-right
– balance height == -2: right-left, right-right
ADSA: Balanced Trees/12
38
Basic addNode()
was P in earlier slides
No AVL rotation
code added yet
private Node<T> addNode(Node<T> t, T item)
{
if (t == null)
// found insertion point
t = new Node<T>(item);
}
else if (((Comparable<T>)item).compareTo(t.nodeValue) < 0) {
t.left = addNode( t.left, item);
// visit left subtree
else if (((Comparable<T>)item).compareTo(t.nodeValue) > 0 ) {
t.right = addNode(t.right, item);
// visit right
else
throw new IllegalStateException();
// duplicate error
return t;
// end of addNode()
ADSA: Balanced Trees/12
39
AVL rotation code added
private AVLNode<T> addNode(AVLNode<T> t, T item)
{
if(t == null)
// found insertion point
t = new AVLNode<T>(item);
else if (((Comparable<T>)item).compareTo(t.nodeValue) < 0) {
// visit left subtree: add node then maybe rotate
t.left = addNode( t.left, item); // add node, then...
if (height(t.left) - height(t.right) == 2 ) { //too heavy on left
if (((Comparable<T>)item).compareTo(t.left.nodeValue) < 0)
// problem on left-left
t = singleRotateRight(t);
else
// problem on left-right
t = doubleRotateRight(t);
// left then right rotation
}
}
:
ADSA: Balanced Trees/12
continued
40
else if (((Comparable<T>)item).compareTo(t.nodeValue) > 0 ) {
// visit right subtree: add node then maybe rotate
t.right = addNode(t.right, item ); // add node, then...
if (height(t.left)-height(t.right) == -2){ //too heavy on right
if (((Comparable<T>)item).compareTo(t.right.nodeValue) > 0)
// problem on right-right
t = singleRotateLeft(t);
else
// problem on right-left
t = doubleRotateLeft(t); // right then left rotation
}
}
else
// duplicate; throw IllegalStateException
throw new IllegalStateException();
// calculate new height of t
t.height = max(height(t.left), height(t.right)) + 1;
}
return t;
// end of addNode()
ADSA: Balanced Trees/12
41
add()
public interface for inserting an item
public boolean add(T item)
{
try {
root = addNode(root, item); // start from root
}
catch (IllegalStateException e)
{ return false; }
// item is a duplicate
// increment the tree size and modCount
treeSize++;
modCount++;
return true;
// node was added ok
}
ADSA: Balanced Trees/12
42
2.6. Building an AVL Tree
gray node is
too heavy
left outside
grandchild
(left-left)
ADSA: Balanced Trees/12
continued
43
right outside
grandchild
(right-right)
ADSA: Balanced Trees/12
45
continued
44
right inside
grandchild
(right-left)
double rotate left
(right then left rotation)
ADSA: Balanced Trees/12
continued
45
left inside
grandchild
(left-right)
ADSA: Balanced Trees/12
double rotate right
(left then right rotation)
continued
46
2.7. Efficiency of AVL Tree Insertion
• Detailed analysis shows:
int(log2n)  height < 1.4405 log2(n+2) - 1.3277
• So the worst case running time for insertion is
O(log2n).
• The worst case for deletion is also O(log2n).
ADSA: Balanced Trees/12
47
2.8. Deletion in an AVL Tree
• Deletion can easily cause an imbalance
– e.g delete 32
44
44
17
62
32
50
48
17
78
54
50
88
48
78
54
88
after deletion
before deletion of 32
ADSA: Balanced Trees/12
62
AVL Trees
48
48
3. 2-3-4 Trees
• In a 2-3-4 tree:
The numbers refer to the
maximum number of
branches that can leave
the node
– a 2-node has 1 value and a max of 2 children
– a 3-node has 2 values and a max of 3 children
– a 4-node has 3 values and a max of 4 children
same as a binary
tree node
ADSA: Balanced Trees/12
49
3.1. Searching a 2-3-4 Tree
• To find an item:
– start at the root and compare the item with all
the values in the node;
– if there's no match, move down to the
appropriate subtree;
– repeat until you find a match or reach an empty
subtree
ADSA: Balanced Trees/12
50
Search Example
ADSA: Balanced Trees/12
Try finding 9 and 30
51
3.2. Inserting into a 2-3-4 Tree
• Search to the bottom for an insertion node
– 2-node at bottom: convert to 3-node
– 3-node at bottom: convert to 4-node
– 4-node at bottom: ??
ADSA: Balanced Trees/12
52
Splitting 4-nodes
• Transform tree on the way down:
– ensures last node is not a 4-node
– local transformation to split a 4-node
Insertion at the bottom is now easy since it's not a 4-node
ADSA: Balanced Trees/12
53
Example
• To split a 4-node. move middle value up.
ADSA: Balanced Trees/12
54
3.3. Building
This 4-node will be split during
the next insertion.
insert 4
This 4-node will be split during
the next insertion.
ADSA: Balanced Trees/12
continued
55
insert 10
Insertions happen at the bottom.
ADSA: Balanced Trees/12
This 4-node will be split during
the next insertion.
56
insert 55
The insertion point is at level 1, so the new 4-node
at level 0 is not split during this insertion.
ADSA: Balanced Trees/12
continued
57
insert 11
12
12
4
2
8
4
25
10
15
Split 4-node (4, 12, 25)
35
55
2
8
25
10 11
15
35
55
Insert 11
This 4-node will be split during
the next insertion.
ADSA: Balanced Trees/12
58
Another Example
insert
The search missed
insert
the 4-nodes on
the left, so
not changed.
ADSA: Balanced Trees/12
59
3.4. Efficiency of 2-3-4 Trees
fast!
• Searching for an item in a 2-3-4 tree with n
elements:
– the max number of nodes visited during the
search is int(log2n) + 1
• Inserting an element into a 2-3-4 tree:
– requires splitting no more than int(log2n) + 1
4-nodes
•
normally requires far fewer splits
ADSA: Balanced Trees/12
60
3.5. Drawbacks of 2-3-4 Trees
• Since any node may become a 4-node, then all
nodes must have space for 3 values and 4 links
– but most nodes are not 4-nodes
– lots of wasted memory, unless impl. is fancier
• Complex nodes and links
– slower to process than binary search trees
ADSA: Balanced Trees/12
61
4. Red-Black Trees
• A red-black tree is a binary search tree
where each node has a 'color'
– BLACK or RED
• A red-black tree is a binary version of a
2-3-4 tree, using different color combinations
to represent 3-nodes and 4-nodes.
– a 2-node is already a binary node
ADSA: Balanced Trees/12
62
BLACK
RED
ADSA: Balanced Trees/12
BLACK and RED are drawn
in Ford and Topp
(and here) in white and gray!!
63
4.1. From 2-3-4 Tree Nodes to
Red-Black Nodes
2-node Conversion
• A 2-node is already a binary node so doesn't
need to change its shape.
• The color of a 2-node is always BLACK
(drawn as white in these slides).
ADSA: Balanced Trees/12
continued
64
4-node Conversion
• A 4-node has it's middle value become a
BLACK (white) parent and the other values
become RED (gray) children.
BLACK
RED
ADSA: Balanced Trees/12
continued
65
3-node Conversion
• Represent a 3-node as:
– a BLACK parent and a smaller RED left child or
– a BLACK parent and a larger RED right child
3-node (A, B)
in a 2-3-4 Tree
(a) Red-black tree representation
A is a black parent; B is a red right child
A
A B
B
OR
S
S
T
(b) Red-black tree representation
B is a black parent; A is a red left child
U
A
B
U
T
ADSA: Balanced Trees/12
U
S
T
66
4.2. Changing a 2-3-4 Tree into
a Red-Black Tree
change
this node
ADSA: Balanced Trees/12
continued
67
change
this node
ADSA: Balanced Trees/12
continued
68
change
these nodes
ADSA: Balanced Trees/12
69
4.3. Three Properties of a Red-Black Tree
that must always be true for the tree to be red-black
• 1. The root must always be BLACK
(white in our pictures)
• 2. A RED parent never has a RED child
– in other words: there are never two successive
RED nodes in a path
ADSA: Balanced Trees/12
continued
70
• 3. Every path from the root to an empty
subtree contains the same number of
BLACK nodes
– called the black height
• We can use black height to measure the
balance of a red-black tree.
ADSA: Balanced Trees/12
71
Check the Example Properties
ADSA: Balanced Trees/12
72
4.4. Inserting a Node
Three things
to do.
• 1. Search down the tree to find the insertion
point, splitting any 4-nodes (a BLACK parent
with two RED children) by coloring the
children BLACK and the parent RED
– called a color flip
• Splitting a 4-node may involve additional
rotations and color changes
– there are 4 cases to consider (section 4.4.1)
ADSA: Balanced Trees/12
continued
73
• 2. Once the insertion point is found, add
the new item as a RED leaf node (section
4.4.2)
– this may create two successive RED nodes
•
again use rotation and recoloring to
reorder/rebalance the tree
• 3. Keep the root as a BLACK node.
ADSA: Balanced Trees/12
74
4.4.1. Four Cases for Splitting a 4-Node
L
G
L
L
L
R
L
1
LL/black parent
(also mirror
case, RR)
G
G
L
G
R
2
3
4
LR/black parent
(also mirror
case, RL)
LL/red parent
(also mirror
case, RR)
LR/red parent
(also mirror
case, RL)
ADSA: Balanced Trees/12
75
Case 1 (LL/black P): An Example
• If the parent is BLACK, only a color flip is
needed.
1
L
G
L
ADSA: Balanced Trees/12
L
L
G
L
L
G
L
G
76
Case 2 (LR/black P): Insert 55
L
G
L
R
ADSA: Balanced Trees/12
G
R
2
L
G
L
G
R
Only a color flip is required
for same reason as case 1
77
Case 3 (LL / red parent)
3
L
L
L
L
The color-flip creates two successive red nodes
-- this breaks property 2, so must be fixed
ADSA: Balanced Trees/12
78
• To fix the red color conflict, carry out a single
left or right rotation of node P:
• LL  right rotation of P
• RR (mirror case)  left rotation of P
• Also change the colors of nodes P and G.
ADSA: Balanced Trees/12
continued
79
3
3
R
L
R
L
LL of G → right rot of P
RR of G → left rot of P
and P and G color changes
ADSA: Balanced Trees/12
80
Case 3 (LL / red P) as a 2-3-4 Tree
3
L
L
XPG
A
ADSA: Balanced Trees/12
B
C
D
81
Case 4 (LR / red parent)
4
L
L
R
R
The color-flip creates two successive red nodes
-- this breaks property 2, so must be fixed
ADSA: Balanced Trees/12
82
• To fix the red color conflict, carry out a
double left or right rotation of node X:
• LR  double right rotation of X
– left then right rotations
• RL (mirror case)  double left rot of X
– right then left rotations
• Also change the colors of nodes X and G.
ADSA: Balanced Trees/12
83
LR Example
4
L
X
R
P
left rotation
of X
ADSA: Balanced Trees/12
right rotation
of X
X and G
recoloured
84
Same Example, with 2-3-4 Views
4
L
R
ADSA: Balanced Trees/12
85
4.4.2. Inserting a New Item
• Always add a new item to a tree as a RED leaf
node
– this may create two successive RED nodes, which
breaks property 2
• Fix using single / double rotation and color flip
as used for splitting 4-nodes:
– LL/RR  single right/left rotation of parent (P)
– LR/RL  double right/left rot of new node (X)
ADSA: Balanced Trees/12
86
Example: Insert 14
R
R
ADSA: Balanced Trees/12
single left
rotation of 12
and color flip
87
Insert 10 instead of 14
R
L
single right
rotation of 10
single left
rotation and
color flip
10
12
RL = double left rotation of node 10
(right then left)
ADSA: Balanced Trees/12
88
4.5. Building a Red-Black Tree
L
L
ADSA: Balanced Trees/12
single right rotation
of 20 and color flip
continued
89
these numbers are
from section 4.4.
1
2
3
Insert 35
Insert 25
ADSA: Balanced Trees/12
now
continued
90
Insert 30
L
R
LR = double right rotation of node 30
(left then right)
ADSA: Balanced Trees/12
91
4.6. Search Running Time
• The worst-case running time to search a redblack tree or insert an item is O(log2n)
– the maximum length of a path in a red-black tree
with black height B is 2*B-1
but this cannot
happen if the
insertion rules
are followed
ADSA: Balanced Trees/12
92
4.7. Deleting a Node
• Deletion is more difficult than insertion!
– must usually replace the deleted node
– but no further action is necessary when the
replacement node is RED
Delete 75
Replacement node 78 is RED
75
78
60
50
60
90
70
80
78
ADSA: Balanced Trees/12
100
replacement
(next biggest)
50
90
70
80
100
continued
93
• But deletion requires recoloring and rotations
when the replacement node is BLACK.
Delete 90
Replacement node is BLACK
75
60
50
Replace 90
with 100
90
70
80
78
75
75
100
replacement
ADSA: Balanced Trees/12
60
50
100
70
80
Right rotation with
pivot 80 and
recoloring
80
60
50
70
78
100
78
94
4.8. The RBTree Class
• RBTree implements the Collection interface
and uses RBNode objects to create a red-black
tree.
nodeValue
color
RBNode
object
parent
left
ADSA: Balanced Trees/12
right
95
class RBTree<T> implements Collection<T>
ds.util
Constructor
RBTree()
Creates an empty red-black tree.
Methods
String displayTree(int maxCharacters)
Returns a string that gives a hierarchical view of the tree. An
asterisk (*) marks red nodes.
void drawTree(int maxCharacters)
Creates a single frame that gives a graphical display of the tree.
Nodes are colored.
String drawTrees(int maxCharacters)
Creates of the action of the function and any return value.
String toString()
Returns a string that describes the elements in a comma-separated
list enclosed in brackets.
ADSA: Balanced Trees/12
96
• Ford and Topp's tutorial, "RBTree Class.pdf",
provides more explanation of the RBTree class
– local copy at
•
http://fivedots.coe.psu.ac.th/Software.coe/
ADSA/Ford%20and%20Topp/
• Includes:
– a discussion of the private data
– explanation of the algorithms for splitting a 4-node
and performing a top-down insertion
ADSA: Balanced Trees/12
97
Using the RBTree Class
import ds.util.RBTree;
public class UseRBTree
{
public static void main (String[] args)
{
// 10 values for the red-black tree
int[] intArr = {10, 25, 40, 15, 50, 45,
30, 65, 70, 55};
RBTree<Integer> rbtree = new RBTree<Integer>();
// load the tree with values
for(int i = 0; i < intArr.length; i++) {
rbtree.add(intArr[i]);
rbtree.drawTrees(4); // display on-going tree
}
// in a JFrame
:
ADSA: Balanced Trees/12
98
// display final tree to stdout
System.out.println(rbtree.displayTree(2));
/*
// remove red-node 25
rbtree.remove(25);
rbtree.drawTrees(4);
// tree shown in JFrame
// remove black-node root 45
rbtree.remove(45);
rbtree.drawTree(3);
// tree shown in JFrame
*/
} // end of main()
}
// end of UseRBTree class
ADSA: Balanced Trees/12
99
Execution
Tree changes are shown graphically
by drawTrees() and drawTree()
ADSA: Balanced Trees/12
100
JFrame Output: Add 10 Values
single left rot of 25
BLACK RED
40
25
started red, then
flipped to black
15
a
50
b
split 25; color change 25
ADSA: Balanced Trees/12
continued
101
double right rotation of 45
split 45
45
30
c
d
65
ADSA: Balanced Trees/12
continued
102
single left rotation of 65
70
e
f
ADSA: Balanced Trees/12
55
split 65; left rotation of 45
103
Download
Related flashcards

Pediatrics

86 cards

Pediatricians

20 cards

Breastfeeding

11 cards

French pediatricians

13 cards

Tourette syndrome

17 cards

Create Flashcards