東京大学 情報理工学系研究科 コンピュータ科学専攻 2017年2月実施 問題3

Author

kainoj, 祭音Myyura

Description

Consider the problem of sorting an array of integers using the heapsort algorithm. Assume that heapsort brings the minimum element to the front.

Answer the following questions.

(1) Heapsort consists of two phases. Explain what is to be performed in each phase.

(2) Consider sorting of the following array using heapsort.

Draw the tree structure of the heap just after the first phase.

(3) Answer the time complexity of each phase when sorting an array of length . Explain the reason.

(4) Answer the time complexity of obtaining a sorted list of the smallest elements from an array of length using heapsort. Explain the reason.

(5) The execution time of heapsort on modern computer systems is often longer than that of some other sort algorithms such as quicksort and mergesort when sorting a large array. Explain a possible reason.

Kai

(1)

• Building the heap – level-by-level, starting from the deepest level.
• Extracting minimum times. Extracting means printing the root value, replacing it with the last heap element, and then fixing heap order. If we represent the heap in an array of length , we can swap first element (minimum) with the last element, fix heap order and call recursively on first elements of array.Resulting array is sorted in descending order. Reverse it for ascending order.

(2)

Let's put elements of into a binary tree:

        3
      /    \
     8      1
   /  \    /  \
  5    4  9    7         ] proper heaps

Note that the deepest level consists of proper, one-element heaps. Let's fix the heap order on second to last deepest level:

        3
      /    \
     4      1             ] 
   /  \    /  \           ] proper heaps
  5    8  9    7          ] 

Now we have two proper heaps of height . Now, swap and to get the final answer:

        1
      /    \
     4      3
   /  \    /  \
  5    8  9    7

(3)

For simplicity, assume that , i.e. the heap the deepest level is fully occupied.

Phase 1, building the heap is when building the heap from the bottom. On the deepest level we do nothing: it consists of nodes, each of them is a proper one-element heap. On second-to-the-last level, we perform two comparisons, and possibly one swap. In general we'll perform, ceil omitted for simplicity:

Now, let's evaluate the right-hand side:

Thus, we can bound the running time as:

See Cormen's Introduction to Algorithms, 3rd ed, Chapter 6.3 for more.

Phase 2 is : for each element out of we perform extract-min, which takes .

Heapsort pseudocode:

heapsort(T[1..n])
    build-heap(T[1..n])
    for i = n..2
        swap(T[1], T[i])
        shift-down(T[1..(i-1)], 1)

(4)

. First, we build heap in , then we perform ext tract-min times.

(5)

Let's look at an example. If input array is already sorted, then mergesort will just scan through the array with no swaps. Same with partition in quicksort. On the other hand heapsort, after building a heap (), will extract minimum and replace it with the last element of array – which is maximum. The maximum will be later "bubbled" down back to the deepest level. This means two comparisons and a swap at every of iterations. This is pricey.

The other reason might be caching. In heapsort, accessing a parent might result in memory accesses which are distant more than (in particular leaves' parents). If is big, we might have a lot of cache misses.