Title: Trees CLRS: chapter 12
1TreesCLRS chapter 12
2A hierarchical combinatorial structure
????? ?????????
1. ???? ????. ??? ?? ???? ???.
2. ?? n ??? ???? ? T1.TK ???? ????, ???? ?????
?? ??? ??? n ????? ? T1.TK ???? ??? ????.
n
n
T1
TK
. . .
T1
TK
??????
3Terminology
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
6The dictionary problem
- Maintain (distinct) items with keys from a
totally ordered universe subject to the following
operations
7The 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
8The ADT
- successor(x,D)
- predecessor(x,D)
- Min(D)
- Max(D)
9The 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
10Reminder 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)
11Binary 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
12BST
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
13BST
x
x.parent
x.left
x.right
x.key
14Find(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
15Find(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
16Find(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
17Find(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
18Find(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
19Find(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
20Find(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
21Find(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
22Find(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
23Min(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
24Insert(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
25Insert(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
26Insert(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
27Delete(6,T)
7
2
8
1
10
5
6
28Delete(6,T)
7
2
8
1
10
5
29Delete(8,T)
7
2
8
1
10
5
30Delete(8,T)
7
2
8
1
10
5
31Delete(2,T)
7
2
8
1
10
5
Switch 5 and 2 and delete the node containing 5
6
32Delete(2,T)
7
5
8
1
10
Switch 5 and 2 and delete the node containing 5
6
33delete(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
34delete(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
35delete(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
36delete(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
37delete(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
38delete(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
39delete(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
40delete(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
41delete(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
42delete(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
43Variation 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
44Analysis
- 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
45Balance
? h O(log n)
How do we keep the tree balanced through
insertions and deletions ?
46successor(x,T)
7
2
8
1
10
5
1.5
6
47successor(x,T)
x
If x has a right child its the minimum in the
subtree of x.right
48successor(6,T)
7
2
8
1
10
5
1.5
6
49successor(x,T)
If x.right is null, go up until the lowest
ancestor such that x is at its left subtree
x
50successor(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
51successor(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
52successor(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
53successor(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