Question

Originally we stored our heap in an array. Consider instead storing our heap as a doubly linked list. (1) For a node i what are the new asymptotic run times for left(i), right(i), and parent(i)? (2) How does this affect the run times of insert(key), extractMax(), findMax()?

Answer 1

1)

                If heap is in an array, then to find left child of any index will be (root node index)*2

                To find right child of any index will be (root node index)*2 + 1

                To find parent node of any index will be (index)/2

                For all these, it will take constant time with some computation.

                But in linked list every node is pointing to it’s left side node address and right side node address and parent address.

                So to find left child and right child and parent node for any node is

                                Left child = Given node->next

                                Right child = Given node->prev

                                Parent = given node->parent

                It is also constant time but no computation like in array.

2)

                In array, Insertion will take O(log n). because we can insert the key in right position by binary search. Where in linked list, we search the key in sequential order, so it will take O(n) time

                In array, find max will take constant time (i.e O(1)). Because the first index it self is a root node, so no need to search. Where in linked list, find max will also take constant time, because the head node will point to the root node which is max in the heap.

                In array, extract max will take O(log n), after deleting max node, we need replace that position with max number in the array, so we need to search, we follow binary search which will take O(log n). where in linked list, to find max also we need search, searching is sequential. So it will take O(n).