1

TreesCLRS: chapter 12

2

A hierarchical combinatorial structure

הגדרה רקורסיבית:

צומת בודד. זהו גם שורש העץ.. 1

הינם עצים, ניתן לבנות עץ T1….TK הוא צומת ו nאם . 2 הינם “תתי עצים”.T1….TK השורש ו n חדש שבו

T1 TKn

T1 TK

n

. . .

3

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

Terminology

April 21, 2023

(height - אורך המסלול הארוך ביותר מהשורש לעלה )גובה העץ

(depth - אורך המסלול מהצומת לשורש )עומק צומת

Ordered tree

יש משמעות לסדר הילדים. מסדרים משמאל לימין.

a

b C

a

C b

( unordered tree) עץ לא מסודראם הסדר לא חשוב -

April 21, 2023

}ילד ימני, ילד שמאלי{ עץ ריק או לכל צומת יש תת קבוצה של-

דוגמא:

בינאריים עצים

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

• E.g.: 5, 19, 2, 989, 7 • ( < > = order )

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

(worth to add an indicator if found or not)

Order not important

8

The ADT

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

Order Operation

s

D= {5, 2, 7, 19, 989}

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

D= {5, 2, 7, 19, 989}

D1= {5, 2, 7}

{19, 989}

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

BST2

7

3

5 8

4

2 8

7

5 101

If y is in the left subtree of x then y.key < x.key

If y is in the right subtree of x then y.key > x.key

13

BST2

7

3

5 8

4

2 8

7

5 101

x.rightx.key

x.left

x x.parent

14

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(x,T)

2 8

7

5 101

Return pointer to where element should

be (this is why we have y

15

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101

z

Return pointer to where element

should be

16

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101

zy

Return pointer to where element

should be

17

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101

z

y

Return pointer to where element

should be

18

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101

zy

Return pointer to where element

should be

19

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101z

y

Return pointer to where element

should be

20

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(5,T)

2 8

7

5 101z

y

Return pointer to where element

should be

21

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(6,T)

2 8

7

5 101z

y

Return pointer to where element should

be(this case predecessor

of 6)

22

Y ← nullz ← T.rootWhile z ≠ null do y ← z if x = z.key return z if x < z.key then z ← z.left else z ← z.rightreturn y

Find(6,T)

2 8

7

5 101y

z=null

Return pointer to where element

should be (this case predecessor of 6)

23

2 8

7

5 101

Min(T)

6

Min(T.root)

min(z):While (z.left ≠ null) do z ← z.leftreturn (z)

1.5

24

n ← new noden.key←xn.left ← n.right ← nully ← find(x,T)n.parent ← yif x < y.key then y.left ← n else y.right ← n

2 8

7

5 101

Insert(x,T)

25

2 8

7

5 101

Insert(6,T)

n ← new noden.key←xn.left ← n.right ← nully ← find(x,T)n.parent ← yif x < y.key then y.left ← n else if x > y.key y.right ← n

else (x= y.key) do nothing

To avoid duplicates: must check if

element is there

26

2 8

7

5 101

Insert(6,T)

6

y

n ← new noden.key←xn.left ← n.right ← nully ← find(x,T)n.parent ← yif x < y.key then y.left ← n else y.right ← n

27

2 8

7

5 101

Delete(6,T)

6

If node has < 2 children: take father(node) and make it point to child(node) (Node is leaf or has one child)

28

2 8

7

5 101

Delete(6,T)

If node has < 2 children: take father(node) and make point to child(node)

29

2 8

7

5 101

Delete(8,T)

If node has < 2 children: take father(node) and make point to child(node)

30

2 8

7

5 101

Delete(8,T)

If node has < 2 children: take father(node) and make point to child(node)

31

2 8

7

5 101

Delete(2,T)

6

Switch 5 and 2 and delete the node containing now 2

If node has < 2 children: take father(node) and make point to child(node)

32

5 8

7

101

Delete(2,T)

6

Switch 5 and 2 and delete the node containing 5

33

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.key

q

Find z that does not have 2 children!

Z is physical deletion point

Why minimum?

Minimum never has 2 children

34

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.key

qz

Find z that does not have 2 children!

Z is physical deletion point

35

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.key

q

Find z that does not have 2 children!

Z is physical deletion point

36

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.key

q

z

Find z that does not have 2 children!

Z is physical deletion point

Z has at most one child now!

37

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf z.left ≠ null then y ← z.left else y ← z.right

z

Z is physical deletion point

38

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf 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 = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf z.left ≠ null then y ← z.left else y ← z.rightIf y ≠ null then y.parent ← z.parent

z

y

40

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf z.left ≠ null then y ← z.left else y ← z.rightIf y ≠ null then y.parent ← z.parent p = z.parentIf z = p.left then p.left = y else p.right = y

z

y

p

41

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf z.left ≠ null then y ← z.left else y ← z.rightIf y ≠ null then y.parent ← z.parent p = z.parentIf z = p.left then p.left = y else p.right = y

z

y

p

42

delete(x,T)

q ← find(x,T)

If q.left = null or q.right = nullthen z ← q else z ← min(q.right) q.key ← z.keyIf z.left ≠ null then y ← z.left else y ← z.rightIf y ≠ null then y.parent ← z.parent p = z.parentIf 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

5 9

8

7 102

1 2 5 7

8

9 11

Implementation is simpler (e.g. delete)

Costs space

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

1 )O)n( : Worst Case

איברים n )תוחלת( להכניסבממוצעכמה זמן לוקח ( 2?אקראיים

:עץ מושלם

:עץ קווי

log n כל איבר לוקח לכל היותר

n

i

nni1

2)1(

O)n( לצומת

צריך להניח הנחות:ממוצע

INSERT רק -

אלמנטים( n )סדרים בין כל הסדרים שווי הסתברות-

Data Structures, CS, TAU - 5.6

בינארי חיפוש עץ של זמן אנליזת

47

- רוצים לחשב אורך מסלול ממוצע:(a את האיבר הראשון )קח

n איברים קטנים ממנו היא iההסתברות ש1

a

i N-i-1

n של צומת שרירותי בעץ בגודל אורך ממוצע של מסלול )L)n יהי)אורך מסלול כאן = מס’ צמתים במסלול(

:, האורך הממוצע הואaאיברים קטנים מ- i , אםאזי

ninLnin

iLni

inL1

)1)1()(1

()1)(()|(

שמאל ימין מרכז

)()(1 jLnj

iLni

(j=n-i-1)

Data Structures, CS, TAU - 5.7

48

:iנוריד את ההתניה על )|(

1

01)( inL

n

i nnL

1

0)(

1

0 21)(2

11

n

iiiL

n

i niiL

nהצב:

1

0)(2

21

n

iiiL

n

nnLנראה באינדוקציה: log41)(

הוכחה:

1

0)log4(2

21)(

n

iiii

nnL

1

01log2

81n

iii

n

Data Structures, CS, TAU - 5.8

49

12/

0

1

2/]log)2/log([2

82n

i

n

ninini

n

)2log(82 nn )log(8

23 nn

)1(log82

nn

nlog41

Data Structures, CS, TAU - 5.9

1

01log2

81n

iii

n

50

Balance

h = O(log n)How do we keep the tree balanced through

insertions and deletions ?

- Next chapter!