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东北地区大学生程序设计竞赛 - 重现赛