HashedArrayTree.java

package ds;

/**
 * Created by sherxon on 5/23/17.
 */

/**
 * This is the implementation of Hashed Array Tree (HAT) data structure that is the same as Dynamic
 * Array (ArrayList in Java) in terms of time complexity, however, it wastes O(SQRT(N)) extra space
 * when increasing capacity.
 *
 * Although name implies hashing, HAT does not use any hash.
 *
 * Initially, we start with base array that stores only references to leaf arrays whose size is
 * the same as base array. Every time current leaf array is full we create new leaf array and start
 * to insert data into newly created leaf array.
 *
 * When increasing capacity, we double size of base array and leaf create leaf arrays with doubles
 * size and copy entries from previous HAT. In this way, only quarter of newly created HAT is full
 * and other leaf arrays will be null.
 */
public class HashedArrayTree {

 private Object[][] data; // base array, used to store references to leaf arrays

 private int size;
 private int iPointer = -1;
 private int jPointer = 17;

 public HashedArrayTree() {
 this.data = new Object[16][]; // should be power of 2, all leaf arrays are not initialized
 }

 public void add(Integer elem) {

 ensureCapacity();

 Object[] leaf = getLeaf();

 leaf[jPointer++] = elem;

 size++;

 }

 /**
 * this method checks capacity and extend it if needed.
 * all data copied to new storage and only one empty leaf will be available to insert
 * Extra wasted space is equal to 2*SQRT(n);
 */

 private void ensureCapacity() {
 if (iPointer + 1 < data.length || jPointer < data[iPointer].length) {
 return;
 }
 int prevLength = data.length;

 Object[][] newData = new Object[prevLength * 2][];

 iPointer = prevLength / 2;

 for (int i = 0; i < iPointer; i++) {
 newData[i] = new Object[prevLength * 2];

 for (int j = 0; j < newData[i].length; j++) {
 newData[i][j] = data[i % prevLength + j / prevLength][j % prevLength];
 }
 }
 jPointer = 0;
 newData[iPointer] = new Object[prevLength * 2];
 this.data = newData;

 }

 /**
 * helper method to see capacity and number of entries in HAT
 */
 public void printStats() {
 int busy = 0;
 int cap = 0;
 for (int i = 0; i < data.length; i++) {
 if (data[i] != null) {
 for (int j = 0; j < data[i].length; j++) {
 if (data[i][j] != null) {
 busy++;
 }
 cap++;
 }
 }
 }
 System.out.println("Size: " + size + "; Capacity: " + cap + "; Busy: " + busy);
 }

 public Object get(int index) {
 if (index < 0 || index >= size) {
 throw new IndexOutOfBoundsException();
 }
 int iiPointer = index / data.length;
 int jjPointer = index % data.length;

 return data[iiPointer][jjPointer];

 }

 public int size() {
 return size;
 }

 /**
 * returns available leaf to insert data.
 * if current leaf is already full,creates new leaf and returns it
 */
 private Object[] getLeaf() {

 if (jPointer >= data.length) {
 data[++iPointer] = new Object[data.length];
 jPointer = 0;
 }
 return data[iPointer];
 }
}