# Lab 9: Validating a min heap

## Goals for this lab

By the time you have completed this lab, you should:

• understand the internal structure of a min heap
• understand how an array can be used to represent a tree
• determine whether or not items in an array are in a valid min heap order

## Lab pairing

For this lab you may work with a partner. To facilitate your submissions as a pair you MUST pair up using the submission system. When you visit the project page from where you can view all your submission you should see a link to a page where you can join a group. Of the two people in the group, one of you must invite the other, and the other must confirm the invitation. Once you group up, any submissions that either you, or your partner have already made will be visible to each other in addition to all future submissions.

## Lab preparation

After logging in, create the directory for this lab:

``````mkdir -p cs24/lab9
``````

Change into the lab directory and copy the files you will need for this lab:

``````cd cs24/lab9
cp ~bboe/public_html/cs24_f13/code/lab9/* .
``````

## Min heap

### Definition

A min heap is a tree like data structure that satisfies the min heap properties: (1) it is a complete binary tree, and (2) each node's value is smaller than or equal to the value of its children. Given these properties, the root value of the tree will always be the smallest value contained in the tree.

Note: A max heap is similar to a min heap, except each node's value is larger than or equal to the value of its children.

### Array-based implementation

The complete property of the tree makes using an array the ideal data structure for storing heaps. Thus far we have not considered using an array to represent a tree. Let's look at the following heap example to see how it's done:

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

This heap can be represented by the integer array:

``````{1, 5, 3, 7, 9, 8}
``````

Note that the order is simply the breadth-first traversal order assuming we visit the left-hand-side before the right-hand-side.

Let's assume we're looking at the element `i` in the array. With respect to the tree, at what position in the array are its children located? What about its parent?

The computation is relatively simple:

Element `i`'s left child is at position `2 * i + 1`, and its right child is at position `2 * i + 2`. Working in the other direction, element `i`'s parent can be found at position `(i - 1) / 2`. Recall that when dividing integers, the result is always rounded down (also known as the floor).

For completeness here is our array with the element values and their positions:

``````element   1 5 3 7 9 8
position  0 1 2 3 4 5
``````

Element 5, at position 1, has children at `2 * 1 + 1`, position 3, and ```2 * 1 + 2```, position 4, which correspond to values 7 and 9 respectively. Likewise its parent is `(1 - 1) / 2`, position 0, which corresponds to value 1 as expected.

## Testing for valid heaps

In this lab you will have to implement a program, `test_heap.cpp`, that takes command line arguments and checks if its arguments, as integers, satisfies the min heap property.

Your program should only produce one of two outputs, either `True\n` or `False\n`, which indicates whether or not the arguments, as integers, are given in a valid minimum heap order. The following are some example executions:

``````> ./a.out 1
True
> ./a.out 1 10 2
True
> ./a.out 2 1
False
> ./a.out 1 2 3 4 5 6 7 8 9 10
True
> ./a.out 1 2 3 4 5 6 7 8 9 1
False
``````

## Submitting the assignment

Only one person in a group need submit the assignment but make sure that both you and your partner can view the submission on the submission site. If you cannot, you need to complete the making a group process. Please review the submission instructions as needed. Note that you may resubmit this assignment as many times as necessary up until the deadline.

Template design by Andreas Viklund