Trees Binary Trees Extended Binary Trees Tree A

Trees Binary Trees Extended Binary Trees

Tree • • • A Tree consist of Nodes connected by Edges. Node is represented by Circle Edges as Lines or Arrows A Tree can have only One Root There Must be One and Only One Path from the Root to Any Other Nodes Tree Edges Non - Tree

Terminology • Path: Nodes connected by Edges form a Path • Root: Top node of the Tree • Parent: The Above Node of any Node • Child: Downward Node of any Node • Leaf: Node with No Child Node • Level: How many Generation the Node is from the Root • Key: The value used to find any Node in a tree

A is the Root B is the parent of D and E D is the left child of B B A The dashed line is a path E is the right child of B D E H F is the Root of a subtree C F J Level 0 Level 1 G K J and K are siblings H, E, J, K and G are leaf nodes Level 2 Level 3

BINARY TREES • Binary Tree ‘T’ is define as a Finite set of Elements called Nodes • T is Empty – Null or Empty Tree • T has a Root Node ‘R’ • T 1 and T 2 will be the Left and Right Subtrees • If T 1 and T 2 are Nonempty, their Roots will called Left and Right Successors of R • Any Node can have 0, 1 or 2 Successors. • Node with No Successors are called Terminal Nodes

BINARY TREE REPRESENTATION 2 7 2 5 6 5 9 8 4 A Binary Tree of Size 9 and Height 3, with a Root 2

Definitions • An Arrow (Edge) is Refers to the link from the Parent to the Child. Sequence of Edges forms a Path. • The Root Node of a Tree is the Node with No Parents • A Leaf or Terminal Node has No Children • The Depth of a Node N is the Length of the Path from the Root to the Node. The set of all Nodes at a Given Depth is sometimes called a Level of the Tree. The Root Node is at Depth Zero. • The Height of a Tree is the Depth of its Furthest Leaf • A Tree with only a Root node has a Height of Zero • Siblings are Nodes that Share the same Parent Node • The size of a Node is the Number of Descendants it has Including Itself • Root is the only Node in the Tree with in-Degree = 0

A 1 B C A B D C E F G D E F 2 H 3 G 4 H 1, 3 and 4 are Similar. 1 and 3 are Copies – 2 and 4 Are Neither Similar Nor Copy.

Algebraic Expression E = (a – b) / ((c * d) + e) / a + b e * c d

Formula: Node K, 2*K+1 and K/2 1 2 4 8 3 5 6 7 9 Depth dn: n Nodes, Dn = log 2 n +1

Representation in Memory • By a Single Array (Formula Discussed) • By Link List – Root – INFO[K] – LEFT[K] – RIGHT[K] Location of the Root Data of the Node N Left Child of Node N Right Child of Node N Root A B C D E

Traversing Binary Trees • Preorder: – Process the Root R – Traverse the Left Subtree of R – Traverse the Right Subtree of R • Inorder: – Traverse the Left Subtree of R – Process the Root R – Traverse the Right Subtree of R • Postorder: – Traverse the Left Subtree of R – Traverse the Right Subtree of R – Process the Root R

Preorder Inorder Postorder A C B D E F H G J Preorder : A B D E C F H J G Inorder : D B E A H F J C G Postorder : D E B H J F G C A

Preorder Traversing Initially push NULL onto Stack and Set PTR: = Root (a) Process the Left Path, Push Right Child in Stack. Ends when Node has No Left Child (b) [Backtracking] Pop and Assign PTR to the TOP Element, If PTR ≠ NULL then Return to Step (a) otherwise Exit. Initially push NULL onto Stack (Stack= 0) A Set PTR = A Root of T Process A; Push C in Stack (Stack=0, C) C B Process B; No Right Child Process D; Push H in Stack E D F (Stack=0, C, H) Process G; No Left, Right Child Pop H from Stack G H Set PTR : = H (Stack=0, C) Return to Step (a) Process H; Push K in Stack (Stack=0, C, K) K Pop K from Stack Continues………. Output: A, B, D, G, H, K, C, E, F

PREORDER (INFO, LEFT, RIGHT, ROOT) - Algorithm 1. 2. 3. 4. 5. 6. STACK is used to Temporarily hold the Addresses of Nodes [Push NULL onto STACK and Initialize PTR] Set TOP : = 1, STACK[1] : = NULL and PTR : = ROOT Repeat Step 3 to 5 while PTR ≠ NULL Apply PROCESS to INFO[PTR] [Right Child ? ] If Right Child ≠ NULL then [Push on STACK] Set TOP : = TOP + 1 and STACK[TOP] : = RIGHT[PTR] [End of If Structure] [Left Child ? ] If LEFT [PTR] ≠ NULL then: Set PTR : = LEFT [PTR] Else [Pop from STACK] Set PTR : = STACK [TOP] and TOP : = TOP - 1 [End of If Structure] [End of Step 2 loop] Exit.

Postorder Traversing Initially push NULL onto Stack and Set PTR: = Root (a) Process the Left Path, Push all Nodes N in Stack; and If N has a Right Child R(N) Push –R(N) (b) [Backtracking] Pop and Process Positive Nodes. Assign PTR to the TOP Element, If PTR = -VE, Set PTR +VE then Return to Step (a) otherwise Exit. Initially push NULL onto Stack (Stack= 0) A Set PTR = A Root of T, Push A, -C, B, D, -H, G, K Stack = 0, A, -C, B, D, -H, G, K C Pop and Process K then G, Only Pop –H B PTR = - H, Reset PTR = H and Push it in Stack Step (a) E D Stack = 0, A, -C, B, D, H, -M, L PTR = - M, Reset PTR = M H G Stack = 0, A, -C, B, D, H, M Continues………. L M Output: K K, G, L, M, H, D, B, E, C, A

POSTORDER (INFO, LEFT, RIGHT, ROOT) - Algorithm 1. 2. 3. 4. 5. 6. • • • [Push NULL onto STACK and Initialize PTR] Set TOP : = 1, STACK[1] : = NULL and PTR : = ROOT [Push Left-most Path in Stack] Repeat Step 3 to 5 while PTR ≠ NULL Set TOP : = TOP + 1 and STACK[TOP] : = PTR [Pushes PTR on Stack] If Right [PTR] ≠ NULL then [Push on STACK] Set TOP : = TOP + 1 and STACK[TOP] : = - RIGHT[PTR] [End of If Structure] Set PTR : = LEFT[PTR] [Updates Pointer PTR] [End of Step 2 loop] Set PTR : = STACK[TOP] and TOP : = TOP – 1 [Pops node from STACK] Repeat while PTR > 0 (a) Apply Process to INFO[PTR] (b) Set PTR : = STACK[ TOP] and TOP : = TOP – 1 [Pops node from STACK] [End of Loop] If PTR < 0 then (a) Set PTR : = - PTR (b) Go to Step 2 [End of If Structure] Exit

Binary Search Tree • Why Use Binary Search Tree – Combines the advantages of Ordered Array and Linked List – Searching • Equals Compared to Ordered Array • Fast Compared to Linked List – Insert and Delete Item • Fast Compared to Ordered Array • Equals Compared to Linked List

Binary Search Tree Properties • The value of Node ‘N’ is Greater then every value in the Left Subtree • The value of Node ‘N’ is Less then every value in the Right Subtree • Inorder Traversing Produce a Sorted List 38 14 56 23 8 18 45 82 70

Searching and Insertion a) Compare ITEM with the Root Node ‘N’ i. If ITEM < N, Proceed to the Left Child of N ii. If ITEM > N, Proceed to the Right Child of N b) Repeat (a) until one of the following occurs i. ITEM found ii. ITEM not found, Insert ITEM 38 ITEM = 20 Inserted 14 56 23 8 18 45 82 70 20

FIND (INFO, LEFT, RIGHT, ROOT, ITEM, LOC, PAR) - Algorithm i. iii. 1. 2. 3. 4. 5. 6. i. ii. LOC = NULL and PAR = NULL : Tree is Empty LOC ≠ NULL and PAR = NULL: ITEM is Root of Tree LOC = NULL and PAR ≠ NULL: ITEM is not in Tree, Added using PAR [Tree Empty ? ] If Root = NULL; Set LOC : = NULL and PAR : = NULL. Return [ITEM at Root? ] If ITEM = INFO[Root]; Set LOC: =Root and PAR : = NULL. Return [Initialize ITEM and SAVE] If ITEM < INFO[Root] then Set PTR : = LEFT[Root] and SAVE : = Root Else Set PTR : = RIGHT[Root] and SAVE : = Root [End of If Structure] Repeat Steps 5 and 6 while PTR ≠ NULL [ITEM Found? ] If ITEM < INFO[PTR] then Set LOC : =PTR and PTR: =SAVE. Return If ITEM < INFO [PTR] then Set SAVE: =PTR and PTR: = LEFT[PTR] Else Set SAVE : = PTR and PTR: = RIGHT[PTR] [End of If Structure] [End of Step 4 Loop] [Search Unsuccessful] Set LOC : = NULL and PAR : = SAVE Exit

INSBST(INFO, LEFT, RIGHT, ROOT, ITEM, LOC) 1. 2. 3. 4. Call FIND (INFO, LEFT, RIGHT, ROOT, ITEM, LOC, PAR) If LOC ≠ NULL then Exit [Add ITEM to Tree] Set New : = Create Node Set INFO[New] : = ITEM Set RIGHT[New] : = NULL and LEFT[New] : = NULL If PAR = NULL then Set Root : = New Else if ITEM < INFO[PAR] then Set LEFT[PAR] : = NEW Else Set RIGHT[PAR] : = NEW [End of If Structure] Exit

Deletion in a Binary Tree • Case 1: Node N has No Children – Replace the Pointer in Parent Node by NULL • Case 2: Node N has Exactly One Child – Replace the Pointer in Parent Node by its Only Child • Case 3: Node N has Two Children – Find the Inorder Successor – Remove the Inorder Successor by using Case 1 or Case 2 – Replace the Node N by the Inorder Successor

Case 1: Deletion with No Child 10 10 5 5 3 7 Before Deletion 3 Null 7 After Deletion

Case 2: Deletion with One Child 80 80 To Be Deleted 52 48 71 48 52 63 67 Before Deletion After Deletion

Case 3: Deletion with Two Children 50 50 To Be Deleted 30 25 15 5 20 30 35 15 35 40 5 20 Successor of 25 Before Deletion After Deletion 40

Case 3: Deletion with Successor Child 50 50 To Be Deleted 75 77 87 62 93 77 Successor of 75 Before Deletion 87 62 79 Successor Right Child 79 After Deletion 93

1. 2. 3. Procedure: CASEA (INFO, LEFT, RIGHT, ROOT, LOC, PAR) Deletes N at LOC where N has No 2 Children, PAR gives the Parent of N or PAR = NULL Shows N is Root. CHILD Shows the Only Child of N or CHILD = NULL [Initialize CHILD] If LEFT[LOC] = NUL and RIGHT[LOC] = NULL then: Set CHILD : = NULL Else if LEFT[LOC] ≠, then: Set CHILD : = LEFT[LOC] Else Set CHILD : = RIGHT[LOC]. [End of If Structure] If PAR ≠ NULL, then: If LOC = LEFT[PAR], then: Set LEFT[PAR] : = CHILD Else Set RIGHT[PAR] : = CHILD. [End of If Structure] Else: Set ROOT : = CHILD [End of If Structure] Return

Procedure: CASEB (INFO, LEFT, RIGHT, ROOT, LOC, PAR) 1. 2. 3. 4. Deletes N at LOC where N has 2 Children, PAR gives the Parent of N or PAR = NULL Shows N is Root. SUC Shows the Inorder Successor and PARSUC Shows the Parent of Successor [Find SUC and PARSUC] (a) Set PTR : = RIGHT[LOC] and SAVE : = LOC. (b) Repeat while LEFT[PTR] ≠ NULL: Set SAVE : = PTR and PTR: =LEFT[PTR] [End of Loop] (c) Set SUC : = PTR and PTR : = SAVE [Delete Inorder Successor using Previous Procedure] [Replace Node N by its Inorder Successor] (a) If PAR ≠ NULL, then: If LOC = LEFT[PAR], then: Set LEFT[PAR : =SUC Else: Set RIGHT[PAR] : = SUC [End of If Structure] Else: Set ROOT : = SUC [End of If Structure] (b) Set LEFT [SUC] : = LEFT[LOC] and RIGHT[SUC] : = RIGHT[LOC] Return

Algorithm: DEL (INFO, LEFT, RIGHT, ROOT, ITEM) 1. 2. 3. 4. This Algorithm Deletes the Given ITEM of Information from the Binary Search Tree T. [Find the Location of ITEM and its Parent] Call FIND (INFO, LEFT, RIGHT, ROOT, ITEM, LOC, PAR) [ITEM in Tree? ] If LOC = NULL then Write Item not in Tree and Exit. [Delete Node Containing ITEM] If RIGHT[LOC] ≠ NULL and LEFT[LOC] ≠ NULL, then: Call CASEB (INFO, LEFT, RIGHT, ROOT, LOC, PAR). Else call CASEA (INFO, LEFT, RIGHT, ROOT, LOC, PAR). [End of If Structure] Exit.

HEAP – HEAP SORT • A Complete Binary Tree H can be maxheap or minheap If: – The Value of Node N is Greater then or Equal to the Value of Each of its Children (Max. Heap) – The Value of Node N is Less then or Equal to the Value of Each of its Children (Min. Heap) • H[ 1 ] is the root , H[ 2 k ], H[ 2 k + 1 ] • Parent of Any Non root Node j: H[ j / 2 ] 97 88 95 66 55 95 48 66 35 48 55 62 77 25 38 18 40 30 26 24 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

97 88 95 66 55 95 48 66 35 48 55 62 77 25 38 18 40 30 26 24 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 97 88 95 66 66 18 48 35 40 95 55 30 26 24 55 62 48 77 25 38

Insertion in a Heap • First Set the New ITEM on the Available Location i. e. If ITEM = 70 its Location is H[21] • Then Compare the ITEM with its Parents – If Parent is Greater Then ITEM Leave it – Else Swap Them • • 70 is the Right Child of H[10] = 48 Compare 70 with 48 and Interchange Compare 70 with 55 and Interchange Compare 70 with 88 and Leave

New Heap: 44, 30, 50, 22, 60, 55, 77, 55 44 30 77 50 55 30 60 44 50 22 30 44 45

INSHEAP( TREE, N, ITEM) H is a Heap with N items in which ITEM will be inserted. PTR will Find the Location of ITEM and PAR will be the Parent Location 1. [Add New Node to H and Initialize PTR] Set N : = N + 1 and PTR : = N 2. [Find Location to Insert ITEM] Repeat Steps 3 to 6 while PTR > 1 3. Set PAR = [PAR / 2] [Location of Parent Node] 4. If ITEM <= TREE [PAR] then: Set TREE[PAR] : = ITEM and Return [End of If Structure] 5. Set TREE[PTR] : = TREE[PAR] [Move Node Down] 6. Set PTR : = PAR [Update PTR] [End of Step 2 Loop] 7. [Assign ITEM as the ROOT of H] Set TREE[1] : = ITEM 8. Return.

Deletion in a Heap • Deletion of the Root • Replace the Root with the Last Value L of the Heap • L will Sink to its Proper Position 95 85 85 55 15 30 33 20 15 55 70 22 65 15 22 70 33 20 15 30 65

DELHEAP (TREE, N, ITEM) 1. 2. 3. 4. 5. 6. 7. 8. 9. Set LAST : = TREE[N] and N: = N-1 [remove the Last Node] Set PTR : = 1, LEFT : = 2 and RIGHT : = 3 [Initialize Pointers] Repeat Step 4 to 7 while RIGHT < = N If LAST >= TREE[LEFT] and LAST >= TREE[RIGHT] then: Set TREE [PTR] : = LAST and Return [End of If Structure] If TREE[RIGHT] <= TREE[LEFT] then: Set TREE[PTR] : = TREE[LEFT] and PTR : = LEFT Else: Set TREE[PTR] : = TREE[RIGHT] and PTR : = RIGHT [End of If Structure] Set LEFT : = 2 * PTR and RIGHT : = LEFT + 1 [End of Step 4 Loop] If LEFT = N and If LAST < TREE[LEFT], then Set PTR: = LEFT Set TREE[PTR] : = LAST Return

HEAPSORT (A, N) An array A with N Elements is given. 1. [Build a Heap H] Repeat for J = 1 to N – 1: Call INSHEAP(A, J, A[J+1]) [End of Loop] 2. [Sort A by repeatedly deleting the Root of H] Repeat while N > 1: a) Call DELHEAP(A, N, ITEM) b) Set A[N +1] : = ITEM [End of Loop] 3. Exit.