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. 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

  3. 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

  4. 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

  5. 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

    　　

时间： 2024-10-23 02:05:47

Data structure basics - Java Implementation的相关文章

[LeetCode] 211. Add and Search Word - Data structure design Java

题目: Design a data structure that supports the following two operations: void addWord(word) bool search(word) search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one le

How to implement an ArrayList structure in Java - Tutorial

List implementations in Java This article describes how to implement a list data structure in Java. The implementations in this articles are for demonstration and education purpose. They do not try to be as efficient as the standard libraries and the

Java for LeetCode 211 Add and Search Word - Data structure design

Design a data structure that supports the following two operations: void addWord(word)bool search(word) search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can represent any one letter.

What is “passive data structure” in Android/Java?

From the Android developer web link: http://developer.android.com/reference/android/content/Intent.html, you can find that it says "It (Intent) is basically a passive data structure holding an abstract description of an action to be performed."

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

题目链接: Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 207    Accepted Submission(s): 41 Problem Description Mr. Frog learned a basic data structure recently, which is called

HDU 5929 Basic Data Structure 模拟

Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Problem Description Mr. Frog learned a basic data structure recently, which is called stack.There are some basic operations of stack: ? PUSH x: p

[LintCode] Two Sum - Data Structure Design

Design and implement a TwoSum class. It should support the following operations: add and find. add - Add the number to an internal data structure.find - Find if there exists any pair of numbers which sum is equal to the value. Example add(1); add(3);

[LeetCode]Add and Search Word - Data structure design,解题报告

目录 目录 思路 思路 AC代码 思路 Design a data structure that supports the following two operations: void addWord(word) bool search(word) search(word) can search a literal word or a regular expression string containing only letters a-z or .. A . means it can repr

Summary: Trie Data Structure

Implement a Trie Data Structure, and search() & insert() function: we need to implement both Class Trie and Class TrieNode Class Trie: 1 import java.util.ArrayList; 2 import java.util.List; 3 4 public class Trie 5 { 6 private TrieNode root; 7 8 /** 9