Data structure basics - Java Implementation

• Stack & Queue Implementations

1. FixedCapacityQueue

   1. package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class FixedCapacityQueue<T> {
          private int size;
          private int head;
          private int tail;
          private T[] items;
      
          FixedCapacityQueue(int cap) {
              this.size = cap;
              this.head = this.tail = 0;
              this.items = (T[]) new Object[cap];
          }
      
          private void enqueue(T item) throws Exception {
              if ((this.tail + 1) % this.size == this.head) {
                  throw new Exception();
              }
      
              this.items[this.tail] = item;
              this.tail = (this.tail + 1) % this.size;
          }
      
          private T dequeue() throws Exception {
              if (this.head >= this.size || this.head == this.tail) {
                  throw new Exception();
              }
              T node =  this.items[this.head];
              this.head = (this.head + 1) % this.size;
              return node;
          }
      
          public static void main(String[] args) throws Exception {
              FixedCapacityQueue<String> queue = new FixedCapacityQueue<>(4);
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex"};
              for (String s :
                      tstCases) {
                  queue.enqueue(s);
              }
      
              queue.dequeue();
              queue.enqueue("Bob");
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = queue.dequeue();
              outputVerified[1] = queue.dequeue();
              outputVerified[2] = queue.dequeue();
      
              tstCases = new String[]{"Tina", "Alex", "Bob"};
      
              for (int i = 0; i < 3; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }
      

2. FixedCapacityStack

   1. package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class FixedCapacityStack<T> {
          private int size;
          private int index;
          private T[] items;
      
          FixedCapacityStack(int cap) {
              this.size = cap;
              this.index = 0;
              this.items = (T[]) new Object[cap];
          }
      
          private void push(T item) throws Exception {
              if (this.index == this.size) {
                  throw new Exception();
              }
      
              this.items[this.index++] = item;
          }
      
          private T pop() throws Exception {
              if (this.index == 0) {
                  throw new Exception();
              }
      
              return this.items[--this.index];
          }
      
          public static void main(String[] args) throws Exception {
              FixedCapacityStack<String> stack = new FixedCapacityStack<>(3);
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex"};
              for (String s :
                      tstCases) {
                  stack.push(s);
              }
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = stack.pop();
              outputVerified[1] = stack.pop();
              outputVerified[2] = stack.pop();
      
              for (int i = 0; i < 3; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[2 - i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }
      

3. ResizingArrayQueue

   1. package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      import static java.lang.Math.min;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class ResizingArrayQueue<T> {
          private int size;
          private int head;
          private int tail;
          private T[] items;
      
          ResizingArrayQueue(int cap) {
              this.size = cap;
              this.head = this.tail = 0;
              this.items = (T[]) new Object[cap];
          }
      
          private void resize(int newCapacity) {
              T[] newItems = (T[]) new Object[newCapacity];
              for (int i = 0; i < min(this.size, newCapacity); ++i) {
                  newItems[i] = this.items[i];
              }
              this.size = newCapacity;
              this.items = newItems;
          }
      
          private void enqueue(T item) throws Exception {
              if (this.tail == this.size) {
                  resize(this.size * 2);
              }
      
              this.items[this.tail++] = item;
          }
      
          private T dequeue() throws Exception {
              if (this.head >= this.size || this.head == this.tail) {
                  throw new Exception();
              }
      
              int length = this.tail - this.head;
              if (length * 4 <= this.size) {
                  for (int i = this.head; i < this.tail; ++i) {
                      this.items[i - this.head] = this.items[i];
                  }
                  resize(this.size / 2);
                  this.tail = this.tail - this.head;
                  this.head = 0;
              }
      
              return this.items[this.head++];
          }
      
          public static void main(String[] args) throws Exception {
              ResizingArrayQueue<String> queue = new ResizingArrayQueue<>(3);
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex", "Lilith", "Bob"};
              for (String s :
                      tstCases) {
                  queue.enqueue(s);
              }
      
              queue.dequeue();
              queue.dequeue();
              queue.dequeue();
              queue.dequeue();
              queue.dequeue();
      
              tstCases = new String[]{"Lydia", "Tina", "Alex", "Lilith", "Bob"};
              for (String s :
                      tstCases) {
                  queue.enqueue(s);
              }
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = queue.dequeue();
              outputVerified[1] = queue.dequeue();
              outputVerified[2] = queue.dequeue();
              outputVerified[3] = queue.dequeue();
              outputVerified[4] = queue.dequeue();
      
              for (int i = 0; i < 5; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }
      

4. ResizingArrayStack

   1. package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      import static java.lang.Math.min;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class ResizingArrayStack<T> {
          private int size;
          private int index;
          private T[] items;
      
          ResizingArrayStack(int cap) {
              this.size = cap;
              this.index = 0;
              this.items = (T[]) new Object[cap];
          }
      
          private void resize(int newCapacity) {
              T[] newItems = (T[]) new Object[newCapacity];
              for (int i = 0; i < min(this.size, newCapacity); ++i) {
                  newItems[i] = this.items[i];
              }
              this.size = newCapacity;
              this.items = newItems;
          }
      
          private void push(T item) throws Exception {
              if (this.index == this.size) {
                  resize(this.size * 2);
              }
      
              this.items[this.index++] = item;
          }
      
          private T pop() throws Exception {
              if (this.index == 0) {
                  throw new Exception();
              }
      
              if (this.index * 4 <= this.size) {
                  resize(this.size / 2);
              }
      
              return this.items[--this.index];
          }
      
          public static void main(String[] args) throws Exception {
              ResizingArrayStack<String> stack = new ResizingArrayStack<>(5);
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex", "Bob", "Lilith"};
              for (String s :
                      tstCases) {
                  stack.push(s);
              }
      
              stack.pop();
              stack.pop();
              stack.pop();
              stack.pop();
              stack.pop();
      
              tstCases = new String[]{"Lydia", "Tina", "Alex", "Bob", "Lilith"};
              for (String s :
                      tstCases) {
                  stack.push(s);
              }
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = stack.pop();
              outputVerified[1] = stack.pop();
              outputVerified[2] = stack.pop();
              outputVerified[3] = stack.pop();
              outputVerified[4] = stack.pop();
      
              for (int i = 0; i < 5; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[4 - i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }

5. LinkedListQueue
   
   

   1. package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class LinkedListQueue<T> {
          private class Node{
              private T item;
              private Node next;
      
              Node(T item, Node next) {
                  this.item = item;
                  this.next = next;
              }
          }
      
          private Node head;
          private Node tail;
      
          LinkedListQueue() {
              this.head = this.tail = null;
          }
      
          private void enqueue(T item) {
              Node newNode = new Node(item, null);
      
              if (this.tail == null) {
                  this.head = this.tail = newNode;
              } else {
                  this.tail.next = newNode;
                  this.tail = newNode;
              }
          }
      
          private T dequeue() throws Exception {
              if (this.head == null) {
                  throw new Exception();
              }
      
              Node retNode = this.head;
              this.head = this.head.next;
              return retNode.item;
          }
      
          public static void main(String[] args) throws Exception {
              LinkedListQueue<String> queue = new LinkedListQueue<>();
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex"};
              for (String s :
                      tstCases) {
                  queue.enqueue(s);
              }
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = queue.dequeue();
              outputVerified[1] = queue.dequeue();
              outputVerified[2] = queue.dequeue();
      
              for (int i = 0; i < 3; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }
      

6. LinkedListStack
   1. 　　

      package cn.edu.tsinghua.stat.mid_term;
      
      import java.util.Objects;
      
      /**
       * Created by shuaiyi on 04/11/2017.
       */
      public class LinkedListStack<T> {
          private class Node{
              private T item;
              private Node next;
      
              Node(T item, Node next) {
                  this.item = item;
                  this.next = next;
              }
          }
      
          private Node head;
      
          private void push(T item) {
              this.head = new Node(item, this.head);
          }
      
          private T pop() {
              T value = this.head.item;
              this.head = this.head.next;
              return value;
          }
      
          public static void main(String[] args) {
              LinkedListStack<String> stack = new LinkedListStack<>();
              String[] tstCases = new String[]{"Lydia", "Tina", "Alex"};
              for (String s :
                      tstCases) {
                  stack.push(s);
              }
      
              String[] outputVerified = new String[tstCases.length];
              outputVerified[0] = stack.pop();
              outputVerified[1] = stack.pop();
              outputVerified[2] = stack.pop();
      
              for (int i = 0; i < 3; ++i) {
                  if (Objects.equals(outputVerified[i], tstCases[2 - i])) {
                      System.out.println("Test " + i + "#: succeeded");
                  } else {
                      System.out.println("Test " + i + "#: failed");
                  }
              }
          }
      }

• Basic Sorting Algorithm Implementations

1. 
   

   package cn.edu.tsinghua.stat.mid_term;
   
   /**
    * Created by shuaiyi on 04/11/2017.
    */
   public class InsertionSort {
       private void swap(Comparable[] a, int i, int j) {
           Comparable tmp = a[i];
           a[i] = a[j];
           a[j] = tmp;
       }
   
       private static boolean less(Comparable v, Comparable w) {
           return v.compareTo(w) < 0;
       }
   
       private void sort(Comparable[] a) {
           for (int i = 1; i < a.length; ++i) {
               for (int j = i; j > 0 && less(a[j], a[j - 1]); --j) {
                   swap(a, j, j - 1);
               }
           }
       }
   
       public static void main(String[] args) {
           InsertionSort insertionSort = new InsertionSort();
   
           String[] a = new String[]{"54", "23", "98", "67", "12", "32", "23", "55", "98", "94"};
   
           insertionSort.sort(a);
   
           for (String item :
                   a) {
               System.out.print(item + ", ");
           }
       }
   }

2.  

3. package cn.edu.tsinghua.stat.mid_term;
   
   import static java.lang.Math.min;
   
   /**
    * Created by shuaiyi on 04/11/2017.
    */
   public class SelectionSort {
   
       private void swap(Comparable[] a, int i, int j) {
           Comparable tmp = a[i];
           a[i] = a[j];
           a[j] = tmp;
       }
   
       private void sort(Comparable[] a) {
           int i, j;
           for (i = 0; i < a.length; ++i) {
               int curMinIndex = i;
               for (j = i + 1; j < a.length; ++j) {
                   if (less(a[j], a[curMinIndex])) {
                       curMinIndex = j;
                   }
               }
   
               if (curMinIndex != i) {
                   swap(a, i, curMinIndex);
               }
           }
       }
   
       private static boolean less(Comparable v, Comparable w) {
           return v.compareTo(w) < 0;
       }
   
       public static void main(String[] args) {
           SelectionSort selectionSort = new SelectionSort();
   
           String[] a = new String[]{"54", "23", "98", "67", "12", "32", "23", "55", "98", "94"};
   
           selectionSort.sort(a);
   
           for (String item :
                   a) {
               System.out.print(item + ", ");
           }
       }
   
   }

    

4. package cn.edu.tsinghua.stat.mid_term;
   
   /**
    * Created by shuaiyi on 04/11/2017.
    */
   public class MergeSort {
   
       private Comparable[] aux;
   
       public MergeSort(int cap) {
           aux = new Comparable[cap];
       }
   
       private void swap(Comparable[] a, int i, int j) {
           Comparable tmp = a[i];
           a[i] = a[j];
           a[j] = tmp;
       }
   
       private static boolean less(Comparable v, Comparable w) {
           return v.compareTo(w) < 0;
       }
   
       private void sort(Comparable[] a) {
           sort(a, 0, a.length - 1);
       }
   
       private void sort(Comparable[] a, int low, int high) {
           if (low >= high) {
               return;
           }
           int mid = (low + high) / 2;
           sort(a, low, mid);
           sort(a, mid + 1, high);
           merge(a, low, high);
       }
   
       private void merge(Comparable[] a, int low, int high) {
           int mid = (low + high) / 2;
           int lft_index = low;
           int right_index = mid + 1;
   
           for (int k = low; k <= high; ++k) {
               this.aux[k] = a[k];
           }
   
           int flag = lft_index;
           while(lft_index <= mid && right_index <= high) {
               if (less(this.aux[lft_index], this.aux[right_index])) {
                   a[flag++] = this.aux[lft_index++];
               } else {
                   a[flag++] = this.aux[right_index++];
               }
           }
   
           while(lft_index <= mid) {
               a[flag++] = this.aux[lft_index++];
           }
   
           while(right_index <= high) {
               a[flag++] = this.aux[right_index++];
           }
       }
   
       private void officialMerge(Comparable[] a, int low, int high) {
           int mid = (low + high) / 2;
           int i = low;
           int j = mid + 1;
   
           for (int k = low; k <= high; ++k) {
               this.aux[k] = a[k];
           }
   
           for (int k = low; k <= high; ++k) {
               if (i > mid) {
                   a[k] = this.aux[j++];
               } else if (j > high) {
                   a[k] = this.aux[i++];
               } else if (less(this.aux[j], this.aux[i])) {
                   a[k] = this.aux[j++];
               } else {
                   a[k] = this.aux[i++];
               }
           }
       }
   
       public static void main(String[] args) {
   
           String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
   
           MergeSort mergeSort = new MergeSort(a.length);
   
           mergeSort.sort(a);
   
           for (String item :
                   a) {
               System.out.print(item + ", ");
           }
       }
   }

    

5. package cn.edu.tsinghua.stat.mid_term;
   
   /**
    * Created by shuaiyi on 04/11/2017.
    */
   public class QuickSort {
       private void swap(Comparable[] a, int i, int j) {
           Comparable tmp = a[i];
           a[i] = a[j];
           a[j] = tmp;
       }
   
       private static boolean less(Comparable v, Comparable w) {
           return v.compareTo(w) < 0;
       }
   
   
       private void sort(Comparable[] a) {
           sort(a, 0, a.length - 1);
       }
   
       private void sort(Comparable[] a, int lft, int rht) {
           if (lft >= rht) {
               return;
           }
           int mid = partition(a, lft, rht);
           sort(a, lft, mid);
           sort(a, mid + 1, rht);
       }
   
       private int partition(Comparable[] a, int lft, int rht) {
           int mid = (lft + rht) / 2;
           int cnt = 0;
           for (int k = lft; k <= rht; ++k) {
               if (less(a[k], a[mid])) {
                   ++cnt;
               }
           }
   
           if (cnt + lft != mid) {
               swap(a, cnt + lft, mid);
           }
   
           mid = cnt + lft;
           int less_index = lft;
           int more_index = mid + 1;
           while (less_index < mid && more_index <= rht) {
               if (less(a[less_index], a[mid])) {
                   less_index++;
               } else{
                   swap(a, less_index, more_index);
                   more_index++;
               }
           }
   
           return mid;
       }
   
       private int officalPartition(Comparable[] a, int lo, int hi) {
           int i = lo, j = hi + 1;
           Comparable v = a[lo];
           while (true) {
               while (less(a[++i], v)) if (i == hi) break;
               while (less(v, a[--j])) if (j == lo) break;
               if (i >= j) break;
               swap(a, i, j);
           }
   
           swap(a, lo, j);
           return j;
       }
   
       public static void main(String[] args) {
   
           String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
   
           QuickSort quickSort = new QuickSort();
   
           quickSort.sort(a);
   
           for (String item :
                   a) {
               System.out.print(item + ", ");
           }
       }
   }

    

6. package cn.edu.tsinghua.stat.mid_term;
   
   /**
    * Created by shuaiyi on 04/11/2017.
    */
   public class MaxPQ<T extends Comparable<T>> {
   
       private int N = 0;
       private T[] pq;
   
       MaxPQ(int cap) {
           this.pq = (T[]) new Comparable[cap + 1];
       }
   
       public void insert(T item) {
           this.pq[++N] = item;
           swim(N);
       }
   
       public T delMax() {
           T maxNode = this.pq[1];
           swap(this.pq, 1, N);
           this.pq[N] = null;
           N--;
           sink(1);
           return maxNode;
       }
   
       public void swap(Comparable[] a, int i, int j) {
           Comparable tmp = a[i];
           a[i] = a[j];
           a[j] = tmp;
       }
   
       public static boolean less(Comparable v, Comparable w) {
           return v.compareTo(w) < 0;
       }
   
       public void swim(int k) {
           while(k > 1 && less(this.pq[k / 2], this.pq[k])) {
               swap(this.pq, k/2, k);
               k /= 2;
           }
       }
   
       public void sink(int k) {
           while(k * 2 <= N) {
               int child = k * 2;
               if (child + 1 <= N && less(this.pq[child], this.pq[child + 1])) {
                   child = k * 2 + 1;
               }
               if (less(this.pq[k], this.pq[child])) {
                   swap(this.pq, k, child);
                   k = child;
               } else {
                   break;
               }
           }
       }
   
       public void officialSink(int k) {
           while(2 * k <=N) {
               int j = 2 * k;
               if (j < N && less(pq[j], pq[j + 1])) j++;
               if (!less(pq[k], pq[j])) break;
               swap(pq, k, j);
               k = j;
           }
       }
   
       public String[] sort() {
           String[] res = new String[this.N];
           int flag = 0;
           while (N > 0) {
               res[flag++] = (String)delMax();
           }
           return res;
       }
   
       public static void main(String[] args) {
   
           String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
   
           MaxPQ<String> maxPQ = new MaxPQ<>(a.length);
   
           for (String s :
                   a) {
               maxPQ.insert(s);
           }
   
           String[]b  = maxPQ.sort();
   
           for (String item :
                   b) {
               System.out.print(item + ", ");
           }
       }
   }