Heap & HeapSort

(Supplement) Trees

1. Basic Concepts

• Tree is a nonlinear/nonsequential data structure where nodes are organized in a hierarchical way.
• Some preliminaries:

  

  • depth (level) of a node -- length of the path from the root to the node
  • height of a node -- length of the path from the node to the deepest node in the tree
  • height of a tree -- height of the root

  Definitions on the nodes in a tree

  • leaf node -- a node with no children
  • internal node -- any node in a tree that is not a leaf

---

2. Binary Trees

• Binary tree is a special kind of tree in which nodes have at most 2 children (none or left-child only or right-child or both).

  

• When a tree of height d has all nodes filled from level 0 to d-1, and the leaf nodes at the d^th level are filled from the left-most position, then the tree is called a complete binary tree. 

  

• If every node in a binary tree has either 2 children or 0, then the tree is called a full binary tree.

  
   

---

3. Mathematical Properties of binary trees

1. Number of nodes on each level i is at most 2ⁱ
   • level 0: 2⁰ = 1 ... root
   • level 1: 2¹ = 2
   • level 2: 2² = 4

   Those are upper bound numbers which hold when a tree is fully expanded (i.e., a tree of depth d is complete and all nodes at depth 0 through d-1 have two children).

2. Total number of nodes in a (general) binary tree of depth d is
   • upper bound: 2⁰ + 2¹ + 2² + .. + 2^d = 2^d+1 -1 (by geometric sequence) -- when a tree is fully expanded
   • lower bound: d + 1 -- when all internal nodes have 1 child (called a degenerate tree)

3. Depth (or height) of a binary tree with N nodes >= floor(lgN)
   • lower bound: floor(lgN) .. when a tree is fully expanded
   • upper bounf: N - 1 .. , when a tree is a degenerate tree

     e.g. floor(lg31) = 4

EXERCISES:

1. How many nodes are in a fully expanded binary tree of depth 5? Of them, how many are internal, and how many are leaf nodes?

    

2. What is the depth of a complete binary tree with 200 nodes?
    

Priority Queues (Heaps)

1. Basic concepts

• Heap is an array-based binary tree in which nodes are ordered in a special way: heap order. A heap is a complete binary tree, and quite often used as the data structure for priority queue.
• Property of heap order -- Each node in the heap has a value that is less than or equal to the values of its children (in the case of min-heap). In this ordering, the root of a tree has the minimum value.

  

• In the case of max-heap, the parent must have bigger value than either child.
• Indices (0-based) for parent and left/right children:
  • parent -- i, left child -- 2i + 1, right child --2i + 2
  • child -- j, parent -- (j-1) / 2
• Heap supports efficient processing:
  • insertion -- O(lgn)
  • deletion -- O(lgn)
  • heap construction -- O(n)
  • sort (heap sort algorithm) -- O(nlgn)

2. Heap Insertion

• A new element is added to the end of the list first (assuming the list is already a heap), always.  Then the tree is updated to restore the heap property by repeatedly swapping its value with that of its parent -- the percolateUp procedure..
• Example: Insert 8

  

EXERCISE: Assume that the array representing a min binary heap contains the values 2, 8, 3, 10, 16, 7, 18, 13. Show the contents of the array after inserting the value 4.

3. Heap Deletion

• Deletion always occurs at the root (assuming the list is already a heap) -- DeleteMin.
• After popping the root, the last element in the list is used to replace the vacated root.
• Repeatedly swap the parent with the smaller of its two children (in the case of min-heap) if the parent has a bigger value --the percolateDown procedure.
• Example: DeleteMin

  

• In the case of max-heap, swapping terminates when the parent (at some node/level) has bigger value than either child.

EXERCISE: Assume that the array representing a min binary heap contains the values 2, 8, 3, 10, 16, 7, 18, 13. Show the contents of the array after deleting the minimum element.

4. Heap Construction

• To make an unordered list to a heap, call swap-parent procedure (in heap deletion) on all internal nodes.
• To do so, start from the last internal node in the list -- the parent of the last leaf node, found at index (n - 1 - 1) / 2 = (n - 2) / 2.
• Example: heap H

  

  Steps:

  1. H[4] = 50 is greater than its child H[9] = 19, and must be swapped.
  2. H[3] = 30 is greater than its child H[8] = 4, and must be swapped.
  3. H[2] = 17 already satisfies the heap order, so no change.
  4. H[1] = 12 is greater than its child H[3] = 4, and must be swapped.
  5. H[0] = 9 is greater than its child H[1] = 4, and must be swapped.

  Final result:

  

EXERCISE: Show the array representing the min binary heap constructed using the initial values 18, 2, 13, 10, 15, 3, 7, 16, 8.

5. Heap Sort

• Sorting is done by calling DeleteMin n times and narrowing the part of heap array to be sorted.
• Efficiency: O(nlgn)
• Algorithm:

  Before processing, if a heap H is a min-heap, 
  change it to a max-heap.
  
  1. Build-Heap(H).
  2. For i = length[H]-1 downto 1
  3.   Swap(H[0], H[i]).
  4.   percDown(H, 0, i).       // range between H[0] to H[i]

EXERCISE: Given an array [17, 23, 10, 1, 7, 16, 9, 20], sort it on paper using heapsort. Write down explicitly each step.