Question

JAVA (advanced data structures) write a completed program using HashIntSet and HashMain

Exercises 1. Write a method in the HashIntset class called addA11 that accepts another hash set as a parameter and adds all of the elements from the other set into the current set. For example, if the set stores [-5, 3] and the method is 1, 2, passed [2, 3, 6, 44, 79], your set would store t-5, 1, 2, 3, 6, 44, 791

include the method in the main if possible. those are just the sample HashIntSet and HashMain (don't have to be the same but follow the Q requirement. thanks

HashIntSet.java

public class HashIntSet {

private static final double MAX_LOAD_FACTOR = 0.75;

private HashEntry[] elementData;

private int size;

// Constructs an empty set.

public HashIntSet() {

elementData = new HashEntry[10];

size = 0;

}

// Adds the given element to this set, if it was not already

// contained in the set.

public void add(int value) {

if (!contains(value)) {

if (loadFactor() >= MAX_LOAD_FACTOR) {

rehash();

}

// insert new value at front of list

int bucket = hashFunction(value);

elementData[bucket] = new HashEntry(value,

elementData[bucket]);

size++;

}

}

// Removes all elements from the set.

public void clear() {

for (int i = 0; i < elementData.length; i++) {

elementData[i] = null;

}

size = 0;

}

// Returns true if the given value is found in this set.

public boolean contains(int value) {

int bucket = hashFunction(value);

HashEntry current = elementData[bucket];

while (current != null) {

if (current.data == value) {

return true;

}

current = current.next;

}

return false;

}

// Returns true if there are no elements in this queue.

public boolean isEmpty() {

return size == 0;

}

// Removes the given value if it is contained in the set.

// If the set does not contain the value, has no effect.

public void remove(int value) {

int bucket = hashFunction(value);

if (elementData[bucket] != null) {

// check front of list

if (elementData[bucket].data == value) {

elementData[bucket] = elementData[bucket].next;

size--;

} else {

// check rest of list

HashEntry current = elementData[bucket];

while (current.next != null && current.next.data != value)

{

current = current.next;

}

// if the element is found, remove it

if (current.next != null && current.next.data == value) {

current.next =

current.next.next;

size--;

}

}

}

}

// Returns the number of elements in the queue.

public int size() {

return size;

}

// Returns a string representation of this queue, such as "[10, 20,

30]";

// The elements are not guaranteed to be listed in sorted order.

public String toString() {

String result = "[";

boolean first = true;

if (!isEmpty()) {

for (int i = 0; i < elementData.length; i++) {

HashEntry current = elementData[i];

while (current != null) {

if (!first) {

result += ", ";

}

result += current.data;

first = false;

current = current.next;

}

}

}

return result + "]";

}

// Returns the preferred hash bucket index for the given value.

private int hashFunction(int value) {

return Math.abs(value) % elementData.length;

}

private double loadFactor() {

return (double) size / elementData.length;

}

// Resizes the hash table to twice its former size.

private void rehash() {

// replace element data array with a larger empty version

HashEntry[] oldElementData = elementData;

elementData = new HashEntry[2 * oldElementData.length];

size = 0;

// re-add all of the old data into the new array

for (int i = 0; i < oldElementData.length; i++) {

HashEntry current = oldElementData[i];

while (current != null) {

add(current.data);

current = current.next;

}

}

}

// Represents a single value in a chain stored in one hash bucket.

private class HashEntry {

public int data;

public HashEntry next;

public HashEntry(int data) {

this(data, null);

}

public HashEntry(int data, HashEntry next) {

this.data = data;

this.next = next;

}

}

}

HashMain.java

import java.util.Arrays;

public class HashMain {

public static void main(String[] args) {

HashIntSet set = new HashIntSet();

set.add(7);

set.add(5);

set.add(1);

set.add(9);

// test adding duplicates

set.add(7);

set.add(7);

set.add(5);

// test collisions and linked lists

set.add(45);

set.add(91);

set.add(71);

// test rehashing

set.add(810); // re-hash should occur here (8/10, load = 0.8)

set.add(62);

set.add(1238);

set.add(-99);

set.add(-30);

set.add(42);

set.add(49857);

set.add(1520); // re-hash should occur here (15/20, load = 0.75)

set.add(2);

set.add(31);

set.add(11);

set.add(21);

// test removal

set.remove(7);

set.remove(9);

set.remove(1);

set.remove(1);

set.remove(21);

set.remove(71);

for (int n : new int[] {1520, 99, 2, 55, 42, 11, 45, 0, 5, -10,

810}) {

System.out.println("contains " + n + "? " +

set.contains(n));

}

System.out.println(set + ", size " + set.size());

}

}

Answer 1

//1
//place this method in HasIntSet class
void addAll(HashIntSet n)
{
   if(!n.isEmpty())//if n is not empty
   {
   for(int i=0;i<n.elementData.length;i++)  
   {
       HashEntry current = n.elementData[i];
       while(current !=null)
       {
           add(current.data);//adding element to set
           current=current.next;
       }  
   }
   }
}
//to place in main
static void addAll(HashIntSet n,HashIntSet s)//adds all elements in n to s
{
   if(!n.isEmpty())//if n is not empty
   {
   for(int i=0;i<n.elementData.length;i++)  
   {
       HashEntry current = n.elementData[i];
       while(current !=null)
       {
           s.add(current.data);//adding element to set
           current=current.next;
       }  
   }
   }
}

public static void main(String[] args) {

HashIntSet set = new HashIntSet();
HashIntSet set2 = new HashIntSet();
set2.add(7);
set2.add(11);
set.add(9);
set.add(7);

set.add(5);

set.add(1);

set.add(9);

// test adding duplicates

set.add(7);

set.add(7);

set.add(5);

// test collisions and linked lists

set.add(45);

set.add(91);

set.add(71);

// test rehashing

set.add(810); // re-hash should occur here (8/10, load = 0.8)

set.add(62);

set.add(1238);

set.add(-99);

set.add(-30);

set.add(42);

set.add(49857);

set.add(1520); // re-hash should occur here (15/20, load = 0.75)

set.add(2);

set.add(31);

set.add(11);

set.add(21);

// test removal

set.remove(7);

set.remove(9);

set.remove(1);

set.remove(1);

set.remove(21);

set.remove(71);

for (int n : new int[] {1520, 99, 2, 55, 42, 11, 45, 0, 5, -10,

810}) {

System.out.println("contains " + n + "? " +

set.contains(n));

}

System.out.println(set + ", size " + set.size());

//set2 has 7 ,11, 9

set.addAll(set2);//adding all elments of set2 to set

}