Updated 2 solutions

Author: RodneyShag

Chp. 07 - Object-Oriented Design/_7_12_Hash_Table/Cell.java

@@ -1,36 +1,14 @@
 package _7_12_Hash_Table;
 
-public class Cell<K, V> {
- private K key;
- private V value;
+public class Cell<K, V> { // public variables for simplicity.
+ K key;
+ V value;
 
- /* Constructor */
  Cell(K k, V v) {
  key = k;
  value = v;
  }
 
- /* Setters */
- public void setKey(K k) {
- key = k;
- }
- public void setValue(V v) {
- value = v;
- }
-
- /* Getters */
- public K getKey() {
- return key;
- }
- public V getValue() {
- return value;
- }
-
- /* Functions to test equivalence */
- public boolean equivalent(Cell<K, V> cell) {
- return equivalent(cell.getKey());
- }
-
  public boolean equivalent(K k) {
  return key.equals(k);
  }

Chp. 07 - Object-Oriented Design/_7_12_Hash_Table/Hash.java

@@ -1,112 +1,87 @@
 package _7_12_Hash_Table;
 
-import java.util.ArrayList;
-import java.util.LinkedList;
-
-import __Intro_Prime.Prime;
+import java.util.*;
 
 // Hints:
 // - Create Cell<K,V> generic class
 // - Represent everything as ArrayList of LinkedLists of Cells
 
 public class Hash<K, V> {
- private int MAX_SIZE; // Initial MAX_SIZE of our ArrayList
- private ArrayList<LinkedList<Cell<K,V>>> items; // Our main data structure to hold Cells
- private int numItems; // number of items saved in our data structure
- private boolean [] primes; // will hold prime numbers as "true"
- private int primeArraySize; // size of our "boolean[] prime" array
+ int numBuckets = 3; // small to test resizing. public for testing.
+ private ArrayList<LinkedList<Cell<K, V>>> lists = new ArrayList<>(numBuckets);
+ private final double LOAD_FACTOR = 0.7;
+ private int numItems = 0;
 
- /* Constructor */
  public Hash() {
- MAX_SIZE = 3; // small to test resizing
- items = new ArrayList<>(MAX_SIZE);
- for (int i = 0; i < MAX_SIZE; i++) {
- items.add(new LinkedList<>()); // Crucial. We don't magically get LinkedLists even though we created an ArrayList of a certain size
- }
- numItems = 0;
- primeArraySize = 100;
- primes = Prime.generatePrimes(primeArraySize);
+ initializeLists(lists);
  }
 
- public Hash(int size) {
- this();
- MAX_SIZE = size;
+ private void initializeLists(ArrayList<LinkedList<Cell<K, V>>> lists) {
+ for (int i = 0; i < numBuckets; i++) {
+ lists.add(new LinkedList<>());
+ }
  }
 
- /* Bad hash function: may not distribute keys uniformly */
  public int hashCodeOfKey(K key) {
- return key.toString().length() % MAX_SIZE; // should the % be done here or elsewhere?
+ return key.hashCode() % numBuckets;
  }
 
  public void put(K key, V value) {
- /* Find the LinkedList that we should put the Cell into */
- int hashKey = hashCodeOfKey(key);
- LinkedList<Cell<K, V>> list = items.get(hashKey);
+ // Find the LinkedList that we should put the Cell into.
+ int hashCode = hashCodeOfKey(key);
+ LinkedList<Cell<K, V>> list = lists.get(hashCode);
 
+ // See if we should overwrite an old Cell.
  for (Cell<K, V> cell : list) {
- if (cell.equivalent(key)) {
- cell.setValue(value); // overwrites the old value.
+ if (cell.key == key) {
+ cell.value = value; // overwrites the old value.
  return;
  }
  }
+ 
+ // Create new Cell and add it to our LinkedList.
+ list.add(new Cell<K, V>(key, value));
  numItems++;
- if (calculateLoadFactor() > 0.7) {
- increaseSize();
+
+ // Rehash if our load factor is too high.
+ double loadFactor = (double) numItems / numBuckets;
+ if (loadFactor > LOAD_FACTOR) {
+ rehash();
  }
- list.add(new Cell<K, V>(key, value)); // create a new Cell and add it to our LinkedList
  }
 
  public V get(K key) {
- /* Find the LinkedList that may contain the value */
- int code = hashCodeOfKey(key);
- LinkedList<Cell<K, V>> list = items.get(code);
+ // Find the LinkedList that may contain the value.
+ int hashCode = hashCodeOfKey(key);
+ LinkedList<Cell<K, V>> list = lists.get(hashCode);
 
- if (list == null) {
- return null;
- }
  for (Cell<K, V> cell : list) {
- if (cell.equivalent(key)) {
- return cell.getValue();
+ if (cell.key == key) {
+ return cell.value;
  }
  }
-
- return null; // failure
+ return null; // key doesn't exist.
  }
 
- /* Used to resize array when it gets too full */
- public double calculateLoadFactor() {
- return (double) numItems / MAX_SIZE;
- }
-
- public void increaseSize() {
- int nextPrime = getNextPrime();
- if (nextPrime == -1) { // error
- return;
- }
- Hash<K, V> hashNew = new Hash<K, V>(nextPrime);
- for (LinkedList<Cell<K, V>> list : items) {
+ private void rehash() {
+ ArrayList<LinkedList<Cell<K, V>>> temp = lists;
+ numBuckets *= 2;
+ lists = new ArrayList<>(numBuckets);
+ initializeLists(lists);
+ numItems = 0;
+ for (LinkedList<Cell<K, V>> list : temp) {
  for (Cell<K, V> cell : list) {
- hashNew.put(cell.getKey(), cell.getValue());
+ put(cell.key, cell.value);
  }
  }
- MAX_SIZE = nextPrime;
- items = hashNew.items;
- }
-
- public int getNextPrime() {
- return Prime.getNextPrime(primes, 2 * MAX_SIZE);
- }
-
- public int getMaxSize() {
- return MAX_SIZE;
  }
 
  @Override
  public String toString() {
  StringBuffer result = new StringBuffer();
- for (LinkedList<Cell<K, V>> list : items) {
+ for (LinkedList<Cell<K, V>> list : lists) {
  for (Cell<K, V> cell : list) {
- result.append("key = " + cell.getKey() + " value = " + cell.getValue() + "\n");
+ result.append("key = " + cell.key + " value = " + cell.value + "\n");
  }
  }
  return result.toString();

Chp. 07 - Object-Oriented Design/_7_12_Hash_Table/Main.java

@@ -5,26 +5,27 @@ public static void main(String[] args) {
  Hash<Integer, String> map = new Hash<>();
  map.put(2, "Bob");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
 
  map.put(3, "Jenny");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
 
  map.put(6, "Alex");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
 
  map.put(7, "Jenny");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
 
  map.put(10, "Cynthia");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
 
- map.put(6, "Sam"); // Sam should overwrite Alex
+ System.out.println("** Sam should overwrite Alex **\n");
+ map.put(6, "Sam");
  System.out.print(map);
- System.out.println("Hash MAX_SIZE = " + map.getMaxSize() + "\n");
+ System.out.println("Hash numBuckets = " + map.numBuckets + "\n");
  }
 }

Chp. 17 - More Problems (Hard)/_17_05_Letters_and_Numbers/LettersAndNumbers.java

@@ -1,19 +1,53 @@
 package _17_05_Letters_and_Numbers;
 
-import java.util.Arrays;
-import java.util.HashMap;
+import java.util.*;
 
-// Algorithm:
-// 1. Count the "running" differences (between letters and numbers) at each spot in array. Save in int[]
-// 2. If 2 indices in our int[] have the same difference, that means there's an equal subarray between them
-// 3. To find the max subarray, we find the largest distance between 2 indices with equal differences
+// Algorithm
+//
+// 1. Create "deltas" array. Each value in this array will 
+// represent (number of letters) minus (number of numbers) seen so far.
+// 2. Create a HashMap<Integer, Integer>, that for each delta, 
+// it saves the first index we saw this delta in our array
+// - "key" is the "delta" calculated earlier
+// - "value" is first index of this delta in original array
+
+// Example
+// 
+// index: [ 0 1 2 3 4 5 6 7]
+// input: [ 0 0 a 0 0 0 a a]
+// deltas: [-1 -2 -1 -2 -3 -4 -3 -2]
+//
+// In our deltas array, if we encounter the same value twice, it means 
+// the number of letters and the number of numbers are equal between these indices.
+//
+// The largest valid subarray corresponds to the largest j-i where deltas[i] equals deltas[j].
+// In this case, i=1, j=7, deltas[i] == deltas[j] == -2, and j-i = 7-1 = 6.
+// This corresponds to subarray (i, j] which is [a, 0, 0, 0, a, a]
 
 public class LettersAndNumbers {
  public static char[] maxSubarray(char[] array) {
+ if (array == null) {
+ return new char[0];
+ }
  int[] deltas = findDeltas(array);
- Pair pair = findLongestMatch(deltas);
- char[] result = Arrays.copyOfRange(array, pair.left + 1, pair.right + 1);
- return result;
+
+ int startIndex = -1;
+ int endIndex = -1;
+ Map<Integer, Integer> map = new HashMap<>();
+ map.put(0, -1); // for testcases such as [a, 0], [a, 0, 0]
+ int maxLength = 0;
+ for (int i = 0; i < array.length; i++) {
+ if (!map.containsKey(deltas[i])) {
+ map.put(deltas[i], i);
+ } else {
+ if (i - map.get(deltas[i]) > maxLength) {
+ maxLength = Math.max(maxLength, i - map.get(deltas[i]));
+ startIndex = map.get(deltas[i]);
+ endIndex = i;
+ }
+ }
+ }
+ return Arrays.copyOfRange(array, startIndex + 1, endIndex + 1);
  }
 
  private static int[] findDeltas(char[] array) {
@@ -29,25 +63,7 @@ private static int[] findDeltas(char[] array) {
  }
  return deltas;
  }
-
- private static Pair findLongestMatch(int[] deltas) {
- HashMap<Integer, Integer> map = new HashMap<>();
- map.put(0, -1); // crucial
- Pair maxPair = new Pair(-1, -1);
- for (int i = 0; i < deltas.length; i++) {
- if (!map.containsKey(deltas[i])) { // we only save the first occurrence of each number we see
- map.put(deltas[i], i);
- } else {
- int leftIndex = map.get(deltas[i]);
- int rightIndex = i;
- Pair pair = new Pair(leftIndex, rightIndex);
- if (pair.getSize() > maxPair.getSize()) {
- maxPair = new Pair(pair);
- }
- }
- }
- return maxPair;
- }
 }
 
-// Time Complexity: O(n)
+// Time Complexity: O(n)
+// Space Complexity: O(n)