Analysis and design of algorithms part2

A l i d D i f Al ithAnalysis and Design of Algorithms

Deepak JohnDepartment Of Computer Applications , SJCET-Pala

Analysis of searching and sorting. Insertion sort,Analysis of searching and sorting. Insertion sort,Quick sort, Merge sort and Heap sort. BinomialHeaps and Fibonacci Heaps, Lower bounds forsorting by comparison of keys. Comparison of sortingalgorithms. Amortized Time Analysis. Red-BlackT I ti d D l tiTrees – Insertion and Deletion.

Approachpp

Step I:Choose the criteria (for natural numbers, criteria can beascending or descending order).

Step II:Step II:How to put data in order using the criterion selected.

AnalysisAnalysis• Final ordering of data can be obtained in a variety of ways.• Some are meaningful and efficient.g• Meaningful and efficient ways depend on many aspects of an

application- type of data, randomness of data, run time constraints,i f th d t t f it i tsize of the data, nature of criteria, etc.

• To make comparisons, certain properties of sorting algorithmsshould be defined.

• Properties which are used to compare algorithms withoutdepending on the type and speed of the machines are:– number of comparisons– number of comparisons.– number of data movements.– Use of auxiliary storage.

SortinggSorting is the process of arranging a group of items

into a defined order based on particular criteriainto a defined order based on particular criteriaThere are many, different types of sorting algorithms,

but the primary ones are:1. insertion sort1. insertion sort2. Quick sort3. Merge sort 4. Heap sort.

Insertion sortInsertion sort

th iti t i t th t l t i f d b• the proper position to insert the current element is found bycomparing the current element with the elements in the sortedsub-array.which is an efficient algorithm for sorting a small

b f l tnumber of elements.

Analyzing Algorithmy g g

O t l (li 1 8) tl 1 ti ( ith l th(A))Outer loop (lines 1–8) runs exactly n − 1 times (with n = length(A))

Best case•The best case for insertion sort is when the input array is already•The best case for insertion sort is when the input array is alreadysorted, in which case the while loop never executes (but thecondition must be checked once).•tj=1, and line 6 and 7 will be executed 0 times.•T(n) = c1n + c2(n - 1) + c4(n - 1) + c5(n - 1) + c8(n - 1)

( 1 2 4 5 8) ( 2 4 5 8)= (c1 + c2 + c4 + c5 + c8)n - (c2 + c4 + c5 + c8)= an + b= Θ(n)= Θ(n)

Deepak John,Department Of IT,CE Poonjar

worst case for insertion sort is when the input array is in reversesorted order, in which case the while loop executes the maximumnumber of times.•the inner loop is executed exactly j − 1 times for every iteration of theouter loop.outer loop.

=an2+bn-c (consider only leading terms of formula, since lower orderterms are insignificant for large n Ignore the leading terms constantterms are insignificant for large n.Ignore the leading terms constantcoefficient ,since constant factors are less significant than the rate ofgrowth in determine computational efficiency of large inputs)Θ( 2)=Θ(n2)

Average case• when random data is sorted, insertion sort is usually closer to the

worst caseworst case.

• in average, tj = j/2. T(n) will still be in the order of n2, same as theworst case.

Order of GrowthThe order of a running-time function is the fastest growing term,g g g ,discarding constant factorsBest case: an + b →Θ(n)

2 2Worst case : an2 + bn - c →Θ(n2)Average case: Θ(n2)

• AdvantagegThe advantage of Insertion Sort is that it is relatively simple andeasy to implement.

• DisadvantageThe disadvantage of Insertion Sort is that it is not efficient tooperate with a large list or input sizeoperate with a large list or input size.

Quick-SortQ• Quick-sort is a randomized

ti l ith b d thsorting algorithm based on thedivide-and-conquer paradigm:

– Divide: pick a randomx

Divide: pick a randomelement x (called pivot)and partition S into xp

• L elements less than x• E elements equal x

x

L GE• G elements greater than x

– Recur: sort L and G

L GE

x

– Conquer: join L, E and G

Choice Of PivotChoice Of PivotThree ways to choose the pivot:• Median-of-Three - from the leftmost, middle, and rightmostg

elements of the list to be sorted, select the one with mediankey as the pivot

• Pi ot is rightmost element in list that is to be sorted• Pivot is rightmost element in list that is to be sorted– When sorting A[6:20], use A[20] as the pivot

• Randomly select one of the elements to be sorted as the pivotRandomly select one of the elements to be sorted as the pivot– When sorting A[6:20], generate a random number r in the

range [6, 20]– Use A[r] as the pivot

AlgorithmGiven an array of n elements (e.g.,

integers):• If array only contains one element,

return• Else• Else

– pick one element to use as pivot.– Partition elements into two sub-arrays:

• Elements less than or equal to pivot• Elements greater than pivot

– Quick sort two sub-arraysQuick sort two sub arrays– Return results

The Pseudo-Code

P titi iPartitioning

• The key to the algorithm is the PARTITION procedure, whichrearranges the sub-array in place.g y p

• Given a pivot, partition the elements of the array such that theresulting array consists of:1 One sub array that contains elements > pivot1. One sub-array that contains elements >= pivot2. Another sub-array that contains elements < pivot

• The sub-arrays are stored in the original data array.y g y

Analysisy

The running time of quick sort depends on whether the partitioning isb l d t A th t k d if lbalanced or not. Assume that keys are random, uniformlydistributed.

Best caseBest caseRecursion:

1. Partition splits array in two sub-arrays of size n/22. Quicksort each sub-array

the depth of the recursion is log2nAt each level of the recursion, the work done in all the partitions at

that level is =O(n)O(log n) * O(n) = O(n log n)O(log2n) O(n) O(n log2n)Best case running time: O(n log2n)


W tWorst case• Data is sorted already

Recursion:– Recursion:1. Partition splits array in two sub-arrays:

• one sub-array of size 0• the other sub-array of size n-1

2. Quick sort each sub-arrayRec rring on the length n 1 part req ires rec rring to depth n 1Recurring on the length n-1 part requires recurring to depth n-1

• recursion is O(n) levels deep (for an array of size n).• the partitioning work done at each level is O(n)the partitioning work done at each level is O(n).• O(n) * O(n) = O(n2)

Worst case running time: O(n2)

Average-case• If the pivot element is randomly chosen we expect the split of the

input array to be reasonably well balanced on average .• Assuming random input, average-case running time is much closer to

(n lg n) than (n2)• T(n)=O(n lgn)• T(n)=O(n lgn)

Improved Pivot Selection

Pick median value of three elements from data array : data[0],y [ ],data[n/2], and data[n-1].Use this median value as pivot.

Merge sortgMerge-sort on an input sequence S with n elements consists of threesteps:

Divide: partition S into two sequences S1 and S2 of about n/2elements eachRecur: recursively sort S1 and S2y 1 2Conquer: merge S1 and S2 into a unique sorted sequence

A L G O R I T H M S

divideA L G O R I T H M S

sortA G L O R H I M S T


mergeA G H I L M O R S T

AlgorithmMERGE-SORT (A, p, r)

1 IF p < r // Check for base case

Algorithm

1. IF p < r // Check for base case2. THEN q = (p + r)/2 // Divide step3. MERGE-SORT (A, p, q // Conquer step.4 MERGE SORT(A + 1 ) // C t4. MERGE-SORT(A, q + 1, r) // Conquer step.5. MERGE (A, p, q, r) // Conquer step.

( )1 2 3 4 5 6 7 8

p rq

MERGE(A, p, q, r)1. Compute n1 and n22 Copy the first n1 elements into

63217542

n1 n22. Copy the first n1 elements intoL[1 . . n1 + 1] and the next n2 elements into R[1 . . n2 + 1]

3. L[n1 + 1] ← �; R[n2 + 1] ← �4 i 1 j 1 p q

1 2

4. i ← 1; j ← 15. for k ← p to r6. do if L[ i ] ≤ R[ j ]

p q

7542

rq + 1

L �

6. do if L[ i ] ≤ R[ j ]7. then A[k] ← L[ i ]8. i ←i + 1

6321R �

9. else A[k] ← R[ j ]10. j ← j + 1

Analysis• For simplicity assume that n is a power of 2 so that each divide step• For simplicity, assume that n is a power of 2 so that each divide step

yields two subproblems, both of size exactly n/2.• The base case occurs when n = 1.When n > 1, time for merge sort

steps:Divide: Just compute q as the average of p and r, which takes constanttime i e Θ(1)time i.e. Θ(1).

Conquer: Recursively solve 2 sub problems, each of size n/2, which is2T(n/2).

Combine: MERGE on an n-element sub array takes Θ(n) time.• Summed together they give a function ,the recurrence for merge sort

i i irunning time isT(n) = Θ(1) if n=1

= 2T(n/2)+ Θ (n)+Θ(1) If n>1= 2T(n/2)+ Θ (n)+Θ(1). If n>1T(n)=Θ(n lg2n)

Analysis of MergeSort

O(n log n) best-, average-, and worst-case complexity because themerging is always linear

Analysis of MergeSort

g g y―Extra O(n) temporary array for merging data―Extra copying to the temporary array and backUseful only for external sorting


HeapspDefinitions of heap:

1. A balanced, left-justified binary tree in which no node has a, j yvalue greater than the value in its parent.

Example min heapY>=XZ>=X

Heap• The binary heap data structures is an array that can be

viewed as a complete binary tree. Each node of the binarytree corresponds to an element of the array. The array iscompletely filled on all levels except possibly lowest.

19

12 16

41 7

1619 1 412 7Array A 1619 1 412 7Array A

Max Heap Example Min Heap Example

19

1

12 16

4 16

41 7

127 19

1619 1 412 7

41 7

127 191641

Array A Array A

Heap Property

Heap Proceduresp

• Algorithm1. Add the new element to the next available position at the

lowest level2. Restore the max-heap property if violated

• General strategy is percolate up (or bubble up): if the parent• General strategy is percolate up (or bubble up): if the parentof the element is smaller than the element, then interchangethe parent and child.

ORORRestore the min-heap property if violated• General strategy is percolate up (or bubble up): if the parentgy p p ( p) p

of the element is larger than the element, then interchangethe parent and child.

19 19

12 16 12 16

41 7 41 7 17

19 Insert 17

12 17

swap

41 7 16

Percolate up to maintain the heap property

• Delete max– Copy the last number to the root ( overwrite the maximum

l t t d th )element stored there ).– Restore the max heap property by percolate down.

• Delete min– Copy the last number to the root ( overwrite the minimumpy (

element stored there ).– Restore the min heap property by percolate down.

Maintaining the Heap PropertyMaintaining the Heap Property

• Suppose a node is smaller than a childpp– Left and Right subtrees of i are max-

heaps• To eliminate the violation:

– Exchange with larger childMove down the tree– Move down the tree

– Continue until node is not smaller thanchildren

Maintaining the Heap Property• Assumptions:

– Left and RightAlg: MAX-HEAPIFY(A, i, n)1 l ← LEFT(i)Left and Right

subtrees of i aremax-heaps

1. l ← LEFT(i)2. r ← RIGHT(i)3. if l ≤ n and A[l] > A[i]

– A[i] may besmaller than itschildren

[ ] [ ]4. then largest ←l5. else largest ←i6. if r ≤ n and A[r] > A[largest]7. then largest ←r8 if l ≠ i8. if largest ≠ i9. then exchange A[i] ↔A[largest]10 MAX HEAPIFY(A largest n)10. MAX-HEAPIFY(A, largest, n)

ExampleMAX-HEAPIFY(A 2 10)MAX HEAPIFY(A, 2, 10)

A[2] → A[4]

A[2] violates the heap property A[4] violates the heap property

A[4] → A[9]

Heap property restored

T(n)=O(lg n )•Best Case Occurs when no swap is performed, T(n)=O(1)p p , ( ) ( )•Worst case occurs when we swap all elements

BUILD-MAX-HEAPProduces a max-heap from an unordered input array

BUILD MAX HEAP

•O(n) calls( )• Each call takes O(lg n) time for max haepify ,so O(n lg n) be thetotal time.

Heap sortThe heapsort algorithm consists of two phases:

- build a heap from an arbitrary array- use the heap to sort the datause the heap to sort the data

• To sort the elements in the decreasing order, use a min heap• To sort the elements in the increasing order, use a max heap

11

Example Heap SortLet us look at this example: we must convert the unordered arraywith n = 10 elements into a max-heapwith n 10 elements into a max heap

we start with position 10/2 = 5

We compare 3 with its child and swap them

W 17 ith it t hild d it ith thWe compare 17 with its two children and swap it with themaximum child (70)

We compare 28 with its two children, 63 and 34, and swap it withthe largest child

We compare 52 with its children, swap it with the largestRec rsing no f rther s aps are needed– Recursing, no further swaps are needed

Finally, we swap the root with its largest child, and recurse,i 46 i i h 81 d h i i h 70swapping 46 again with 81, and then again with 70

We have now converted the unsortedarray

into a max-heap:

Suppose we pop the maximum element of this heap

This leaves a gap at the back of the array:

This is the last entry in the array, so why not fill it with the largestelement?element?

Repeat this process: pop the maximum element, and then insert it atthe end of the array:

Repeat this process– Pop and append 70Pop and append 70

– Pop and append 63

We have the 4 largest elements in order– Pop and append 52


Continuing...– Pop and append 34


Finally we can pop 17 insert it into the 2nd location and theFinally, we can pop 17, insert it into the 2nd location, and theresulting array is sorted

Analysisy• The call to BuildHeap() takes O(n) time • Each of the n - 1 calls to Heapify() takes O(lg n) timep y() ( g )• Thus the total time taken by HeapSort()

= O(n) + (n - 1) O(lg n)O( ) + O( l )= O(n) + O(n lg n)

= O(n lg n)There are no best-case and worst-case scenarios for heap sortp

Binomial trees•Is an ordered tree defined recursively•Binomial tree properties:

Examples

B00

B1

B2

B2B1

B0

Bk-1

Bk-22

Bk

Binomial heaps A binomial heap is a linked list of binomial trees with the following

properties:1 The binomial trees are linked in increasing order of size1. The binomial trees are linked in increasing order of size.2. There is at most one binomial tree of each size.3. Each binomial tree has the heap structure: the value in each node is ≤

5 1h d[H]

3. Each binomial tree has the heap structure: the value in each node is ≤the values in its children.

5 1

1210

head[H]

7

2

13103

15 151210

1616

Binomial Heap ImplementationE h d h th f ll i fi ld• Each node has the following fields:

p: parentchild: leftmost childchild: leftmost childsiblingDegreegKey

•Roots of the trees are connected using linked list.•Each node x also contains the field degree[x] , which is the number ofchildren of x.

Binomial Heap Implementation

a) c)keyp

20

NIL

h d[H]

12

NIL

)keydegreechild sibling

NILhead[H] NIL

1210b)

2120NIL NIL

head[H] 1

1210

101

15 150NIL NIL

Binomial Heap OperationsBinomial Heap Operations1 Make-Heap()1. Make-Heap().2. Insert(H, x), where x is a node .3. Minimum(H).( )4. Extract-Min(H).5. Union(H1, H2): merge H1 and H2, creating a new heap.6. Decrease-Key(H, x, k): decrease x.key (x is a node in

H) to k. (It’s assumed that k � x.key.)

Make-Heap():p()•Make an empty binomial heap. Creating all of the pointers can bedone in O(1) time.

Th ti i l t i t d t it t NILThe operation simply creates a new pointer and sets it to NIL.

Binomial-Heap-Create()1 head[H] <- NIL2 return head[H]

Minimum(H):•To do this we find the smallest key among those stored at the rootsTo do this we find the smallest key among those stored at the rootsconnected to the head of H.•The minimum must be in some root in the top list.•If there are n nodes in the heap there are at most lg n roots at the top at•If there are n nodes in the heap there are at most lg n roots at the top, atmost one each of degree 0, 1, 2, . . . , lg n , so this can be found in O(lgn) time. Binomial-Heap-Minimum(H)

1 y <- NIL2 x <- head[H]3 min <- ∞4 while x is not NIL5 do if key[x] < min then6 min < key[x]6 min <- key[x]7 y <- x8 x <- sibling[x]9 return y

Find Minimum Key Example

5 1head[ 2 5 1head[ 2

a) b)

1210

15

H]7 1210

15

H]7

15 15

5 1head[ 2 5 1head[ 2

c) d)

1210

head[H]

7 1210

head[H]

7

15 15


Binomial-Link(y,z)Link binomial trees with the same degree. Note that z, the secondargument to BL(), becomes the parent, and y becomes the child.

Link(y,z)p[y] := z;ibli [ ] hild[ ]

Link(y,z)p[y] := z;ibli [ ] hild[ ]sibling[y] := child[z];

child[z] := y;degree[z] := degree[z] + 1

sibling[y] := child[z];child[z] := y;degree[z] := degree[z] + 1g [ ] g [ ]g [ ] g [ ]

y yz

z

Bk-1

Bk-1Bk-1 Bk-1

yLink


Union(H1,H2)•is the most sophisticated of the binomial heap operationsis the most sophisticated of the binomial heap operations.•It’s used in many other operations.The running time will be O(log n).g ( g )

UnionH1, H2 H1 H2

H1 = H2 =

Union traverses the new root list like this:prev-x x next-x

Union traverses the new root list like this:


Starting with the following two binomial heaps:1880602

58 19

18

93

8060

32 63

2

69

M t li t b t 2 188060

53

Merge root lists, butnow we have twotrees of same degree

53

32 63

2

69

58 19

18

93

8060

53 69

Combine trees of same28060

Combine trees of samedegree using binomiallink, make smaller keythe root of the

53

32 63

58 19

1893

the root of thecombined tree 69

Casesprev-x x next-x sibling[next-x] prev-x x next-x

a b c dp g[ ]

Bk Bl

Case 1 a b c d

p x next-x

Bk Bl

Case 1:occurs when degree[x] ≠ degree[next-x], that is, when x is theroot of a Bk-tree and next-x is the root of a Bl-tree for some l > k.k l

prev-x x next-x sibling[next-x] prev-x x next-x

a b c d

p g[ ]

BB

Case 2 a b c dprev x x

BBBBkBkBk BkBkBk

Case 2: occurs when x is the first of three roots of equal degree, that is when


is, whendegree[x] = degree[next-x] = degree[sibling[next-x]].

a b c dprev-x x next-x sibling[next-x]

Case 3 a b d

prev-x x next-x

BkBk Blkey[x] key[next[x]]

cBk

Bk

Bl

prev-x x next-x sibling[next-x] C 4

Bk+1

prev-x x next-xa b c d

prev x x next x sibling[next x]

Bk BkBl

Case 4 a

bc d

Bk Bl

prev x x next x

kkey[x] > key[next[x]]

k

Bk

Bk+1

Case 3 and 4: occur when x is the first of two roots of equal degree, that is, when

d [ ] d [ t ] ≠d [ ibli [ t ]]degree[x] = degree[next-x] ≠degree[sibling[next-x]].

Union(H1, H2)Union(H1, H2)( 1, 2)H := new heap;head[H] := merge(H1, H2); /* simple merge of root lists */if head[H] = NIL then return H fi;

( 1, 2)H := new heap;head[H] := merge(H1, H2); /* simple merge of root lists */if head[H] = NIL then return H fi;if head[H] NIL then return H fi;prev-x := NIL;x := head[H];next-x := sibling[x];

if head[H] NIL then return H fi;prev-x := NIL;x := head[H];next-x := sibling[x];next x : sibling[x];while next-x NIL do

if (degree[x] degree[next-x]) or(sibling[next-x] NIL and degree[sibling[next-x]] = degree[x]) then

next x : sibling[x];while next-x NIL do

if (degree[x] degree[next-x]) or(sibling[next-x] NIL and degree[sibling[next-x]] = degree[x]) then(sibling[next-x] NIL and degree[sibling[next-x]] = degree[x]) then

prev-x := x;x := next-x;

else

(sibling[next-x] NIL and degree[sibling[next-x]] = degree[x]) thenprev-x := x;x := next-x;

else

Cases 1,2

elseelse


if key[x] key[next-x] thenif key[x] key[next-x] thensibling[x] := sibling[next-x];

Link(next-x, x)else

if NIL th h d[H] l ibli [ ] fi

sibling[x] := sibling[next-x];Link(next-x, x)

elseif NIL th h d[H] l ibli [ ] fi

Case 3

if prev-x = NIL then head[H] := next-x else sibling[prev-x] := next-x fiLink(x, next-x);x := next-x

fi

if prev-x = NIL then head[H] := next-x else sibling[prev-x] := next-x fiLink(x, next-x);x := next-x

fi

Case 4

fifi;next-x := sibling[x]

od;

fifi;next-x := sibling[x]

od;od;return Hod;return H


Union Example12

3328

15

25

7head[H1] 18

37

3

441029

6

8

head[H2]

41

50

31 1748

32 2445

222330

55

Merge

18

37

3

4410

612

3328

15

25

7head[H]x next-x

37

50

31 1748

441029

32 24

222330

833

41

2825

50

55

32 2445

t18

37

3

441029

6

8

12

3328

15

25

7head[H]x next-x

50

31 1748

32 2445

22233041

55Case 3

37

3

441029

6

83328

15

25

7head[H]

18

12x next-x

50

31 1748

1029

32 2445

222330

841

55

3245

t

37

3

441029

6

83328

15

25

7head[H]

18

12x next-x

50

31 1748

32 2445

22233041

Case 2 55

37

3

441029

6

83328

15

25

7head[H]

18

12prev-x x next-x

50

31 1748

32 2445

22233041

55

37

3

441029

6

83328

15

25

7head[H]

18

12prev-x x next-x

50

31 1748

1029

32 2445

222330

841

Case 455

3245

37

3

441029

6

3328

15

7

head[H]

18

12prev-x x next-x

50

31 1748

441029

32 2445

222330

84125

7

55

32 2445

prev x next x

37

3

441029

6

83328

15

7

head[H]

18

12prev-x x next-x

50

31 1748

32 2445

2223304125

Case 3 55

37

3

441029

6

815 7

head[H]

18

12prev-x x next-x

50

31 1748

32 2445

222330

8

33

41

28 25

55

37

3

441029

6

815 7

head[H]

18

12prev-x x next-x

50

31 1748

32 2445

22233033

41

28 25

55Case 1

37

3

441029

6

815 7

head[H]

18

12prev-x x next-x = NIL

terminates

50

31 1748

29

32 2445

222330

8

33

41

28

5

25

Note: Union isO(l )

55

345 O(lg n).

insertInsert(H, x)

H’ := Make-B-H();Insert(H, x)

H’ := Make-B-H();();p[x] := NIL;child[x] := NIL;sibling[x] := NIL;

();p[x] := NIL;child[x] := NIL;sibling[x] := NIL;sibling[x] := NIL;degree[x] := 0;head(H’) := x;

i ( ’)

sibling[x] := NIL;degree[x] := 0;head(H’) := x;

i ( ’)H := Union(H, H’)H := Union(H, H’)


Extract Node With Minimum KeyThis operation is started by finding and removing the node x withThis operation is started by finding and removing the node x withminimum key from the binomial heap H. Create a new binomial heapH’ and set to the list of x’s children in the reverse order. Unite H and H’to get the resulting binomial heap.to get the resulting binomial heap.Pseudocode

Binomial-Heap-Extract-Min(H)1 find the root x with the minimum key in the root list of H,

and remove x from the root list of H.2 H’ <- Make-Binomial-Heap()2 H <- Make-Binomial-Heap()3 reverse the order of the linked list of x’s children,and set

head[H’] to point to the head of the resulting list.4 H <- Binomial-Heap-Union(H,H’)5 Return x

Run time: O(log n)Run time: O(log n)


Extract Minimum Key Exampley p

5 1head[H] 2

12107

2

12103

15 151210

15

5 1head[H] 2

1210

15

7 1210

15

3

1210

Deepak John,Department Of IT,CE Poonjar15

5 12 10head[H] 2 head[H’]

157 1210

15

2

151210

15

5

7

2

12102

head[H]

10

12

15

2

121015


15

Decreasing a keyThe current key is replaced with a new key To maintain the min-heapThe current key is replaced with a new key. To maintain the min-heapproperty, it is then compared to the key of the parent. If its parent’s key isgreater then the key and data will be exchanged. This process continues untilthe new key is greater than the parent’s key or the new key is in the root.y g p y yPseudocode:

Binomial-Heap-Decrease-Key(H,x,k)1 if k > key[x]1 if k > key[x]2 then error “new key is greater than current key”3 key[x] <-k4 y <-x5 z <-p[y]6 while z not NIL and key[y] < key[z]6 while z not NIL and key[y] key[z]7 do exchange key[y] <-> key[z]8 if y and z have satellite fields, exchange them, too.9 <9 y <- z10 z <- p[y]


Decreasing a keyExecution time: This procedure takes O(log n) since the maximumExecution time: This procedure takes O(log n) since the maximumdepth of x is log n.Example:p

5 2h d[H] 5 2

1210

head[H] 5 2

1210

head[H]

15 1

5 2head[H] 5 15 2

121

head[H] 5 1

122

head[H]


10 10

Delete a NodeWith assumption that there is no node in H has a key of -∞.

h k f d l i d i fi d dThe key of deleting node is first decreased to -∞.This node is then deleted using extracting min procedure.Pseudocode:

Binomial-Heap-Delete(H,x)1 Binomial-Heap-Decrease-Key(H,x,-∞)2 Binomial-Heap-Extract-Min(H)2 Binomial-Heap-Extract-Min(H)

Run time: O(log n) since the run time of both Binomial-Heap-Decrease-K d Bi i l H E t t Mi d i d f O(l )Key and Binomial-Heap-Extract-Min procedures are in order of O(log n).


Delete a Node Examplep

a) b)

5 2head[H] 5 2head[H]

a) b)

1210

15

12-∞

1515

5 -∞head[H] 5head[H]

c) d)

122

1

12 2head[H’]


15 15

e) f)

5 12 2

15

head[H] 5

12

2

15

head[H]

)

15 12 15

g)

5

2

15

head[H]

12


Fibonacci heap

•A Fibonacci heap is Set of min heap ordered trees

Fibonacci heap

•A Fibonacci heap is Set of min-heap ordered trees.•Each node x has pointed p[x] to its parent & child [x] to one of itschildren•Represent trees using left-child, right sibling pointers and circular,doubly linked list.Child li k d t th i d bl li k d i l li t•Children are linked together in a doubly-linked circular list.

•The entire heap is accessed by a pointer min [H] which points to theminimum-key rootu ey oo


min[ H ]

(a) 23 7 24

30

17

26

3

4139

303818 52 26 46

3541

min[ H ]

(b) 23 7 24

30

17

3818 52 26

3

46

4139

303818 52 26 46

35


• Potential function:

Number of marked nodes in H

Fibonacci heapNumber of trees in the rooted list of H

Number of marked nodes in H (H) = t(H) + 2m(H)

�(H) = 5 + 2�3 = 11 minHeap H trees(H) = 5 marks(H) = 3

72317 24 3

30

35

26 464118 52

3539 44marked


Fibonacci Heap Operationsp pCreateInsertInsertFind-MinUnionU oDeleteDelete-Min

•Make-Fib-Heap(H):Allocate and return the Fibonacci heap object H with n[H]=0 andmin[H]=nil, t(H)=0 , m(H)=0 so (H)=0

The cost of Make-Fib-Heap is O(1)The cost of Make-Fib-Heap is O(1).


Fibonacci Heaps: InsertInsert.

Create a new singleton tree.Add to left of min pointer.Update min pointer.

i t 21

21

insert 21

min

72317 24 3

30 26 464118 52


3539 44Heap H

min

41

723

18 52

3

30

17

26 46

24 21

39

4118 52

3544

Heap H

Insert Analysisse t a ys s

Actual cost. O(1)

Change in potential. +1

Amortized cost O(1)Amortized cost. O(1)

Fib-Heap-Insert(H x)Fib Heap Insert(H, x){ degree[x] 0

P[x] NIL[ ]child[x] NILleft[x] x ; right[x] xmark[x] FALSEconcatenate the root list containing x with root list Hif i [H] NIL k [ ] k [ i [H]]if min[H] = NIL or key[x]<key[min[H]]

then min[H] xn[H] n[H]+1n[H] n[H]+1

}

Fibonacci Heaps: UnionUnion.

Concatenate two Fibonacci heaps.Root lists are circular, doubly linked lists.

min min

717 323 24 21

39

4118 5230

35

26 46

44Heap H' Heap H''

39 44


min

717 323 24 21

4118 5230 26 46

3935

44Heap H

Actual cost. O(1)

Change in potential. 0

Amortized cost. O(1)( )

Fib-Heap-Union(H1, H2){ k ib []{ H Make-Fib-Heap[]

min[H] min[H1]concatenate the root list of H with the root list of Hconcatenate the root list of H2 with the root list of Hif (min[H1]=NIL) or (min[H2] NIL and

min[H2]<min[H1])[ 2] [ 1])then min[H] min[H2]

n[H] n[H1]+n[H2]free the objects H1 and H2

return H}


Extract min()Fib-Heap-Extract-Min(H)

{ z min[H]if z NILif z NIL

then { for each child x of zdo { add x to the root list of H

P[x] NIL }P[x] NIL }remove z from the root list of Hif z = right[z]

then min[H] NILthen min[H] NILelse min[H] right[z]

Consolidate(H)n[H] n[H] – 1n[H] n[H] – 1

}return z

}


}

Fib-Heap-Link(H, y, x){ remove y from

the root list of H;Consolidate(H) the root list of H;make y a child of x;degree[x]degree[x]+1;mark[y] FALSE;

Consolidate(H){ for i 0 to D(n[H]) do A[i]=NIL

for each node w in the root list of Hdo { x w ; d degree[x] ; mark[y] FALSE;

}do { x w ; d degree[x] ;

while A[d] NILdo { yA[d]

if key[x]>key[y] then exchange xyif key[x]>key[y] then exchange xyFib-Heap-Link(H, y, x)A[d] NIL ; d d+1 }

A[d] }A[d] x }min[H] NIL

for i 0 to D(n[H]) doif A[i] NIL h { dd A[i] h li f Hif A[i] NIL then { add A[i] to the root list of H ;

if min[H]=NIL or key[A[i]]<key[min[H]]then min[H] A[i] }


}

Fibonacci Heaps: Delete MinFibonacci Heaps: Delete Min• Delete min.

Delete min; meld its children into root list; update min– Delete min; meld its children into root list; update min.– Consolidate trees so that no two roots have same rank.

min

317237 24

39

4118 52

44

30

35

26 46

39 4435

411723 18 527 24

min

3930 26 46 44

35

min current

411723 18 527 24

3930

35

26 46 44

35

0 1 2 3rank

411723 18 527 24

currentmin

3930 26 46 44

35 0 1 2 3

411723 18 527 24

min current

39

411723 18 52

30

7

26 46

24

4430

35

26 46

0 1 2 3rank

411723 18 527 24

min

3930 26 46 44currentrank

350 1 2 3

rank

411723 18 527 24

min

3930 26 46 44current

35link 23 into 17

0 1 2 3rank

min

4117 18 527 24

392330

35

26 46 44current

35

link 17 into 7

0 1 2 3rank

0 1 2 3

current

417 18 5224min

39301726 46 44

35 23

link 24 into 7

0 1 2 3rank

mincurrent

39

417

30

18 52

1724 443930

23

17

26 46

24 44

35

rank0 1 2 3

a

417 18 52min

current

39301724 44

23

35

26 46

35

0 1 2 3rank

417 18 52min

current

39

417

30

18 52

1724 44

2326 46

35

0 1 2 3rank

417 18 52min

current

39

417

30

18 52

1724 44

2326 46

35link 41 into 18

0 1 2 3rank

7 1852min

current

3941

7

30

1852

1724

2326 46 44

35

0 1 2 3rank

min

current

7

30

52

1724 3941

18

30

23

17

26 46

24 3941

44

35

7 52min

18

301724 3941

23

35

26 46 44

stop

Fibonacci Heaps: Decrease KeyDecrease key of element x to k.

Case 0: min-heap property not violated.Case 0: min heap property not violated.•decrease key of x to k•change heap min pointer if necessary

7 18 38min

24 17 23 21 39 41

46 3026 5245


88Decrease 46 to 45.

7235

Case 1: parent of x is unmarked.d k f t k•decrease key of x to k

•cut off link between x and its parent•mark parent•mark parent•add tree rooted at x to root list, updating heap min pointer

7 18 38min

24 17 23 21 39 41

45 3026 52

Decrease 45 to 15

15



7235

7 18 38min

24 17 23 21 39 4124

15 3026 52

Decrease 45 to 15.88

ec ease 5 to 5.7235

7 18 38min

15

24 17 23 21 39 412472

3026 52


35


Case 2: parent of x is marked.•decrease key of x to k•cut off link between x and its parent p[x], and add x to root list•cut off link between p[x] and p[p[x]], add p[x] to root list

If p[p[x]] unmarked, then mark it.If p[p[x]] marked, cut off p[p[x]], unmark, and repeat.

15 7 18 38min

24 17 23 21 39 4172 24

3026 52

Decrease 35 to 535


88Decrease 35 to 5.

5

7 18 38515min

24 17 23 21 39 412472

3026 52

D 35 5

parent marked

Decrease 35 to 5.88

26 7 18 38515min

24 17 23 21 39 4188 2472

30 52

Decrease 35 to 5.parent marked


26 7 18 38515 24min

17 23 21 39 418872

30 52

Decrease 35 to 5.




Amortized Analysis techniquesy q• In amortized analysis we average the time required for a sequence

of operations over all the operations performed.• A ti d l i t t f h• Amortized analysis guarantees an average worst case for each

operation.– No involvement of probability

• The amortized cost per operation is therefore T(n)/n. The aggregate method The Accounting method The Accounting method. The potential method

Aggregate analysisAggregate analysis

– The total amount of time needed for the n operations iscomputed and divided by n.

– Treat all operations equally.– Compute the worst-case running time of a sequence of n

operationsoperations.– Divide by n to get an amortized running time.– We aggregate the cost of a series of n operations to T(n), thengg g p ( ),

each operation has the same amortized cost of T(n)/n

The Accounting methodThe Accounting method

• Principles of the accounting methodp g– 1. Associate credit accounts with different parts of the

structure– 2. Associate amortized costs with operations and show

how they credit or debit accounts• Different costs may be assigned to different operations• Different costs may be assigned to different operations.operations are assigned an amortized cost. Objects of the

data structure are assigned a credit

Accounting Method vs. Aggregate Method

• Aggregate method:gg g– first analyze entire sequence– then calculate amortized cost per operation

• Accounting method:– first assign amortized cost per operation– check that they are valid (never go into the red)– then compute cost of entire sequence of operations

The Potential method• Similar to accounting method• Similar to accounting method• Amortized costs are assigned in a more complicated way

– based on a potential functionbased on a potential function– and the current state of the data structure

• Must ensure that sum of amortized costs of all operations in thesequence is at least the sum of the actual costs of all operations in thesequence.

• Define potential function which maps any state of the data• Define potential function which maps any state of the data structure to a real number

• Notation:– D0 - initial state of data structure– Di - state of data structure after i-th operation

t l t f i th ti– ci - actual cost of i-th operation– mi - amortized cost of i-th operation

Red-Black TreesA red-black tree can also be defined as a binary search tree that satisfiesthe following properties:1.A node is either red or black.2.The root is ALWAYS black.3 All leaves are black3.All leaves are black.4.Both Children of a node that is red, are black. (no red node can havea red child).5 E h f i d d d d l f i h5.Every path from a given node down to any descendant leaf contains thesame number of black nodes. The number of black nodes on such a path(not including the initial node but including leaves) is called the black-height (bh) of the node.

The red-black tree has O(lg n) height


Red-Black Tree

■ Root Property: the root is black■ External Property: every leaf is blackp y y■ Internal Property: the children of a red node are black■ Depth Property: all the leaves have the same black depth


Rotations•Rotations are the basic tree-restructuring operation for almost allbalanced search trees.R t ti t k d bl k t d d•Rotation takes a red-black-tree and a node,

•Changes pointers to change the local structure, and Won’t violate thebinary-search-tree property.•Left rotation and right rotation are inverses.

y

Left-Rotate(T, x)x

x

y

Right-Rotate(T, y)


An example of LEFT-ROTATE(T,x)


Left and Right RotationLeft Rotate (T x)Left Rotate (T x)Left-Rotate (T, x)1. y right[x] // Set y.2. right[x] left[y] //Turn y’s left subtree into x’s right subtree.

Left-Rotate (T, x)1. y right[x] // Set y.2. right[x] left[y] //Turn y’s left subtree into x’s right subtree.3. if left[y] nil[T ]4. then p[left[y]] x5 [ ] [ ] // Li k ’ t t

3. if left[y] nil[T ]4. then p[left[y]] x5 [ ] [ ] // Li k ’ t t5. p[y] p[x] // Link x’s parent to y.6. if p[x] = nil[T ]7. then root[T ] y

5. p[y] p[x] // Link x’s parent to y.6. if p[x] = nil[T ]7. then root[T ] y

•The code for RIGHT-ROTATE is symmetric.

[ ] y8. else if x = left[p[x]]9. then left[p[x]] y10 l i h [ [ ]]

[ ] y8. else if x = left[p[x]]9. then left[p[x]] y10 l i h [ [ ]] •Both LEFT-ROTATE

and RIGHT-ROTATErun in O(1) time

10. else right[p[x]] y11. left[y] x // Put x on y’s left.12. p[x] y

10. else right[p[x]] y11. left[y] x // Put x on y’s left.12. p[x] y


run in O(1) time.12. p[x] y12. p[x] y

Ri h iRight rotation:1. x=left[y];2. left[y]=right[x];[y] g [ ];3. If(right[x]!=nil)4. then p[right[x]]=y;5 p[x]=p[y];5. p[x] p[y];6. if(p[y]==nil)7. then root=x;8 El If(l f [ [ ]] )8. Else If(left[p[y]]=y)9. then left[p[y]]=x;10. else right[p[y]]=x;g [p[y]]11. right[x]=y;12. p[y]=x;

RotationTh d d f L f R h• The pseudo-code for Left-Rotate assumes that– right[x] nil[T ], and

root’s parent is nil[T ]– root s parent is nil[T ].• Left Rotation on x, makes x the left child of y, and the left subtree

of y into the right subtree of x.• Pseudocode for Right-Rotate is symmetric: exchange left and right

everywhere.Ti O(1) f b h L f R d Ri h R i• Time: O(1) for both Left-Rotate and Right-Rotate, since a constantnumber of pointers are modified.

Operations on RB TreesOperations on RB Trees• All operations can be performed in O(lg n) time.• Insertion and Deletion are not straightforward.

When Inserting a NodegRemember:1. Insert nodes one at a time, and after every Insertionbalance the treebalance the tree.2. Every node inserted starts as a Red node.3. Consult the cases, for rebalancing the tree.

•Basic steps:1. Use Tree-Insert from BST (slightly modified) to insert a node

x into Tx into T.-Procedure RB-Insert(x).-Color the node x red.Color the node x red.

2. Fix the modified tree by re-coloring nodes and performingrotation to preserve RB tree property.


-Procedure RB-Insert-Fixup.

Red-Black fixup• y = z’s “uncle”y• Three cases:

– y is red– y is black and z is a right child– y is black and z is a left child.

Case 1 – Z’s uncle y is redC C

new zp[p[z]]

A D

y

C

A D

p[z]

B

z

A D

B

B

B

z is a right child here.Similar steps if z is a left child.

• y.Color = black• z.Parent.Color = black• z.Parent.Parent.Color = red• z = z.Parent.Parent

R fi• Repeat fixup

11

2 14

71 15

5 8

4

y

4zy.Color = blackz.Parent.Color = blackNew . a e .Co o b acz.Parent.Parent.Color = redz = z.Parent.Parent

NewNode

repeat fixup

1111

2 14

71 15

5 8 y

4z y.Color = blackz.Parent.Color = blackz.Parent.Parent.Color = redz = z.Parent.Parent

fi

NewNode

repeat fixup

11

2 142 14

71 15

5 8 yC l bl k

4zy.Color = blackz.Parent.Color = blackz Parent Parent Color = redNew z.Parent.Parent.Color redz = z.Parent.Parentrepeat fixup

NewNode

p p

1111

2 14

71 15

5 8 y

4z y.Color = blackz.Parent.Color = blackz Parent Parent Color redz.Parent.Parent.Color = redz = z.Parent.Parentrepeat fixup

NewNode

repeat fixup

1111

2 14 y

71 15z

5 8y.Color = black

4 z.Parent.Color = blackz.Parent.Parent.Color = red

P PNew z = z.Parent.Parentrepeat fixup

NewNode

Case 2 – y is black, z is a right childC C

p[z] p[z]A

z

y B y

B

A

z

• z = z.Parent• Left-Rotate(T, z)• Do Case 3

N t th t C 2 i b t f C 3• Note that Case 2 is a subset of Case 3

1111

2 14 y

71 15z

5 8 z = z.Parent

4Left-Rotate(T,z)Do Case 3

1111

2 14z y

71 15

5 8 z = z.ParentLeft-Rotate(T,z)

4( , )

Do Case 3

11

147 y

2

1

15

5

8z

1 5

44

z = z.ParentLeft-Rotate(T,z)Do Case 3

Case 3 – y is black, z is a left child

BC

p[z]

AB y

p[z]

C

z

A z

• z.Parent.Color = black• z.Parent.Parent.Color = red• Right-Rotate(T, z.Parent.Parent)

1111

147 y

2 158z

1 5

4 z.Parent.Color = blackz.Parent.Parent.Color = redRight-Rotate(T, z.Parent.Parent)

1111

147 y

2 158z

1 5

z Parent Color = black4 z.Parent.Color = blackz.Parent.Parent.Color = redRight-Rotate(T, z.Parent.Parent)Right Rotate(T, z.Parent.Parent)

11

147 y

2 158z

1 5

4 z.Parent.Color = black4z.Parent.Parent.Color = redRight-Rotate(T, z.Parent.Parent)

7

112

7

z

141 5 8 y

154

z.Parent.Color = blackz.Parent.Parent.Color = redRight-Rotate(T, z.Parent.Parent)

RB-Insert(T, z)1. y nil[T]2 x root[T]2. x root[T]3. while x nil[T]4. do y x5 if key[z] < key[x]5. if key[z] < key[x]6. then x left[x]7. else x right[x]8 [ ] 8. p[z] y9. if y = nil[T]10. then root[T] z11 l if k [ ] k [ ]11. else if key[z] < key[y]12. then left[y] z13. else right[y] z14. left[z] nil[T]15. right[z] nil[T]16 color[z] RED16. color[z] RED17. RB-Insert-Fixup (T, z)

RB-Insert-Fixup (T, z)1. while color[p[z]] = RED2 d if [ ] l ft[ [ [ ]]]2. do if p[z] = left[p[p[z]]]3. then y right[p[p[z]]]4. if color[y] = RED5. then color[p[z]] BLACK // Case 16. color[y] BLACK // Case 17. color[p[p[z]]] RED // Case 1[p[p[ ]]]8. z p[p[z]] // Case 19. else if z = right[p[z]] // color[y] RED10 then z p[z] // Case 210. then z p[z] // Case 211. LEFT-ROTATE(T, z) // Case 212. color[p[z]] BLACK // Case 313 color[p[p[z]]] RED // Case 313. color[p[p[z]]] RED // Case 314. RIGHT-ROTATE(T, p[p[z]]) // Case 315. else (if p[z] = right[p[p[z]]])(same as 10-1416 ith “ i ht” d “l ft” h d)16. with “right” and “left” exchanged)17. color[root[T ]] BLACK

Correctness

Loop invariant:• At the start of each iteration of the while loop,

– z is red.– If p[z] is the root, then p[z] is black.– There is at most one red-black violation:

• Property 2: z is a red root or• Property 2: z is a red root, or• Property 4: z and p[z] are both red.

• Termination: The loop terminates only if p[z] is black. Hence,property 4 is OK. The last line ensures property 2 always holds.p p y p p y y

• Maintenance: We drop out when z is the root (since then p[z] issentinel nil[T ], which is black). When we start the loop body, the

l i l ti i f t 4only violation is of property 4.– There are 6 cases, 3 of which are symmetric to the other 3. We

consider cases in which p[z] is a left child.p[ ]– Let y be z’s uncle (p[z]’s sibling).

Algorithm AnalysisAlgorithm Analysis• O(lg n) time to get through RB-Insert up to theO(lg n) time to get through RB Insert up to the

call of RB-Insert-Fixup.• Within RB-Insert-Fixup:• Within RB-Insert-Fixup:

– Each iteration takes O(1) time.Each iteration but the last moves up 2 levels– Each iteration but the last moves z up 2 levels.

– O(lg n) levels O(lg n) time.Th i ti i d bl k t t k O(l ) ti– Thus, insertion in a red-black tree takes O(lg n) time.

– Note: there are at most 2 rotations overall.

Deletion

• Find• Swap

– Moves entry to node with one external node (left)• Remove entry• Reattach right child

DeletionDeletion from a red black tree, is similar to deletion for a binarysearch tree, with a few exception:

•Always set the parent of a deleted node, to be the parent of oneof the deleted nodes children.•Red black fix-up method called if removed node is black.p

After a deletion of a red node (no violations occur):N bl k h i h h b ff d•No black-heights have been affected.

•No red nodes have been made adjacent (parent and child bothred).)•Deleted node is not the root since the root is black.


• After Deletion of a Black node a restore function must be called tofix red-black properties that might be violated. There are 3possible initial violations.

If d l t d d th t d hild i ht b th t– If deleted node was the root, a red child might now be the root,Violation of property 2.

– If both the parent of removed node, and a child of removedIf both the parent of removed node, and a child of removednode are red, we have a violation of property 4.

– The removal of a black node can cause the black-height of oneh b h (b 1) i l i 5path to be shorter (by 1), violating property 5.

– We correct the problem of rule 5 by adding an extra “black” tothe node passed into the fix-up procedure. This leads tothe node passed into the fix up procedure. This leads toviolations in rules 1 since this node is now neither red or black.


Delete PossibilitiesDelete Possibilities1:Delete Red node

• No problem2:Delete black node with red child

• Color red child black3:Delete black node with black child

C l hild “D bl Bl k”• Color child “Double Black”• 3 possibilities depending on neighboring nodes

X’s sibling is black with at least one red child– X s sibling is black with at least one red child– X’s sibling is black with no red children– X’s sibling is reds s b g s ed

Deletion – Fixup p• Idea: Move the extra black up the tree until x points to a red &

black node turn it into a black node,• x points to the root just remove the extra black, or• We can do certain rotations and recolorings and finish.

Withi th hil l• Within the while loop:– x always points to a nonroot doubly black node.– w is x’s siblingw is x s sibling.– w cannot be nil[T ], since that would violate property 5 at

p[x].

Case 1 – w is redp[x]

B

A D Bx w

D

E

p[ ]

A D

C E

B

A C

E

x new wC E

w

•w must have black children.•Make w black and p[x] red.•Th l ft t t [ ]•Then left rotate on p[x].•New sibling of x was a child of w before rotation must be black.Go immediately to case 2, 3, or 4.


Case 2 – w is black, both w’s children are blackp[x] black

B

A Dx w

Bnew xc

cp[x]

A D

C E

A D

C E

•Take 1 black off x ( singly black) and off w ( red)

C E

C E

•Take 1 black off x ( singly black) and off w ( red).•Move that black to p[x].•Do the next iteration with p[x] as the new xDo the next iteration with p[x] as the new x.•If entered this case from case 1, then p[x] was red new x is red &black color attribute of new x is RED loop terminates. Then newx is made black in the last line.


Case 3 – w is black, w’s left child is red, w’s right child is blackw s right child is black

Bx w

Bc

c

A D

x w

A C

D

new wx

C E

D

E

•Make w red and w’s left child black.

Make w red and w s left child black.•Then right rotate on w.•New sibling w of x is black with a red right child case 4.


Case 4 – w is black, w’s right child is redB

A D Bx w

D

E

c

A D

C E

B

A C

E

xc’C E

•Make w be p[x]’s color (c).•Make p[x] black and w’s right child black.Th l ft t t [ ]•Then left rotate on p[x].

•Remove the extra black on x ( x is now singly black) withoutviolating any red-black properties.g y p p•All done. Setting x to root causes the loop to terminate.


RB-Delete(T, z)1. if left[z] = nil[T] or right[z] = nil[T]2. then y z

RB-Delete(T, z)1. if left[z] = nil[T] or right[z] = nil[T]2. then y z3. else y TREE-SUCCESSOR(z)4. if left[y] = nil[T ]5. then x left[y]

3. else y TREE-SUCCESSOR(z)4. if left[y] = nil[T ]5. then x left[y]6. else x right[y]7. p[x] p[y] // Do this, even if x is nil[T]6. else x right[y]7. p[x] p[y] // Do this, even if x is nil[T]8. if p[y] = nil[T ]8. if p[y] = nil[T ]9. then root[T ] x10. else if y = left[p[y]]11. then left[p[y]] x

9. then root[T ] x10. else if y = left[p[y]]11. then left[p[y]] x11. then left[p[y]] x12. else right[p[y]] x13. if y = z14 then key[z] key[y]

11. then left[p[y]] x12. else right[p[y]] x13. if y = z14 then key[z] key[y]14. then key[z] key[y]15. copy y’s satellite data into z16. if color[y] = BLACK17 th RB D l t Fi (T )

14. then key[z] key[y]15. copy y’s satellite data into z16. if color[y] = BLACK17 th RB D l t Fi (T )


17. then RB-Delete-Fixup(T, x)18. return y17. then RB-Delete-Fixup(T, x)18. return y

RB D l Fi (T )RB D l Fi (T )RB-Delete-Fixup(T, x)1. while x root[T ] and color[x] = BLACK2 do if x = left[p[x]]

RB-Delete-Fixup(T, x)1. while x root[T ] and color[x] = BLACK2 do if x = left[p[x]]2. do if x = left[p[x]]3. then w right[p[x]]4. if color[w] = RED

2. do if x = left[p[x]]3. then w right[p[x]]4. if color[w] = RED[ ]5. then color[w] BLACK // Case 16. color[p[x]] RED // Case 1

[ ]5. then color[w] BLACK // Case 16. color[p[x]] RED // Case 17. LEFT-ROTATE(T, p[x]) // Case 18. w right[p[x]] // Case 17. LEFT-ROTATE(T, p[x]) // Case 18. w right[p[x]] // Case 1


/* x is still left[p[x]] */9. if color[left[w]] = BLACK and color[right[w]] = BLACK

l //

/* x is still left[p[x]] */9. if color[left[w]] = BLACK and color[right[w]] = BLACK

l //10. then color[w] RED // Case 211. x p[x] // Case 212. else if color[right[w]] = BLACK

10. then color[w] RED // Case 211. x p[x] // Case 212. else if color[right[w]] = BLACK12. else if color[right[w]] BLACK13. then color[left[w]] BLACK // Case 314. color[w] RED // Case 3

12. else if color[right[w]] BLACK13. then color[left[w]] BLACK // Case 314. color[w] RED // Case 315. RIGHT-ROTATE(T,w) // Case 316. w right[p[x]] // Case 317 color[w] color[p[x]] // Case 4

15. RIGHT-ROTATE(T,w) // Case 316. w right[p[x]] // Case 317 color[w] color[p[x]] // Case 417. color[w] color[p[x]] // Case 418. color[p[x]] BLACK // Case 419. color[right[w]] BLACK // Case 4

17. color[w] color[p[x]] // Case 418. color[p[x]] BLACK // Case 419. color[right[w]] BLACK // Case 420. LEFT-ROTATE(T, p[x]) // Case 421. x root[T ] // Case 422 else (same as then cla se ith “right” and “left” e changed)

20. LEFT-ROTATE(T, p[x]) // Case 421. x root[T ] // Case 422 else (same as then cla se ith “right” and “left” e changed)22. else (same as then clause with “right” and “left” exchanged)23. color[x] BLACK22. else (same as then clause with “right” and “left” exchanged)23. color[x] BLACK

Delete AnalysisO(lg n) time to get through RB-Delete up to the call of RB-Delete-Fixup.Within RB-Delete-Fixup:

Case 2 is the only case in which more iterations occur.x moves up 1 levelx moves up 1 level.Hence, O(lg n) iterations.

Each of cases 1, 3, and 4 has 1 rotation 3 rotations in all.Hence, O(lg n) time.


Education

Analysis and design of algorithms part2