Data structure basics - Java Implementation

Posted ALWAYS CHALLENGE MIRACLES

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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 + ", ");
            }
        }
    }
    InsertionSort
  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 + ", ");
            }
        }
    
    }
    SelectionSort

     

  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 + ", ");
            }
        }
    }
    MergeSort

     

  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 + ", ");
            }
        }
    }
    QuickSort

     

  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 + ", ");
            }
        }
    }
    MaxPQ

       




以上是关于Data structure basics - Java Implementation的主要内容,如果未能解决你的问题,请参考以下文章

hdu-5929 Basic Data Structure(双端队列+模拟)

HDU 5929 Basic Data Structure

[HDOJ5929]Basic Data Structure(双向队列,规律)

HDU 5929 Basic Data Structure(模拟 + 乱搞)题解

HDU 5929 Basic Data Structure(模拟,deque)——2016CCPC东北地区大学生程序设计竞赛 - 重现赛

HDU 5929 Basic Data Structure(模拟,deque)——2016CCPC东北地区大学生程序设计竞赛 - 重现赛