Loading...

PPT – CHAPTER 5 Trees PowerPoint presentation | free to download - id: 730310-MDk3Y

The Adobe Flash plugin is needed to view this content

CHAPTER 5Trees

All the programs in this file are selected

from Ellis Horowitz, Sartaj Sahni, and Susan

Anderson-Freed Fundamentals of Data Structures

in C, Computer Science Press,

1992. Fundamentals of Data Structures in C

2/E, 2007

Trees

Root

leaf

P.192 Fig 5.1 (2/E)

Definition of Tree

- A tree is a finite set of one or more nodes such

that - There is a specially designated node called the

root. - The remaining nodes are partitioned into ngt0

disjoint sets T1, ..., Tn, where each of these

sets is a tree. - We call T1, ..., Tn the subtrees of the root.

Level and Depth

Level 1 2 3 4

Node (13) Degree of a node Leaf

(terminal) Nonterminal Parent Children Sibling Deg

ree of a tree (3) Ancestor Level of a node Height

of a tree (4)

Level

Degree

3

1

2

1

3

2

2

2

2

3

0

3

3

0

0

1

0

3

3

3

0

0

4

4

0

4

Terminology

- The degree of a node is the number of subtreesof

the node - The degree of A is 3 the degree of C is 1.
- The node with degree 0 is a leaf or terminal

node. - A node that has subtrees is the parent of the

roots of the subtrees. - The roots of these subtrees are the children of

the node. - Children of the same parent are siblings.
- The ancestors of a node are all the nodes along

the path from the root to the node.

Representation of Trees

- List Representation
- ( A ( B ( E ( K, L ), F ), C ( G ), D ( H ( M ),

I, J ) ) ) - The root comes first, followed by a list of

sub-trees

data

link 1

link 2

...

link n

How many link fields are needed in such a

representation?

Left Child - Right Sibling

P.196 Fig 5.6 (2/E)

Binary Trees

- A binary tree is a finite set of nodes that is

either empty or consists of a root and two

disjoint binary trees called the left subtree

and the right subtree. - Any tree can be transformed into binary tree.
- by left child-right sibling representation
- The left subtree and the right subtree are

distinguished.

Figure 5.6 Left child-right child tree

representation of a tree (p.191)

P. 197 Fig 5.7 (2/E)

A

B

C

E

D

G

F

K

H

L

I

M

J

Abstract Data Type Binary_Tree

structure Binary_Tree(abbreviated BinTree)

is objects a finite set of nodes either empty or

consisting of a root node, left Binary_Tree,

and right Binary_Tree. functions for all bt,

bt1, bt2 ? BinTree, item ? element Bintree

Create() creates an empty binary tree

Boolean IsEmpty(bt) if (btempty binary

tree) return TRUE else return FALSE

BinTree MakeBT(bt1, item, bt2) return a binary

tree whose left subtree is bt1, whose

right subtree is bt2, and whose root node

contains the data item Bintree Lchild(bt) if

(IsEmpty(bt)) return error

else return the left subtree of bt element

Data(bt) if (IsEmpty(bt)) return error

else return the data in the

root node of bt Bintree Rchild(bt) if

(IsEmpty(bt)) return error

else return the right subtree of bt

Samples of Trees

Complete Binary Tree

Skewed Binary Tree

1

2

3

4

5

P.200 Fig 5.10 (2/E)

Maximum Number of Nodes in BT

- The maximum number of nodes on level i of a

binary tree is 2i-1, igt1. - The maximum nubmer of nodes in a binary tree of

depth k is 2k-1, kgt1.

Prove by induction.

Relations between Number ofLeaf Nodes and Nodes

of Degree 2

For any nonempty binary tree, T, if n0 is the

number of leaf nodes and n2 the number of nodes

of degree 2, then n0n21 proof Let n and

B denote the total number of nodes branches

in T. Let n0, n1, n2 represent the nodes with

no children, single child, and two children

respectively. n n0n1n2, B1n, Bn12n2

gt n12n21 n, n12n21 n0n1n2 gt

n0n21

Full BT VS Complete BT

- A full binary tree of depth k is a binary tree of

depth k having 2 -1 nodes, kgt0. - A binary tree with n nodes and depth k is

complete iff its nodes correspond to the nodes

numbered from 1 to n in the full binary tree of

depth k.

k

????, ??????

1

1

2

2

3

3

5

7

6

7

4

6

4

5

13

14

12

15

11

10

9

8

8

9

Complete binary tree

Full binary tree of depth 4

Binary Tree Representations

- If a complete binary tree with n nodes (depth

log n 1) is represented sequentially, then

forany node with index i, 1ltiltn, we have - parent(i) is at i/2 if i!1. If i1, i is at the

root and has no parent. - left_child(i) ia at 2i if 2iltn. If 2igtn, then i

has noleft child. - right_child(i) ia at 2i1 if 2i 1 ltn. If 2i 1

gtn, then i has no right child.

Sequential Representation

1 2 3 4 5 6 7 8 9

A B C D E F G H I

(1) waste space (2) insertion/deletion

problem

A B -- C -- -- -- D -- . E

1 2 3 4 5 6 7 8 9 . 16

Linked Representation

typedef struct node tree_pointer typedef struct

node int data tree_pointer left_child,

right_child

data

right_child

data

left_child

right_child

left_child

Binary Tree Traversals

- Let L, V, and R stand for moving left, visiting

the node, and moving right. - There are six possible combinations of traversal
- LVR, LRV, VLR, VRL, RVL, RLV
- Adopt convention that we traverse left before

right, only 3 traversals remain - LVR, LRV, VLR
- inorder, postorder, preorder

Arithmetic Expression Using BT

inorder traversal A / B C D E infix

expression preorder traversal / A B C D

E prefix expression postorder traversal A B / C

D E postfix expression level order

traversal E D / C A B

P.206 Fig 5.16 (2/E)

Inorder Traversal (recursive version)

void inorder(tree_pointer ptr) / inorder tree

traversal / if (ptr)

inorder(ptr-gtleft_child) printf(d,

ptr-gtdata) inorder(ptr-gtright_child)

A / B C D E

P.207 Program 5.1 (2/E)

Preorder Traversal (recursive version)

void preorder(tree_pointer ptr) / preorder tree

traversal / if (ptr)

printf(d, ptr-gtdata)

preorder(ptr-gtleft_child)

preorder(ptr-gtright_child)

/ A B C D E

P.208 Program 5.2 (2/E)

Postorder Traversal (recursive version)

void postorder(tree_pointer ptr) / postorder

tree traversal / if (ptr)

postorder(ptr-gtleft_child)

postorder(ptr-gtright_child) printf(d,

ptr-gtdata)

A B / C D E

P.209 Program 5.3 (2/E)

Iterative Inorder Traversal (using stack)

void iterInorder(treepointer node) int top

-1 / initialize stack / treePointer

stackMAX_STACK_SIZE for () for (

node nodenode-gtleftChild) push(node)/

add to stack / nodepop() / delete from

stack / if (!node) break / empty stack /

printf(d, node-gtdata) node

node-gtrightChild

O(n)

P.210 Program 5.4 (2/E)

Trace Operations of Inorder Traversal

Level Order Traversal (using queue)

void levelOrder(treePointer ptr) / level order

tree traversal / int front rear 0

treePointer queueMAX_QUEUE_SIZE if (!ptr)

return / empty queue / addq(ptr) for ()

ptr deleteq()

if (ptr) printf(d, ptr-gtdata)

if (ptr-gtleftChild) addq(ptr-gtleftChild)

if (ptr-gtrightChild)

addq(ptr-gtrightChild) else break

E D / C A B

P.211 Program 5.5 (2/E)

Copying Binary Trees

treePointer copy(treePointer original) treePoint

er temp if (original) MALLOC(temp,

sizeof(temp)) temp-gtleftChildcopy(original-gtle

ftChild) temp-gtrightChildcopy(original-gtrightCh

ild) temp-gtdataoriginal-gtdata return

temp return NULL

postorder

P.212 Program 5.6 (2/E)

Equality of Binary Trees

the same topology and data

int equal(treePointer first, treePointer

second) / function returns FALSE if the binary

trees first and second are not equal,

otherwise it returns TRUE / return ((!first

!second) (first second

(first-gtdata second-gtdata)

equal(first-gtleftChild, second-gtleftChild)

equal(first-gtrightChild, second-gtrightChild)))

P.213 Program 5.7 (2/E)

Threaded Binary Trees

- Two many null pointers in current

representationof binary trees n number of

nodes number of non-null links n-1 total

links 2n null links 2n-(n-1)n1 - Replace these null pointers with some useful

threads.

Threaded Binary Trees (Continued)

If ptr-gtleftChild is null, replace it with a

pointer to the node that would be visited

before ptr in an inorder traversal If

ptr-gtrightChild is null, replace it with a

pointer to the node that would be visited

after ptr in an inorder traversal

A Threaded Binary Tree

root

dangling

dangling

inorder traversal H, D, I, B, E, A, F, C, G

P.218 Fig 5.21 (2/E)

Data Structures for Threaded BT

left_thread left_child data

right_child right_thread

?

TRUE

?

FALSE child

TRUE thread

typedef struct threaded_tree threaded_pointer ty

pedef struct threaded_tree short int

left_thread threaded_pointer left_child

char data threaded_pointer right_child

short int right_thread

Memory Representation of A Threaded BT

root

--

f

f

A

f

f

C

B

f

f

f

f

G

E

F

t

t

D

t

t

t

f

t

f

I

H

t

t

t

t

P.219 Fig 5.23 (2/E)

Next Node in Threaded BT

threaded_pointer insucc(threaded_pointer tree)

threaded_pointer temp temp

tree-gtright_child if (!tree-gtright_thread)

while (!temp-gtleft_thread) temp

temp-gtleft_child return temp

Inorder Traversal of Threaded BT

void tinorder(threadedPointer tree) / traverse

the threaded binary tree inorder /

threadedPointer temp tree for ()

temp insucc(temp) if (temptree)

break printf(3c, temp-gtdata)

O(n)

P.221 Program 5.11 (2/E)

Inserting Nodes into Threaded BTs

- Insert child as the right child of node parent
- change parent-gtright_thread to FALSE
- set child-gtleft_thread and
- child-gtright_thread to TRUE
- set child-gtleft_child to point to parent
- set child-gtright_child to
- parent-gtright_child
- change parent-gtright_child to point to child

Examples

Insert a node D as a right child of B.

root

root

A

A

(1)

parent

B

parent

B

(3)

child

child

C

C

D

D

(2)

empty

(3)

(1)

(2)

(4)

nonempty

Figure 5.24 Insertion of child as a right child

of parent in a threaded binary tree (p.222)

Right Insertion in Threaded BTs

void insertRight(threadedPointer parent,

threadedPointer child)

threadedPointer temp child-gtrightChild

parent-gtrightChild child-gtrightThread

parent-gtrightThread child-gtleftChild parent

case (a) child-gtleftThread TRUE

parent-gtrightChild child parent-gtrightThread

FALSE if (!child-gtrightThread) case (b)

temp insucc(child) temp-gtleftChild

child

(1)

(2)

(3)

(4)

Heap

- A max tree is a tree in which the key value in

each node is no smaller than the key values in

its children. A max heap is a complete binary

tree that is also a max tree. - A min tree is a tree in which the key value in

each node is no larger than the key values in

its children. A min heap is a complete binary

tree that is also a min tree. - Operations on heaps
- creation of an empty heap
- insertion of a new element into the heap
- deletion of the largest element from the heap

Figure 5.25 Sample max heaps (1/E p.219)

P.225 Fig 5.25 (2/E)

4

Property The root of max heap (min heap)

contains the largest (smallest).

Figure 5.26Sample min heaps (1/E p.220)

P.225 Fig 5.26 (2/E)

ADT for Max Heap

structure MaxHeap objects a complete binary

tree of n gt 0 elements organized so that the

value in each node is at least as large as those

in its children functions for all heap

belong to MaxHeap, item belong to Element, n,

max_size belong to integer MaxHeap

Create(max_size) create an empty heap that can

hold a

maximum of max_size elements Boolean

HeapFull(heap, n) if (nmax_size) return

TRUE

else return FALSE MaxHeap Insert(heap,

item, n) if (!HeapFull(heap,n)) insert

item into heap and

return the resulting heap else return

error Boolean HeapEmpty(heap, n) if (ngt0)

return FALSE

else return TRUE Element

Delete(heap,n) if (!HeapEmpty(heap,n)) return

one instance of

the largest element in the heap

and remove it from the heap

else

return error

Application priority queue

- machine service
- amount of time (min heap)
- amount of payment (max heap)
- factory
- time tag

Data Structures

- unordered linked list
- unordered array
- sorted linked list
- sorted array
- heap

Figure 5.27 Priority queue representations (1/E

p.221)

Example of Insertion to Max Heap

21

20

20

20

15

5

2

15

15

2

14

10

2

10

14

14

10

insert 21 into heap

insert 5 into heap

initial location of new node

Insertion into a Max Heap (2/E)

void push (element item, int n) / insert item

into a max heap of current size n / int i

if (HEAP_FULL(n)) fprintf(stderr, The

heap is full.\n) exit(EXIT_FAILURE)

i(n) while ((i!1) (item.keygtheapi/2.k

ey)) heapiheapi/2 i/2

heapiitem

P.227 Program 5.13 (2/E)

2k-1n gt k?log2(n1)?

O(log2n)

Insertion into a Max Heap (1/E)

void insert_max_heap(element item, int n)

int i if (HEAP_FULL(n)) fprintf(stderr,

the heap is full.\n) exit(1) i

(n) while ((i!1)(item.keygtheapi/2.key))

heapi heapi/2 i / 2

heapi item

2k-1n gt k?log2(n1)?

O(log2n)

Example of Deletion from Max Heap

remove

10

15

20

14

2

2

15

2

15

14

10

10

14

(a) Heap structure

(c) Finial heap

(b) 10 inserted at the root

Deletion from a Max Heap (2/E)

P.229 Program 5.14 (2/E)

element pop(int n) / delete element with the

highest key from the heap/ int parent, child

element item, temp if (HEAP_EMPTY(n))

fprintf(stderr, The heap is empty\n)

exit(EXIT_FAILURE) / save value of the

element with the highest key / item

heap1 / use last element in heap to adjust

heap / temp heap(n)-- parent 1

child 2

while (child lt n) / find the larger

child of the current parent / if

((child lt n) (heapchild.keyltheapchil

d1.key)) child if (temp.key gt

heapchild.key) break / move to the next

lower level / heapparent heapchild

parent child child 2

heapparent temp return item

Deletion from a Max Heap (1/E)

element delete_max_heap(int n) int parent,

child element item, temp if

(HEAP_EMPTY(n)) fprintf(stderr, The heap

is empty\n) exit(1) / save value of

the element with the highest key / item

heap1 / use last element in heap to adjust

heap / temp heap(n)-- parent 1

child 2

while (child lt n) / find the larger

child of the current parent / if

((child lt n) (heapchild.keyltheapchil

d1.key)) child if (temp.key gt

heapchild.key) break / move to the next

lower level / heapparent heapchild

child 2 heapparent temp return

item

Binary Search Tree

- Heap
- a min (max) element is deleted. O(log2n)
- deletion of an arbitrary element O(log2n)
- search for an arbitrary element O(n)
- Binary search tree
- Every element has a unique key.
- The keys in a nonempty left subtree (right

subtree) are smaller (larger) than the key in the

root of subtree. - The left and right subtrees are also binary

search trees.

Examples of Binary Search Trees

60

30

20

70

40

25

15

5

80

65

12

2

22

(c)

(b)

10

(a)

Searching a Binary Search Tree (recursive)

P.233 Program 5.15 (2/E)

element search(treePointer root, int

k) / ???parameter???????(by TA) / / return a

pointer to the node that contains key. If there

is no such node, return NULL / if (!root)

return NULL if (k root-gtdata.key)

return (root-gtdata) if (key lt root-gtdata.key)

return search(root-gtleftChild,

k) return search(root-gtrightChild,key)

Another Searching Algorithm (iterative)

P.233 Program 5.16 (2/E)

element iterSearch(treePointer tree, int k) /

return a pointer to the element whose key is k,

if theres no such element, return NULL, /

while (tree) if (key tree-gtdata.key)

return (tree-gtdata) if (key lt

tree-gtdata.key) tree tree-gtleftChild

else tree tree-gtrightChild return

NULL

O(h)

Insert Node in Binary Search Tree

30

30

30

40

5

40

40

5

5

80

35

2

80

2

2

Insert 35

Insert 80

Insertion into A dictionary pair into a Binary

Search Tree

void insert(treePointer node, int k, iType

theItem) / if k is in the tree pointed at by

node do nothing otherwise add a new node with

data (k, theItem) / treePointer ptr

treePointer temp modifiedSearch(node, k) if

(temp !(node)) / k isnt in the tree /

MALLOC(ptr, sizeof(ptr)) ptr-gtdata.key

k ptr-gtleftChild ptr-gtrightChild NULL

if (node) / insert as child of temp /

if (k lt temp-gtdata) temp-gtleftChildptr

else temp-gtrightChild ptr else node

ptr

P.235 Program 5.17 (2/E)

Deletion for A Binary Search Tree

1

leaf node

30

80

5

T2

T1

1

2

2

X

T1

T2

Deletion for A Binary Search Tree

non-leaf node

40

40

55

60

20

20

70

30

50

70

10

30

50

10

52

45

55

45

52

After deleting 60

Before deleting 60

1

2

T1

T3

T2

1

2

T1

T3

T2

Forest

- A forest is a set of n gt 0 disjoint trees

A

Forest

G

E

A

B

E

I

H

F

G

F

D

C

C

B

H

D

I

Transform a forest into a binary tree

- T1, T2, , Tn a forest of treesB(T1, T2, ,

Tn) a binary tree corresponding to this forest - algorithm(1) empty, if n 0(2) has root equal

to root(T1) has left subtree equal to

B(T11,T12,,T1m) has right subtree equal to

B(T2,T3,,Tn)

Forest Traversals

- Preorder
- If F is empty, then return
- Visit the root of the first tree of F
- Taverse the subtrees of the first tree in tree

preorder - Traverse the remaining trees of F in preorder
- Inorder
- If F is empty, then return
- Traverse the subtrees of the first tree in tree

inorder - Visit the root of the first tree
- Traverse the remaining trees of F is indorer

inorder EFBGCHIJDA preorder ABEFCGDHIJ

A

B

A

C

E

B

D

C

D

G

F

E

F

J

H

I

G

H

I

B E F

C G

preorder

D H I J

J