Trees CLRS: chapter 12

1
TreesCLRS chapter 12
2
A hierarchical combinatorial structure
????? ?????????
1. ???? ????. ??? ?? ???? ???.
2. ?? n ??? ???? ? T1.TK ???? ????, ???? ?????
?? ??? ??? n ????? ? T1.TK ???? ??? ????.
n
n
T1
TK
. . .
T1
TK
??????
3
Terminology
r
c1
c2
c3
s1.1
s1.2
s1.3
s2.1
s2.2
s3.1
??????
r - ????/Parent (???) ?? c1, c2, c3
c1, c2 - ?????/children ?? r
s2.1 - ????/Descendant (?? ????) ?? r
r,c1,s1.2 - ?????/Path (?? ?? ???? ?? ?????)
???? ?????? ?? ??????
?? ?????? (???? ???)
???? ??? ????? ???/Leaf
r - ?? ?????/Ancestor ?? s3.1
4
???? ??? - ???? ?????? ????? ????? ?????? ????
(height) ???? ???? - ???? ?????? ?????? ?????
(depth)
Ordered tree
?? ?????? ???? ??????. ?????? ????? ?????.
?? ???? ?? ???? - ?? ?? ????? (unordered tree)
5
???? ????????
- ?? ??? ?? ??? ???? ?? ?? ????? ?? ??? ????,
??? ?????
?????
Full each internal node always has both children
6
The dictionary problem

• Maintain (distinct) items with keys from a
  totally ordered universe subject to the following
  operations

7
The ADT

• Insert(x,D)
• Delete(x,D)
• Find(x,D)
• Returns a pointer to x if x ? D, and a pointer
  to the successor or predecessor of x if x is not
  in D

8
The ADT

• successor(x,D)
• predecessor(x,D)
• Min(D)
• Max(D)

9
The ADT

• catenate(D1,D2) Assume all items in D1 are
  smaller than all items in D2
• split(x,D) Separate to D1, D2, D1 with all
  items smaller than x and D2 with all items
  greater than x

10
Reminder from mavo

• We have seen solutions using unordered lists and
  ordered lists.
• Worst case running time O(n)
• We also defined Binary Search Trees (BST)

11
Binary search trees

• A representation of a set with keys from a
  totally ordered universe
• We put each element in a node of a binary tree
  subject to

12
BST
If y is in the left subtree of x then y.key lt
x.key
If y is in the right subtree of x then y.key gt
x.key
13
BST
x
x.parent
x.left
x.right
x.key
14
Find(x,T)
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
15
Find(5,T)
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
16
Find(5,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
17
Find(5,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
18
Find(5,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
19
Find(5,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
20
Find(5,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
21
Find(6,T)
y
z
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
22
Find(6,T)
y
Y ? null z ? T.root While z ? null do y ?
z if x z.key return z if
x lt z.key then z ? z.left
else z ? z.right return y
znull
23
Min(T)
7
2
8
Min(T.root) min(z) While (z.left ? null)
do z ? z.left return (z)
1
10
5
1.5
6
24
Insert(x,T)
n ? new node n.key?x n.left ? n.right ? null y ?
find(x,T) n.parent ? y if x lt y.key then y.left
? n else y.right ? n
25
Insert(6,T)
n ? new node n.key?x n.left ? n.right ? null y ?
find(x,T) n.parent ? y if x lt y.key then y.left
? n else y.right ? n
26
Insert(6,T)
7
2
8
1
10
5
n ? new node n.key?x n.left ? n.right ? null y ?
find(x,T) n.parent ? y if x lt y.key then y.left
? n else y.right ? n
6
27
Delete(6,T)
7
2
8
1
10
5
6
28
Delete(6,T)
7
2
8
1
10
5
29
Delete(8,T)
7
2
8
1
10
5
30
Delete(8,T)
7
2
8
1
10
5
31
Delete(2,T)
7
2
8
1
10
5
Switch 5 and 2 and delete the node containing 5
6
32
Delete(2,T)
7
5
8
1
10

Switch 5 and 2 and delete the node containing 5
6
33
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key
q
34
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key
q
z
35
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key
q
36
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key
q
z
37
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right
38
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right
z
y
39
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right If y ?
null then y.parent ? z.parent
z
y
40
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right If y ?
null then y.parent ? z.parent p
z.parent If z p.left then p.left y
else p.right y
z
y
41
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right If y ?
null then y.parent ? z.parent p
z.parent If z p.left then p.left y
else p.right y
z
y
42
delete(x,T)
q ? find(x,T) If q.left null or q.right
null then z ? q else z ? min(q.right)
q.key ? z.key If z.left ? null then y ? z.left
else y ? z.right If y ?
null then y.parent ? z.parent p
z.parent If z p.left then p.left y
else p.right y
43
Variation Items only at the leaves

• Keep elements only at the leaves
• Each internal node contains a number to direct
  the search

8
Implementation is simpler (e.g. delete)
5
9
Costs space
8
2
10
7
1
2
5
9
11
7
44
Analysis

• Each operation takes O(h) time, where h is the
  height of the tree
• In general h may be as large as n
• Want to keep the tree with small h

45
Balance















? h O(log n)
How do we keep the tree balanced through
insertions and deletions ?
46
successor(x,T)
7
2
8
1
10
5
1.5
6
47
successor(x,T)
x
If x has a right child its the minimum in the
subtree of x.right
48
successor(6,T)
7
2
8
1
10
5
1.5
6
49
successor(x,T)
If x.right is null, go up until the lowest
ancestor such that x is at its left subtree
x
50
successor(x,T)
If x.right ? null then min(x.right) y ?
x.parent While y?null and xy.right do x ?
y y ? y.parent return(y)
x
51
successor(x,T)
If x.right ? null then min(x.right) y ?
x.parent While y?null and xy.right do x ?
y y ? y.parent return(y)
y
x

52
successor(x,T)
If x.right ? null then min(x.right) y ?
x.parent While y?null and xy.right do x ?
y y ? y.parent return(y)
y
x

53
successor(x,T)
y
If x.right ? null then min(x.right) y ?
x.parent While y?null and xy.right do x ?
y y ? y.parent return(y)
x