Question

JAVA

Submit:    HashSet.java    with the following methods added:

B.longestLinkedList an int method that returns the number of nodes in the longest linked list of this HashSet. The empty set returns zero, most small sets return one, but sets where hash code collisions are common can have long linked lists..

HashSet.java

// Implements a set of objects using a hash table.

// The hash table uses separate chaining to resolve collisions.

// Original from buildingjavaprograms.com supplements

public class HashSet<E> {

private static final double MAX_LOAD_FACTOR = 0.75;

private HashEntry<E>[] elementData;

private int size;

// Constructs an empty set.

@SuppressWarnings("unchecked")

public HashSet() {

elementData = new HashEntry[10];

size = 0;

}

// ADD METHODS HERE for exercise solutions:

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

// contained in the set.

//Method toString2()
public String toString2() {

String output = "";
String index = "";
String data[][] = new String[elementData.length][elementData.length];
int temp = 0;

if (!isEmpty()) {
  
   for (int i = 0; i < elementData.length; i++){
   for (int j = 0; j < elementData.length; j++) {
   data[i][j] = "";
   }
   }
     
   for (int i = 0; i < elementData.length; i++) {
   int j = 0;
   HashEntry <E> current = elementData[i];
   index += String.format("[" + i + "]");
     
   while (current != null) {
   data[i][j++] += current.data;
   current = current.next;
   }
     
   if (temp < j)
   temp = j;
   index += "\t";
   }

   index += "\n";
   output += index;

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

   if (!data[j][i].equals(""))
   output += data[j][i];

   else
   output += " ";
   output += "\t";
   }
   output += "\n";
   }
   }
   return output;
   }

public void add(E 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<E>(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(E value) {

int bucket = hashFunction(value);

HashEntry<E> current = elementData[bucket];

while (current != null) {

if (current.data.equals(value)) {

return true;

}

current = current.next;

}

return false;

}

// Returns true if there are no elements.

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(E value) {

int bucket = hashFunction(value);

if (elementData[bucket] != null) {

// check front of list

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

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

size--;

} else {

// check rest of list

HashEntry<E> current = elementData[bucket];

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

current = current.next;

}

// if the element is found, remove it

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

current.next = current.next.next;

size--;

}

}

}

}

// Returns the number of elements.

public int size() {

return size;

}

// Returns a string representation 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<E> 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(E value) {

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

}

private double loadFactor() {

return (double) size / elementData.length;

}

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

@SuppressWarnings("unchecked")

private void rehash() {

// replace element data array with a larger empty version

HashEntry<E>[] 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<E> current = oldElementData[i];

while (current != null) {

add((E)current.data);

current = current.next;

}

}

}

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

@SuppressWarnings("hiding")

private class HashEntry<E> {

public E data;

public HashEntry<E> next;

@SuppressWarnings("unused")

public HashEntry(E data) {

this(data, null);

}

public HashEntry(E data, HashEntry<E> next) {

this.data = data;

this.next = next;

}

}

}

Answer 1

        public int longestLinkedList() {
                int longest = 0;
                for (int i = 0; i < elementData.length; i++) {
                        
                        int count = 0;
                        HashEntry<E> start = elementData[i];
                        
                        while(start != null) {
                                count++;
                                start = start.next;
                        }
                        
                        if(count > longest) {
                                longest = count;
                        }
                        
                }
                
                return longest;
                
        }

If you have any issues, please ask in comments.. Please do not unnecessarily downvote the answer directly like you did last time.. Ask your questions in comment, and i will help surely.