Question

Using Java

In this project, you are going to build a max-heap. You will use an array to implement the heap.

Your program should:

? Allow the user to select one of the following two choices (Note that your program needs to implement both choices): o

(1) test your program with 100 randomly generated integers (no duplicates, positive numbers with proper range); o

(2) test your program with the following 100 fixed values from 1, 2, 3, ..., and 100.

? Implement both methods of building a max heap: o Using sequential insertions (its time complexity: ??(??????????)). o Using the optimal (“smart”) method (its time complexity: ??(??)). For both methods, you need to keep track of how many swaps (swapping parent and child) are required to build a heap.

? For choice (1), you need to generate 20 sets of randomly generated integers; compute, the average number of swaps for both methods. Your program should output the average number of swaps for both methods (an average over 20 sets).

? For choice (2), your program should output the first 10 integers in your array and the number of swaps for both methods. Then perform 10 removals on the heap and output the first 10 integers. In your project report, you need to analyze both methods of heap implementation in terms of their efficiency theoretically and experimentally.

Answer 1

import java.util.*;

public class Project2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
Random rand = new Random();
System.out.print("Please select how to test the program:\n(1) 20 sets of 100 randomly generated integers\n(2) Fixed integer values 1-100\nEnter choice: ");
int choice = input.nextInt();
switch (choice) {
case 1: Heap heaps[] = new Heap[20];
int totSwaps = 0;

//series of insertions
for (int i = 0; i < 20; i ++) {
heaps[i] = new Heap(100);
for (int j = 0; j < 100;) {
if (heaps[i].add(rand.nextInt(2147483647) + 1)) //if it was added, meaning it wasn't a duplicate, increase the count
j++;
}
totSwaps += heaps[i].getSwaps();
}
double avgSwaps = totSwaps / 20.0;
System.out.print("\nAverage swaps for series of insertions: ");
System.out.println(avgSwaps);

//optimal method
totSwaps = 0;
for (int i = 0; i < 20; i ++) {
heaps[i] = new Heap(100);
for (int j = 0; j < 100;) {
if (heaps[i].addArbitrarily(rand.nextInt(2147483647) + 1)) //checks for duplicates
j++; //only increment if it was added, meaning no duplicates
}
heaps[i].optimize();
totSwaps += heaps[i].getSwaps();
}
avgSwaps = totSwaps / 20.0;
System.out.print("Average swaps for optimal method: ");
System.out.println(avgSwaps);
break;
  
case 2: //series of insertions
Heap heap = new Heap(100);
for (int i = 1; i <= 100; i++) {
heap.add(i);
}
System.out.print("\nHeap built using series of insertions: ");
heap.print(10);
System.out.println();
System.out.print("Number of swaps: ");
System.out.println(heap.getSwaps());
for (int i = 0; i < 10; i++) {
heap.remove();
}
System.out.print("Heap after 10 removals: ");
heap.print(10);
System.out.println();

//optimal method
heap = new Heap(100);
for (int i = 1; i <= 100; i++) {
heap.addArbitrarily(i);
}
heap.optimize();
System.out.print("\nHeap built using optimal method: ");
heap.print(10);
System.out.println();
System.out.print("Number of swaps: ");
System.out.println(heap.getSwaps());
for (int i = 0; i < 10; i++) {
heap.remove();
}
System.out.print("Heap after 10 removals: ");
heap.print(10);
System.out.println();
break;
default: System.out.print("Invalid selection.");
}
}
}

Heap.java

//A heap implemented using an array
import java.lang.Math;

public class Heap {
private final int array[];
private int end;
private int swaps;

//size must be provided to produce the array
public Heap(int size) {
array = new int[size];
end = 0; //last element + 1
swaps = 0;
}

//adds an item directly into the next slot, checking for duplicates, optimize must be called when complete
public boolean addArbitrarily(int num) {
if (duplicate(num) || end > array.length - 1)
return false;
else {
array[end] = num;
end++;
return true;
}
}

//reheaps the tree after a series of arbitrary adds
public void optimize() {
//find the bottom rung
int j = end - 1;
int level;
level = (int) Math.ceil(Math.log((double) (j + 1)) / Math.log(2.0)); //the the level of j
int i = j - 1;
int newLevel;
newLevel = (int) Math.ceil(Math.log((double) (i + 1)) / Math.log(2.0)); // the level of the previous node
while (newLevel == level) { //find the left most node on this level
i--;
newLevel = (int) Math.ceil(Math.log((double) (i + 1)) / Math.log(2.0));
} //now i to j is the last level, i - 1 is the end of the next level up
while (i != 0) {
for (int k = i; k <= j; k += 2) {
if (k + 1 > j) { //only one child
if (array[k] > array[(k - 1) / 2]) {
//swap
int temp = array[k];
array[k] = array[(k - 1) / 2];
array[(k - 1) / 2] = temp;
swaps++;
shiftDown(k);
}
}
else { //two children
if (array[k] > array[k + 1] && array[k] > array[(k - 1) / 2]) {
//swap
int temp = array[k];
array[k] = array[(k - 1) / 2];
array[(k - 1) / 2] = temp;
swaps++;
shiftDown(k);
}
else if (array[k + 1] > array[k] && array[k + 1] > array[(k - 1) / 2]) {
//swap
int temp = array[k + 1];
array[k + 1] = array[(k - 1) / 2];
array[(k - 1) / 2] = temp;
swaps++;
shiftDown(k + 1);
}
}
}
//move to the next level
j = i - 1;
i = (i - 1) / 2;
}
}
  
//helper function for optomize to move down swapped nodes
private void shiftDown(int m) {
//have to do bounds checking before accessing the array
while (m != end - 1 && ( (2 * m + 1 < end && array[m] < array[2 * m + 1]) || (2 * m + 2 < end && array[m] < array[2 * m + 2]) ) ) {
if (2 * m + 2 >= end || array[2 * m + 1] > array[2 * m + 2]) {
//swap
int temp = array[2 * m + 1];
array[2 * m + 1] = array[m];
array[m] = temp;
swaps++;
m = 2 * m + 1;
}
else {
//swap
int temp = array[2 * m + 2];
array[2 * m + 2] = array[m];
array[m] = temp;
swaps++;
m = 2 * m + 2;
}
}
}

//add with swapping
public boolean add(int num) {
if (duplicate(num) || end > array.length - 1)
return false;
int i = end;
array[i] = num;
int parent = (i - 1) / 2;
while (i != 0 && num > array[parent]) {
array[i] = array[parent]; //swap
array[parent] = num;
swaps++;
i = parent;
parent = (i - 1) / 2;
}
end++;
return true;
}

//efficient check for duplicates
public boolean duplicate(int num) {
for (int i = 0; i < end; i++) {
if (num > array[i])
return false;
else if (num == array[i])
return true;
}
return false;
}

//remove the root node and shift the new one down
public void remove() {
array[0] = array[end - 1];
int i = 0;
shiftDown(0);
end--;
}

//returns the number of swaps made by this heap
public int getSwaps() {
return swaps;
}

//prints the first n values of the array
public void print(int n) {
int i;
for (i = 0; i < n && i < end; i++) {
System.out.print(array[i]);
if (i != end- 1)
System.out.print(',');
}
if (i != end)
System.out.print("...");
}

}

/*Output*/