Data Structures and Algorithms. Dr. Amit Kumar and Dr. Amitabha Bagchi IIT Delhi

Transcription

1 Data Structures and Algorithms Dr. Amit Kumar and Dr. Amitabha Bagchi IIT Delhi 1

2 Algorithms & Data structures Algorithm Outline, the essence of a computational procedure, step by step instructions Program an implementation of an algorithm in some programming language Data structure Organization of data needed to solve the problem 2

3 Overall Picture Using a computer to help solve problems Designing programs architecture algorithms Writing programs Verifying (Testing) programs Data Structure and Algorithm Design Goals Efficiency Correctness Implementation Goals Robustness Reusability Adaptability 3

4 Algorithmic problem Specification of input? Specification of output as a function of input Infinite number of input instances satisfying the specification. For example: A sorted, non decreasing sequence of natural numbers. The sequence is of non zero, finite length: 1, 20, 908, 909, ,

5 Algorithmic Solution Input instance, adhering to the specification Algorithm Output related to the input as required Algorithm describes actions on the input instance Infinitely many correct algorithms for the same algorithmic problem 5

6 Data structures Input instance, adhering to the specification Algorithm Output related to the input as required How to organize and manipulate the data Affects the efficiency of the algorithm 6

7 The Goals of this Course The main things that we will try to learn in this course: To be able to think algorithmically, to get the spirit of how algorithms are designed To get to know a toolbox of techniques for designing data structures and algorithms. To learn reason (in a formal way) about the efficiency and the correctness of algorithms 7

8 Example: Sorting OUTPUT INPUT a permutation of the sequence of numbers sequence of numbers a1, a2, a3,.,an Sort Correctness (requirements for the output) For any given input the algorithm halts with the output: b1 < b2 < b3 <. < bn b1, b2, b3,., bn is a permutation of a1, a2, a3,.,an b1,b2,b3,.,bn Running time Depends on number of elements (n) how (partially) sorted they are algorithm 8

9 Insertion Sort A j 5 1 n i Strategy Start empty handed Insert a card in the right position of the already sorted hand Continue until all cards are inserted/sorted 9

10 Insertion Sort

11 Insertion Sort

12 Insertion Sort

13 Insertion Sort

14 Insertion Sort

15 Insertion Sort A j 5 1 n i INPUT: A[1..n] an array of integers OUTPUT: a permutation of A such that A[1] A[2] A [n] for j 2 to n do key A[j] Insert A[j] into the sorted sequence A[1..j 1] i j 1 while i>0 and A[i]>key do A[i+1] A[i] i A[i+1] key 15

16 Issues Efficiency: Running time Space used Efficiency as a function of input size: Number of data elements (numbers, points) A number of bits in an input number How does efficiency depend on the data structure? 16

17 The RAM model Very important to choose the level of detail. The RAM model: Instructions (each taking constant time): Arithmetic (add, subtract, multiply, etc.) Data movement (assign) Control (branch, subroutine call, return) Data types integers and floats 17

18 Analysis of Insertion Sort Time to compute the running time as a function of the input size for j 2 to n do key A[j] Insert A[j] into the sorted sequence A [1..j 1] i j 1 while i>0 and A[i]>key do A[i+1] A[i] i A[i+1]:=key cost c1 c2 0 c3 c4 c5 c6 c7 times n n 1 n 1 n 1 n t (t (t j nj = 2 nj = 2 j j =2 j n 1 1) 1) 18

19 Best/Worst/Average Case Best case: elements already sorted tj=1, running time = f(n), i.e., linear time. Worst case: elements are sorted in inverse order tj=j, running time = f(n2), i.e., quadratic time Average case: tj=j/2, running time = f(n2), i.e., quadratic time 19

20 Best/Worst/Average Case For a specific size of input n, investigate running times for different input instances: 6n 5n 4n 3n 2n 1n 20

21 Best/Worst/Average Case For inputs of all sizes: worst case average case Running time 6n 5n best case 4n 3n 2n 1n Input instance size 21

22 Asymptotic Analysis Goal: to simplify analysis of running time by getting rid of details, which may be affected by specific implementation and hardware like rounding : 1,000,001» 1,000,000 3n2» n2 Capturing the essence: how the running time of an algorithm increases with the size of the input in the limit. Asymptotically more efficient algorithms are best for all but small inputs 22

23 Asymptotic Notation The big Oh O Notation asymptotic upper bound f(n) = O(g(n)), if there exists constants c and n0, s.t. f(n) c g(n) for n n0 f(n) and g(n) are functions over non negative integers Used for worst case analysis c g ( n) f n Running Time n0 Input Size 23

24 Examples f ( n )2 = n 6+ 2n+6 is O(n). c g(n) = 4n g(n) = n n 24

25 Examples Simple Rule: Drop lower order terms and constant factors. 50 n log n is O(n log n) 7n 3 is O(n) 8n2 log n + 5n2 + n is O(n2 log n) Note: Even though (50 n log n) is O(n5), it is expected that such an approximation be of as small an order as possible 25

26 More Examples 26

27 Asymptotic Notation The big Omega Ω Notation asymptotic lower bound f(n) = Ω(g(n)) if g(n) = O(f(n)) Used to describe best case running times or lower bounds of algorithmic problems E.g., lower bound of searching in an unsorted array is Ω(n). Running Time f n c g ( n) n0 Input Size 27

28 Asymptotic Notation The big Theta Θ Notation asymptoticly tight bound f(n) = Θ(g(n)) if f(n) = O(g(n)) and f(n) = Ω (g(n)) O(f(n)) is often misused instead of Θ(f(n)) c 2 g n Running Time f n c 1 g n n0 Input Size 28

29 Asymptotic Notation Analogy with real numbers f(n) = O(g(n)) f g f(n) = Ω(g(n)) f g f(n) = Θ(g(n)) f=g Abuse of notation: f(n) = O(g(n)) actually means f(n) O(g(n)) 29

30 Asymptotic Notation Special classes of algorithms: logarithmic: O(log n) linear: O(n) quadratic: O(n2) polynomial: O(nk), k 1 exponential: O(an), n > 1 30

31 Comparison of Running Times Running Time Maximum problem size (n) 1 second 1 minute 1 hour 400n n log n n n n

32 Sorting Insertion sort takes Θ(n2) time. Are there better strategies? There are many alternate strategies, in fact it is possible to get Θ(n log n) running time. 32

33 Example 2: Searching INPUT sequence of numbers (database) a single number (query) a1, a2, a3,.,an; q OUTPUT an index of the found number or NIL j ; ; 9 NIL 33

34 Searching INPUT: A[1..n] an array of integers, q an integer. OUTPUT: an index j such that A[j] = q. NIL, if q does not appear in A j 1 while j n and A[j] q do j++ if j n then return j else return NIL Worst case running time: Θ(n), average case: Θ(n/2) We can t do better. This is a lower bound for the problem of searching in an arbitrary sequence. 34

35 Searching in a Sorted Array OUTPUT INPUT sorted non descending sequence of a single number (query) a1, a2, a3,.,an; q numbers (database) an index of the found j ; ; 9 NIL number or NIL 35

36 Binary search Idea: Divide and conquer, one of the key design techniques INPUT: A[1..n] a sorted (non decreasing) array of integers, q an integer. OUTPUT: an index j such that A[j] = q. NIL, if q does not appear in A left=1 right=n do j=(left+right)/2 if A[j]=q then return j else if A[j]>q then right=j 1 else left=j+1 while left<=right return NIL 36

37 Binary search example ; 7 37

38 Binary search example ; 7 38

39 Binary search example ;7 39

40 Binary search example ;7 40

41 Binary search example 7 8 ;7 41

42 Binary search example 7 8 ;7 42

43 Insertion Sort : A fresh look A j 5 1 n i While inserting the next element in the partially sorted list, why not use binary search? 43

44 Insertion Sort : A fresh look A j 5 1 n i While inserting the next element in the partially sorted list, why not use binary search? Even though we know where to insert, shifting the array locations will take too much time. Need a better Data structure 44

45 Correctness proofs The algorithm is correct if for any legal input it terminates and produces the desired output. Automatic proof of correctness is not possible But there are practical techniques and rigorous formalisms that help to reason about the correctness of algorithms 45

46 Assertions To prove partial correctness we associate a number of assertions (statements about the state of the execution) with specific checkpoints in the algorithm. E.g., A[1],, A[k] form an increasing sequence Preconditions assertions that must be valid before the execution of an algorithm or a subroutine Postconditions assertions that must be valid after the execution of an algorithm or a subroutine 46

47 Loop Invariants Invariants assertions that are valid any time they are reached (many times during the execution of an algorithm, e.g., in loops) We must show three things about loop invariants: Initialization it is true prior to the first iteration Maintenance if it is true before an iteration, it remains true before the next iteration Termination when loop terminates the invariant gives a useful property to show the correctness of the algorithm 47

48 A Quick Math Review Geometric progression given an integer n0 and a real number 0< a < 1 n +1 1 a i 2 n a = 1 + a + a a = 1 a i= 0 n geometric progressions exhibit exponential growth Arithmetic progression n2 + n i = n = 2 i= 0 n 48

49 A Quick Math Review (2) 49

50 Summations The running time of insertion sort is determined by a nested loop for j 2 to length(a) key A[j] i j 1 while i>0 and A[i]>key A[i+1] A[i] i i 1 A[i+1] key Nested loops correspond to summations 2 ( j 1) = O ( n ) j =2 n 50

51 Proof by Induction We want to show that property P is true for all integers n n0 Basis: prove that P is true for n0 Inductive step: prove that if P is true for all k such that n0 k n 1 then P is also true for n n n( n + 1) Example S ( n) = i = for n 1 i =0 Basis 2 1(1 + 1) S (1) = i = 2 i=

52 Proof by Induction Inductive Step S (k) = k i = i =0 S ( n) = k ( k + 1) for 1 k n 1 2 n n 1 i =0 i =0 i = i + n =S (n 1) + n = ( n 1 +1) ( n 2 n + 2 n) = (n 1) +n= = 2 2 n( n +1) = 2 52

53 Abstract Data Types (ADTs) An Abstract Data Type is an abstraction of a data structure. (No coding is involved.) The ADT specifies: what can be stored in the ADT what operations can be done on/by the ADT For example, if we are going to model a bag of marbles as an ADT, we could specify that: this ADT stores marbles this ADT supports putting in a marble and getting out a marble. 53

54 Abstract Data Types (ADTs) Types of operations: Constructors Access functions Manipulation procedures 54

55 Abstract Data Types Why do we need to talk about ADTs? They serve as specifications of requirements for the building blocks of solutions to algorithmic problems Provides a language to talk on a higher level of abstraction ADTs encapsulate data structures and algorithms that implement them Separate the issues of correctness and efficiency 55

56 Example Dynamic Sets We will deal with ADTs, instances of which are sets of some type of elements. Operations are provided that change the set We call such class of ADTs dynamic sets 56

57 Dynamic Sets An example dynamic set ADT Methods: New():ADT Insert(S:ADT, v:element):adt Delete(S:ADT, v:element):adt IsIn(S:ADT, v:element):boolean Insert and Delete manipulation operations IsIn Access method method 57

58 Other Examples Simple ADTs: Queue Deque Stack 58

59 Stacks A stack is a container of objects that are inserted and removed according to the last in first out (LIFO) principle. Objects can be inserted at any time, but only the last (the most recently inserted) object can be removed. Inserting an item is known as pushing onto the stack. Popping off the stack is synonymous with removing an item. 59

60 Stacks A PEZ dispenser as an analogy: 60

61 Stacks A stack is an ADT that supports three main methods: new():adt Creates a new stack push(s:adt, o:element):adt Inserts object o onto top of stack S pop(s:adt):adt Removes the top object of stack S; if the stack is empty an error occurs top(s:adt):element Returns the top object of the stack, without removing it; if the stack is empty an error occurs 61

62 Stacks The following support methods could also be defined: size(s:adt):integer Returns the number of objects in stack S isempty(s:adt): boolean Indicates if stack S is empty 62

63 An Array Implementation Create a stack using an array by specifying a maximum size N for our stack. The stack consists of an N element array S and an integer variable t, the index of the top element in array S. Array indices start at 0, so we initialize t to 1 63

64 An Array Implementation Pseudo code Algorithm size() return t+1 Algorithm isempty() return (t<0) Algorithm top() if isempty() then return Error return S[t] Algorithm push(o) if size()==n then return Error t=t+1 S[t]=o Algorithm pop() if isempty() then return Error S[t]=null t=t 1 64

65 An Array Implementation The array implementation is simple and efficient (methods performed in O(1)). There is an upper bound, N, on the size of the stack. The arbitrary value N may be too small for a given application, or a waste of memory. 65

66 Applications (1) Matching brackets : a sequence of left and right brackets can every left bracket be matched with a right bracket? ( ) ( ) ( ( ( ) ( ) ) ( ) ) : well formed ((() : not well formed 66

67 Applications (1) When see a ( : push When see a ) : pop Brackets well formed when? Otherwise can get errors 67

68 Applications (2) Procedure calls : 68

69 Applications (3) : time series The span s of a stock s price on a certain day i is the maximum number of consecutive days (up to i the current day) the price of the stock has been less than or equal to its price on day i 69

70 Applications (3) : time series Problem : compute the span of the stock for each day. Naïve algorithm : For each day i, scan back and find the first time price exceeds s i Worst case running time? O(n ) 2 Question : Can this be done in O(n) time? 70

71 Applications (3) : time series We see that si on day i can be easily computed if we know the closest day preceding i, such that the price is greater than on that day than the price on day i. If such a day exists, let s call it h(i), otherwise, we conventionally define h(i) = 1 The span is now computed as si = i h(i) 71

72 Applications (3) : time series Compute h(i) using a stack. On day i, the stack contains i, h(i), h(h(i)), How to update the stack?? 72

73 Applications (3) : time series Compute h(i) using a stack. On day i, the stack contains i, h(i), h(h(i)), How to update the stack?? On day i : x = top of stack while (s > s i) { x pop the stack x = top of stack } push i 73

74 Applications (3) : time series Compute h(i) using a stack. On day i, the stack contains i, h(i), h(h(i)), How to update the stack?? On day i : x = top of stack while (s > s i) { x pop the stack x = top of stack } push i Why is the running time O(n)? 74

75 Teaser Design a data structure which can do push, pop and find min on numbers. All operations in O(1) time! 75

76 Singly Linked List Nodes (data, pointer) connected in a chain by links the head or the tail of the list could serve as the top of the stack 76

77 Singly Linked List Can implement a stack with a linked list. Head = top of stack. Advantage : no limit on size of stack. 77

78 Queues A queue differs from a stack in that its insertion and removal routines follows the first in first out (FIFO) principle. Elements may be inserted at any time, but only the element which has been in the queue the longest may be removed. Elements are inserted at the rear (enqueued) and removed from the front (dequeued) Front Queue Rear 78

79 Queues The queue supports three fundamental methods: New():ADT Creates an empty queue Enqueue(S:ADT, o:element):adt Inserts object o at the rear of the queue Dequeue(S:ADT):ADT Removes the object from the front of the queue; an error occurs if the queue is empty Front(S:ADT):element Returns, but does not remove, the front element; an error occurs if the queue is empty 79

80 Queues These support methods should also be defined: Size(S:ADT):integer IsEmpty(S:ADT):boolean 80

81 An Array Implementation A maximum size N is specified. The queue consists of an N element array Q and two integer variables: f, index of the front element (head for dequeue) r, index of the element after the rear one (tail for enqueue) 81

82 An Array Implementation Enqueue? Dequeue? Empty? Full? Problems?? 82

83 An Array Implementation wrapped around configuration what does f=r mean? 83

84 An Array Implementation (3) Pseudo code Algorithm size() return (N f+r) mod N Algorithm isempty() return (f=r) Algorithm front() if isempty() then return Error return Q[f] Algorithm dequeue() if isempty() then return Error Q[f]=null f=(f+1)modn Algorithm enqueue(o) if size = N 1 then return Error Q[r]=o r=(r +1)modN 84

85 Linked List Implementation Dequeue advance head reference 85

86 Linked List Implementation Enqueue create a new node at the tail chain it and move the tail reference 86

87 Double Ended Queue A double ended queue, or deque, supports insertion and deletion from the front and back The deque supports six fundamental methods InsertFirst(S:ADT, o:element):adt Inserts e at the beginning of deque InsertLast(S:ADT, o:element):adt Inserts e at end of deque RemoveFirst(S:ADT):ADT Removes the first element RemoveLast(S:ADT):ADT Removes the last element First(S:ADT):element and Last(S:ADT):element Returns the first and the last elements 87

88 Stacks with Deques Implementing ADTs using implementations of other ADTs as building blocks Stack Method Deque Implementation size() size() isempty() isempty() top() last() push(o) insertlast(o) pop() removelast() 88

89 Queues with Deques Queue Method Deque Implementation size() size() isempty() isempty() front() first() enqueue(o) insertlast(o) dequeue() removefirst() 89

90 Doubly Linked Lists Deletions at the tail of a singly linked list cannot be done in constant time To implement a deque, we use a doubly linked list A node of a doubly linked list has a next and a prev link Then, all the methods of a deque have a constant (that is, O(1)) running time. 90

91 Doubly Linked Lists When implementing a doubly linked lists, we add two special nodes to the ends of the lists: the header and trailer nodes The header node goes before the first list element. It has a valid next link but a null prev link. The trailer node goes after the last element. It has a valid prev reference but a null next reference. The header and trailer nodes are sentinel or dummy nodes because they do not store elements 91

92

93 Circular Lists No end and no beginning of the list, only one pointer as an entry point Circular doubly linked list with a sentinel is an elegant implementation of a stack or a queue 93

94 Trees a tree represents a hierarchy examples: organization structure of a corporation, tables of contents 94

95 Other examples File system structure 95

96 Trees: Definitions A is the root node. B is the parent of D and E. A is ancestor of D and E. D and E are descendants of A. C is the sibling of B D and E are the children of B. D, E, F, G, I are leaves. 96

97 Trees: Definitions A, B, C, H are internal nodes The depth (level) of E is 2 The height of the tree is 3 The degree of node B is 2 97

98 Binary Tree Binary tree: ordered tree with all internal nodes of degree 2 98

99 Example of Binary Tree Representing arithmetic expressions 99

100 More examples Decision trees 100

101 ADT for trees isempty, number of elements parent, children, siblings is_leaf, is_root Left and right child for binary tree 101

102 Representing BinaryTrees BinaryTree: Root Parent: BinaryTree LeftChild: BinaryTree RightChild: BinaryTree 102

103 The Node Structure Each node in the tree contains key[x] key left[x] pointer to left child right[x] pt. to right child p[x] pt. to parent node 103

104 Example 104

105 How about general trees? Several possibilities : each node stores an array/list of child pointers. Use a binary tree implementation! 105

106 Binary tree implementation Root 106

107 Tree Traversals Visit every node in the tree. How do we do it in an array, list,? 107

108 Pre order traversal preorder(v) visit node v for each child w of v do recursively perform preorder(w) 108

109 Applications Reading a document from beginning to end. 109

110 Post order traversal postorder(v) for each child w of v do recursively perform postorder(w) visit node v 110

111 Applications Disk usage in unix 111

112 Applications Evaluation of arithmetic expressions 112

113 In order traversal InOrder(v) InOrder(left child of v) visit node v Inorder(right child of v) A B D C E F 113

114 Applications Printing an arithmetic expression print ( before traversing left subtree print ) after traversing right subtree 114

115 Applications Printing an arithmetic expression 115

116 Teaser Suppose the in order traversal of a binary tree is H, B, I, A, D, C, F, E, G and its post order traversal is H, I, B, D, F, G, E, C, A Can you recover the actual binary tree? 116

117 Teaser Given a tree, we want to print the nodes in ascending order of their levels, and within each level from left to right. A, B, C, D, E, F, G, H, I 117

118 Dictionary Dictionary ADT a dynamic set with methods: Search(S, k) an access operation that returns a pointer x to an element where x.key = k Insert(S, x) a manipulation operation that adds the element pointed to by x to S Delete(S, x) a manipulation operation that removes the element pointed to by x from S An element has a key part and a satellite data part 118

119 Dictionaries Dictionaries store elements so that they can be located quickly using keys A dictionary may hold bank accounts each account is an object that is identified by an account number each account stores a wealth of additional information including the current balance, the name and address of the account holder, and the history of deposits and withdrawals performed an application wishing to operate on an account would have to provide the account number as a search key 119

120 Dictionaries Supporting order (methods min, max, successor, predecessor ) is not required, thus it is enough that keys are comparable for equality 120

121 Dictionaries Different data structures to realize dictionaries arrays, linked lists (inefficient) Hash table (used in Java...) Binary trees Red/Black trees AVL trees B trees In Java: java.util.dictionary abstract class java.util.map interface 121

122 A List Based Implementation Unordered list searching takes O(n) time inserting takes O(1) time Ordered list searching takes O(n) time inserting takes O(n) time Using array would definitely improve search time. 122

123 Binary Search Narrow down the search range in stages findelement(22) 123

124 Running Time The range of candidate items to be searched is halved after comparing the key with the middle element Binary search runs in O(lg n) time. T(n) <= T(n/2) + 1 <= T(n/4) <=... T(n/2 ) + i i We also have the base case T(1) = 1 which implies that T(n) <= log n 2 124

125 Binary Search The binary search process can be represented by a tree 125

126 Binary Search Trees A binary search tree is a binary tree T such that each internal node stores an item (k,e) of a dictionary keys stored at nodes in the left subtree of v are less than or equal to k keys stored at nodes in the right subtree of v are greater than or equal to k 126

127 Examples How to print the keys in a sorted order? 127

128 Searching a BST To find an element with key k in a tree T compare k with key[root[t]] if k < key[root[t]], search for k in left[root[t]] otherwise, search for k in right[root[t]] 128

129 Pseudocode for BST Search Recursive version Search(T,k) x root[t] if x = NIL then return NIL if k = key[x] then return x if k < key[x] then return Search(left[x],k) else return Search(right[x],k) Iterative version Search(T,k) 01 x root[t] 02 while x NIL and k key[x] do 03 if k < key[x] 04 then x left[x] 05 else x right[x] 06 return x 129

130 Search Examples Search(T, 11) 130

131 Search Examples (2) Search(T, 6) 131

132 Analysis of Search Running time on tree of height h is O(h) After the insertion of n keys, the worst case running time of searching is O(n) 132

133 Analysis of Search How good or bad can the height get? In the bad case : height = n In the good case : height = log n 2 why? 133

134 BST Minimum (Maximum) Find the minimum key in a tree rooted at x (compare to a solution for heaps) TreeMinimum(x) 01 while left[x] NIL 02 do x left[x] 03 return x Running time O(h), i.e., it is proportional to the height of the tree 134

135 Successor Given x, find the node with the smallest key greater than key[x] We can distinguish two cases, depending on the right subtree of x Case 1 right subtree of x is nonempty successor is leftmost node in the right subtree (Why?) this can be done by returning TreeMinimum(right [x]) 135

136 Successor (2) Case 2 the right subtree of x is empty successor is the lowest ancestor of x whose left child is also an ancestor of x (Why?) 136

137 Successor Pseudocode TreeSuccessor(x) if right[x] NIL then return TreeMinimum(right[x]) y p[x] while y NIL and x = right[y] x y y p[y] return y For a tree of height h, the running time is O(h) 137

138 BST Insertion The basic idea is similar to searching take an element z (whose left and right children are NIL) and insert it into T find place in T where z belongs (as if searching for z), and add z there The running on a tree of height h is O(h), i.e., it is proportional to the height of the tree 138

139 BST Insertion Pseudo Code TreeInsert(T,z) y NIL x root[t] while x NIL y x if key[z] < key[x] then x left[x] else x right[x] p[z] y if y = NIL then root[t] z else if key[z] < key[y] then left[y] z else right[y] z 139

140 BST Insertion Example Insert 8 140

141 BST Insertion: Worst Case In what kind of sequence should the insertions be made to produce a BST of height n? 141

142 BST Sorting Use TreeInsert and InorderTreeWalk to sort a list of n elements, A TreeSort(A) 01 root[t] NIL 02 for i 1 to n 03 TreeInsert(T,A[i]) 04 InorderTreeWalk(root[T]) 142

143 BST Sorting (2) Sort the following numbers Build a binary search tree Call InorderTreeWalk

144 Deletion Delete node x from a tree T We can distinguish three cases x has no children x has one child x has two children 144

145 Deletion Case 1 If x has no children just remove x 145

146 Deletion Case 2 If x has exactly one child, then to delete x, simply make p[x] point to that child 146

147 Deletion Case 3 If x has two children, then to delete it we have to find its successor (or predecessor) y remove y (note that y has at most one child why?) replace x with y 147

148 Delete Pseudocode TreeDelete(T,z) 01 if left[z] = NIL or right[z] = NIL 02 then y z 03 else y TreeSuccessor(z) 04 if left[y] NIL 05 then x left[y] 06 else x right[y] 07 if x NIL 08 then p[x] p[y] 09 if p[y] = NIL 10 then root[t] x 11 else if y = left[p[y]] 12 then left[p[y]] x 13 else right[p[y]] x 14 if y z 15 then key[z] key[y] //copy all fileds of y 16 return y 148

149 Problems with BST Running time of Insert and Delete depend upon the height of the BST. But the height of a BST on n nodes can be close to n. 149

150 named after inventors Adel son Vel skii & Landis AVL Trees An AVL Tree is a binary search tree that has the height balance property: for every internal node v of T, the heights of the children of v can differ by at most 1. This assures that the height of an AVL tree storing n keys is O (log n)

151 Insertion in an AVL Tree Insertion is as in a binary search tree Always done by expanding an external node. Example: before insertion after insertion 151

152 Restoring the Height Balance Property Like a heap that requires upheaping to restore heap order property, we may have to fix the AVL tree after insertion if the height balance property is now violated Insertion changes heights of nodes on path from new unbalanced 44 nodes node w to root of tree Idea: find and fix unbalanced nodes with restructuring operation

153 Restoring the Height Balance Property Let z be the first unbalanced ancestor of the new inserted node. y is a child of z and x is a child of y. Restructure(x) 2. Let (a, b, c) be a left to right (inorder) listing of x, y, and z, and let (T0, T1, T2, T3) be an inorder listing of the 4 subtrees of x, y, and not rooted at x, y, or z 2. Replace the subtree rooted at z with a new subtree rooted at b 3. Let a be the left child of b and T0 & T1 be the left and right subtrees of a, respectively 4. Let c be the right child of b and let T2 and T3 be the left and right subtrees of c, respectively 153

154 Insertion Example, continued

155 Restructuring: Notes Restructuring after insertion is guaranteed to restore height balance property to entire tree (i.e., we just have to do it once) It s an O(1) operation But overall insertion is O(log n) because we had to do the binary search tree insertion first Similarly deletion can be done in O(log n) time. 155