21 views

Uploaded by Prateek Dhawan

save

- DS Practical Journal
- UNIT 2&3 final
- unit 2 ds
- 5 - Trees
- lo04
- Data Structures
- DS OBJECTIVE QUESTIONS SET -3.doc
- CS9215-SET I.pdf
- 8-tree1-141204104913-conversion-gate02
- Week16 Trees
- quiz1-sol
- Computer
- Graphs and Trees_July 2012
- PICT ADSL Final Schedule
- Trees
- Binary Search Tree
- datastructure-100211095005-phpapp02
- Final Sample 3
- DATA STRUCTURES
- DSA_First_Draft
- Lower Bound Theory
- Data Structures and Algorithms
- 10-Define Workforce Structures
- Synopsis CSE
- IRJET-Comparison Analysis of Post- Processing Method for Punjabi Font
- 7007773 C Data Structures
- Abstract Data Types Exercise
- JSS-ART.pdf
- DSA Book.pdf
- 1-Java.docx
- The Innovators: How a Group of Hackers, Geniuses, and Geeks Created the Digital Revolution
- Elon Musk: Tesla, SpaceX, and the Quest for a Fantastic Future
- Dispatches from Pluto: Lost and Found in the Mississippi Delta
- Yes Please
- The Unwinding: An Inner History of the New America
- Sapiens: A Brief History of Humankind
- The Prize: The Epic Quest for Oil, Money & Power
- The Emperor of All Maladies: A Biography of Cancer
- Grand Pursuit: The Story of Economic Genius
- This Changes Everything: Capitalism vs. The Climate
- A Heartbreaking Work Of Staggering Genius: A Memoir Based on a True Story
- Devil in the Grove: Thurgood Marshall, the Groveland Boys, and the Dawn of a New America
- John Adams
- The Hard Thing About Hard Things: Building a Business When There Are No Easy Answers
- Smart People Should Build Things: How to Restore Our Culture of Achievement, Build a Path for Entrepreneurs, and Create New Jobs in America
- Rise of ISIS: A Threat We Can't Ignore
- The World Is Flat 3.0: A Brief History of the Twenty-first Century
- The New Confessions of an Economic Hit Man
- Team of Rivals: The Political Genius of Abraham Lincoln
- Bad Feminist: Essays
- Angela's Ashes: A Memoir
- Steve Jobs
- How To Win Friends and Influence People
- The Incarnations: A Novel
- You Too Can Have a Body Like Mine: A Novel
- The Sympathizer: A Novel (Pulitzer Prize for Fiction)
- Extremely Loud and Incredibly Close: A Novel
- Leaving Berlin: A Novel
- The Silver Linings Playbook: A Novel
- The Light Between Oceans: A Novel
- Brooklyn: A Novel
- The Flamethrowers: A Novel
- The First Bad Man: A Novel
- We Are Not Ourselves: A Novel
- The Blazing World: A Novel
- The Rosie Project: A Novel
- The Master
- Bel Canto
- A Man Called Ove: A Novel
- The Love Affairs of Nathaniel P.: A Novel
- Life of Pi
- The Cider House Rules
- A Prayer for Owen Meany: A Novel
- Lovers at the Chameleon Club, Paris 1932: A Novel
- The Bonfire of the Vanities: A Novel
- The Perks of Being a Wallflower
- The Kitchen House: A Novel
- Beautiful Ruins: A Novel
- Interpreter of Maladies
- The Wallcreeper
- The Art of Racing in the Rain: A Novel
- Wolf Hall: A Novel
- A Tree Grows in Brooklyn

You are on page 1of 104

Ch. 6 – Trees

Trees

Recursive Definition of a Tree A tree T is either empty or it consists of a root and zero or more nonempty subtrees T1,T2,…Tk each of whose roots are connected by an edge from the root of T.

Root

T1

T2

…

Tk

**nodes, vertices arcs, edges
**

Scott Goodwin & Luis Rueda, 2003 1 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**The terminology of trees
**

A: Root of the tree B C D E B,C,D,E: Children of the root B,C,D,E: Sibblings F G H I E is an ancestor of K K is a descendant of E F,G,C,H,I,K are the leaves of the tree The depth of a node is the length of the path from the root to the node Length of path = # of edges Depth of E =1 Height of a node = length of the longest path from that node to a leaf Height of E = 2 Height of tree = height of root Height of example tree is 3

Scott Goodwin & Luis Rueda, 2003 2 of 104

A

J K

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Applications Trees are a ubiquitous data structure in Computer Science. The Unix directory structure is a tree. Allows user to store files in a logical/organized fashion. Issues: • How to implement tree structure • How to insert and delete nodes in a tree structure • How to find nodes in a tree structure • How to traverse the entire tree structure • How to organize structure for efficiency These issues will be at the core of much of the discussion of trees.

Scott Goodwin & Luis Rueda, 2003 3 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Binary Trees A binary tree T is either empty or it consists of a root and two (possibly empty) binary subtrees TLeft and TRight each of whose roots are connected by an edge from the root of T.

Root B D E F H A C G

TLeft

TRight

If the left (right) binary subtree is not empty, its root is called the left (right) child of the root of the tree. The degree of a node is the number of children it has.

Scott Goodwin & Luis Rueda, 2003 4 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Problem Show by induction that the number of degree 2 nodes in any binary tree is 1 less than the number of leaves. Proof: The induction is on the number of nodes n in the binary tree. For n=1, there is only the root node with 0 children. Hence, 1 leaf node and 0 nodes of degree 2. Suppose the claim is true for all binary trees with n or less nodes. Consider a binary tree with n+1 nodes. It has one of the following structures:

(i) (ii) (iii)

**Let nL and nR be the number of nodes in the left and right subtrees respectively.
**

Scott Goodwin & Luis Rueda, 2003 5 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Since nL ≤ n and nR ≤ n, the claim is true for the left subtree in case (i) and the right subtree in case (ii). Since in both these cases the degree 2 nodes and the leaves belong to these subtrees alone, the claim holds for the entire tree. In case (iii), the claim is true for both subtrees. If we add the root to the count of degree 2 nodes of these trees, the claim follows. nL2 = nL0 -1 nR2 = nR0 -1 nT2 = nL2+nR2+1 (root is degree 2) = nL0 - 1 + nR0 - 1 + 1 = nL0 +nR0 - 1 = n T0 – 1

Scott Goodwin & Luis Rueda, 2003 6 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Exercise Show by induction that a binary tree with n nodes has height at least log n .

Scott Goodwin & Luis Rueda, 2003

7 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Operations that we would like to do on a binary tree (a) (b) (c) (d) Find its height Find its size (number of nodes) Visit its nodes in a systematic way Etc.

Scott Goodwin & Luis Rueda, 2003

8 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Height of a binary tree Height(T) = 1 + max(Height(TL),Height(TR)) Height(∅) = -1 Write a recursive function based on the above definition. height(T) if (T is empty) return –1 else return 1 + max(height(T.left),height(T.right))

Scott Goodwin & Luis Rueda, 2003

9 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Size of a binary tree Size(∅) = 0 Size(T) = 1 + Size(TL) + Size(TR) Write a recursive function based on the above definition. size(T) if (T is empty) return 0 else return 1 + size(T.left) + size(T.right)

Scott Goodwin & Luis Rueda, 2003

10 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Tree traversals Many problems require that we visit the nodes of a binary tree structure in a systematic way. Three such ways are: a) Preorder traversal b) Postorder traversal c) Inorder traveral

Scott Goodwin & Luis Rueda, 2003

11 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Preorder traversal 1. Visit the root 2. Visit the left subtree in preorder 3. Visit the right subtree in preorder

A B D E F H C G

For example, printing the labels of the nodes in the given tree using a preorder traversal gives: A,B,D,E,C,F,G,H

Scott Goodwin & Luis Rueda, 2003

12 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Postorder traversal 1. Visit the left subtree in postorder 2. Visit the right subtree in postorder 3. Visit the root

A B D E F H C G

For example, printing the labels of the nodes in the given tree using a postorder traversal gives: D,E,B,F,H,G,C,A

Scott Goodwin & Luis Rueda, 2003

13 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Inorder traversal 1. Visit the left subtree in inorder 2. Visit the root 3. Visit the right subtree in inorder

B D E

A C F H G

For example, printing the labels of the nodes in the given tree using a inorder traversal gives: D,B,E,A,F,C,H,G

Scott Goodwin & Luis Rueda, 2003

14 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Printing printPreorder(T) print T.data // visit root if (T.left is not empty) printPreorder(T.left) // visit left if (T.right is not empty) printPreorder(T.right) // visit right printPostorder(T) if (T.left is not empty) printPostorder(T.left) // visit left if (T.right is not empty) printPostorder(T.right)// visit right print T.data // visit root printInorder(T) if (T.left is not empty) printInorder(T.left) // visit left print T.data // visit root if (T.right is not empty) printInorder(T.right) // visit right

Scott Goodwin & Luis Rueda, 2003 15 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Heapsort

We can define another sorting algorithm that uses a binary tree. Definition: An (essentially) complete binary tree is a binary tree that is complete at all levels except possibly the last. Examples:

Definition: A heap is an essentially complete binary tree with the additional property: The key stored at any node is ≥ the keys stored at its children, if any.

Scott Goodwin & Luis Rueda, 2003 16 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Note: In the above definition, we can replace ≥ with ≤. Example:
**

16 11 10 1 2 4 5 6 9 8

Array Representation of a heap: 11 9 10 5 6 8 1 2 4 16 0 1 2 3 4 5 6 7 8 9 Key values placed in array level-by-level and left to right. Children of node at index i placed at indices 2i+1 and 2i+2. Given, an array of n elements, how can we heapify them?

Scott Goodwin & Luis Rueda, 2003

17 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Input: Indices i and j of an array A[0..n-1] of key values. Output: A[i] sinks to appropriate place in A[i..j] Procedure Heapify(i, j) if A[i] is a leaf node then return Set A[k] ← max{A[2i+1],A[2i+2]} // k is index of max. where 2i+1 and 2i+2 ≤ j if (A[i] < A[k]) then Exchange(A[i],A[k]) Heapify(k, j) 12 0 10 1 20 2 19 3 8 4 7 5 15 6

19 12 10 8 7 20 15

Algorithm Heapify

**Heapify(1,6): causes 10 to sink 12 0 19 1 20 2 10 3 8 4 7 5 15 6
**

10 Scott Goodwin & Luis Rueda, 2003 12 19 8 7 20 15

18 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Heapify(0,6): causes 12 to sink 20 0 19 1 12 2 10 3 8 4 7 5 15 6
**

10 20 19 8 7 12 15

**Heapify(2,6): causes 12 to continue sinking 20 0 19 1 15 2 10 3 8 4 7 5 12 6
**

10 20 19 8 7 15 12

Heapify(0,n-1) is O(log n) Heapify(i,n-1) only fixes element i To build the entire heap, we must apply heapify to all of the elements in turn.

Scott Goodwin & Luis Rueda, 2003 19 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Algorithm BuildHeap

Input: An array A[0..n-1] of key values. Output: An array A[0..n-1] that satisfies the heap property. Procedure BuildHeap(A) for i ← n div 2 - 1 downto 0 Heapify(i, n-1) Initial array: 12 0 10 1 20 2 19 3 8 4 7 5 15 6

19 12 10 8 7 20 15

Heapify(2,6): no change

Scott Goodwin & Luis Rueda, 2003

20 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

12 0

10 1

20 2

19 3

8 4

7 5

15 6

19

12 10 8 7 20 15

**Heapify(1,6): causes 10 to sink 19 20 10 8 12 0 1 2 3 4 Heapify(0,6): causes 12 to sink 20 0 19 1 12 2 10 3 8 4 7 5 7 5 15 6
**

10 12 19 8 7 20 15

15 6

10

20 19 8 7 12 15

**Heapify(2,6): causes 12 to continue sinking 20 0 19 1 15 2 10 3 8 4 7 5 12 6
**

10 Scott Goodwin & Luis Rueda, 2003 20 19 8 7 15 12

21 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Input: An array A[0..n-1] of key-values. Output: A sorted array A[0..n-1] of key-values. BuildHeap(A) for i ← n-1 downto 1 Exchange(A[0],A[i]) Heapify(0,i-1) Initial array: 10 20 19 8 12 0 1 2 3 4 BuildHeap: produces array below 20 0 19 1 15 2 10 3 8 4 7 5 7 5 15 6

19 12 10 8 7 20 15

Algorithm Heapsort

12 6

10

20 19 8 7 15 12

Scott Goodwin & Luis Rueda, 2003

22 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Exchange(A[0],A[6]): produces array below 19 15 12 0 1 2 Heapify(0,5): produces 19 12 15 0 1 2 Heapify(1,5): no change 10 3 10 3 8 4 8 4 7 5 7 5 20 6
**

10 12 19 8 7 15 20

20 6

10

19 12 8 7 15 20

Exchange(A[0],A[5]): produces 7 0 12 1 15 2 10 3 8 4 19 5 20 6

10 7 12 8 19 15 20

Scott Goodwin & Luis Rueda, 2003

23 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Heapify(0,4): produces 12 7 15 0 1 2 Heapify(2,4): no change

10 3

8 4

19 5

20 6

10

15 12 8 19 7 20

**Exchange(A[0],A[4]): produces 12 7 10 15 8 0 1 2 3 4 Heapify(0,3): produces 8 7 12 0 1 2 Heapify(1,3): produces 10 7 12 0 1 2
**

Scott Goodwin & Luis Rueda, 2003

19 5 19 5 19 5

20 6

10

8 12 15 19 7 20

10 3 8 3

15 4 15 4

20 6

10

12 8 15 19 7 20

20 6

8

12 10 15 19 7 20

24 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Exchange(A[0],A[3]) produces 10 7 12 15 8 0 1 2 3 4 Heapify(0,2): produces 8 7 12 10 0 1 2 3 Heapify(1,2): nochange Exchange(A[0],A[2]) produces 8 10 12 7 0 1 2 3 Heapify(0,1): produces 7 10 12 8 0 1 2 3 Heapify(1,1): no change
**

Scott Goodwin & Luis Rueda, 2003

19 5 19 5 19 5 19 5

20 6

12

8 10 15 19 7 20

15 4 15 4 15 4

20 6

12

10 8 15 19 7 20

20 6

12

7 8 15 19 10 20

20 6

12

8 7 15 19 10 20

25 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Exchange(A[0],A[1]): produces 8 10 12 15 7 0 1 2 3 4 Heapify(0,0): no change Data is sorted.

19 5

20 6

12

7 8 15 19 10 20

Scott Goodwin & Luis Rueda, 2003

26 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Complexity of Heapsort

BuildHeap is O(n) : True but difficult hard to prove it!! Heapify is O(log n) Heapify is called n times in heapsort. Therefore, Heapsort is O(n log n)

Scott Goodwin & Luis Rueda, 2003

27 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Binary Search Trees
**

Definition: A Binary Search Tree (BST) is a binary tree that satisfies the property that for every node x in the BST, • x.Key > every key in x.Left (left subtree), and • x.Key < every key in x.Right (right subtree). A node of a binary search tree may be represented with 5 fields: Left Key Data Parent Right For simplicity, we usually omit the data field in examples. Also, the parent field can often be omitted depending on the intended application and/or the particular implementation.

Scott Goodwin & Luis Rueda, 2003 28 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**An example of a BST
**

5 3 2 4 7 8

BST property Inorder traversal of a BST visits the nodes in sorted order: 2,3,4,5,7,8 (ascending order)

Scott Goodwin & Luis Rueda, 2003

29 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Querying a BST

1. Searching for a node with a given key, k: TreeSearch(x,k) // x is the node where search starts if (x == NULL or k == x.Key) return x else if (k < x.Key) return TreeSearch(x.Left,k) else return TreeSearch(x.Right,k)

Scott Goodwin & Luis Rueda, 2003

30 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

2. Minimum and Maxium keys TreeMin(x) while (x.Left != NULL) x = x.Left return x; TreeMax(x) while (x.Right != NULL) x = x.Right return x;

Scott Goodwin & Luis Rueda, 2003

31 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

3. Successor and Predecessor of a key Definition: The successor of a node x is the node with the smallest key greater than x.Key TreeSuccessor(x) if (x.Right != NULL) return TreeMin(x.Right) else p = x.Parent while (p != NULL and x == p.Right) x=p p = x.Parent return p

Scott Goodwin & Luis Rueda, 2003

32 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Example: Successor of 13?

15 6 3 2 4 7 13 9 17 18 20

Note that 13 is the maximum key in the BST rooted at 6

Scott Goodwin & Luis Rueda, 2003

33 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Definition: The predecessor of a node x is the node with the largest key smaller than x.Key. TreePredecessor(x) if (x.Left != NULL) return TreeMax(x.Left) else p = x.Parent while (p != NULL and x == p.Left) x=p p = x.Parent return p

Scott Goodwin & Luis Rueda, 2003

34 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Example: Predecessor of 13?

17 6 3 2 4 16 14 13 15 18 19 20

Note that 13 is the minimum key in the BST rooted at 16

Scott Goodwin & Luis Rueda, 2003

35 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Insertion

TreeInsert(x, k) if (x == NULL) Create new node with key k Establish the corresponding links else if (k < x.Key) TreeInsert(x.Left, k) else if (k > x.Key) TreeInsert(x.Right, k) else return “Key is in BST”

3

12 6 7 13 15 17 18 19

Example: Insert key 13 into existing BST

Scott Goodwin & Luis Rueda, 2003

36 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Deletion

Case 1: Node has no children Simply remove the node. Example: Delete 13:

12 6 3 7 13 15 17 18 19

Scott Goodwin & Luis Rueda, 2003

37 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Case 2: Node has one child Replace node with its child. Example: Delete 13
**

9 6 3 7 10 11 12 13 3 6 7 10 9 11 12

Scott Goodwin & Luis Rueda, 2003

38 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 3: Node has two children Replace node with minimum key m in right subtree and recursively delete m in right subtree. Example: Delete 13

13 6 3 7 14 15

Scott Goodwin & Luis Rueda, 2003

14 6 3 7 14 15 14 16 17 18 19

18 16 17 19 3

6 7 15 16

18 19 17

39 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Balanced Search Trees
**

Definition: Binary Search Tree with a worst-case height of O(log n) are called balanced trees We can guarantee O(log n) performance for each search tree operation for balanced trees. We will discuss two kinds of balanced trees (a) AVL trees (b) Red-black trees

Scott Goodwin & Luis Rueda, 2003

40 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

AVL Trees Named after its discoverers: Adelson, Velskii and Landis, 1962 Definition: An empty binary tree is an AVL tree. If T is a non-empty binary tree with T L and T R as its left and right sub-trees, then T is an AVL tree iff (a) T L and T R are AVL trees and (b) | hL − hR | ≤ 1 where hL and hR are the heights of T L and T R respectively.

Scott Goodwin & Luis Rueda, 2003

41 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Definition: An AVL search tree is a binary search tree that is also an AVL tree Henceforth, by an AVL tree we shall mean an AVL search tree. Node of an AVL tree: balance balance = height of left subtree – height of right subtree

Scott Goodwin & Luis Rueda, 2003

42 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Examples of AVL search trees 30 –1 = 0 – 1 0 5 0 35 20 0 = 1 – 1 Fig.2: The number outside each node is its balance factor
**

Scott Goodwin & Luis Rueda, 2003

40

1 = 0 – (–1)

0 – 0 = 0 15 0 12

25 0 18 = –1 – (–1)

–1=–1–0

30 0

43 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Height of an AVL tree Let N h be the minimum number of nodes in an AVL tree of height h. Then N h =N h − 1 + N h−2 +1, N 0 =1, N1=2 assuming the worst-case scenario in which one sub-tree has height h -1 and the other h - 2 The solution to the recurrence given above is: N h = F h + 3 -1 , where F n is the nth Fibonacci number

Scott Goodwin & Luis Rueda, 2003

44 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Thus if n is the number of nodes… in an AVL tree of height h n > Nh = Fh+3 - 1 ≈ where
**

φ=

φ h+3

5 −1

5 +1 2

**h < 1.44 log(n+2) - 1.328 h = O(log n)
**

Scott Goodwin & Luis Rueda, 2003 45 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Insertion into an AVL tree –2 30 0 5 35 1 32 0 Fig.3: Inserting key 32 causes the tree to become unbalanced 40 2

Scott Goodwin & Luis Rueda, 2003

46 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Imbalance due to: Insertion into left sub-tree of left child of a node k2 k1 C B
**

1 level 1 level

A Fig. 4

Scott Goodwin & Luis Rueda, 2003

47 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balanced by LL-rotation k1 k2

A

B

C

Fig. 5

Scott Goodwin & Luis Rueda, 2003

48 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Results in: 30 –1 0 5 32 0 35 0 40 0

Tree balanced by LL rotation

Scott Goodwin & Luis Rueda, 2003

49 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Pseudocode: LL rotation Input: Binary Node k2 Procedure withLeftChild( k2) Set k1 ← k2.Left if (k2 is Left child) k2.Parent.Left ← k1 else k2.Parent.Right ← k1 k2.Left ← k1.Right k1.Right ← k2 // Also, update Parent fields! return k1

Scott Goodwin & Luis Rueda, 2003 50 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Imbalance due to Insertion into right sub-tree of right child of a node k1 k2 C B A Fig. 6

Scott Goodwin & Luis Rueda, 2003

51 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balanced by RR-rotation k2 k1

C

B

A

Fig. 7

Scott Goodwin & Luis Rueda, 2003

52 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Example of RR rotation: Insert 45 30 –2 0 5 35 –2 40 –1 45 0 Tree unbalanced after insertion

Scott Goodwin & Luis Rueda, 2003

53 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

After the RR rotation: 30 –1 0 5 35 0 40 0 45 0

Scott Goodwin & Luis Rueda, 2003

54 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Pseudocode: RR rotation Input: Binary Node k1 Procedure withRightChild( k1) Set k2 ← k1.Right if (k1 is Left child) k1.Parent.Left ← k2 else k2.Parent.Right ← k2 k1.Right ← k2.Left k2.Left ← k1 // Update Parent fields too! return k2

Scott Goodwin & Luis Rueda, 2003 55 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Imbalance caused by Insertion into right sub-tree of the left child of a node k3 k1 k1 k3

Before insertion

After insertion

Scott Goodwin & Luis Rueda, 2003

56 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balanced by LR-rotation k3 k1 k2 D A B Before C After A B C D k1 k2 k3

Scott Goodwin & Luis Rueda, 2003

57 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Example of LR rotation:

8 4 2 5 6

12 16

10

14

Insertion of 5 causes the imbalance at node 8

12 6 4 2 5 8 14 10 16

Balanced by LR rotation

Scott Goodwin & Luis Rueda, 2003

58 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Remark: An LR rotation is often called a double rotation because it can be viewed as an RR rotation, followed by an LL rotation On the example:

8 6 4 2 5 10 14

12 16

RR-rotation

Scott Goodwin & Luis Rueda, 2003

59 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

12 6 4 2 5 8 14 10 16

LL-rotation

Scott Goodwin & Luis Rueda, 2003

60 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Imbalance caused by Insertion into left sub-tree of right child Balance is restored by an RL rotation Details are the same as in the case of a LR rotation

Scott Goodwin & Luis Rueda, 2003

61 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**An example of RL rotation:
**

5 4 8 10 12

Insert 7

5 4 8 7 10 12

Scott Goodwin & Luis Rueda, 2003

62 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

After the RL rotation: 8 5 4 7 10 12

Scott Goodwin & Luis Rueda, 2003

63 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

5 4 8 7

5 LL rotation 4 RR rotation 5 4 7 8 10 12

64 of 104

10 12

RL unbalanced at 5

8

7 10 12

Scott Goodwin & Luis Rueda, 2003

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Pseudocode: LR rotation Input: Binary Node k3 Procedure doubleWithLeftChild( k3) Set k3.Left ← withRightChild(k3.Left) return withLeftChild(k3)

Pseudocode: RL rotation Input: Binary Node k3 Procedure doubleWithRightChild( k3) Set k3.Right ← withLeftChild(k3.Right) return withRightChild(k3)

Scott Goodwin & Luis Rueda, 2003

65 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balance:

5 4 3 2 8 9 10

unbalanced at 4

heights are the same !!!

2 5 3 4 8 9 10

LL rotation

Scott Goodwin & Luis Rueda, 2003

66 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balance:

5 1 8 9 10 12

height = 2

**RR rotation height = 2
**

1 5 8

9 10 12

**Note: the height of the tree is restored to its original value before RR rotation
**

67 of 104

Scott Goodwin & Luis Rueda, 2003

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Balance this:

1

5 9 8 7 8 5 1 7 9 10 10

Insert 7

RR rotation

Note: The imbalance due to insertion is corrected by a single or a double rotation. The height of the tree becomes the height of the sub-tree rooted at the node where the imbalance is restored.

Scott Goodwin & Luis Rueda, 2003 68 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Deletion from an AVL tree • We delete a node just as in a binary search tree • Let q be the parent of the physically deleted node. • We might need to go all the way from q to the root in order to balance the tree and restore AVL-balance

Scott Goodwin & Luis Rueda, 2003

69 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Three cases arise: C1: Balance at q has changed to 0 height has decreased by 1 (of the tree rooted at q) and we need to check the balance factor of the ancestors of q. Balance at q has changed to +1 or –1 height of subtrees at q is unchanged, so the balance of all the ancestors of q remains unchanged Balance at q is ±2 tree needs to be balanced at q

C2:

C3:

Scott Goodwin & Luis Rueda, 2003

70 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

q

Fig. Case C1, delete root Case C2, delete node circled in green Case C3, delete node circled in blue

Scott Goodwin & Luis Rueda, 2003

71 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Let A be the first node on the path from q to the root where the balance has changed to ±2 The imbalance is of type L if deletion has taken from the left sub-tree of A R if deletion has taken from the right sub-tree of A We discuss the R-type imbalance

Scott Goodwin & Luis Rueda, 2003

72 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

An R-type imbalance with balance factor 2 we had one of the following three situations (configurations) before deletion R0-type A B BL h 0 BR h Before

Scott Goodwin & Luis Rueda, 2003

1 AR h => BL h B

A 0 BR h After

2 , AR h-1

73 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

R1-type A B BL h 1 BR h-1 Before 1 AR h => B BL h After A 1 BR h-1 2 , AR h-1

Scott Goodwin & Luis Rueda, 2003

74 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

R-1 type A B BL h-1 CL -1 C b CR 1 AR h => B BL h-1 CL A -1 C b CR 2 , AR h-1

Before

Scott Goodwin & Luis Rueda, 2003

After

75 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Restoration R0 rotation B BL h -1 A BR h 1 , AR h-1

Scott Goodwin & Luis Rueda, 2003

76 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

R1-rotation

B BL h

0 A BR h-1 0 , AR h-1

Scott Goodwin & Luis Rueda, 2003

77 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

R-1 Rotation C B BL h-1 0 A CL CR , AR h-1

Similarly for an L-type of imbalance

Scott Goodwin & Luis Rueda, 2003

78 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Red-Black Trees Definition: A red-black tree is a binary search tree with the following properties: P1: P2: P3: P4: Each node is colored red or black The root is colored black A red node can only have black children Every path from a node to a null reference must contain the same number of black nodes

Scott Goodwin & Luis Rueda, 2003

79 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Example 30 15 10 5 40 20 50 45 60 65 80 70 85 90

**Fig.1 A red-black tree
**

Scott Goodwin & Luis Rueda, 2003 80 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Note: It is important to know that we are talking about paths to a null node This excludes a tree like

B

B B B B B

**In a tree like this:
**

B B

B

B B B B

**All trees are null nodes The theorem is about such a tree
**

81 of 104

Scott Goodwin & Luis Rueda, 2003

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Theorem 1. If every path from the root to a null node B contains B black nodes then the # of black nodes is > 2 −1 Proof By induction on B

Theorem 2. The height h of a red black tree with n nodes is at most 2log(n+1)-1 Proof

n ≥ 2 −1 ≥ 2

B

h+1 2

h +1 ≤ 2 log(n +1) h ≤ 2 log(n +1) −1

Scott Goodwin & Luis Rueda, 2003

h +1 ≤ log( n + 1) 2

−1

82 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Important conclusion h=O(log n) for a red-black tree with n nodes

Scott Goodwin & Luis Rueda, 2003

83 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Insertion into a red-black tree Insert node as a leaf Restore properties P1-P4, bottom-up OK? Observations Inserted node must be colored red Red-black property P3 is violated if it has a red parent

Scott Goodwin & Luis Rueda, 2003

84 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 1: Inserted node has a red parent, which has a black sibling Single rotation restoration G P X A B Fig.2

Scott Goodwin & Luis Rueda, 2003

S C D E A X

P G BC D S E

85 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Double rotation restoration G P A B X D C S E A P BC D X G S E

Fig.3

Scott Goodwin & Luis Rueda, 2003

86 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Case 2. Inserted node has a red parent, which has a red sibling G P X A B C D S E A X BC D
**

87 of 104

P G S E

Fig.4

Scott Goodwin & Luis Rueda, 2003

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

More on Case 2.

This case is problematic because P could have a red parent and we propagate the restoration to the root

Scott Goodwin & Luis Rueda, 2003

88 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

**Examples: Red-black trees.
**

30 15 10 5 20 50 40 35 55 60 65 80 70 85 90

Fig. 5

Changed to black

60 40 35 50 55 65

**Insert 35, color is red, Red parent, sibling of parent also red, LL rotation involving key 40 and 50
**

Scott Goodwin & Luis Rueda, 2003

**Now after rotation parent of 40 is red with black children
**

89 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

70 60 40 35 50 55 65 80 85 90

LL Rotation involving the keys 60 and 70 60 It is colored red because we want to present the # 40 70 of black nodes on the path 60-70-85 35 50 65 85

55

Scott Goodwin & Luis Rueda, 2003

80

90

90 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

30 15 10 5 3 40 20 50 55 60 65 80 70 85 90

Fig. 6

**Insert 3. Inserted node has red parent with no sibling. LL rotation involving 5 & 10
**

15 5 3

Scott Goodwin & Luis Rueda, 2003

20 10

Note: on slide 85 case 2. It would not make if the sibling of P did not exist, as is the case. The same adjustment holds. This take care of everthing.

91 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

30 15 10 5 40 20 50 55 60 65 80 82 70 85 90

Fig. 7

**Insert 82. Parent has red sibling
**

85 80 82 90 80 82 85 90

LR rotation

Scott Goodwin & Luis Rueda, 2003

92 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Top-down insertion Rule: If we hit a node with red children, we flip the color of the node & the children. If the node’s parent is red, then the node’s parent’s sibling cannot be red and we can apply the single rotation of Fig.2 or the double rotation of Fig.3

Claim.

Scott Goodwin & Luis Rueda, 2003

93 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Insert 45 into the tree of Fig.1 At node 50, we do a color flip 30 70 60 50 40 55 65 80 85 90

Fig. 8

Scott Goodwin & Luis Rueda, 2003

94 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Then do a single rotation at node 70 30 60 50 40 55 65 70

Fig. 9

Scott Goodwin & Luis Rueda, 2003 95 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Continue to descend … 30 60 50 40 45 55

Fig. 10

Scott Goodwin & Luis Rueda, 2003

96 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Deletion from a red-black tree Deletion is as the case of a binary search tree, with the guarantee that the color of the physically deleted node is red Start from the root… As we search down the tree, we maintain the invariant that the color of the current node X is red

Scott Goodwin & Luis Rueda, 2003

97 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Sentinel node

T Given red-black tree We add a sentinel node, color it red and make the given red-black tree the right sub-tree of the sentinel node.

Scott Goodwin & Luis Rueda, 2003 98 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Let X be the current node Let P be its parent Let T be its sibling Always ensure that, P is red both X & T are black … why? Two cases: Case 1: X has 2 black children

Scott Goodwin & Luis Rueda, 2003

99 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 1.1: P X

T has 2 black children

T X

P T

**Fig. Flip colors
**

Scott Goodwin & Luis Rueda, 2003 100 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 1.2: P X

T has an outer child that is red

T R => P

T R

**X Fig. Single rotation on P: RR-rotation
**

Scott Goodwin & Luis Rueda, 2003 101 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 1.3:

T has an inner red child P

X R

T => P

R T

X

**Fig. Double rotation on P (RL = LL + RR)
**

Scott Goodwin & Luis Rueda, 2003 102 of 104

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Case 2:

X has a red child

Move one level down, obtaining a new X, T, P. If X is black, do a rotation as in the example below X X T P X’ B C P T B Fig. Single rotation continue from X’

103 of 104

’

C

Scott Goodwin & Luis Rueda, 2003

60-254 Algorithms and Data Structures – W03

Ch. 6 – Trees

Deletion from a red-black tree Note that the rotation is the main case when X has two black children, always when X red When X has a red child we have to move one level down on the search path (whether the child along the search path is red, the rotation is both) Note that in Case 1.2, if both children of T are red we can still apply the case.

Scott Goodwin & Luis Rueda, 2003

104 of 104

- DS Practical JournalUploaded byAnshuman Biswas
- UNIT 2&3 finalUploaded bykashokcse16
- unit 2 dsUploaded byNivitha
- 5 - TreesUploaded bywe0038
- lo04Uploaded byhisuin
- Data StructuresUploaded byVenkatesh Chowdary
- DS OBJECTIVE QUESTIONS SET -3.docUploaded byAbinash Behera
- CS9215-SET I.pdfUploaded bysharmila
- 8-tree1-141204104913-conversion-gate02Uploaded byNiaSania
- Week16 TreesUploaded byDylan Gray
- quiz1-solUploaded byJoe Knut Ant
- ComputerUploaded byAdrian Carlo Fajardo Lustina
- Graphs and Trees_July 2012Uploaded byMarl Mwegi
- PICT ADSL Final ScheduleUploaded byWhatsapp stuff
- TreesUploaded byunnati patel
- Binary Search TreeUploaded bySandeep Sahu
- datastructure-100211095005-phpapp02Uploaded byakshaygondalia
- Final Sample 3Uploaded byvivek patel
- DATA STRUCTURESUploaded byLokesh Arya
- DSA_First_DraftUploaded bymarcio1404
- Lower Bound TheoryUploaded byMuzafar Ahmad Bhat
- Data Structures and AlgorithmsUploaded byabhi
- 10-Define Workforce StructuresUploaded byShravanUday
- Synopsis CSEUploaded byNarinder Bansal
- IRJET-Comparison Analysis of Post- Processing Method for Punjabi FontUploaded byIRJET Journal
- 7007773 C Data StructuresUploaded byjavednjaved
- Abstract Data Types ExerciseUploaded byShuaib
- JSS-ART.pdfUploaded byParag Darade
- DSA Book.pdfUploaded bySathish kumar
- 1-Java.docxUploaded bymanas199