diff --git a/.classpath b/.classpath deleted file mode 100644 index 18d70f02..00000000 --- a/.classpath +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..2e6c8bb4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +# Created by .ignore support plugin (hsz.mobi) +### Example user template template +### Example user template + +# IntelliJ project files +.idea +*.iml +out +gen +.html +bin/LICENSE +bin/README.md +bin/com/jwetherell/ +bin/lib/ diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 00000000..5c98b428 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,2 @@ +# Default ignored files +/workspace.xml \ No newline at end of file diff --git a/.idea/.name b/.idea/.name new file mode 100644 index 00000000..9db94d5f --- /dev/null +++ b/.idea/.name @@ -0,0 +1 @@ +JavaAlgorithmsImplementation \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 00000000..6560a989 --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,36 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 00000000..84da703c --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 00000000..6257a3e4 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 00000000..35eb1ddf --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.project b/.project deleted file mode 100644 index 3cd55b5c..00000000 --- a/.project +++ /dev/null @@ -1,17 +0,0 @@ - - - JavaAlgorithmsImplementation - - - - - - org.eclipse.jdt.core.javabuilder - - - - - - org.eclipse.jdt.core.javanature - - diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs deleted file mode 100644 index 21101703..00000000 --- a/.settings/org.eclipse.jdt.core.prefs +++ /dev/null @@ -1,12 +0,0 @@ -#Thu Dec 15 14:40:25 EST 2011 -eclipse.preferences.version=1 -org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled -org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 -org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve -org.eclipse.jdt.core.compiler.compliance=1.6 -org.eclipse.jdt.core.compiler.debug.lineNumber=generate -org.eclipse.jdt.core.compiler.debug.localVariable=generate -org.eclipse.jdt.core.compiler.debug.sourceFile=generate -org.eclipse.jdt.core.compiler.problem.assertIdentifier=error -org.eclipse.jdt.core.compiler.problem.enumIdentifier=error -org.eclipse.jdt.core.compiler.source=1.6 diff --git a/JavaAlgorithmsImplementation.iml b/JavaAlgorithmsImplementation.iml new file mode 100644 index 00000000..77779b49 --- /dev/null +++ b/JavaAlgorithmsImplementation.iml @@ -0,0 +1,54 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/README.md b/README.md index 49b9be2c..ecc6437b 100644 --- a/README.md +++ b/README.md @@ -2,3 +2,148 @@ java-algorithms-implementation ============================== Algorithms and Data Structures implemented in Java + + +This is a collection of algorithms and data structures which I've implement over the years in my academic and professional life. The code isn't overly-optimized but is written to be correct and readable. The algorithms and data structures are well tested and, unless noted, are believe to be 100% correct. + +* Created by Justin Wetherell +* Google: http://code.google.com/p/java-algorithms-implementation +* Github: http://github.com/phishman3579/java-algorithms-implementation +* LinkedIn: http://www.linkedin.com/in/phishman3579 +* E-mail: phishman3579@gmail.com +* Twitter: http://twitter.com/phishman3579 + +# What's been implemented: + +## Data Structures +* AVL Tree +* B-Tree +* Binary Heap [backed by an array or a tree] +* Binary Search Tree +* Compact Suffix Trie [backed by a Patricia Trie] +* Graph + + Undirected + + Directed (Digraph) +* Hash Array Mapped Trie (HAMT) +* Hash Map (associative array) +* Interval Tree +* KD Tree (k-dimensional tree or k-d tree) +* List [backed by an array or a linked list] +* Matrix +* Patricia Trie +* Quad-Tree (Point-Region or MX-CIF) +* Queue [backed by an array or a linked list] +* Radix Trie (associative array) [backed by a Patricia Trie] +* Red-Black Tree +* Segment Tree +* Skip List +* Splay Tree +* Stack [backed by an array or a linked list] +* Suffix Tree (Ukkonen's algorithm) +* Suffix Trie [backed by a Trie] +* Treap +* Tree Map (associative array) [backed by an AVL Tree] +* Trie +* Trie Map (associative array) [backed by a Trie] + +## Mathematics +* Distance + + chebyshev + + euclidean +* Division + + using a loop + + using recursion + + using shifts and multiplication + + using only shifts + + using logarithm +* Multiplication + + using a loop + + using recursion + + using only shifts + + using logarithms +* Primes + + is prime + + prime factorization + + sieve of eratosthenes + +## Numbers +* Integers + + to binary String + - using divide and modulus + - using right shift and modulus + - using BigDecimal + - using divide and double + + is a power of 2 + - using a loop + - using recursion + - using logarithm + - using bits + + greatest common divisor + - using Euclid's algorithm + + to English (e.g. 1 would return "one") +* Longs + + to binary String + - using divide and modulus + - using right shift and modulus + - using BigDecimal + +## Path +* Find shortest path(s) in a Graph from a starting Vertex + - Dijkstra's algorithm (non-negative weight graphs) + - Bellman-Ford algorithm (negative and positive weight graphs) +* Find minimum spanning tree + - Prim's (undirected graphs) +* Find all pairs shortest path + - Johnsons's algorithm (negative and positive weight graphs) + - Floyd-Warshall (negative and positive weight graphs) +* Cycle detection + - Depth first search while keeping track of visited Verticies +* Topological sort + +## Search +* Get index of value in array + + Linear + + Quickselect + + Binary [sorted array input only] + + Optimized binary (binary until a threashold then linear) [sorted array input only] + + Interpolation [sorted array input only] + +## Sequences +* Find longest common subsequence (dynamic programming) +* Find number of times a subsequence occurs in a sequence (dynamic programming) +* Find i-th element in a Fibonacci sequence + + using a loop + + using recursion + + using matrix multiplication + + using Binet's formula +* Find total of all elements in a sequence + + using a loop + + using Triangular numbers + +## Sorts +* American Flag Sort +* Bubble Sort +* Counting Sort (Integers only) +* Heap Sort +* Insertion Sort +* Merge Sort +* Quick Sort +* Radix Sort (Integers only) +* Shell's Sort + +## String Functions +* Reverse characters in a string + + using additional storage (a String or StringBuilder) + + using in-place swaps + + using in-place XOR +* Reverse words in a string + + using char swaps and additional storage (a StringBuilder) + + using StringTokenizer and additional (a String) + + using split() method and additional storage (a StringBuilder and String[]) + + using in-place swaps +* Is Palindrome + + using additional storage (a StringBuilder) + + using in-place symetric element compares +* Subsets of characters in a String +* Edit (Levenshtein) Distance of two Strings + diff --git a/Test Results - Sorts_testInsertionSorts.html b/Test Results - Sorts_testInsertionSorts.html new file mode 100644 index 00000000..3f6d761a --- /dev/null +++ b/Test Results - Sorts_testInsertionSorts.html @@ -0,0 +1,614 @@ + + + + + Test Results — Sorts.testInsertionSorts + + + + + + + + + +
+ +
+ +
+
+ + + diff --git a/bin/com/gw/myalgo/HelloAlgo.class b/bin/com/gw/myalgo/HelloAlgo.class new file mode 100644 index 00000000..9e65f28d Binary files /dev/null and b/bin/com/gw/myalgo/HelloAlgo.class differ diff --git a/lib/apiguardian-api-1.0.0.jar b/lib/apiguardian-api-1.0.0.jar new file mode 100644 index 00000000..6cbff70f Binary files /dev/null and b/lib/apiguardian-api-1.0.0.jar differ diff --git a/lib/commons-lang3-3.9.jar b/lib/commons-lang3-3.9.jar new file mode 100644 index 00000000..0d896939 Binary files /dev/null and b/lib/commons-lang3-3.9.jar differ diff --git a/lib/junit-4.11.jar b/lib/junit-4.11.jar new file mode 100644 index 00000000..aaf74448 Binary files /dev/null and b/lib/junit-4.11.jar differ diff --git a/lib/junit-jupiter-5.4.2.jar b/lib/junit-jupiter-5.4.2.jar new file mode 100644 index 00000000..b3bf6976 Binary files /dev/null and b/lib/junit-jupiter-5.4.2.jar differ diff --git a/lib/junit-jupiter-api-5.4.2.jar b/lib/junit-jupiter-api-5.4.2.jar new file mode 100644 index 00000000..40828b7a Binary files /dev/null and b/lib/junit-jupiter-api-5.4.2.jar differ diff --git a/lib/junit-jupiter-engine-5.4.2.jar b/lib/junit-jupiter-engine-5.4.2.jar new file mode 100644 index 00000000..3444a980 Binary files /dev/null and b/lib/junit-jupiter-engine-5.4.2.jar differ diff --git a/lib/junit-jupiter-params-5.4.2.jar b/lib/junit-jupiter-params-5.4.2.jar new file mode 100644 index 00000000..ee565041 Binary files /dev/null and b/lib/junit-jupiter-params-5.4.2.jar differ diff --git a/lib/junit-platform-commons-1.4.2.jar b/lib/junit-platform-commons-1.4.2.jar new file mode 100644 index 00000000..27055251 Binary files /dev/null and b/lib/junit-platform-commons-1.4.2.jar differ diff --git a/lib/junit-platform-engine-1.4.2.jar b/lib/junit-platform-engine-1.4.2.jar new file mode 100644 index 00000000..2c46ae92 Binary files /dev/null and b/lib/junit-platform-engine-1.4.2.jar differ diff --git a/lib/opentest4j-1.1.1.jar b/lib/opentest4j-1.1.1.jar new file mode 100644 index 00000000..3f355292 Binary files /dev/null and b/lib/opentest4j-1.1.1.jar differ diff --git a/src/com/gw/myalgo/HelloAlgo.java b/src/com/gw/myalgo/HelloAlgo.java new file mode 100644 index 00000000..ea2a9aa4 --- /dev/null +++ b/src/com/gw/myalgo/HelloAlgo.java @@ -0,0 +1,7 @@ +package com.gw.myalgo; + +public class HelloAlgo { + public static void main(String[] args) { + System.out.println("Hello, idea algo"); + } +} diff --git a/src/com/gw/myalgo/datastructure/SingleLinkedList.java b/src/com/gw/myalgo/datastructure/SingleLinkedList.java new file mode 100644 index 00000000..ca6222ea --- /dev/null +++ b/src/com/gw/myalgo/datastructure/SingleLinkedList.java @@ -0,0 +1,437 @@ +package com.gw.myalgo.datastructure; + +import java.security.Principal; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.ListIterator; + +/** + * Single Linked list + * @author hsden + */ +public class SingleLinkedList implements List { + + /** + * size of the linked list, the default size is 0 + */ + private transient int size = 0; + + /** + * head node of the linked list + */ + private Node headNode; + + /** + * tail node of the linked list + */ + private Node tailNode; + + public SingleLinkedList(){ + + } + + public SingleLinkedList(E firstItem) { + Node firstNode = new Node(firstItem,null); + this.headNode = firstNode; + this.tailNode = firstNode; + this.size += 1; + } + + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return false; + } + + @Override + public boolean contains(Object o) { + return false; + } + + @Override + public Iterator iterator() { + return null; + } + + @Override + public Object[] toArray() { + return new Object[0]; + } + + @Override + public T[] toArray(T[] a) { + return null; + } + + @Override + public boolean add(E e) { + boolean result = false; + if(null == e){ + return result; + } else { + Node newNode = new Node(e,null); + if(size == 0){ + this.headNode = newNode; + this.tailNode = newNode; + } else { + this.tailNode.next = newNode; + this.tailNode =newNode; + } + + this.size += 1; + } + + + return result; + } + + @Override + public boolean remove(Object o) { + return false; + } + + @Override + public boolean containsAll(Collection c) { + return false; + } + + @Override + public boolean addAll(Collection c) { + return false; + } + + @Override + public boolean addAll(int index, Collection c) { + return false; + } + + @Override + public boolean removeAll(Collection c) { + return false; + } + + @Override + public boolean retainAll(Collection c) { + return false; + } + + @Override + public void clear() { + + } + + @Override + public E get(int index) { + return null; + } + + @Override + public E set(int index, E element) { + return null; + } + + @Override + public void add(int index, E element) { + + } + + @Override + public E remove(int index) { + return null; + } + + @Override + public int indexOf(Object o) { + return 0; + } + + @Override + public int lastIndexOf(Object o) { + return 0; + } + + @Override + public ListIterator listIterator() { + return null; + } + + @Override + public ListIterator listIterator(int index) { + return null; + } + + @Override + public List subList(int fromIndex, int toIndex) { + return null; + } + + + /** + * 正序打印List + */ + public void printList() { + if(this.size > 0) { + Node tmpNode = this.headNode; + + while(null != tmpNode) { + System.out.print(tmpNode.item + " "); + tmpNode = tmpNode.next; + } + System.out.println(); + } + } + + /** + * 倒序打印列表， 递归实现 + */ + public void printListByRecursion() { + if(this.size <= 0) { + return; + } + + printRecursion(this.headNode); + System.out.println(); + } + + public void printRecursion(Node head) { + if(null == head) { + return; + } + + if(head.next != null) { + printRecursion(head.next); + } + + System.out.print(head.item + " "); + + } + + + /** + * reverse the list + * head->1->2->3->4->6->7，after reverse + * head->7->6->5->4->3->2->1 + */ + public void simpleReverseList() { + if(this.size <= 1) { + return; + } + + Node newTailNode = headNode, tempHeadNextNode, tempTailNextNode; + while(newTailNode.next != null){ + newTailNode = newTailNode.next; + } + + while(headNode != newTailNode) { + tempHeadNextNode = headNode.next; + + tempTailNextNode = newTailNode.next; + newTailNode.next = headNode; + newTailNode.next.next = tempTailNextNode; + headNode = tempHeadNextNode; + } + } + + /** + * reverse the list 就地逆序,需要记忆pre + * head->1->2->3->4->6->7，after reverse + * head->7->6->5->4->3->2->1 + */ + public void localReverseList() { + if(size <= 1) { + return; + } + + Node cur = headNode.next, pre = headNode, next; + pre.next = null; + while(cur!= null) { + next = cur.next; + + headNode = cur; + cur.next = pre; + pre = cur; + cur = next; + } + + } + + /** + * reverse the list by recursion 递归逆序 + * head->1->2->3->4->6->7，after reverse + * head->7->6->5->4->3->2->1 + */ + public Node recurseReverse(Node head) { + Node newHead; + if(null != head && head.next != null) { + newHead = recurseReverse(head.next); + + head.next.next = head; + head.next = null; + + } else { + newHead = head; + } + + return newHead; + } + + + public void recurseReverseList() { + if(this.size <= 1) { + return; + } + + headNode =recurseReverse(headNode); + } + + + /** + * reverse the list 插入逆序，每次插入最前面 + * head->1->2->3->4->6->7，after reverse + * head->7->6->5->4->3->2->1 + */ + public void insertReverseList() { + if(this.size <= 1) { + return; + } + + Node cur = headNode.next, next; + headNode.next = null; + while(cur != null) { + next = cur.next; + + cur.next = headNode; + headNode = cur; + cur = next; + } + } + + /** + * 给定一个没有排序的链表，去掉其重复项 ， 并保留原顺序， + * 例如链表 1->3->1->5->5->7, + * 去掉重复项后变为 1->3->5->7 + */ + public void removeRepeatItemFromUnorderedListM1(){ + if(this.size <= 1) { + return; + } + + Node cur = headNode.next, innerCur, pre = headNode; + while(null != cur) { + E curItem = cur.item; + + innerCur = headNode; + while(null != innerCur && cur != innerCur) { + if(innerCur.item.equals(curItem)) { + break; + } else { + innerCur = innerCur.next; + } + } + + if(innerCur != null && cur != innerCur && innerCur.item.equals(cur.item)) { + pre.next = cur.next; + cur = cur.next; + } else { + pre = cur; + cur = cur.next; + } + } + + } + + + /** + * 给定一个没有排序的链表，去掉其重复项 ， 并保留原顺序， + * 例如链表 1->3->1->5->5->7, + * 去掉重复项后变为 1->3->5->7 + * + * 递归法 + */ + public void removeRepeatItemFromUnorderedListM2(){ + if(size <= 1) { + return; + } + + removeRepeatItemByRecursion(this.headNode); + } + + public void removeRepeatItemByRecursion(Node node) { + if(null == node || null == node.next ) { + return; + } else { + removeRepeatItemByRecursion(node.next); + + Node next = node.next, pre=node; + while(null != next) { + if(node.item.equals(next.item)) { + pre.next = next.next; + break; + } + + pre = next; + next = next.next; + } + } + } + + + /** + * 给定一个有序的链表，去掉其重复项 ， 并保留原顺序， + * 例如链表 1->3->3->5->5->7, + * 去掉重复项后变为 1->3->5->7 + * + */ + public void removeRepeatItemFromOrderedListM1(){ + if(this.size <= 1) { + return; + } + + Node cur = headNode.next, pre= headNode; + while(cur != null) { + if(cur.item.equals(pre.item)) { + pre.next = cur.next; + } else { + pre = cur; + } + cur = cur.next; + } + } + private static class Node { + E item; + Node next; + + Node(E element, Node next) { + this.item = element; + this.next = next; + } + } + + + public static void main(String[] args) { + SingleLinkedList list = new SingleLinkedList<>(2); + + list.add(2); + list.add(2); + list.add(3); + list.add(3); + list.add(3); + list.add(5); + list.add(5); + list.add(7); + list.add(7); + + list.printList(); + list.removeRepeatItemFromOrderedListM1(); + list.printList(); + } + + +} + diff --git a/src/com/gw/myalgo/gctest/FullGCTest.java b/src/com/gw/myalgo/gctest/FullGCTest.java new file mode 100644 index 00000000..ad4682e1 --- /dev/null +++ b/src/com/gw/myalgo/gctest/FullGCTest.java @@ -0,0 +1,15 @@ +package com.gw.myalgo.gctest; + +public class FullGCTest { + public static void main(String[] args) { + byte[] array1 = new byte[4 * 1024 * 1024]; + array1 = null; + + byte[] array2 = new byte[2 * 1024 * 1024]; + byte[] array3 = new byte[2 * 1024 * 1024]; + byte[] array4 = new byte[2 * 1024 * 1024]; + byte[] array5 = new byte[128 * 1024]; + + byte[] array6 = new byte[2 * 1024 * 1024]; + } +} diff --git a/src/com/gw/myalgo/gctest/GCTest.java b/src/com/gw/myalgo/gctest/GCTest.java new file mode 100644 index 00000000..ce0faeb8 --- /dev/null +++ b/src/com/gw/myalgo/gctest/GCTest.java @@ -0,0 +1,12 @@ +package com.gw.myalgo.gctest; + +public class GCTest { + public static void main(String[] args) { + byte[] array1 = new byte[1024 * 1024]; + array1 = new byte[1024 * 1024]; + array1 = new byte[1024 * 1024]; + array1 = null; + + byte[] array2 = new byte[2 * 1024 * 1024]; + } +} diff --git a/src/com/gw/myalgo/gctest/GCTest1.java b/src/com/gw/myalgo/gctest/GCTest1.java new file mode 100644 index 00000000..b0d8588f --- /dev/null +++ b/src/com/gw/myalgo/gctest/GCTest1.java @@ -0,0 +1,14 @@ +package com.gw.myalgo.gctest; + +public class GCTest1 { + public static void main(String[] args) { + byte[] array1 = new byte[2 * 1024 * 1024]; + array1 = new byte[2 * 1024 * 1024]; + array1 = new byte[2 * 1024 * 1024]; + + byte[] array2 = new byte[128 * 1024]; + array2 = null; + + byte[] array3 = new byte[2 * 1024 * 1024]; + } +} diff --git a/src/com/gw/myalgo/gctest/JstatTest.java b/src/com/gw/myalgo/gctest/JstatTest.java new file mode 100644 index 00000000..e5939c9d --- /dev/null +++ b/src/com/gw/myalgo/gctest/JstatTest.java @@ -0,0 +1,18 @@ +package com.gw.myalgo.gctest; + +public class JstatTest { + public static void main(String[] args) throws InterruptedException { + Thread.sleep(30000); // main线程休眠30s，以便jstat命令通过PID观察 + while (true) { + loadData(); + } + } + private static void loadData() throws InterruptedException { + byte[] data = null; + for (int i = 0; i < 50; i++) { + data = new byte[100 * 1024]; // 100KB + } + data = null; + Thread.sleep(1000); // 模拟上述操作全部发生在1s内 + } +} diff --git a/src/com/gw/myalgo/gctest/JstatTest2.java b/src/com/gw/myalgo/gctest/JstatTest2.java new file mode 100644 index 00000000..60d66e6c --- /dev/null +++ b/src/com/gw/myalgo/gctest/JstatTest2.java @@ -0,0 +1,30 @@ +package com.gw.myalgo.gctest; + +/** + * -XX:NewSize=209715200 -XX:MaxNewSize=209715200 -XX:InitialHeapSize=314572800 -XX:MaxHeapSize=314572800 -XX:SurvivorRatio=2 -XX:MaxTenuringThreshold=15 -XX:PretenureSizeThreshold=20971520 -XX:+UseParNewGC -XX:+UseConcMarkSweepGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps -Xloggc:gc-jstat2.log + */ +public class JstatTest2 { + public static void main(String[] args) throws InterruptedException { + Thread.sleep(30000); // main线程休眠30s，以便jstat命令通过PID观察 + + while (true) { + loadData(); + } + } + + private static void loadData() throws InterruptedException { + byte[] data = null; + for (int i = 0; i < 4; i++) { + data = new byte[10 * 1024 * 1024]; // 10MB + } + data = null; + + byte[] data1 = new byte[10 * 1024 * 1024]; + byte[] data2 = new byte[10 * 1024 * 1024]; + + byte[] data3 = new byte[10 * 1024 * 1024]; + data3 = new byte[10 * 1024 * 1024]; + + Thread.sleep(1000); // 模拟上述操作全部发生在1s内 + } +} diff --git a/src/com/gw/myalgo/gctest/VolatileTest.java b/src/com/gw/myalgo/gctest/VolatileTest.java new file mode 100644 index 00000000..d0e556db --- /dev/null +++ b/src/com/gw/myalgo/gctest/VolatileTest.java @@ -0,0 +1,30 @@ +package com.gw.myalgo.gctest; + +import java.util.concurrent.atomic.AtomicInteger; + + +public class VolatileTest { + public static AtomicInteger t = new AtomicInteger(0); + + public static void main(String[] args) throws InterruptedException { + + int tnum = 10; + Thread[] threads = new Thread[tnum]; + for(int i = 0; i < tnum; i++){ + //每个线程对t进行1000次加1的操作 + threads[i] = new Thread(() -> { + for(int j = 0; j < 1000; j++){ + t.incrementAndGet(); + } + System.out.println(Thread.currentThread().getName() + " is over"); + }); + threads[i].start(); + } + + Thread.sleep(1000); + + //打印t的值 + System.out.println(t); + } +} + diff --git a/src/com/gw/myalgo/juc/AbstractTest.java b/src/com/gw/myalgo/juc/AbstractTest.java new file mode 100644 index 00000000..4d49030c --- /dev/null +++ b/src/com/gw/myalgo/juc/AbstractTest.java @@ -0,0 +1,8 @@ +package com.gw.myalgo.juc; + +public abstract class AbstractTest { + + public static void main(String[] args) { + System.out.println("Abstract class can still be executed"); + } +} diff --git a/src/com/gw/myalgo/sort/SortAlgo.java b/src/com/gw/myalgo/sort/SortAlgo.java new file mode 100644 index 00000000..4d5a62a3 --- /dev/null +++ b/src/com/gw/myalgo/sort/SortAlgo.java @@ -0,0 +1,181 @@ +package com.gw.myalgo.sort; + + +import org.apache.commons.lang3.StringUtils; + +/** + * @author hsden + */ +public class SortAlgo { + + /** + * Bubble sort + * @param arr + */ + public static void bubbleSort(int[] arr) { + if(null == arr || 0 == arr.length){ + return ; + } + + int i, j, tmp; + for(i = 0; i < arr.length - 1; i++){ + for(j = 0; j < arr.length - i - 1; j++){ + if(arr[j] > arr[j+1]){ + tmp = arr[j]; + arr[j] = arr[j+1]; + arr[j+1] = tmp; + } + } + } + + } + + /** + * Select sort + * @param arr + */ + public static void selectSort(int[] arr) { + if(null == arr || 1 >= arr.length){ + return; + } + + + for(int i = 0; i < arr.length -1; i++){ + int smallestIdx = i; + for(int j = i + 1; j < arr.length; j++) { + if(arr[smallestIdx] > arr[j]) { + smallestIdx = j; + } + } + + int tmp = arr[i]; + arr[i] = arr[smallestIdx]; + arr[smallestIdx] = tmp; + } + } + + /** + * 2-way select sort + * @param arr + */ + public static void selectSortUpdate(int[] arr) { + if(null == arr || 1 >= arr.length){ + return; + } + + for(int i = 0; i <= arr.length/2 ; i++){ + int minIdx = i, maxIdx = i; + for(int j = i + 1; j < arr.length - i; j++) { + if(arr[minIdx] >= arr[j]) { + minIdx = j; + } + + if(arr[maxIdx] <= arr[j]) { + maxIdx = j; + } + } + + if(minIdx != i) { + int tmp = arr[i]; + arr[i] = arr[minIdx]; + arr[minIdx] = tmp; + if(maxIdx == i){ + maxIdx = minIdx; + } + } + + int n = arr.length -i -1; + if(maxIdx != n) { + int tmp = arr[n]; + arr[n] = arr[maxIdx]; + arr[maxIdx] = tmp; + } + + printArr(arr); + } + } + + + /** + * Insert sort + * @param arr + */ + public static void insertSort(int[] arr){ + if(null == arr || 1 >= arr.length){ + return; + } + + for(int i = 1; i < arr.length; i++){ + if(arr[i-1] > arr[i]) { + int j, tmp=arr[i]; + for (j = i - 1; j >= 0; j--) { + if (arr[j] < tmp) { + break; + } else { + arr[j + 1] = arr[j]; + } + } + + arr[j + 1] = tmp; + } + } + + } + + + /** + * Shell sort + * @param arr + */ + public static void shellSortMain(int[] arr){ + + if(null == arr || 1 >= arr.length){ + return; + } + + int segment = arr.length/2; + while(segment >= 1){ + shellInsertSort(arr,segment); + segment = segment/2; + } + } + + public static void shellInsertSort(int[] arr, int dk){ + if(null == arr || 1 >= arr.length || 0 >= dk){ + return; + } + + for(int i=dk; i < arr.length; ++i) { + if(arr[i] < arr[i -dk]) { + int j = i -dk, x=arr[i]; + arr[i]=arr[j]; + while(j >= 0 && x < arr[j]){ + arr[j+dk] = arr[j]; + j -= dk; + } + arr[j+dk] = x; + } + } + } + + public static void printArr(int[] arr){ + StringBuilder sb = new StringBuilder(); + for(int value : arr){ + sb.append(value + ","); + } + System.out.println(sb.substring(0, sb.length() - 1)); + } + + public static void main(String[] args) { + //5,7,9,10,2,32,4,4,3 + int[] sortedArr = new int[]{5,7,9,10,2,32,4,4,3}; + printArr(sortedArr); + //bubbleSort(sortedArr); + //selectSort(sortedArr); + selectSortUpdate(sortedArr); + //insertSort(sortedArr); + //shellSortMain(sortedArr); + + printArr(sortedArr); + } +} diff --git a/src/com/jwetherell/algorithms/DataStructures.java b/src/com/jwetherell/algorithms/DataStructures.java deleted file mode 100644 index 3017dcad..00000000 --- a/src/com/jwetherell/algorithms/DataStructures.java +++ /dev/null @@ -1,4098 +0,0 @@ -package com.jwetherell.algorithms; - -import java.text.DecimalFormat; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.Formatter; -import java.util.Iterator; -import java.util.ListIterator; -import java.util.Locale; -import java.util.Map; -import java.util.NavigableSet; -import java.util.NoSuchElementException; -import java.util.Random; -import java.util.Set; -import java.util.concurrent.ConcurrentSkipListMap; -import java.util.concurrent.ConcurrentSkipListSet; - -import com.jwetherell.algorithms.data_structures.AVLTree; -import com.jwetherell.algorithms.data_structures.BTree; -import com.jwetherell.algorithms.data_structures.BinarySearchTree; -import com.jwetherell.algorithms.data_structures.BinaryHeap; -import com.jwetherell.algorithms.data_structures.CompactSuffixTrie; -import com.jwetherell.algorithms.data_structures.Graph.Edge; -import com.jwetherell.algorithms.data_structures.Graph.Vertex; -import com.jwetherell.algorithms.data_structures.Graph; -import com.jwetherell.algorithms.data_structures.HashArrayMappedTrie; -import com.jwetherell.algorithms.data_structures.HashMap; -import com.jwetherell.algorithms.data_structures.IHeap; -import com.jwetherell.algorithms.data_structures.IList; -import com.jwetherell.algorithms.data_structures.IMap; -import com.jwetherell.algorithms.data_structures.IQueue; -import com.jwetherell.algorithms.data_structures.ISet; -import com.jwetherell.algorithms.data_structures.IStack; -import com.jwetherell.algorithms.data_structures.ITree; -import com.jwetherell.algorithms.data_structures.IntervalTree; -import com.jwetherell.algorithms.data_structures.KdTree; -import com.jwetherell.algorithms.data_structures.PatriciaTrie; -import com.jwetherell.algorithms.data_structures.QuadTree; -import com.jwetherell.algorithms.data_structures.RadixTrie; -import com.jwetherell.algorithms.data_structures.RedBlackTree; -import com.jwetherell.algorithms.data_structures.SegmentTree; -import com.jwetherell.algorithms.data_structures.SegmentTree.DynamicSegmentTree; -import com.jwetherell.algorithms.data_structures.SegmentTree.FlatSegmentTree; -import com.jwetherell.algorithms.data_structures.SkipListMap; -import com.jwetherell.algorithms.data_structures.SuffixTree; -import com.jwetherell.algorithms.data_structures.TreeMap; -import com.jwetherell.algorithms.data_structures.TrieMap; -import com.jwetherell.algorithms.data_structures.List; -import com.jwetherell.algorithms.data_structures.Matrix; -import com.jwetherell.algorithms.data_structures.Queue; -import com.jwetherell.algorithms.data_structures.SkipList; -import com.jwetherell.algorithms.data_structures.SplayTree; -import com.jwetherell.algorithms.data_structures.Stack; -import com.jwetherell.algorithms.data_structures.SuffixTrie; -import com.jwetherell.algorithms.data_structures.Treap; -import com.jwetherell.algorithms.data_structures.Trie; -import com.jwetherell.algorithms.graph.BellmanFord; -import com.jwetherell.algorithms.graph.CycleDetection; -import com.jwetherell.algorithms.graph.Dijkstra; -import com.jwetherell.algorithms.graph.FloydWarshall; -import com.jwetherell.algorithms.graph.Johnson; -import com.jwetherell.algorithms.graph.Prim; -import com.jwetherell.algorithms.graph.TopologicalSort; - -@SuppressWarnings("unchecked") -public class DataStructures { - - private static final int NUMBER_OF_TESTS = 3; - private static final Random RANDOM = new Random(); - private static final int ARRAY_SIZE = 1000; - private static final int RANDOM_SIZE = 1000 * ARRAY_SIZE; - private static final Integer INVALID = RANDOM_SIZE + 10; - private static final DecimalFormat FORMAT = new DecimalFormat("0.##"); - - private static Integer[] unsorted = null; - private static Integer[] sorted = null; - private static String string = null; - - private static int debug = 1; // Debug level. 0=None, 1=Time and Memory (if enabled), 2=Time, Memory, data structure debug - private static boolean debugTime = true; // How much time to: add all, remove all, add all items in reverse order, remove all - private static boolean debugMemory = true; // How much memory is used by the data structure - private static boolean validateStructure = true; // Is the data structure valid (passed invariants) and proper size - private static boolean validateContents = true; // Was the item added/removed really added/removed from the structure - private static boolean validateIterator = true; // Does the iterator(s) work - - private static final int TESTS = 38; // Max number of dynamic data structures to test - private static final String[] testNames = new String[TESTS]; // Array to hold the test names - private static final long[][] testResults = new long[TESTS][]; // Array to hold the test results - private static int testIndex = 0; // Index into the tests - private static int testNumber = 0; // Number of aggregate tests which have been run - - private static enum Type {Integer, String}; - - public static void main(String[] args) { - System.out.println("Starting tests."); - boolean passed = false; - for (int i = 0; i < NUMBER_OF_TESTS; i++) { - try { - passed = runTests(); - } catch (NullPointerException e) { - System.err.println(string); - throw e; - } - if (!passed) break; - } - if (passed) System.out.println("Tests finished. All passed."); - else System.err.println("Tests finished. Detected a failure."); - } - - private static void generateData() { - System.out.println("Generating data."); - StringBuilder builder = new StringBuilder(); - builder.append("Array="); - unsorted = new Integer[ARRAY_SIZE]; - java.util.Set set = new java.util.HashSet(); - for (int i = 0; i < ARRAY_SIZE; i++) { - Integer j = RANDOM.nextInt(RANDOM_SIZE); - // Make sure there are no duplicates - boolean found = true; - while (found) { - if (set.contains(j)) { - j = RANDOM.nextInt(RANDOM_SIZE); - } else { - unsorted[i] = j; - set.add(j); - found = false; - } - } - unsorted[i] = j; - if (i!=ARRAY_SIZE-1) builder.append(j).append(','); - } - set.clear(); - set = null; - builder.append('\n'); - string = builder.toString(); - if (debug > 1) System.out.println(string); - - sorted = Arrays.copyOf(unsorted, unsorted.length); - Arrays.sort(sorted); - - System.out.println("Generated data."); - } - - private static boolean runTests() { - testIndex = 0; - testNumber++; - - generateData(); - - boolean passed = true; - - // Trees - - passed = testJavaRedBlackIntegerTree(); - if (!passed) { - System.err.println("Java Red-Black [Integer] failed."); - return false; - } - - passed = testRedBlackTree(); - if (!passed) { - System.err.println("Red-Black Tree failed."); - return false; - } - - passed = testAVLTree(); - if (!passed) { - System.err.println("AVL Tree failed."); - return false; - } - - passed = testSplayTree(); - if (!passed) { - System.err.println("Splay Tree failed."); - return false; - } - - passed = testBTree(); - if (!passed) { - System.err.println("B-Tree failed."); - return false; - } - - passed = testTreap(); - if (!passed) { - System.err.println("Treap failed."); - return false; - } - - passed = testBST(); - if (!passed) { - System.err.println("BST failed."); - return false; - } - - passed = testJavaRedBlackStringTree(); - if (!passed) { - System.err.println("Java Red-Black [String] failed."); - return false; - } - - passed = testTrie(); - if (!passed) { - System.err.println("Trie failed."); - return false; - } - - passed = testPatriciaTrie(); - if (!passed) { - System.err.println("Patricia Trie failed."); - return false; - } - - // Sets - - passed = testJavaSkipList(); - if (!passed) { - System.err.println("Java's Skip List failed."); - return false; - } - - passed = testSkipList(); - if (!passed) { - System.err.println("Skip List failed."); - return false; - } - - // Heaps - - passed = testJavaMinHeap(); - if (!passed) { - System.err.println("Java Min-Heap failed."); - return false; - } - - passed = testMinHeap(); - if (!passed) { - System.err.println("Min-Heap failed."); - return false; - } - - passed = testJavaMaxHeap(); - if (!passed) { - System.err.println("Java Max-Heap failed."); - return false; - } - - passed = testMaxHeap(); - if (!passed) { - System.err.println("Max-Heap failed."); - return false; - } - - // Lists - - passed = testJavaArrayList(); - if (!passed) { - System.err.println("Java List failed."); - return false; - } - - passed = testArrayList(); - if (!passed) { - System.err.println("List failed."); - return false; - } - - passed = testJavaLinkedList(); - if (!passed) { - System.err.println("Java List failed."); - return false; - } - - passed = testLinkedList(); - if (!passed) { - System.err.println("List failed."); - return false; - } - - // Queues - - passed = testJavaArrayQueue(); - if (!passed) { - System.err.println("Java Queue failed."); - return false; - } - - passed = testArrayQueue(); - if (!passed) { - System.err.println("Queue failed."); - return false; - } - - passed = testJavaLinkedQueue(); - if (!passed) { - System.err.println("Java Queue failed."); - return false; - } - - passed = testLinkedQueue(); - if (!passed) { - System.err.println("Queue failed."); - return false; - } - - // Stacks - - passed = testJavaStack(); - if (!passed) { - System.err.println("Java Stack failed."); - return false; - } - - passed = testArrayStack(); - if (!passed) { - System.err.println("Stack failed."); - return false; - } - - passed = testLinkedStack(); - if (!passed) { - System.err.println("Stack failed."); - return false; - } - - // Maps - - passed = testJavaHashMap(); - if (!passed) { - System.err.println("Java Hash Map failed."); - return false; - } - - passed = testHashMap(); - if (!passed) { - System.err.println("Hash Map failed."); - return false; - } - - passed = testJavaTreeMap(); - if (!passed) { - System.err.println("Java Tree Map failed."); - return false; - } - - passed = testTreeMap(); - if (!passed) { - System.err.println("Tree Map failed."); - return false; - } - - passed = testTrieMap(); - if (!passed) { - System.err.println("Trie Map failed."); - return false; - } - - passed = testRadixTrie(); - if (!passed) { - System.err.println("Radix Trie failed."); - return false; - } - - passed = testJavaSkipListMap(); - if (!passed) { - System.err.println("Java's Skip List Map failed."); - return false; - } - - passed = testSkipListMap(); - if (!passed) { - System.err.println("Skip List Map failed."); - return false; - } - - passed = testHAMT(); - if (!passed) { - System.err.println("HAMT failed."); - return false; - } - - if (debugTime && debugMemory) { - String results = getTestResults(testNumber, testNames, testResults); - System.out.println(results); - } - - // MY STATIC DATA STRUCTURES - - passed = testCompactSuffixTrie(); - if (!passed) { - System.err.println("Compact Suffix Trie failed."); - return false; - } - - passed = testGraph(); - if (!passed) { - System.err.println("Graph failed."); - return false; - } - - passed = testIntervalTree(); - if (!passed) { - System.err.println("Interval Tree failed."); - return false; - } - - passed = testKdTree(); - if (!passed) { - System.err.println("k-d Tree Tree failed."); - return false; - } - - passed = testMatrix(); - if (!passed) { - System.err.println("Matrix failed."); - return false; - } - - passed = testQuadTree(); - if (!passed) { - System.err.println("QuadTree failed."); - return false; - } - - passed = testSegmentTree(); - if (!passed) { - System.err.println("Segment Tree failed."); - return false; - } - - passed = testSuffixTree(); - if (!passed) { - System.err.println("Suffix Tree failed."); - return false; - } - - passed = testSuffixTrie(); - if (!passed) { - System.err.println("Suffix Trie failed."); - return false; - } - - return true; - } - - private static void handleError(Object obj) { - System.err.println(string); - System.err.println(obj.toString()); - throw new RuntimeException(); - } - - private static boolean testAVLTree() { - String bstName = "AVL Tree"; - BinarySearchTree bst = new AVLTree(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - return true; - } - - private static boolean testBTree() { - String bstName = "B-Tree"; - BTree bst = new BTree(2); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - return true; - } - - private static boolean testBST() { - String bstName = "BST"; - BinarySearchTree bst = new BinarySearchTree(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - return true; - } - - private static boolean testCompactSuffixTrie() { - if (debug > 1) System.out.println("Compact Suffix Trie."); - String bookkeeper = "bookkeeper"; - CompactSuffixTrie trie = new CompactSuffixTrie(bookkeeper); - if (debug > 1) System.out.println(trie.toString()); - if (debug > 1) System.out.println(trie.getSuffixes()); - - boolean exists = trie.doesSubStringExist(bookkeeper); - if (!exists) { - System.err.println("YIKES!! " + bookkeeper + " doesn't exists."); - handleError(trie); - return false; - } - - String failed = "booker"; - exists = trie.doesSubStringExist(failed); - if (exists) { - System.err.println("YIKES!! " + failed + " exists."); - handleError(trie); - return false; - } - - String pass = "kkee"; - exists = trie.doesSubStringExist(pass); - if (!exists) { - System.err.println("YIKES!! " + pass + " doesn't exists."); - handleError(trie); - return false; - } - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testGraph() { - { // UNDIRECTED GRAPH - if (debug > 1) System.out.println("Undirected Graph."); - java.util.List> verticies = new ArrayList>(); - Graph.Vertex v1 = new Graph.Vertex(1); - verticies.add(v1); - Graph.Vertex v2 = new Graph.Vertex(2); - verticies.add(v2); - Graph.Vertex v3 = new Graph.Vertex(3); - verticies.add(v3); - Graph.Vertex v4 = new Graph.Vertex(4); - verticies.add(v4); - Graph.Vertex v5 = new Graph.Vertex(5); - verticies.add(v5); - Graph.Vertex v6 = new Graph.Vertex(6); - verticies.add(v6); - - java.util.List> edges = new ArrayList>(); - Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); - edges.add(e1_2); - Graph.Edge e1_3 = new Graph.Edge(9, v1, v3); - edges.add(e1_3); - Graph.Edge e1_6 = new Graph.Edge(14, v1, v6); - edges.add(e1_6); - Graph.Edge e2_3 = new Graph.Edge(10, v2, v3); - edges.add(e2_3); - Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); - edges.add(e2_4); - Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); - edges.add(e3_4); - Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); - edges.add(e3_6); - Graph.Edge e5_6 = new Graph.Edge(9, v5, v6); - edges.add(e5_6); - Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); - edges.add(e4_5); - - Graph undirected = new Graph(verticies, edges); - if (debug > 1) System.out.println(undirected.toString()); - - Graph.Vertex start = v1; - if (debug > 1) System.out.println("Dijstra's shortest paths of the undirected graph from " + start.getValue()); - Map, Graph.CostPathPair> map1 = Dijkstra.getShortestPaths(undirected, start); - if (debug > 1) System.out.println(getPathMapString(start, map1)); - - Graph.Vertex end = v5; - if (debug > 1) System.out.println("Dijstra's shortest path of the undirected graph from " + start.getValue() + " to " + end.getValue()); - Graph.CostPathPair pair1 = Dijkstra.getShortestPath(undirected, start, end); - if (debug > 1) { - if (pair1 != null) System.out.println(pair1.toString()); - else System.out.println("No path from " + start.getValue() + " to " + end.getValue()); - } - - start = v1; - if (debug > 1) System.out.println("Bellman-Ford's shortest paths of the undirected graph from " + start.getValue()); - Map, Graph.CostPathPair> map2 = BellmanFord.getShortestPaths(undirected, start); - if (debug > 1) System.out.println(getPathMapString(start, map2)); - - end = v5; - if (debug > 1) System.out.println("Bellman-Ford's shortest path of the undirected graph from " + start.getValue() + " to " + end.getValue()); - Graph.CostPathPair pair2 = BellmanFord.getShortestPath(undirected, start, end); - if (debug > 1) { - if (pair2 != null) System.out.println(pair2.toString()); - else System.out.println("No path from " + start.getValue() + " to " + end.getValue()); - } - - // MST - - if (debug > 1) System.out.println("Prim's minimum spanning tree of the undirected graph from " + start.getValue()); - Graph.CostPathPair pair = Prim.getMinimumSpanningTree(undirected, start); - if (debug > 1) System.out.println(pair.toString()); - - // Prim on a graph with cycles - java.util.List> cyclicVerticies = new ArrayList>(); - Graph.Vertex cv1 = new Graph.Vertex(1); - cyclicVerticies.add(cv1); - Graph.Vertex cv2 = new Graph.Vertex(2); - cyclicVerticies.add(cv2); - Graph.Vertex cv3 = new Graph.Vertex(3); - cyclicVerticies.add(cv3); - Graph.Vertex cv4 = new Graph.Vertex(4); - cyclicVerticies.add(cv4); - Graph.Vertex cv5 = new Graph.Vertex(5); - cyclicVerticies.add(cv5); - - java.util.List> cyclicEdges = new ArrayList>(); - Graph.Edge ce1_2 = new Graph.Edge(3, cv1, cv2); - cyclicEdges.add(ce1_2); - Graph.Edge ce2_3 = new Graph.Edge(2, cv2, cv3); - cyclicEdges.add(ce2_3); - Graph.Edge ce3_4 = new Graph.Edge(4, cv3, cv4); - cyclicEdges.add(ce3_4); - Graph.Edge ce4_1 = new Graph.Edge(1, cv4, cv1); - cyclicEdges.add(ce4_1); - Graph.Edge ce4_5 = new Graph.Edge(1, cv4, cv5); - cyclicEdges.add(ce4_5); - - Graph cyclicUndirected = new Graph(cyclicVerticies, cyclicEdges); - if (debug > 1) System.out.println(cyclicUndirected.toString()); - - start = cv1; - if (debug > 1) System.out.println("Prim's minimum spanning tree of a cyclic undirected graph from " + start.getValue()); - Graph.CostPathPair cyclicPair = Prim.getMinimumSpanningTree(cyclicUndirected, start); - if (debug > 1) System.out.println(cyclicPair.toString()); - - if (debug > 1) System.out.println(); - } - - { // DIRECTED GRAPH - if (debug > 1) System.out.println("Directed Graph."); - java.util.List> verticies = new ArrayList>(); - Graph.Vertex v1 = new Graph.Vertex(1); - verticies.add(v1); - Graph.Vertex v2 = new Graph.Vertex(2); - verticies.add(v2); - Graph.Vertex v3 = new Graph.Vertex(3); - verticies.add(v3); - Graph.Vertex v4 = new Graph.Vertex(4); - verticies.add(v4); - Graph.Vertex v5 = new Graph.Vertex(5); - verticies.add(v5); - Graph.Vertex v6 = new Graph.Vertex(6); - verticies.add(v6); - Graph.Vertex v7 = new Graph.Vertex(7); - verticies.add(v7); - - java.util.List> edges = new ArrayList>(); - Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); - edges.add(e1_2); - Graph.Edge e1_3 = new Graph.Edge(9, v1, v3); - edges.add(e1_3); - Graph.Edge e1_6 = new Graph.Edge(14, v1, v6); - edges.add(e1_6); - Graph.Edge e2_3 = new Graph.Edge(10, v2, v3); - edges.add(e2_3); - Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); - edges.add(e2_4); - Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); - edges.add(e3_4); - Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); - edges.add(e3_6); - Graph.Edge e6_5 = new Graph.Edge(9, v6, v5); - edges.add(e6_5); - Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); - edges.add(e4_5); - Graph.Edge e4_7 = new Graph.Edge(16, v4, v7); - edges.add(e4_7); - - Graph directed = new Graph(Graph.TYPE.DIRECTED, verticies, edges); - if (debug > 1) System.out.println(directed.toString()); - - Graph.Vertex start = v1; - if (debug > 1) System.out.println("Dijstra's shortest paths of the directed graph from " + start.getValue()); - Map, Graph.CostPathPair> map = Dijkstra.getShortestPaths(directed, start); - if (debug > 1) System.out.println(getPathMapString(start, map)); - - Graph.Vertex end = v5; - if (debug > 1) System.out.println("Dijstra's shortest path of the directed graph from " + start.getValue() + " to " + end.getValue()); - Graph.CostPathPair pair = Dijkstra.getShortestPath(directed, start, end); - if (debug > 1) { - if (pair != null) System.out.println(pair.toString()); - else System.out.println("No path from " + start.getValue() + " to " + end.getValue()); - } - - start = v1; - if (debug > 1) System.out.println("Bellman-Ford's shortest paths of the undirected graph from " + start.getValue()); - Map, Graph.CostPathPair> map2 = BellmanFord.getShortestPaths(directed, start); - if (debug > 1) System.out.println(getPathMapString(start, map2)); - - end = v5; - if (debug > 1) System.out.println("Bellman-Ford's shortest path of the undirected graph from " + start.getValue() + " to " + end.getValue()); - Graph.CostPathPair pair2 = BellmanFord.getShortestPath(directed, start, end); - if (debug > 1) { - if (pair2 != null) System.out.println(pair2.toString()); - else System.out.println("No path from " + start.getValue() + " to " + end.getValue()); - } - - if (debug > 1) System.out.println(); - } - - { // DIRECTED GRAPH (WITH NEGATIVE WEIGHTS) - if (debug > 1) System.out.println("Undirected Graph with Negative Weights."); - java.util.List> verticies = new ArrayList>(); - Graph.Vertex v1 = new Graph.Vertex(1); - verticies.add(v1); - Graph.Vertex v2 = new Graph.Vertex(2); - verticies.add(v2); - Graph.Vertex v3 = new Graph.Vertex(3); - verticies.add(v3); - Graph.Vertex v4 = new Graph.Vertex(4); - verticies.add(v4); - - java.util.List> edges = new ArrayList>(); - Graph.Edge e1_4 = new Graph.Edge(2, v1, v4); - edges.add(e1_4); - Graph.Edge e2_1 = new Graph.Edge(6, v2, v1); - edges.add(e2_1); - Graph.Edge e2_3 = new Graph.Edge(3, v2, v3); - edges.add(e2_3); - Graph.Edge e3_1 = new Graph.Edge(4, v3, v1); - edges.add(e3_1); - Graph.Edge e3_4 = new Graph.Edge(5, v3, v4); - edges.add(e3_4); - Graph.Edge e4_2 = new Graph.Edge(-7, v4, v2); - edges.add(e4_2); - Graph.Edge e4_3 = new Graph.Edge(-3, v4, v3); - edges.add(e4_3); - - Graph directed = new Graph(Graph.TYPE.DIRECTED, verticies, edges); - if (debug > 1) System.out.println(directed.toString()); - - Graph.Vertex start = v1; - if (debug > 1) System.out.println("Bellman-Ford's shortest paths of the directed graph from " + start.getValue()); - Map, Graph.CostPathPair> map2 = BellmanFord.getShortestPaths(directed, start); - if (debug > 1) System.out.println(getPathMapString(start, map2)); - - Graph.Vertex end = v3; - if (debug > 1) System.out.println("Bellman-Ford's shortest path of the directed graph from " + start.getValue() + " to " + end.getValue()); - Graph.CostPathPair pair2 = BellmanFord.getShortestPath(directed, start, end); - if (debug > 1) { - if (pair2 != null) System.out.println(pair2.toString()); - else System.out.println("No path from " + start.getValue() + " to " + end.getValue()); - } - - if (debug > 1) System.out.println("Johnson's all-pairs shortest path of the directed graph."); - Map, Map, Set>>> paths = Johnson.getAllPairsShortestPaths(directed); - if (debug > 1) { - if (paths == null) System.out.println("Directed graph contains a negative weight cycle."); - else System.out.println(getPathMapString(paths)); - } - - if (debug > 1) System.out.println("Floyd-Warshall's all-pairs shortest path weights of the directed graph."); - Map, Map, Integer>> pathWeights = FloydWarshall.getAllPairsShortestPaths(directed); - if (debug > 1) System.out.println(getWeightMapString(pathWeights)); - - if (debug > 1) System.out.println(); - } - - { // UNDIRECTED GRAPH - if (debug > 1) System.out.println("Undirected Graph cycle check."); - java.util.List> cycledVerticies = new ArrayList>(); - Graph.Vertex cv1 = new Graph.Vertex(1); - cycledVerticies.add(cv1); - Graph.Vertex cv2 = new Graph.Vertex(2); - cycledVerticies.add(cv2); - Graph.Vertex cv3 = new Graph.Vertex(3); - cycledVerticies.add(cv3); - Graph.Vertex cv4 = new Graph.Vertex(4); - cycledVerticies.add(cv4); - Graph.Vertex cv5 = new Graph.Vertex(5); - cycledVerticies.add(cv5); - Graph.Vertex cv6 = new Graph.Vertex(6); - cycledVerticies.add(cv6); - - java.util.List> cycledEdges = new ArrayList>(); - Graph.Edge ce1_2 = new Graph.Edge(7, cv1, cv2); - cycledEdges.add(ce1_2); - Graph.Edge ce2_4 = new Graph.Edge(15, cv2, cv4); - cycledEdges.add(ce2_4); - Graph.Edge ce3_4 = new Graph.Edge(11, cv3, cv4); - cycledEdges.add(ce3_4); - Graph.Edge ce3_6 = new Graph.Edge(2, cv3, cv6); - cycledEdges.add(ce3_6); - Graph.Edge ce5_6 = new Graph.Edge(9, cv5, cv6); - cycledEdges.add(ce5_6); - Graph.Edge ce4_5 = new Graph.Edge(6, cv4, cv5); - cycledEdges.add(ce4_5); - - Graph undirectedWithCycle = new Graph(cycledVerticies, cycledEdges); - if (debug > 1) System.out.println(undirectedWithCycle.toString()); - - if (debug > 1) { - System.out.println("Cycle detection of the undirected graph."); - boolean result = CycleDetection.detect(undirectedWithCycle); - System.out.println("result=" + result); - System.out.println(); - } - - java.util.List> verticies = new ArrayList>(); - Graph.Vertex v1 = new Graph.Vertex(1); - verticies.add(v1); - Graph.Vertex v2 = new Graph.Vertex(2); - verticies.add(v2); - Graph.Vertex v3 = new Graph.Vertex(3); - verticies.add(v3); - Graph.Vertex v4 = new Graph.Vertex(4); - verticies.add(v4); - Graph.Vertex v5 = new Graph.Vertex(5); - verticies.add(v5); - Graph.Vertex v6 = new Graph.Vertex(6); - verticies.add(v6); - - java.util.List> edges = new ArrayList>(); - Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); - edges.add(e1_2); - Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); - edges.add(e2_4); - Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); - edges.add(e3_4); - Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); - edges.add(e3_6); - Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); - edges.add(e4_5); - - Graph undirectedWithoutCycle = new Graph(verticies, edges); - if (debug > 1) System.out.println(undirectedWithoutCycle.toString()); - - if (debug > 1) { - System.out.println("Cycle detection of the undirected graph."); - boolean result = CycleDetection.detect(undirectedWithoutCycle); - System.out.println("result=" + result); - System.out.println(); - } - } - - { // DIRECTED GRAPH - if (debug > 1) System.out.println("Directed Graph topological sort."); - java.util.List> verticies = new ArrayList>(); - Graph.Vertex cv1 = new Graph.Vertex(1); - verticies.add(cv1); - Graph.Vertex cv2 = new Graph.Vertex(2); - verticies.add(cv2); - Graph.Vertex cv3 = new Graph.Vertex(3); - verticies.add(cv3); - Graph.Vertex cv4 = new Graph.Vertex(4); - verticies.add(cv4); - Graph.Vertex cv5 = new Graph.Vertex(5); - verticies.add(cv5); - Graph.Vertex cv6 = new Graph.Vertex(6); - verticies.add(cv6); - - java.util.List> edges = new ArrayList>(); - Graph.Edge ce1_2 = new Graph.Edge(1, cv1, cv2); - edges.add(ce1_2); - Graph.Edge ce2_4 = new Graph.Edge(2, cv2, cv4); - edges.add(ce2_4); - Graph.Edge ce4_3 = new Graph.Edge(3, cv4, cv3); - edges.add(ce4_3); - Graph.Edge ce3_6 = new Graph.Edge(4, cv3, cv6); - edges.add(ce3_6); - Graph.Edge ce5_6 = new Graph.Edge(5, cv5, cv6); - edges.add(ce5_6); - Graph.Edge ce4_5 = new Graph.Edge(6, cv4, cv5); - edges.add(ce4_5); - - Graph directed = new Graph(Graph.TYPE.DIRECTED, verticies, edges); - if (debug > 1) System.out.println(directed.toString()); - - if (debug > 1) System.out.println("Topological sort of the directed graph."); - java.util.List> results = TopologicalSort.sort(directed); - if (debug > 1) { - System.out.println("result=" + results); - System.out.println(); - } - } - - return true; - } - - private static boolean testMinHeap() { - String aNameMin = "Min-Heap [array]"; - BinaryHeap.BinaryHeapArray aHeapMin = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MIN); - Collection aCollectionMin = aHeapMin.toCollection(); - if((validateStructure||validateContents) && !testHeap(aHeapMin,aNameMin,BinaryHeap.Type.MIN)) return false; - if(!testJavaCollection(aCollectionMin,Type.Integer,aNameMin)) return false; - - String tNameMin = "Min-Heap [tree]"; - BinaryHeap.BinaryHeapTree tHeapMin = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MIN); - Collection tCollectionMin = tHeapMin.toCollection(); - if((validateStructure||validateContents) && !testHeap(tHeapMin,tNameMin,BinaryHeap.Type.MIN)) return false; - if(!testJavaCollection(tCollectionMin,Type.Integer,tNameMin)) return false; - - return true; - } - - private static boolean testMaxHeap() { - String aNameMax = "Max-Heap [array]"; - BinaryHeap.BinaryHeapArray aHeapMax = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MAX); - Collection aCollectionMax = aHeapMax.toCollection(); - if((validateStructure||validateContents) && !testHeap(aHeapMax,aNameMax,BinaryHeap.Type.MAX)) return false; - if(!testJavaCollection(aCollectionMax,Type.Integer,aNameMax)) return false; - - String lNameMax = "Max-Heap [tree]"; - BinaryHeap.BinaryHeapTree tHeapMax = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MAX); - Collection tCollectionMax = tHeapMax.toCollection(); - if((validateStructure||validateContents) && !testHeap(tHeapMax,lNameMax,BinaryHeap.Type.MAX)) return false; - if(!testJavaCollection(tCollectionMax,Type.Integer,lNameMax)) return false; - - return true; - } - - private static boolean testHashMap() { - String mapName = "HashMap"; - HashMap map = new HashMap(unsorted.length/2); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.Integer,mapName)) return false; - if(!testJavaMap(jMap,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testHAMT() { - String mapName = "HAMT"; - HashArrayMappedTrie map = new HashArrayMappedTrie(); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.Integer,mapName)) return false; - if(!testJavaMap(jMap,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testIntervalTree() { - { // Interval tree - if (debug > 1) System.out.println("Interval Tree."); - java.util.List> intervals = new ArrayList>(); - intervals.add((new IntervalTree.IntervalData(2, 6, "RED"))); - intervals.add((new IntervalTree.IntervalData(3, 5, "ORANGE"))); - intervals.add((new IntervalTree.IntervalData(4, 11, "GREEN"))); - intervals.add((new IntervalTree.IntervalData(5, 10, "DARK_GREEN"))); - intervals.add((new IntervalTree.IntervalData(8, 12, "BLUE"))); - intervals.add((new IntervalTree.IntervalData(9, 14, "PURPLE"))); - intervals.add((new IntervalTree.IntervalData(13, 15, "BLACK"))); - IntervalTree tree = new IntervalTree(intervals); - if (debug > 1) System.out.println(tree); - - IntervalTree.IntervalData query = tree.query(2); - if (debug > 1) System.out.println("2: " + query); - - query = tree.query(4); // Stabbing query - if (debug > 1) System.out.println("4: " + query); - - query = tree.query(9); // Stabbing query - if (debug > 1) System.out.println("9: " + query); - - query = tree.query(1, 16); // Range query - if (debug > 1) System.out.println("1->16: " + query); - - query = tree.query(7, 14); // Range query - if (debug > 1) System.out.println("7->14: " + query); - - query = tree.query(14, 15); // Range query - if (debug > 1) System.out.println("14->15: " + query); - - if (debug > 1) System.out.println(); - } - - { // Lifespan Interval tree - if (debug > 1) System.out.println("Lifespan Interval Tree."); - java.util.List> intervals = new ArrayList>(); - intervals.add((new IntervalTree.IntervalData(1888, 1971, "Stravinsky"))); - intervals.add((new IntervalTree.IntervalData(1874, 1951, "Schoenberg"))); - intervals.add((new IntervalTree.IntervalData(1843, 1907, "Grieg"))); - intervals.add((new IntervalTree.IntervalData(1779, 1828, "Schubert"))); - intervals.add((new IntervalTree.IntervalData(1756, 1791, "Mozart"))); - intervals.add((new IntervalTree.IntervalData(1585, 1672, "Schuetz"))); - IntervalTree tree = new IntervalTree(intervals); - if (debug > 1) System.out.println(tree); - - IntervalTree.IntervalData query = tree.query(1890); - if (debug > 1) System.out.println("1890: " + query); - - query = tree.query(1909); // Stabbing query - if (debug > 1) System.out.println("1909: " + query); - - query = tree.query(1792, 1903); // Range query - if (debug > 1) System.out.println("1792->1903: " + query); - - query = tree.query(1776, 1799); // Range query - if (debug > 1) System.out.println("1776->1799: " + query); - - if (debug > 1) System.out.println(); - } - - return true; - } - - private static boolean testJavaHashMap() { - String mapName = "Java's HashMap"; - java.util.Map map = new java.util.HashMap(unsorted.length/2); - - if(!testJavaMap(map,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testJavaMinHeap() { - java.util.PriorityQueue minArrayHeap = new java.util.PriorityQueue(10, - new Comparator() { - - @Override - public int compare(Integer arg0, Integer arg1) { - if (arg0.compareTo(arg1) < 0) - return -1; - else if (arg1.compareTo(arg0) < 0) - return 1; - return 0; - } - }); - if(!testJavaCollection(minArrayHeap,Type.Integer,"Java's Min-Heap [array]")) return false; - - return true; - } - - private static boolean testJavaMaxHeap() { - java.util.PriorityQueue maxArrayHeap = new java.util.PriorityQueue(10, - new Comparator() { - - @Override - public int compare(Integer arg0, Integer arg1) { - if (arg0.compareTo(arg1) > 0) - return -1; - else if (arg1.compareTo(arg0) > 0) - return 1; - return 0; - } - }); - if(!testJavaCollection(maxArrayHeap,Type.Integer,"Java's Max-Heap [array]")) return false; - return true; - } - - private static boolean testJavaArrayList() { - if(!testJavaCollection(new java.util.ArrayList(),Type.Integer,"Java's List [array]")) return false; - return true; - } - - private static boolean testJavaLinkedList() { - if(!testJavaCollection(new java.util.LinkedList(),Type.Integer,"Java's List [linked]")) return false; - return true; - } - - private static boolean testJavaArrayQueue() { - String aName = "Java's Queue [array]"; - java.util.Deque aCollection = new java.util.ArrayDeque(); - - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testJavaLinkedQueue() { - String lName = "Java's Queue [linked]"; - java.util.Deque lCollection = new java.util.LinkedList(); - - if(!testJavaCollection(lCollection,Type.Integer,lName)) return false; - return true; - } - - private static boolean testJavaRedBlackIntegerTree() { - String aName = "Java's Red-Black Tree [Integer]"; - java.util.TreeSet aCollection = new java.util.TreeSet(); - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testJavaRedBlackStringTree() { - String aName = "Java's Red-Black Tree [String]"; - java.util.TreeSet aCollection = new java.util.TreeSet(); - if(!testJavaCollection(aCollection,Type.String,aName)) return false; - return true; - } - - private static boolean testJavaStack() { - String aName = "Java's Stack [array]"; - java.util.Stack aCollection = new java.util.Stack(); - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testJavaTreeMap() { - String mapName = "Java's TreeMap"; - java.util.Map map = new java.util.TreeMap(); - - if(!testJavaMap(map,Type.String,mapName)) return false; - return true; - } - - private static boolean testKdTree() { - if (debug > 1) System.out.println("k-d tree with node."); - - java.util.List points = new ArrayList(); - KdTree.XYZPoint p1 = new KdTree.XYZPoint(2, 3); - points.add(p1); - KdTree.XYZPoint p2 = new KdTree.XYZPoint(5, 4); - points.add(p2); - KdTree.XYZPoint p3 = new KdTree.XYZPoint(9, 6); - points.add(p3); - KdTree.XYZPoint p4 = new KdTree.XYZPoint(4, 7); - points.add(p4); - KdTree.XYZPoint p5 = new KdTree.XYZPoint(8, 1); - points.add(p5); - KdTree.XYZPoint p6 = new KdTree.XYZPoint(7, 2); - points.add(p6); - KdTree kdTree = new KdTree(points); - if (debug > 1) System.out.println(kdTree.toString()); - - Collection result = kdTree.nearestNeighbourSearch(1, p3); - if (debug > 1) System.out.println("NNS for " + p3 + " result=" + result + "\n"); - - KdTree.XYZPoint search = new KdTree.XYZPoint(1, 4); - result = kdTree.nearestNeighbourSearch(4, search); - if (debug > 1) System.out.println("NNS for " + search + " result=" + result + "\n"); - - kdTree.remove(p6); - if (debug > 1) System.out.println("Removed " + p6 + "\n" + kdTree.toString()); - kdTree.remove(p4); - if (debug > 1) System.out.println("Removed " + p4 + "\n" + kdTree.toString()); - kdTree.remove(p3); - if (debug > 1) System.out.println("Removed " + p3 + "\n" + kdTree.toString()); - kdTree.remove(p5); - if (debug > 1) System.out.println("Removed " + p5 + "\n" + kdTree.toString()); - kdTree.remove(p1); - if (debug > 1) System.out.println("Removed " + p1 + "\n" + kdTree.toString()); - kdTree.remove(p2); - if (debug > 1) System.out.println("Removed " + p2 + "\n" + kdTree.toString()); - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testArrayList() { - String aName = "List [array]"; - List.ArrayList aList = new List.ArrayList(); - Collection aCollection = aList.toCollection(); - - if((validateStructure||validateContents) && !testList(aList,aName)) return false; - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testLinkedList() { - String lName = "List [linked]"; - List.LinkedList lList = new List.LinkedList(); - Collection lCollection = lList.toCollection(); - - if((validateStructure||validateContents) && !testList(lList,lName)) return false; - if(!testJavaCollection(lCollection,Type.Integer,lName)) return false; - return true; - } - - private static boolean testMatrix() { - if (debug > 1) System.out.println("Matrix."); - Matrix matrix1 = new Matrix(4, 3); - matrix1.set(0, 0, 14); - matrix1.set(0, 1, 9); - matrix1.set(0, 2, 3); - matrix1.set(1, 0, 2); - matrix1.set(1, 1, 11); - matrix1.set(1, 2, 15); - matrix1.set(2, 0, 0); - matrix1.set(2, 1, 12); - matrix1.set(2, 2, 17); - matrix1.set(3, 0, 5); - matrix1.set(3, 1, 2); - matrix1.set(3, 2, 3); - - Matrix matrix2 = new Matrix(3, 2); - matrix2.set(0, 0, 12); - matrix2.set(0, 1, 25); - matrix2.set(1, 0, 9); - matrix2.set(1, 1, 10); - matrix2.set(2, 0, 8); - matrix2.set(2, 1, 5); - - if (debug > 1) System.out.println("Matrix multiplication."); - Matrix matrix3 = matrix1.multiply(matrix2); - if (debug > 1) System.out.println(matrix3); - - int rows = 2; - int cols = 2; - int counter = 0; - Matrix matrix4 = new Matrix(rows, cols); - for (int r = 0; r < rows; r++) { - for (int c = 0; c < cols; c++) { - matrix4.set(r, c, counter++); - } - } - - if (debug > 1) System.out.println("Matrix subtraction."); - Matrix matrix5 = matrix4.subtract(matrix4); - if (debug > 1) System.out.println(matrix5); - - if (debug > 1) System.out.println("Matrix addition."); - Matrix matrix6 = matrix4.add(matrix4); - if (debug > 1) System.out.println(matrix6); - - Matrix matrix7 = new Matrix(2, 2); - matrix7.set(0, 0, 1); - matrix7.set(0, 1, 2); - matrix7.set(1, 0, 3); - matrix7.set(1, 1, 4); - - Matrix matrix8 = new Matrix(2, 2); - matrix8.set(0, 0, 1); - matrix8.set(0, 1, 2); - matrix8.set(1, 0, 3); - matrix8.set(1, 1, 4); - - if (debug > 1) System.out.println("Matrix multiplication."); - Matrix matrix9 = matrix7.multiply(matrix8); - if (debug > 1) System.out.println(matrix9); - - return true; - } - - private static boolean testPatriciaTrie() { - String bstName = "PatriciaTrie"; - PatriciaTrie bst = new PatriciaTrie(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.String,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.String,bstName)) return false; - return true; - } - - private static boolean testQuadTree() { - int size = 16000; - - java.util.Set set = new java.util.HashSet(size); - while (set.size() < size) { - float x = RANDOM.nextInt(size); - float y = RANDOM.nextInt(size); - QuadTree.XYPoint xyPoint = new QuadTree.XYPoint(x,y); - set.add(xyPoint); - } - - java.util.List query = new java.util.ArrayList(size); - for (int j=0; j tree = new QuadTree.PointRegionQuadTree(0,0,size,size); - - beforeMemory = DataStructures.getMemoryUse(); - { - beforeInsert = System.nanoTime(); - for (QuadTree.XYPoint p : set) { - tree.insert(p.getX(), p.getY()); - } - afterInsert = System.nanoTime(); - insertTime = afterInsert - beforeInsert; - System.out.println("PointRegionQuadTree insertTime="+insertTime/100000d+" ms"); - } - afterMemory = DataStructures.getMemoryUse(); - treeMemory = afterMemory - beforeMemory; - System.out.println("PointRegionQuadTree treeMemory="+treeMemory); - - //System.out.println(tree); - - // We should find all points here (tests structure) - for (QuadTree.XYPoint p : set) { - java.util.List result = tree.queryRange(p.getX(), p.getY(), 1, 1); - if (result.size()<=0) return false; - } - - // We should find all points here (tests query speed) - { - beforeQuery = System.nanoTime(); - for (QuadTree.XYPoint p : query) { - tree.queryRange(p.getX(), p.getY(), 1, 1); - } - afterQuery = System.nanoTime(); - queryTime = afterQuery - beforeQuery; - System.out.println("PointRegionQuadTree queryTime="+queryTime/100000d+" ms"); - } - - // Result set should not contain duplicates - beforeTreeQuery = System.nanoTime(); - java.util.List result = tree.queryRange(0, 0, size, size); - afterTreeQuery = System.nanoTime(); - treeQuery = afterTreeQuery - beforeTreeQuery; - System.out.println("PointRegionQuadTree wholeTreeQuery="+treeQuery/100000d+" ms"); - Collections.sort(result); - QuadTree.XYPoint prev = null; - for (QuadTree.XYPoint p : result) { - if (prev!=null && prev.equals(p)) return false; - prev = p; - } - - { // Remove all - beforeRemove = System.nanoTime(); - for (QuadTree.XYPoint p : set) { - //System.out.println(p.toString()); - boolean removed = tree.remove(p.getX(), p.getY()); - //System.out.println(tree.toString()); - if (!removed) return false; - } - afterRemove = System.nanoTime(); - removeTime = afterRemove - beforeRemove; - System.out.println("PointRegionQuadTree removeTime="+removeTime/100000d+" ms"); - } - } - - { // Rectangle base quadtree - QuadTree.MxCifQuadTree tree = new QuadTree.MxCifQuadTree(0,0,size,size,10,10); - beforeMemory = DataStructures.getMemoryUse(); - { - beforeInsert = System.nanoTime(); - for (QuadTree.XYPoint p : set) { - tree.insert(p.getX(), p.getY(), 1, 1); - } - afterInsert = System.nanoTime(); - insertTime = afterInsert - beforeInsert; - System.out.println("MxCifQuadTree insertTime="+insertTime/100000d+" ms"); - } - afterMemory = DataStructures.getMemoryUse(); - treeMemory = afterMemory - beforeMemory; - System.out.println("MxCifQuadTree treeMemory="+treeMemory); - - //System.out.println(tree); - - // We should find all points here - for (QuadTree.XYPoint p : set) { - java.util.List result = tree.queryRange(p.getX(), p.getY(), 1, 1); - if (result.size()<=0) return false; - } - - { // We should find all points here - beforeQuery = System.nanoTime(); - for (QuadTree.XYPoint p : query) { - tree.queryRange(p.getX(), p.getY(), 1, 1); - } - afterQuery = System.nanoTime(); - queryTime = afterQuery - beforeQuery; - System.out.println("MxCifQuadTree queryTime="+queryTime/100000d+" ms"); - } - - // Result set should not contain duplicates - beforeTreeQuery = System.nanoTime(); - java.util.List result = tree.queryRange(0, 0, size, size); - afterTreeQuery = System.nanoTime(); - treeQuery = afterTreeQuery - beforeTreeQuery; - System.out.println("MxCifQuadTree wholeTreeQuery="+treeQuery/100000d+" ms"); - Collections.sort(result); - QuadTree.AxisAlignedBoundingBox prev = null; - for (QuadTree.AxisAlignedBoundingBox p : result) { - if (prev!=null && prev.equals(p)) { - return false; - } - prev = p; - } - - { // Remove all - beforeRemove = System.nanoTime(); - for (QuadTree.XYPoint p : set) { - //System.out.println(p.toString()); - boolean removed = tree.remove(p.getX(), p.getY(), 1, 1); - //System.out.println(tree.toString()); - if (!removed) return false; - } - afterRemove = System.nanoTime(); - removeTime = afterRemove - beforeRemove; - System.out.println("MxCifQuadTree removeTime="+removeTime/100000d+" ms"); - } - } - - return true; - } - - private static boolean testArrayQueue() { - String aName = "Queue [array]"; - Queue.ArrayQueue aQueue = new Queue.ArrayQueue(); - Collection aCollection = aQueue.toCollection(); - - if((validateStructure||validateContents) && !testQueue(aQueue,aName)) return false; - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testLinkedQueue() { - String lName = "Queue [linked]"; - Queue.LinkedQueue lQueue = new Queue.LinkedQueue(); - Collection lCollection = lQueue.toCollection(); - - if((validateStructure||validateContents) && !testQueue(lQueue,lName)) return false; - if(!testJavaCollection(lCollection,Type.Integer,lName)) return false; - return true; - } - - private static boolean testRadixTrie() { - String mapName = "RadixTrie"; - RadixTrie map = new RadixTrie(); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.String,mapName)) return false; - if(!testJavaMap(jMap,Type.String,mapName)) return false; - return true; - } - - private static boolean testRedBlackTree() { - String bstName = "Red-Black Tree"; - RedBlackTree bst = new RedBlackTree(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - - return true; - } - - private static boolean testSegmentTree() { - { // Quadrant Segment tree - if (debug > 1) System.out.println("Quadrant Segment Tree."); - java.util.List segments = new ArrayList(); - segments.add(new SegmentTree.Data.QuadrantData(0, 1, 0, 0, 0)); // first point in the 0th quadrant - segments.add(new SegmentTree.Data.QuadrantData(1, 0, 1, 0, 0)); // second point in the 1st quadrant - segments.add(new SegmentTree.Data.QuadrantData(2, 0, 0, 1, 0)); // third point in the 2nd quadrant - segments.add(new SegmentTree.Data.QuadrantData(3, 0, 0, 0, 1)); // fourth point in the 3rd quadrant - FlatSegmentTree tree = new FlatSegmentTree(segments); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.QuadrantData query = tree.query(0, 3); - if (debug > 1) System.out.println("0->3: " + query + "\n"); - - query = tree.query(2, 3); - if (debug > 1) System.out.println("2->3: " + query + "\n"); - - query = tree.query(0, 2); - if (debug > 1) System.out.println("0->2: " + query + "\n"); - - if (debug > 1) System.out.println(); - } - - { // Range Maximum Segment tree - if (debug > 1) System.out.println("Range Maximum Segment Tree."); - java.util.List> segments = new ArrayList>(); - segments.add(new SegmentTree.Data.RangeMaximumData(0, (Integer) 4)); - segments.add(new SegmentTree.Data.RangeMaximumData(1, (Integer) 2)); - segments.add(new SegmentTree.Data.RangeMaximumData(2, (Integer) 6)); - segments.add(new SegmentTree.Data.RangeMaximumData(3, (Integer) 3)); - segments.add(new SegmentTree.Data.RangeMaximumData(4, (Integer) 1)); - segments.add(new SegmentTree.Data.RangeMaximumData(5, (Integer) 5)); - segments.add(new SegmentTree.Data.RangeMaximumData(6, (Integer) 0)); - segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, 7)); - segments.add(new SegmentTree.Data.RangeMaximumData(21, (Integer) 10)); - FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); - if (debug > 1) System.out.println("0->7: " + query + "\n"); - - query = tree.query(0, 21); - if (debug > 1) System.out.println("0->21: " + query + "\n"); - - query = tree.query(2, 5); - if (debug > 1) System.out.println("2->5: " + query + "\n"); - - query = tree.query(7); - if (debug > 1) System.out.println("7: " + query + "\n"); - - if (debug > 1) System.out.println(); - } - - { // Range Minimum Segment tree - if (debug > 1) System.out.println("Range Minimum Segment Tree."); - java.util.List> segments = new ArrayList>(); - segments.add(new SegmentTree.Data.RangeMinimumData(0, (Integer) 4)); - segments.add(new SegmentTree.Data.RangeMinimumData(1, (Integer) 2)); - segments.add(new SegmentTree.Data.RangeMinimumData(2, (Integer) 6)); - segments.add(new SegmentTree.Data.RangeMinimumData(3, (Integer) 3)); - segments.add(new SegmentTree.Data.RangeMinimumData(4, (Integer) 1)); - segments.add(new SegmentTree.Data.RangeMinimumData(5, (Integer) 5)); - segments.add(new SegmentTree.Data.RangeMinimumData(6, (Integer) 0)); - segments.add(new SegmentTree.Data.RangeMinimumData(17, (Integer) 7)); - FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); - if (debug > 1) System.out.println("0->7: " + query + "\n"); - - query = tree.query(0, 17); - if (debug > 1) System.out.println("0->17: " + query + "\n"); - - query = tree.query(1, 3); - if (debug > 1) System.out.println("1->3: " + query + "\n"); - - query = tree.query(7); - if (debug > 1) System.out.println("7: " + query + "\n"); - - if (debug > 1) System.out.println(); - } - - { // Range Sum Segment tree - if (debug > 1) System.out.println("Range Sum Segment Tree."); - java.util.List> segments = new ArrayList>(); - segments.add(new SegmentTree.Data.RangeSumData(0, (Integer) 4)); - segments.add(new SegmentTree.Data.RangeSumData(1, (Integer) 2)); - segments.add(new SegmentTree.Data.RangeSumData(2, (Integer) 6)); - segments.add(new SegmentTree.Data.RangeSumData(3, (Integer) 3)); - segments.add(new SegmentTree.Data.RangeSumData(4, (Integer) 1)); - segments.add(new SegmentTree.Data.RangeSumData(5, (Integer) 5)); - segments.add(new SegmentTree.Data.RangeSumData(6, (Integer) 0)); - segments.add(new SegmentTree.Data.RangeSumData(17, (Integer) 7)); - FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.RangeSumData query = tree.query(0, 8); - if (debug > 1) System.out.println("0->8: " + query + "\n"); - - query = tree.query(0, 17); - if (debug > 1) System.out.println("0->17: " + query + "\n"); - - query = tree.query(2, 5); - if (debug > 1) System.out.println("2->5: " + query + "\n"); - - query = tree.query(10, 17); - if (debug > 1) System.out.println("10->17: " + query + "\n"); - - query = tree.query(16); - if (debug > 1) System.out.println("16: " + query + "\n"); - - query = tree.query(17); - if (debug > 1) System.out.println("17: " + query + "\n"); - - if (debug > 1) System.out.println(); - } - - { // Interval Segment tree - if (debug > 1) System.out.println("Interval Segment Tree."); - java.util.List> segments = new ArrayList>(); - segments.add((new SegmentTree.Data.IntervalData(2, 6, "RED"))); - segments.add((new SegmentTree.Data.IntervalData(3, 5, "ORANGE"))); - segments.add((new SegmentTree.Data.IntervalData(4, 11, "GREEN"))); - segments.add((new SegmentTree.Data.IntervalData(5, 10, "DARK_GREEN"))); - segments.add((new SegmentTree.Data.IntervalData(8, 12, "BLUE"))); - segments.add((new SegmentTree.Data.IntervalData(9, 14, "PURPLE"))); - segments.add((new SegmentTree.Data.IntervalData(13, 15, "BLACK"))); - DynamicSegmentTree> tree = new DynamicSegmentTree>(segments); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.IntervalData query = tree.query(2); - if (debug > 1) System.out.println("2: " + query); - - query = tree.query(4); // Stabbing query - if (debug > 1) System.out.println("4: " + query); - - query = tree.query(9); // Stabbing query - if (debug > 1) System.out.println("9: " + query); - - query = tree.query(1, 16); // Range query - if (debug > 1) System.out.println("1->16: " + query); - - query = tree.query(7, 14); // Range query - if (debug > 1) System.out.println("7->14: " + query); - - query = tree.query(14, 15); // Range query - if (debug > 1) System.out.println("14->15: " + query); - - if (debug > 1) System.out.println(); - } - - { // Lifespan Interval Segment tree - if (debug > 1) System.out.println("Lifespan Interval Segment Tree."); - java.util.List> segments = new ArrayList>(); - segments.add((new SegmentTree.Data.IntervalData(1888, 1971, "Stravinsky"))); - segments.add((new SegmentTree.Data.IntervalData(1874, 1951, "Schoenberg"))); - segments.add((new SegmentTree.Data.IntervalData(1843, 1907, "Grieg"))); - segments.add((new SegmentTree.Data.IntervalData(1779, 1828, "Schubert"))); - segments.add((new SegmentTree.Data.IntervalData(1756, 1791, "Mozart"))); - segments.add((new SegmentTree.Data.IntervalData(1585, 1672, "Schuetz"))); - DynamicSegmentTree> tree = new DynamicSegmentTree>(segments, 25); - if (debug > 1) System.out.println(tree); - - SegmentTree.Data.IntervalData query = tree.query(1890); - if (debug > 1) System.out.println("1890: " + query); - - query = tree.query(1909); // Stabbing query - if (debug > 1) System.out.println("1909: " + query); - - query = tree.query(1792, 1903); // Range query - if (debug > 1) System.out.println("1792->1903: " + query); - - query = tree.query(1776, 1799); // Range query - if (debug > 1) System.out.println("1776->1799: " + query); - - if (debug > 1) System.out.println(); - } - - return true; - } - - private static boolean testJavaSkipList() { - String sName = "Java's SkipList"; - NavigableSet sList = new ConcurrentSkipListSet(); - Collection lCollection = sList; - if(!testJavaCollection(lCollection,Type.Integer,sName)) return false; - return true; - } - - private static boolean testSkipList() { - String sName = "SkipList"; - SkipList sList = new SkipList(); - Collection lCollection = sList.toCollection(); - - if((validateStructure||validateContents) && !testSet(sList,sName)) return false; - if(!testJavaCollection(lCollection,Type.Integer,sName)) return false; - return true; - } - - private static boolean testSplayTree() { - String bstName = "Splay Tree"; - BinarySearchTree bst = new SplayTree(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - - return true; - } - - private static boolean testArrayStack() { - String aName = "Stack [array]"; - Stack.ArrayStack aStack = new Stack.ArrayStack(); - Collection aCollection = aStack.toCollection(); - - if((validateStructure||validateContents) && !testStack(aStack,aName)) return false; - if(!testJavaCollection(aCollection,Type.Integer,aName)) return false; - return true; - } - - private static boolean testLinkedStack() { - String lName = "Stack [linked]"; - Stack.LinkedStack lStack = new Stack.LinkedStack(); - Collection lCollection = lStack.toCollection(); - - if((validateStructure||validateContents) && !testStack(lStack,lName)) return false; - if(!testJavaCollection(lCollection,Type.Integer,lName)) return false; - return true; - } - - private static boolean testSuffixTree() { - if (debug > 1) System.out.println("Suffix Tree."); - String bookkeeper = "bookkeeper"; - SuffixTree tree = new SuffixTree(bookkeeper); - if (debug > 1) System.out.println(tree.toString()); - if (debug > 1) System.out.println(tree.getSuffixes()); - - boolean exists = tree.doesSubStringExist(bookkeeper); - if (!exists) { - System.err.println("YIKES!! " + bookkeeper + " doesn't exists."); - handleError(tree); - return false; - } - - String failed = "booker"; - exists = tree.doesSubStringExist(failed); - if (exists) { - System.err.println("YIKES!! " + failed + " exists."); - handleError(tree); - return false; - } - - String pass = "kkee"; - exists = tree.doesSubStringExist(pass); - if (!exists) { - System.err.println("YIKES!! " + pass + " doesn't exists."); - handleError(tree); - return false; - } - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testSuffixTrie() { - if (debug > 1) System.out.println("Suffix Trie."); - String bookkeeper = "bookkeeper"; - SuffixTrie trie = new SuffixTrie(bookkeeper); - if (debug > 1) System.out.println(trie.toString()); - if (debug > 1) System.out.println(trie.getSuffixes()); - - boolean exists = trie.doesSubStringExist(bookkeeper); - if (!exists) { - System.err.println("YIKES!! " + bookkeeper + " doesn't exists."); - handleError(trie); - return false; - } - - String failed = "booker"; - exists = trie.doesSubStringExist(failed); - if (exists) { - System.err.println("YIKES!! " + failed + " exists."); - handleError(trie); - return false; - } - - String pass = "kkee"; - exists = trie.doesSubStringExist(pass); - if (!exists) { - System.err.println("YIKES!! " + pass + " doesn't exists."); - handleError(trie); - return false; - } - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testTreap() { - String bstName = "Treap"; - BinarySearchTree bst = new Treap(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.Integer,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; - return true; - } - - private static boolean testTreeMap() { - String mapName = "TreeMap"; - TreeMap map = new TreeMap(); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.String,mapName)) return false; - if(!testJavaMap(jMap,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testTrie() { - String bstName = "Trie"; - Trie bst = new Trie(); - Collection bstCollection = bst.toCollection(); - - if((validateStructure||validateContents) && !testTree(bst,Type.String,bstName)) return false; - if(!testJavaCollection(bstCollection,Type.String,bstName)) return false; - return true; - } - - private static boolean testTrieMap() { - String mapName = "TrieMap"; - TrieMap map = new TrieMap(); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.String,mapName)) return false; - if(!testJavaMap(jMap,Type.String,mapName)) return false; - return true; - } - - private static boolean testJavaSkipListMap() { - String mapName = "Java's SkipListMap"; - ConcurrentSkipListMap map = new ConcurrentSkipListMap(); - if(!testJavaMap(map,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testSkipListMap() { - String mapName = "SkipListMap"; - SkipListMap map = new SkipListMap(); - java.util.Map jMap = map.toMap(); - - if((validateStructure||validateContents) && !testMap(map,Type.String,mapName)) return false; - if(!testJavaMap(jMap,Type.Integer,mapName)) return false; - return true; - } - - private static boolean testMap(IMap map, Type keyType, String name) { - for (int i = 0; i < unsorted.length; i++) { - Integer item = unsorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - V added = map.put(k,v); - if (validateStructure && (!map.validate() || (map.size() != (i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && (added!=null || !map.contains(k))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists."); - handleError(map); - return false; - } - } - - K invalidKey = null; - if (keyType == Type.Integer) { - invalidKey = (K)INVALID; - } else if (keyType == Type.String) { - invalidKey = (K)String.valueOf(INVALID); - } - boolean contains = map.contains(invalidKey); - V removed = map.remove(invalidKey); - if (contains || (removed!=null)) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(map); - return false; - } - - for (int i = 0; i < unsorted.length; i++) { - Integer item = unsorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (validateStructure && (!map.validate() || (map.size() != (unsorted.length-(i+1))))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && map.contains(k)) { - System.err.println(name+" YIKES!! " + item + " still exists."); - handleError(map); - return false; - } - } - - // Add half, remove a quarter, add three-quarters, remove all - int quarter = unsorted.length/4; - int half = unsorted.length/2; - for (int i = 0; i < half; i++) { - Integer item = unsorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - V added = map.put(k,v); - if (validateStructure && (!map.validate() || (map.size() != (i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && (added!=null || !map.contains(k))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists."); - handleError(map); - return false; - } - } - for (int i = (half-1); i >= quarter; i--) { - Integer item = unsorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (validateStructure && (!map.validate() || (map.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && (removed==null || map.contains(k))) { - System.err.println(name+" YIKES!! " + item + " still exists."); - handleError(map); - return false; - } - } - for (int i = quarter; i < unsorted.length; i++) { - Integer item = unsorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - V added = map.put(k,v); - if (validateStructure && (!map.validate() || (map.size() != (i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && (added!=null || !map.contains(k))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists."); - handleError(map); - return false; - } - } - for (int i = unsorted.length-1; i >= 0; i--) { - Integer item = unsorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (validateStructure && (!map.validate() || (map.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(map); - return false; - } - if (validateContents && (removed==null || map.contains(k))) { - System.err.println(name+" YIKES!! " + item + " still exists."); - handleError(map); - return false; - } - } - - if (validateStructure && (map.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(map); - return false; - } - - return true; - } - - /** - * Tests the tree operations - * - * @param tree to test. - * @return True is works as a tree structure. - */ - private static > boolean testTree(ITree tree, Type type, String name) { - for (int i = 0; i < unsorted.length; i++) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - boolean added = tree.add(item); - if (validateStructure && (!tree.validate() || (tree.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (!added || !tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(tree); - return false; - } - } - - T invalidItem = null; - if (type == Type.Integer) { - invalidItem = (T)INVALID; - } else if (type == Type.String) { - invalidItem = (T)String.valueOf(INVALID); - } - boolean contains = tree.contains(invalidItem); - T removed = tree.remove(invalidItem); - if (contains || removed!=null) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(tree); - return false; - } - - int size = tree.size(); - for (int i = 0; i < size; i++) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - removed = tree.remove(item); - if (validateStructure && (!tree.validate() || (tree.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (removed==null || tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been removed."); - handleError(tree); - return false; - } - } - - // Add half, remove a quarter, add three-quarters - int quarter = unsorted.length/4; - int half = unsorted.length/2; - for (int i = 0; i < half; i++) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - boolean added = tree.add(item); - if (validateStructure && (!tree.validate() || (tree.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (!added || !tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(tree); - return false; - } - } - for (int i = (half-1); i >= quarter; i--) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - removed = tree.remove(item); - if (validateStructure && (!tree.validate() || (tree.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (removed==null || tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(tree); - return false; - } - } - for (int i = quarter; i < unsorted.length; i++) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - boolean added = tree.add(item); - if (validateStructure && (!tree.validate() || (tree.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (!added || !tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(tree); - return false; - } - } - for (int i = unsorted.length-1; i >= 0; i--) { - Integer value = unsorted[i]; - T item = null; - if (type == Type.Integer) { - item = (T)value; - } else if (type == Type.String) { - item = (T)String.valueOf(value); - } - removed = tree.remove(item); - if (validateStructure && (!tree.validate() || (tree.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(tree); - return false; - } - if (validateContents && (removed==null || tree.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(tree); - return false; - } - } - - if (validateStructure && (tree.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(tree); - return false; - } - - return true; - } - - /** - * Tests the actual heap like operations - * - * @param heap to test. - * @return True is works as a heap structure. - */ - private static > boolean testHeap(IHeap heap, String name, BinaryHeap.Type type) { - for (int i = 0; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = heap.add(item); - if (validateStructure && (!heap.validate() || (heap.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (!added || !heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(heap); - return false; - } - } - - boolean contains = heap.contains((T)INVALID); - T removed = heap.remove((T)INVALID); - if (contains || (removed!=null)) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(heap); - return false; - } - - int size = heap.size(); - for (int i = 0; i < size; i++) { - T item = heap.removeHead(); - T correct = (T)((type == BinaryHeap.Type.MIN)?sorted[i]:sorted[sorted.length-(i+1)]); - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match heap item."); - handleError(heap); - return false; - } - if (validateStructure && (!heap.validate() || (heap.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (item==null || heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(heap); - return false; - } - } - - // Add half, remove a quarter, add three-quarters, remove all - int quarter = unsorted.length/4; - int half = unsorted.length/2; - Integer[] halfArray = Arrays.copyOf(unsorted, half); - Arrays.sort(halfArray); - Integer[] quarterArray = new Integer[quarter]; - Integer[] sortedQuarterArray = new Integer[quarter]; //Needed for binary search - for (int i=0; i=0) { - threeQuartersArray[idx++] = i; - } else { - index = Arrays.binarySearch(halfArray, i); - if (index<0) threeQuartersArray[idx++] = i; - } - } else { - if (index>=0) { - threeQuartersArray[idx++] = i; - } else { - index = Arrays.binarySearch(halfArray, i); - if (index<0) threeQuartersArray[idx++] = i; - } - } - } - for (int i = 0; i < half; i++) { - T item = (T)unsorted[i]; - boolean added = heap.add(item); - if (validateStructure && (!heap.validate() || (heap.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (!added || !heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(heap); - return false; - } - } - for (int i = 0; i < quarter; i++) { - T item = heap.removeHead(); - T correct = (T)quarterArray[i]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match heap item."); - handleError(heap); - return false; - } - if (validateStructure && (!heap.validate() || (heap.size() != half-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (item==null || heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(heap); - return false; - } - } - for (int i = 0; i < threeQuartersArray.length; i++) { - T item = (T)threeQuartersArray[i]; - boolean added = heap.add(item); - if (validateStructure && (!heap.validate() || (heap.size() != quarter+(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (!added || !heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(heap); - return false; - } - } - for (int i = 0; i < sorted.length; i++) { - T item = heap.removeHead(); - T correct = (T)((type == BinaryHeap.Type.MIN)?sorted[i]:sorted[sorted.length-(i+1)]); - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match heap item."); - handleError(heap); - return false; - } - if (validateStructure && (!heap.validate() || (heap.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(heap); - return false; - } - if (validateContents && (item==null || heap.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(heap); - return false; - } - } - - if (validateStructure && (heap.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(heap); - return false; - } - - return true; - } - - /** - * Tests the actual queue like (FIFO) operations - * - * @param queue to test. - * @return True is works as a FIFO structure. - */ - private static > boolean testQueue(IQueue queue, String name) { - for (int i = 0; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = queue.offer(item); - if (validateStructure && (!queue.validate() || (queue.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (!added || !queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(queue); - return false; - } - } - - boolean contains = queue.contains((T)INVALID); - boolean removed = queue.remove((T)INVALID); - if (contains || removed) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(queue); - return false; - } - - int size = queue.size(); - for (int i = 0; i < size; i++) { - T item = queue.poll(); - T correct = (T)unsorted[i]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match FIFO item."); - handleError(queue); - return false; - } - if (validateStructure && (!queue.validate() || (queue.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (item==null || queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(queue); - return false; - } - } - - // Add half, remove a quarter, add three-quarters - int quarter = unsorted.length/4; - int half = unsorted.length/2; - int changeOver = half-quarter; - for (int i = 0; i < half; i++) { - T item = (T)unsorted[i]; - boolean added = queue.offer(item); - if (validateStructure && (!queue.validate() || (queue.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (!added || !queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(queue); - return false; - } - } - for (int i = 0; i < quarter; i++) { - T item = queue.poll(); - T correct = (T)unsorted[i]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match FIFO item."); - handleError(queue); - return false; - } - if (validateStructure && (!queue.validate() || (queue.size() != (half-(i+1))))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (item==null || queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(queue); - return false; - } - } - for (int i = 0; i < quarter; i++) { - T item = (T)unsorted[i]; - boolean added = queue.offer(item); - if (validateStructure && (!queue.validate() || (queue.size() != ((half-quarter)+(i+1))))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (!added || !queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(queue); - return false; - } - } - for (int i = half; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = queue.offer(item); - if (validateStructure && (!queue.validate() || (queue.size() != (i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(queue); - return false; - } - if (validateContents && (!added || !queue.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(queue); - return false; - } - } - for (int i = 0; i < unsorted.length; i++) { - T item = queue.poll(); - int idx = i; - if (idx < changeOver) { - idx = quarter+i; - } else if (idx>=changeOver && idx> boolean testStack(IStack stack, String name) { - for (int i = 0; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = stack.push(item); - if (validateStructure && (!stack.validate() || (stack.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (!added || item==null || !stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(stack); - return false; - } - } - - boolean contains = stack.contains((T)INVALID); - boolean removed = stack.remove((T)INVALID); - if (contains || removed) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(stack); - return false; - } - - int size = stack.size(); - for (int i = 0; i < size; i++) { - T item = stack.pop(); - T correct = (T)unsorted[unsorted.length-(i+1)]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); - handleError(stack); - return false; - } - if (validateStructure && (!stack.validate() || (stack.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (item==null || stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(stack); - return false; - } - } - - // Add half, remove a quarter, add three-quarters, remove all - int quarter = unsorted.length/4; - int half = unsorted.length/2; - for (int i = 0; i < half; i++) { - T item = (T)unsorted[i]; - boolean added = stack.push(item); - if (validateStructure && (!stack.validate() || (stack.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (!added || item==null || !stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(stack); - return false; - } - } - for (int i = (half-1); i >= quarter; i--) { - T item = stack.pop(); - T correct = (T)unsorted[i]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); - handleError(stack); - return false; - } - if (validateStructure && (!stack.validate() || (stack.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (item==null || stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(stack); - return false; - } - } - for (int i = quarter; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = stack.push(item); - if (validateStructure && (!stack.validate() || (stack.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (!added || item==null || !stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(stack); - return false; - } - } - for (int i = unsorted.length-1; i >= 0; i--) { - T item = stack.pop(); - T correct = (T)unsorted[i]; - if (validateStructure && (item.compareTo(correct)!=0)) { - System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); - handleError(stack); - return false; - } - if (validateStructure && (!stack.validate() || (stack.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(stack); - return false; - } - if (validateContents && (item==null || stack.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(stack); - return false; - } - } - - if (validateStructure && (stack.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(stack); - return false; - } - - return true; - } - - /** - * Tests the actual list operations - * - * @param list to test. - * @return True is works as a list structure. - */ - private static > boolean testList(IList list, String name) { - for (int i = 0; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = list.add(item); - if (validateStructure && (!list.validate() || (list.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!added || !list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(list); - return false; - } - } - - boolean contains = list.contains((T)INVALID); - boolean removed = list.remove((T)INVALID); - if (contains || removed) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(list); - return false; - } - - int size = list.size(); - for (int i = 0; i < size; i++) { - T item = (T)unsorted[i]; - removed = list.remove(item); - if (validateStructure && (!list.validate() || (list.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!removed || list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(list); - return false; - } - } - - // Add half, remove a quarter, add three-quarters, remove all - int quarter = unsorted.length/4; - int half = unsorted.length/2; - for (int i = 0; i < half; i++) { - T item = (T)unsorted[i]; - boolean added = list.add(item); - if (validateStructure && (!list.validate() || (list.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!added || !list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(list); - return false; - } - } - for (int i = (half-1); i >= quarter; i--) { - T item = (T)unsorted[i]; - removed = list.remove(item); - if (validateStructure && (!list.validate() || (list.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!removed || list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(list); - return false; - } - } - for (int i = quarter; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = list.add(item); - if (validateStructure && (!list.validate() || (list.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!added || !list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(list); - return false; - } - } - for (int i = unsorted.length-1; i >= 0; i--) { - T item = (T)unsorted[i]; - removed = list.remove(item); - if (validateStructure && (!list.validate() || (list.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(list); - return false; - } - if (validateContents && (!removed || list.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(list); - return false; - } - } - - if (validateStructure && (list.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(list); - return false; - } - - return true; - } - - /** - * Tests the actual set operations - * - * @param set to test. - * @return True is works as a set structure. - */ - private static > boolean testSet(ISet set, String name) { - for (int i = 0; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = set.add(item); - if (validateStructure && (!set.validate() || (set.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!added || !set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(set); - return false; - } - } - - boolean contains = set.contains((T)INVALID); - boolean removed = set.remove((T)INVALID); - if (contains || removed) { - System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); - handleError(set); - return false; - } - - int size = set.size(); - for (int i = 0; i < size; i++) { - T item = (T)unsorted[i]; - removed = set.remove(item); - if (validateStructure && (!set.validate() || (set.size() != unsorted.length-(i+1)))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!removed || set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(set); - return false; - } - } - - // Add half, remove a quarter, add three-quarters, remove all - int quarter = unsorted.length/4; - int half = unsorted.length/2; - for (int i = 0; i < half; i++) { - T item = (T)unsorted[i]; - boolean added = set.add(item); - if (validateStructure && (!set.validate() || (set.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!added || !set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(set); - return false; - } - } - for (int i = (half-1); i >= quarter; i--) { - T item = (T)unsorted[i]; - removed = set.remove(item); - if (validateStructure && (!set.validate() || (set.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!removed || set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(set); - return false; - } - } - for (int i = quarter; i < unsorted.length; i++) { - T item = (T)unsorted[i]; - boolean added = set.add(item); - if (validateStructure && (!set.validate() || (set.size() != i+1))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!added || !set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); - handleError(set); - return false; - } - } - for (int i = unsorted.length-1; i >= 0; i--) { - T item = (T)unsorted[i]; - removed = set.remove(item); - if (validateStructure && (!set.validate() || (set.size() != i))) { - System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); - handleError(set); - return false; - } - if (validateContents && (!removed || set.contains(item))) { - System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); - handleError(set); - return false; - } - } - - if (validateStructure && (set.size() != 0)) { - System.err.println(name+" YIKES!! a size mismatch."); - handleError(set); - return false; - } - - return true; - } - - private static > boolean testJavaCollection(Collection collection, Type type, String name) { - // Make sure the collection is empty - if (!collection.isEmpty()) { - System.err.println(name+" initial isEmpty() failed."); - handleError(collection); - return false; - } - if (collection.size()!=0) { - System.err.println(name+" initial size() failed."); - handleError(collection); - return false; - } - - long sortedCount = 0; - long unsortedCount = 0; - - long addTime = 0L; - long removeTime = 0L; - - long beforeAddTime = 0L; - long afterAddTime = 0L; - long beforeRemoveTime = 0L; - long afterRemoveTime = 0L; - - long memory = 0L; - - long beforeMemory = 0L; - long afterMemory = 0L; - - long lookupTime = 0L; - - long beforeLookupTime = 0L; - long afterLookupTime = 0L; - - if (debug > 1) System.out.println(name); - testNames[testIndex] = name; - - unsortedCount++; - { // UNSORTED: Add and remove in order (from index zero to length) - beforeMemory = 0L; - afterMemory = 0L; - beforeAddTime = 0L; - afterAddTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean added = collection.add(item); - if (!added) { - System.err.println(name+" unsorted add failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterAddTime = System.nanoTime(); - addTime += afterAddTime - beforeAddTime; - if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - if (debug > 1) System.out.println(collection.toString()); - - if (validateIterator && !testIterator(collection.iterator())) { - System.err.println(name+" unsorted iterator failed."); - handleError(collection); - return false; - } - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean contains = collection.contains(item); - if (!contains) { - System.err.println(name+" unsorted contains failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveTime = 0L; - afterRemoveTime = 0L; - if (debugTime) beforeRemoveTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean removed = collection.remove(item); - if (!removed) { - System.err.println(name+" unsorted remove failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterRemoveTime = System.nanoTime(); - removeTime += afterRemoveTime - beforeRemoveTime; - if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); - } - - if (!collection.isEmpty()) { - System.err.println(name+" unsorted isEmpty() failed."); - handleError(collection); - return false; - } - if (collection.size()!=0) { - System.err.println(name+" unsorted size() failed."); - handleError(collection); - return false; - } - - if (validateIterator && collection instanceof java.util.List && !testListIterator(((java.util.List)collection).listIterator())) { - System.err.println(name+" unsorted list iterator failed."); - handleError(collection); - return false; - } - } - - unsortedCount++; - { // UNSORTED: Add in reverse (from index length-1 to zero) order and then remove in order (from index zero to length) - beforeMemory = 0L; - afterMemory = 0L; - beforeAddTime = 0L; - afterAddTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddTime = System.nanoTime(); - for (int i = unsorted.length - 1; i >= 0; i--) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean added = collection.add(item); - if (!added) { - System.err.println(name+" unsorted add failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterAddTime = System.nanoTime(); - addTime += afterAddTime - beforeAddTime; - if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - if (debug > 1) System.out.println(collection.toString()); - - if (validateIterator && !testIterator(collection.iterator())) { - System.err.println(name+" unsorted iterator failed."); - handleError(collection); - return false; - } - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean contains = collection.contains(item); - if (!contains) { - System.err.println(name+" unsorted contains failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveTime = 0L; - afterRemoveTime = 0L; - if (debugTime) beforeRemoveTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)unsorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(unsorted[i]); - } - boolean removed = collection.remove(item); - if (!removed) { - System.err.println(name+" unsorted remove failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterRemoveTime = System.nanoTime(); - removeTime += afterRemoveTime - beforeRemoveTime; - if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); - } - - if (!collection.isEmpty()) { - System.err.println(name+" unsorted isEmpty() failed."); - handleError(collection); - return false; - } - if (collection.size()!=0) { - System.err.println(name+" unsorted size() failed."); - handleError(collection); - return false; - } - } - - long addSortedTime = 0L; - long removeSortedTime = 0L; - - long beforeAddSortedTime = 0L; - long afterAddSortedTime = 0L; - - long beforeRemoveSortedTime = 0L; - long afterRemoveSortedTime = 0L; - - sortedCount++; - { // SORTED: Add and remove in order (from index zero to length) - beforeMemory = 0L; - afterMemory = 0L; - beforeAddSortedTime = 0L; - afterAddSortedTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean added = collection.add(item); - if (!added) { - System.err.println(name+" sorted add failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterAddSortedTime = System.nanoTime(); - addSortedTime += afterAddSortedTime - beforeAddSortedTime; - if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - if (debug > 1) System.out.println(collection.toString()); - - if (validateIterator && !testIterator(collection.iterator())) { - System.err.println(name+" sorted iterator failed."); - handleError(collection); - return false; - } - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean contains = collection.contains(item); - if (!contains) { - System.err.println(name+" sorted contains failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveSortedTime = 0L; - afterRemoveSortedTime = 0L; - if (debugTime) beforeRemoveSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean removed = collection.remove(item); - if (!removed) { - System.err.println(name+" sorted remove failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterRemoveSortedTime = System.nanoTime(); - removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; - if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); - } - - if (!collection.isEmpty()) { - System.err.println(name+" sorted isEmpty() failed."); - handleError(collection); - return false; - } - if (collection.size()!=0) { - System.err.println(name+" sorted size() failed."); - handleError(collection); - return false; - } - - if (validateIterator && collection instanceof java.util.List && !testListIterator(((java.util.List)collection).listIterator())) { - System.err.println(name+" sorted list iterator failed."); - handleError(collection); - return false; - } - } - - sortedCount++; - { // SORTED: Add in order (from index zero to length) and then remove in reverse (from index length-1 to zero) order - beforeMemory = 0L; - afterMemory = 0L; - beforeAddSortedTime = 0L; - afterAddSortedTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean added = collection.add(item); - if (!added) { - System.err.println(name+" sorted add failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterAddSortedTime = System.nanoTime(); - addSortedTime += afterAddSortedTime - beforeAddSortedTime; - if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - if (debug > 1) System.out.println(collection.toString()); - - if (validateIterator && !testIterator(collection.iterator())) { - System.err.println(name+" sorted iterator failed."); - handleError(collection); - return false; - } - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean contains = collection.contains(item); - if (!contains) { - System.err.println(name+" sorted contains failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveSortedTime = 0L; - afterRemoveSortedTime = 0L; - if (debugTime) beforeRemoveSortedTime = System.nanoTime(); - for (int i = sorted.length - 1; i >= 0; i--) { - T item = null; - if (type==Type.Integer) { - item = (T)sorted[i]; - } else if (type==Type.String) { - item = (T)String.valueOf(sorted[i]); - } - boolean removed = collection.remove(item); - if (!removed) { - System.err.println(name+" sorted remove failed."); - handleError(collection); - return false; - } - } - if (debugTime) { - afterRemoveSortedTime = System.nanoTime(); - removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; - if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); - } - - if (!collection.isEmpty()) { - System.err.println(name+" sorted isEmpty() failed."); - handleError(collection); - return false; - } - if (collection.size()!=0) { - System.err.println(name+" sorted size() failed."); - handleError(collection); - return false; - } - - if (validateIterator && collection instanceof java.util.List && !testListIterator(((java.util.List)collection).listIterator())) { - System.err.println(name+" sorted list iterator failed."); - handleError(collection); - return false; - } - } - - if (testResults[testIndex] == null) testResults[testIndex] = new long[6]; - testResults[testIndex][0] += addTime / unsortedCount; - testResults[testIndex][1] += removeTime / unsortedCount; - testResults[testIndex][2] += addSortedTime / sortedCount; - testResults[testIndex][3] += removeSortedTime / sortedCount; - testResults[testIndex][4] += lookupTime / (unsortedCount + sortedCount); - testResults[testIndex++][5] += memory / (unsortedCount + sortedCount); - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testJavaMap(java.util.Map map, Type keyType, String name) { - // Make sure the map is empty - if (!map.isEmpty()) { - System.err.println(name+" initial isEmpty() failed."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println(name+" initial size() failed."); - handleError(map); - return false; - } - - long sortedCount = 0; - long unsortedCount = 0; - - long addTime = 0L; - long removeTime = 0L; - - long beforeAddTime = 0L; - long afterAddTime = 0L; - long beforeRemoveTime = 0L; - long afterRemoveTime = 0L; - - long memory = 0L; - - long beforeMemory = 0L; - long afterMemory = 0L; - - long lookupTime = 0L; - - long beforeLookupTime = 0L; - long afterLookupTime = 0L; - - if (debug > 1) System.out.println(name); - testNames[testIndex] = name; - - unsortedCount++; - { - beforeMemory = 0L; - afterMemory = 0L; - beforeAddTime = 0L; - afterAddTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - Integer item = unsorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - if (debugTime) { - afterAddTime = System.nanoTime(); - addTime += afterAddTime - beforeAddTime; - if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - K invalidKey = null; - if (keyType == Type.Integer) { - invalidKey = (K)INVALID; - } else if (keyType == Type.String) { - invalidKey = (K)String.valueOf(INVALID); - } - boolean contains = map.containsKey(invalidKey); - V removed = map.remove(invalidKey); - if (contains || (removed!=null)) { - System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); - return false; - } - - if (debug > 1) System.out.println(map.toString()); - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (Integer item : unsorted) { - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - map.containsKey(k); - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - if (debugTime) beforeRemoveTime = System.nanoTime(); - for (int i = 0; i < unsorted.length; i++) { - Integer item = unsorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (removed==null) { - System.err.println(name+" unsorted invalidity check. removed=" + removed); - return false; - } - - } - if (debugTime) { - afterRemoveTime = System.nanoTime(); - removeTime += afterRemoveTime - beforeRemoveTime; - if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); - } - - if (validateIterator && !testMapEntrySet(map,keyType)) return false; - - if (!map.isEmpty()) { - System.err.println(name+" unsorted isEmpty() failed."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println(name+" unsorted size() failed."); - handleError(map); - return false; - } - } - - unsortedCount++; - { - beforeMemory = 0L; - afterMemory = 0L; - beforeAddTime = 0L; - afterAddTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddTime = System.nanoTime(); - for (int i = unsorted.length - 1; i >= 0; i--) { - Integer item = unsorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - if (debugTime) { - afterAddTime = System.nanoTime(); - addTime += afterAddTime - beforeAddTime; - if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - K invalidKey = null; - if (keyType == Type.Integer) { - invalidKey = (K)INVALID; - } else if (keyType == Type.String) { - invalidKey = (K)String.valueOf(INVALID); - } - boolean contains = map.containsKey(invalidKey); - V removed = map.remove(invalidKey); - if (contains || (removed!=null)) { - System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); - return false; - } - - if (debug > 1) System.out.println(map.toString()); - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (Integer item : unsorted) { - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - map.containsKey(k); - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveTime = 0L; - afterRemoveTime = 0L; - if (debugTime) beforeRemoveTime = System.nanoTime(); - for (int i = unsorted.length - 1; i >= 0; i--) { - Integer item = unsorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (removed==null) { - System.err.println(name+" unsorted invalidity check. removed=" + removed); - return false; - } - } - if (debugTime) { - afterRemoveTime = System.nanoTime(); - removeTime += afterRemoveTime - beforeRemoveTime; - if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); - } - - if (!map.isEmpty()) { - System.err.println(name+" unsorted isEmpty() failed."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println(name+" unsorted size() failed."); - handleError(map); - return false; - } - } - - long addSortedTime = 0L; - long removeSortedTime = 0L; - - long beforeAddSortedTime = 0L; - long afterAddSortedTime = 0L; - - long beforeRemoveSortedTime = 0L; - long afterRemoveSortedTime = 0L; - - sortedCount++; - { // sorted - beforeMemory = 0L; - afterMemory = 0L; - beforeAddSortedTime = 0L; - afterAddSortedTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - Integer item = sorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - if (debugTime) { - afterAddSortedTime = System.nanoTime(); - addSortedTime += afterAddSortedTime - beforeAddSortedTime; - if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - K invalidKey = null; - if (keyType == Type.Integer) { - invalidKey = (K)INVALID; - } else if (keyType == Type.String) { - invalidKey = (K)String.valueOf(INVALID); - } - boolean contains = map.containsKey(invalidKey); - V removed = map.remove(invalidKey); - if (contains || (removed!=null)) { - System.err.println(name+" sorted invalidity check. contains=" + contains + " removed=" + removed); - return false; - } - - if (debug > 1) System.out.println(map.toString()); - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (Integer item : sorted) { - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - map.containsKey(k); - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveSortedTime = 0L; - afterRemoveSortedTime = 0L; - if (debugTime) beforeRemoveSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - Integer item = sorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (removed==null) { - System.err.println(name+" unsorted invalidity check. removed=" + removed); - return false; - } - } - if (debugTime) { - afterRemoveSortedTime = System.nanoTime(); - removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; - if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); - } - - if (validateIterator && !testMapEntrySet(map,keyType)) return false; - - if (!map.isEmpty()) { - System.err.println(name+" sorted isEmpty() failed."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println(name+" sorted size() failed."); - handleError(map); - return false; - } - } - - sortedCount++; - { // sorted - beforeMemory = 0L; - afterMemory = 0L; - beforeAddSortedTime = 0L; - afterAddSortedTime = 0L; - if (debugMemory) beforeMemory = DataStructures.getMemoryUse(); - if (debugTime) beforeAddSortedTime = System.nanoTime(); - for (int i = 0; i < sorted.length; i++) { - Integer item = sorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - if (debugTime) { - afterAddSortedTime = System.nanoTime(); - addSortedTime += afterAddSortedTime - beforeAddSortedTime; - if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); - } - if (debugMemory) { - afterMemory = DataStructures.getMemoryUse(); - memory += afterMemory - beforeMemory; - if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); - } - - K invalidKey = null; - if (keyType == Type.Integer) { - invalidKey = (K)INVALID; - } else if (keyType == Type.String) { - invalidKey = (K)String.valueOf(INVALID); - } - boolean contains = map.containsKey(invalidKey); - V removed = map.remove(invalidKey); - if (contains || (removed!=null)) { - System.err.println(name+" sorted invalidity check. contains=" + contains + " removed=" + removed); - return false; - } - - if (debug > 1) System.out.println(map.toString()); - - beforeLookupTime = 0L; - afterLookupTime = 0L; - if (debugTime) beforeLookupTime = System.nanoTime(); - for (Integer item : sorted) { - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - map.containsKey(k); - } - if (debugTime) { - afterLookupTime = System.nanoTime(); - lookupTime += afterLookupTime - beforeLookupTime; - if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); - } - - beforeRemoveSortedTime = 0L; - afterRemoveSortedTime = 0L; - if (debugTime) beforeRemoveSortedTime = System.nanoTime(); - for (int i = sorted.length - 1; i >= 0; i--) { - Integer item = sorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)item; - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - } - removed = map.remove(k); - if (removed==null) { - System.err.println(name+" unsorted invalidity check. removed=" + removed); - return false; - } - } - if (debugTime) { - afterRemoveSortedTime = System.nanoTime(); - removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; - if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); - } - - if (validateIterator && !testMapEntrySet(map,keyType)) return false; - - if (!map.isEmpty()) { - System.err.println(name+" sorted isEmpty() failed."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println(name+" sorted size() failed."); - handleError(map); - return false; - } - - } - - if (testResults[testIndex] == null) testResults[testIndex] = new long[6]; - testResults[testIndex][0] += addTime / unsortedCount; - testResults[testIndex][1] += removeTime / unsortedCount; - testResults[testIndex][2] += addSortedTime / sortedCount; - testResults[testIndex][3] += removeSortedTime / sortedCount; - testResults[testIndex][4] += lookupTime / (unsortedCount + sortedCount); - testResults[testIndex++][5] += memory / (unsortedCount + sortedCount); - - if (debug > 1) System.out.println(); - - return true; - } - - private static boolean testMapEntrySet(java.util.Map map, Type keyType) { - { // Test keys - for (int i = 0; i < sorted.length; i++) { - Integer item = sorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - - java.util.Set set = map.keySet(); - for (int i = 0; i < sorted.length; i++) { - Integer key = sorted[i]; - K k = null; - if (keyType == Type.Integer) { - k = (K)key; - } else if (keyType == Type.String) { - k = (K)String.valueOf(key); - } - if (!set.contains(k)) { - System.err.println("MayEntry contains() failure."); - handleError(map); - return false; - } - } - - java.util.Iterator keyIter = set.iterator(); - while (keyIter.hasNext()) { - keyIter.next(); - keyIter.remove(); - } - - if (!map.isEmpty()) { - System.err.println("MayEntry isEmpty() failure."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println("MayEntry size()!=0 failure."); - handleError(map); - return false; - } - } - - { // Test values - for (int i = 0; i < sorted.length; i++) { - Integer item = sorted[i]; - K k = null; - V v = null; - if (keyType == Type.Integer) { - k = (K)item; - v = (V)String.valueOf(item); - } else if (keyType == Type.String) { - k = (K)String.valueOf(item); - v = (V)item; - } - map.put(k, v); - } - - java.util.Collection collection = map.values(); - for (int i = 0; i < sorted.length; i++) { - Integer value = sorted[i]; - V v = null; - // These are reversed on purpose - if (keyType == Type.Integer) { - v = (V)String.valueOf(value); - } else if (keyType == Type.String) { - v = (V)value; - } - if (!collection.contains(v)) { - System.err.println("MayEntry contains() failure."); - handleError(map); - return false; - } - } - - java.util.Iterator valueIter = collection.iterator(); - while (valueIter.hasNext()) { - valueIter.next(); - valueIter.remove(); - } - - if (!map.isEmpty()) { - System.err.println("MayEntry isEmpty() failure."); - handleError(map); - return false; - } - if (map.size()!=0) { - System.err.println("MayEntry size()!=0 failure."); - handleError(map); - return false; - } - } - return true; - } - - private static > boolean testIterator(Iterator iter) { - while (iter.hasNext()) { - T item = iter.next(); - if (item==null) { - System.err.println("Iterator failure."); - return false; - } - } - return true; - } - - private static > boolean testListIterator(ListIterator iter) { - // Make sure you catch going prev at the start - boolean exceptionThrown = false; - try { - iter.previous(); - } catch (NoSuchElementException e) { - exceptionThrown = true; - } - if (!exceptionThrown) { - System.err.println("ListIterator exception failure."); - return false; - } - - for (int i = 0; i < unsorted.length; i++) { - T t = (T)unsorted[i]; - iter.add(t); - } - while (iter.hasPrevious()) iter.previous(); - - int i = 0; - while (iter.hasNext()) { - T item = iter.next(); - int idx = iter.nextIndex(); - if (idx!=++i) { - System.err.println("ListIterator index failure."); - return false; - } - if (item==null) { - System.err.println("ListIterator item is null."); - return false; - } - } - - // We should be at the end of the collection, this should fail - exceptionThrown = false; - try { - iter.next(); - } catch (NoSuchElementException e) { - exceptionThrown = true; - } - if (!exceptionThrown) { - System.err.println("ListIterator exception failure."); - return false; - } - - //This should be list.size - iter.nextIndex(); - int listSize = iter.nextIndex(); - if (listSize!=ARRAY_SIZE) { - System.err.println("ListIterator ARRAY_SIZE failure."); - return false; - } - - i--; - while (iter.hasPrevious()) { - T item = iter.previous(); - int idx = iter.previousIndex(); - if (idx!=--i) { - System.err.println("ListIterator index failure."); - return false; - } - if (item==null) { - System.err.println("ListIterator item is null."); - return false; - } - } - - // We should be at the beginning of the collection, this should fail - exceptionThrown = false; - try { - iter.previous(); - } catch (NoSuchElementException e) { - exceptionThrown = true; - } - if (!exceptionThrown) { - System.err.println("ListIterator exception failure."); - return false; - } - - // This should be negative one - iter.previousIndex(); - int negOne = iter.previousIndex(); - if (negOne!=-1) { - System.err.println("ListIterator negative_one failure."); - return false; - } - - // Remove all using iterator - while (iter.hasNext()) { - iter.next(); - iter.remove(); - } - - return true; - } - - private static final String getTestResults(int testNumber, String[] names, long[][] results) { - StringBuilder resultsBuilder = new StringBuilder(); - String format = "%-32s %-10s %-15s %-15s %-20s %-15s %-15s\n"; - Formatter formatter = new Formatter(resultsBuilder, Locale.US); - formatter.format(format, "Data Structure", "Add time", "Remove time", "Sorted add time", "Sorted remove time", "Lookup time", "Size"); - - double KB = 1000; - double MB = 1000 * KB; - - double MILLIS = 1000000; - double SECOND = 1000; - double MINUTES = 60 * SECOND; - - for (int i=0; i MINUTES) { - addTime /= MINUTES; - addTimeString = FORMAT.format(addTime) + " m"; - } else if (addTime > SECOND) { - addTime /= SECOND; - addTimeString = FORMAT.format(addTime) + " s"; - } else { - addTimeString = FORMAT.format(addTime) + " ms"; - } - - double removeTime = result[1] / MILLIS; - removeTime /= testNumber; - String removeTimeString = null; - if (removeTime > MINUTES) { - removeTime /= MINUTES; - removeTimeString = FORMAT.format(removeTime) + " m"; - } else if (removeTime > SECOND) { - removeTime /= SECOND; - removeTimeString = FORMAT.format(removeTime) + " s"; - } else { - removeTimeString = FORMAT.format(removeTime) + " ms"; - } - - // sorted - double addSortedTime = result[2] / MILLIS; - addSortedTime /= testNumber; - String sortedAddTimeString = null; - if (addSortedTime > MINUTES) { - addSortedTime /= MINUTES; - sortedAddTimeString = FORMAT.format(addSortedTime) + " m"; - } else if (addSortedTime > SECOND) { - addSortedTime /= SECOND; - sortedAddTimeString = FORMAT.format(addSortedTime) + " s"; - } else { - sortedAddTimeString = FORMAT.format(addSortedTime) + " ms"; - } - - double removeSortedTime = result[3] / MILLIS; - removeSortedTime /= testNumber; - String sortedRemoveTimeString = null; - if (removeSortedTime > MINUTES) { - removeSortedTime /= MINUTES; - sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " m"; - } else if (removeSortedTime > SECOND) { - removeSortedTime /= SECOND; - sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " s"; - } else { - sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " ms"; - } - - double lookupTime = result[4] / MILLIS; - lookupTime /= testNumber; - String lookupTimeString = null; - if (lookupTime > MINUTES) { - lookupTime /= MINUTES; - lookupTimeString = FORMAT.format(lookupTime) + " m"; - } else if (lookupTime > SECOND) { - lookupTime /= SECOND; - lookupTimeString = FORMAT.format(lookupTime) + " s"; - } else { - lookupTimeString = FORMAT.format(lookupTime) + " ms"; - } - - double size = result[5]; - size /= testNumber; - String sizeString = null; - if (size > MB) { - size = size / MB; - sizeString = FORMAT.format(size) + " MB"; - } else if (size > KB) { - size = size / KB; - sizeString = FORMAT.format(size) + " KB"; - } else { - sizeString = FORMAT.format(size) + " Bytes"; - } - - formatter.format(format, name, addTimeString, removeTimeString, sortedAddTimeString, sortedRemoveTimeString, lookupTimeString, sizeString); - } - } - formatter.close(); - - return resultsBuilder.toString(); - } - - private static final String getPathMapString(Graph.Vertex start, Map, Graph.CostPathPair> map) { - StringBuilder builder = new StringBuilder(); - for (Graph.Vertex v : map.keySet()) { - Graph.CostPathPair pair = map.get(v); - builder.append("From ").append(start.getValue()).append(" to vertex=").append(v.getValue()).append("\n"); - if (pair != null) - builder.append(pair.toString()).append("\n"); - - } - return builder.toString(); - } - - private static final String getPathMapString(Map, Map, Set>>> paths) { - StringBuilder builder = new StringBuilder(); - for (Graph.Vertex v : paths.keySet()) { - Map, Set>> map = paths.get(v); - for (Graph.Vertex v2 : map.keySet()) { - builder.append("From=").append(v.getValue()).append(" to=").append(v2.getValue()).append("\n"); - Set> path = map.get(v2); - builder.append(path).append("\n"); - } - } - return builder.toString(); - } - - private static final String getWeightMapString(Map, Map, Integer>> paths) { - StringBuilder builder = new StringBuilder(); - for (Graph.Vertex v : paths.keySet()) { - Map, Integer> map = paths.get(v); - for (Graph.Vertex v2 : map.keySet()) { - builder.append("From=").append(v.getValue()).append(" to=").append(v2.getValue()).append("\n"); - Integer weight = map.get(v2); - builder.append(weight).append("\n"); - } - } - return builder.toString(); - } - - private static final long getMemoryUse() { - putOutTheGarbage(); - long totalMemory = Runtime.getRuntime().totalMemory(); - - putOutTheGarbage(); - long freeMemory = Runtime.getRuntime().freeMemory(); - - return (totalMemory - freeMemory); - } - - private static final void putOutTheGarbage() { - collectGarbage(); - collectGarbage(); - collectGarbage(); - } - - private static final long fSLEEP_INTERVAL = 100; - - private static final void collectGarbage() { - try { - System.gc(); - Thread.sleep(fSLEEP_INTERVAL); - System.runFinalization(); - Thread.sleep(fSLEEP_INTERVAL); - } catch (InterruptedException ex) { - ex.printStackTrace(); - } - } -} diff --git a/src/com/jwetherell/algorithms/Sequences.java b/src/com/jwetherell/algorithms/Sequences.java deleted file mode 100644 index f152d193..00000000 --- a/src/com/jwetherell/algorithms/Sequences.java +++ /dev/null @@ -1,95 +0,0 @@ -package com.jwetherell.algorithms; - -import java.text.DecimalFormat; - -import com.jwetherell.algorithms.sequence.FibonacciSequence; -import com.jwetherell.algorithms.sequence.LongestCommonSubsequence; -import com.jwetherell.algorithms.sequence.TotalOfSequence; - -public class Sequences { - - private static final DecimalFormat FORMAT = new DecimalFormat("#.######"); - - public static void main(String[] args) { - { - // TOTAL OF A SEQUENCE OF NUMBERS - int start = 14; - int length = 10000; - System.out.println("Computing sequence total using a loop."); - long before = System.nanoTime(); - long result = TotalOfSequence.sequenceTotalUsingLoop(start, length); - long after = System.nanoTime(); - System.out.println("start=" + start + " length=" + length + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.gc(); - - System.out.println("Computing sequence total using algorithm."); - before = System.nanoTime(); - result = TotalOfSequence.sequenceTotalUsingTriangularNumbers(start, length); - after = System.nanoTime(); - System.out.println("start=" + start + " length=" + length + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.out.println(); - System.gc(); - } - - { - // COMPUTE FIBONACCI SEQUENCE - System.out.println("Computing Fibonacci sequence total using a loop."); - int element = 25; - long before = System.nanoTime(); - long result = FibonacciSequence.fibonacciSequenceUsingLoop(element); - long after = System.nanoTime(); - System.out.println("element=" + element + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.gc(); - - System.out.println("Computing Fibonacci sequence total using Recursion."); - before = System.nanoTime(); - result = FibonacciSequence.fibonacciSequenceUsingRecursion(element); - after = System.nanoTime(); - System.out.println("element=" + element + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.gc(); - - System.out.println("Computing Fibonacci sequence total using Matrix."); - before = System.nanoTime(); - result = FibonacciSequence.fibonacciSequenceUsingMatrixMultiplication(element); - after = System.nanoTime(); - System.out.println("element=" + element + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.gc(); - - System.out.println("Computing Fibonacci sequence total using Binet's formula."); - before = System.nanoTime(); - result = FibonacciSequence.fibonacciSequenceUsingBinetsFormula(element); - after = System.nanoTime(); - System.out.println("element=" + element + " result=" + result); - System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.out.println(); - System.gc(); - } - - { - // LONGEST COMMON SUBSEQUENCE - System.out.println("Computing longest common subsequence."); - char[] seq1 = new char[] { 'G', 'A', 'C' }; - char[] seq2 = new char[] { 'A', 'G', 'C', 'A', 'T' }; - LongestCommonSubsequence.MatrixPair pair = LongestCommonSubsequence.getLCS(seq1, seq2); - System.out.println(pair.getLengthMatrixString()); - System.out.println(pair.getSequenceMatrixString()); - System.out.println("Longest sequence length = " + pair.getLongestSequenceLength()); - System.out.println("Longest sequences = " + pair.getLongestSequences()); - System.out.println(); - - seq1 = new char[] { 'G', 'A', 'C', 'V', 'X', 'T' }; - seq2 = new char[] { 'A', 'G', 'C', 'A', 'T', 'X' }; - pair = LongestCommonSubsequence.getLCS(seq1, seq2); - System.out.println(pair.getLengthMatrixString()); - System.out.println(pair.getSequenceMatrixString()); - System.out.println("Longest sequence length = " + pair.getLongestSequenceLength()); - System.out.println("Longest sequences = " + pair.getLongestSequences()); - System.out.println(); - } - } -} diff --git a/src/com/jwetherell/algorithms/data_structures/AVLTree.java b/src/com/jwetherell/algorithms/data_structures/AVLTree.java index ceff11f9..fd2e783a 100644 --- a/src/com/jwetherell/algorithms/data_structures/AVLTree.java +++ b/src/com/jwetherell/algorithms/data_structures/AVLTree.java @@ -124,12 +124,15 @@ protected Node removeValue(T value) { // Find the parent of the replacement node to re-factor the // height/balance of the tree AVLNode nodeToRefactor = null; - if (replacementNode != null) + if (replacementNode != null) { nodeToRefactor = (AVLNode) replacementNode.parent; - if (nodeToRefactor == null) + } + if (nodeToRefactor == null) { nodeToRefactor = (AVLNode) nodeToRemoved.parent; - if (nodeToRefactor != null && nodeToRefactor.equals(nodeToRemoved)) + } + if (nodeToRefactor != null && nodeToRefactor.equals(nodeToRemoved)) { nodeToRefactor = (AVLNode) replacementNode; + } // Replace the node replaceNodeWithNode(nodeToRemoved, replacementNode); @@ -163,17 +166,20 @@ private void balanceAfterDelete(AVLNode node) { if (lesser >= greater) { rotateRight(node); node.updateHeight(); - if (node.parent != null) + if (node.parent != null) { ((AVLNode) node.parent).updateHeight(); + } } else { rotateLeft(node.lesser); rotateRight(node); AVLNode p = (AVLNode) node.parent; - if (p.lesser != null) + if (p.lesser != null) { ((AVLNode) p.lesser).updateHeight(); - if (p.greater != null) + } + if (p.greater != null) { ((AVLNode) p.greater).updateHeight(); + } p.updateHeight(); } } else if (balanceFactor == 2) { @@ -184,17 +190,20 @@ private void balanceAfterDelete(AVLNode node) { if (greater >= lesser) { rotateLeft(node); node.updateHeight(); - if (node.parent != null) + if (node.parent != null) { ((AVLNode) node.parent).updateHeight(); + } } else { rotateRight(node.greater); rotateLeft(node); AVLNode p = (AVLNode) node.parent; - if (p.lesser != null) + if (p.lesser != null) { ((AVLNode) p.lesser).updateHeight(); - if (p.greater != null) + } + if (p.greater != null) { ((AVLNode) p.greater).updateHeight(); + } p.updateHeight(); } } @@ -207,8 +216,9 @@ private void balanceAfterDelete(AVLNode node) { @Override protected boolean validateNode(Node node) { boolean bst = super.validateNode(node); - if (!bst) + if (!bst) { return false; + } AVLNode avlNode = (AVLNode) node; int balanceFactor = avlNode.getBalanceFactor(); @@ -221,16 +231,19 @@ protected boolean validateNode(Node node) { } else { AVLNode avlNodeLesser = (AVLNode) avlNode.lesser; int lesserHeight = 1; - if (avlNodeLesser != null) + if (avlNodeLesser != null) { lesserHeight = avlNodeLesser.height; + } AVLNode avlNodeGreater = (AVLNode) avlNode.greater; int greaterHeight = 1; - if (avlNodeGreater != null) + if (avlNodeGreater != null) { greaterHeight = avlNodeGreater.height; + } - if (avlNode.height == (lesserHeight + 1) || avlNode.height == (greaterHeight + 1)) + if (avlNode.height == (lesserHeight + 1) || avlNode.height == (greaterHeight + 1)) { return true; + } return false; } @@ -335,14 +348,16 @@ public String toString() { protected static class AVLTreePrinter { public static > String getString(AVLTree tree) { - if (tree.root == null) + if (tree.root == null) { return "Tree has no nodes."; + } return getString((AVLNode) tree.root, "", true); } public static > String getString(AVLNode node) { - if (node == null) + if (node == null) { return "Sub-tree has no nodes."; + } return getString(node, "", true); } @@ -353,10 +368,12 @@ private static > String getString(AVLNode node, Strin List> children = null; if (node.lesser != null || node.greater != null) { children = new ArrayList>(2); - if (node.lesser != null) + if (node.lesser != null) { children.add(node.lesser); - if (node.greater != null) + } + if (node.greater != null) { children.add(node.greater); + } } if (children != null) { for (int i = 0; i < children.size() - 1; i++) { @@ -371,4 +388,5 @@ private static > String getString(AVLNode node, Strin return builder.toString(); } } + } diff --git a/src/com/jwetherell/algorithms/data_structures/BTree.java b/src/com/jwetherell/algorithms/data_structures/BTree.java index 7e4257d4..edc29aab 100644 --- a/src/com/jwetherell/algorithms/data_structures/BTree.java +++ b/src/com/jwetherell/algorithms/data_structures/BTree.java @@ -5,6 +5,8 @@ import java.util.Comparator; import java.util.Deque; +import com.jwetherell.algorithms.data_structures.interfaces.ITree; + /** * B-tree is a tree data structure that keeps data sorted and allows searches, * sequential access, insertions, and deletions in logarithmic time. The B-tree @@ -69,13 +71,16 @@ public boolean add(T value) { split(node); break; } - // navigate + // Navigate + + // Lesser or equal T lesser = node.getKey(0); - if (value.compareTo(lesser) < 0) { + if (value.compareTo(lesser) <= 0) { node = node.getChild(0); continue; } + // Greater int size = node.numberOfKeys(); int last = size - 1; T greater = node.getKey(last); @@ -84,10 +89,11 @@ public boolean add(T value) { continue; } + // Search internal nodes for (int i = 1; i < node.numberOfKeys(); i++) { T prev = node.getKey(i - 1); T next = node.getKey(i); - if (value.compareTo(prev) > 0 && value.compareTo(next) < 0) { + if (value.compareTo(prev) > 0 && value.compareTo(next) <= 0) { node = node.getChild(i); break; } @@ -150,7 +156,9 @@ private void split(Node node) { parent.addChild(left); parent.addChild(right); - if (parent.numberOfKeys() > maxKeySize) split(parent); + if (parent.numberOfKeys() > maxKeySize) { + split(parent); + } } } @@ -175,7 +183,9 @@ public T remove(T value) { * @return True if value was removed from the tree. */ private T remove(T value, Node node) { - if (node == null) return null; + if (node == null) { + return null; + } T removed = null; int index = node.indexOf(value); @@ -252,10 +262,11 @@ private Node getNode(T value) { while (node != null) { T lesser = node.getKey(0); if (value.compareTo(lesser) < 0) { - if (node.numberOfChildren() > 0) + if (node.numberOfChildren() > 0) { node = node.getChild(0); - else + } else { node = null; + } continue; } @@ -263,10 +274,11 @@ private Node getNode(T value) { int last = size - 1; T greater = node.getKey(last); if (value.compareTo(greater) > 0) { - if (node.numberOfChildren() > size) + if (node.numberOfChildren() > size) { node = node.getChild(size); - else + } else { node = null; + } continue; } @@ -425,8 +437,9 @@ private boolean combined(Node node) { private int getIndexOfPreviousValue(Node node, T value) { for (int i = 1; i < node.numberOfKeys(); i++) { T t = node.getKey(i); - if (t.compareTo(value) >= 0) + if (t.compareTo(value) >= 0) { return i - 1; + } } return node.numberOfKeys() - 1; } @@ -443,8 +456,9 @@ private int getIndexOfPreviousValue(Node node, T value) { private int getIndexOfNextValue(Node node, T value) { for (int i = 0; i < node.numberOfKeys(); i++) { T t = node.getKey(i); - if (t.compareTo(value) >= 0) + if (t.compareTo(value) >= 0) { return i; + } } return node.numberOfKeys() - 1; } @@ -462,7 +476,9 @@ public int size() { */ @Override public boolean validate() { - if (root == null) return true; + if (root == null) { + return true; + } return validateNode(root); } @@ -480,8 +496,9 @@ private boolean validateNode(Node node) { for (int i = 1; i < keySize; i++) { T p = node.getKey(i - 1); T n = node.getKey(i); - if (p.compareTo(n) > 0) + if (p.compareTo(n) > 0) { return false; + } } } int childrenSize = node.numberOfChildren(); @@ -533,17 +550,20 @@ private boolean validateNode(Node node) { T p = node.getKey(i - 1); T n = node.getKey(i); Node c = node.getChild(i); - if (p.compareTo(c.getKey(0)) > 0) + if (p.compareTo(c.getKey(0)) > 0) { return false; - if (n.compareTo(c.getKey(c.numberOfKeys() - 1)) < 0) + } + if (n.compareTo(c.getKey(c.numberOfKeys() - 1)) < 0) { return false; + } } for (int i = 0; i < node.childrenSize; i++) { Node c = node.getChild(i); boolean valid = this.validateNode(c); - if (!valid) + if (!valid) { return false; + } } return true; @@ -594,7 +614,9 @@ private T getKey(int index) { private int indexOf(T value) { for (int i = 0; i < keysSize; i++) { - if (keys[i].equals(value)) return i; + if (keys[i].equals(value)) { + return i; + } } return -1; } @@ -607,7 +629,9 @@ private void addKey(T value) { private T removeKey(T value) { T removed = null; boolean found = false; - if (keysSize == 0) return null; + if (keysSize == 0) { + return null; + } for (int i = 0; i < keysSize; i++) { if (keys[i].equals(value)) { found = true; @@ -625,8 +649,9 @@ private T removeKey(T value) { } private T removeKey(int index) { - if (index >= keysSize) + if (index >= keysSize) { return null; + } T value = keys[index]; for (int i = index + 1; i < keysSize; i++) { // shift the rest of the keys down @@ -642,15 +667,17 @@ private int numberOfKeys() { } private Node getChild(int index) { - if (index >= childrenSize) + if (index >= childrenSize) { return null; + } return children[index]; } private int indexOf(Node child) { for (int i = 0; i < childrenSize; i++) { - if (children[i].equals(child)) + if (children[i].equals(child)) { return i; + } } return -1; } @@ -682,8 +709,9 @@ private boolean removeChild(Node child) { } private Node removeChild(int index) { - if (index >= childrenSize) + if (index >= childrenSize) { return null; + } Node value = children[index]; children[index] = null; for (int i = index + 1; i < childrenSize; i++) { @@ -710,8 +738,9 @@ public String toString() { for (int i = 0; i < numberOfKeys(); i++) { T value = getKey(i); builder.append(value); - if (i < numberOfKeys() - 1) + if (i < numberOfKeys() - 1) { builder.append(", "); + } } builder.append("]\n"); @@ -720,8 +749,9 @@ public String toString() { for (int i = 0; i < parent.numberOfKeys(); i++) { T value = parent.getKey(i); builder.append(value); - if (i < parent.numberOfKeys() - 1) + if (i < parent.numberOfKeys() - 1) { builder.append(", "); + } } builder.append("]\n"); } @@ -737,7 +767,9 @@ public String toString() { private static class TreePrinter { public static > String getString(BTree tree) { - if (tree.root == null) return "Tree has no nodes."; + if (tree.root == null) { + return "Tree has no nodes."; + } return getString(tree.root, "", true); } @@ -748,8 +780,9 @@ private static > String getString(Node node, String p for (int i = 0; i < node.numberOfKeys(); i++) { T value = node.getKey(i); builder.append(value); - if (i < node.numberOfKeys() - 1) + if (i < node.numberOfKeys() - 1) { builder.append(", "); + } } builder.append("\n"); diff --git a/src/com/jwetherell/algorithms/data_structures/BinaryHeap.java b/src/com/jwetherell/algorithms/data_structures/BinaryHeap.java index 61ecf952..7e4f60b3 100644 --- a/src/com/jwetherell/algorithms/data_structures/BinaryHeap.java +++ b/src/com/jwetherell/algorithms/data_structures/BinaryHeap.java @@ -6,6 +6,8 @@ import java.util.Deque; import java.util.List; +import com.jwetherell.algorithms.data_structures.interfaces.IHeap; + /** * A binary heap is a heap data structure created using a binary tree. It can be * seen as a binary tree with two additional constraints: 1) The shape property: @@ -24,11 +26,11 @@ public interface BinaryHeap> extends IHeap { public enum HeapType { Tree, Array - }; + } public enum Type { MIN, MAX - }; + } /** * Get the heap in array form. @@ -59,8 +61,9 @@ public static class BinaryHeapArray> implements BinaryHe * @return index of parent node or Integer.MIN_VALUE if no parent. */ private static final int getParentIndex(int index) { - if (index > 0) + if (index > 0) { return (int) Math.floor((index - 1) / 2); + } return Integer.MIN_VALUE; } @@ -132,7 +135,9 @@ protected void heapUp(int nodeIndex) { T value = this.array[nodeIndex]; while (nodeIndex >= 0) { int parentIndex = getParentIndex(nodeIndex); - if (parentIndex < 0) break; + if (parentIndex < 0) { + break; + } T parent = this.array[parentIndex]; if ((type == Type.MIN && parent != null && value.compareTo(parent) < 0) @@ -190,10 +195,14 @@ public void clear() { */ @Override public boolean contains(T value) { - if (array.length == 0) return false; + if (array.length == 0) { + return false; + } for (int i = 0; i < size; i++) { T t = array[i]; - if (t.equals(value)) return true; + if (t.equals(value)) { + return true; + } } return false; } @@ -550,8 +559,11 @@ private void replaceNode(Node node) { if (node.right!=null) node.right.parent = lastNode; if (node.equals(root)) { - if (!lastNode.equals(root)) root = lastNode; - else root = null; + if (!lastNode.equals(root)) { + root = lastNode; + } else { + root = null; + } } size--; diff --git a/src/com/jwetherell/algorithms/data_structures/BinarySearchTree.java b/src/com/jwetherell/algorithms/data_structures/BinarySearchTree.java index 6da25208..19543b4b 100644 --- a/src/com/jwetherell/algorithms/data_structures/BinarySearchTree.java +++ b/src/com/jwetherell/algorithms/data_structures/BinarySearchTree.java @@ -9,6 +9,8 @@ import java.util.Queue; import java.util.Set; +import com.jwetherell.algorithms.data_structures.interfaces.ITree; + /** * A binary search tree (BST), which may sometimes also be called an ordered or * sorted binary tree, is a node-based binary tree data structure which has the @@ -169,8 +171,9 @@ protected void rotateLeft(Node node) { node.parent = greater; node.greater = lesser; - if (lesser != null) + if (lesser != null) { lesser.parent = node; + } if (parentPosition != null) { if (parentPosition == Position.LEFT) { @@ -212,8 +215,9 @@ protected void rotateRight(Node node) { node.parent = lesser; node.lesser = greater; - if (greater != null) + if (greater != null) { greater.parent = node; + } if (parentPosition != null) { if (parentPosition == Position.LEFT) { @@ -238,16 +242,18 @@ protected void rotateRight(Node node) { * sub-tree or NULL if startingNode has no greater children. */ protected Node getGreatest(Node startingNode) { - if (startingNode == null) + if (startingNode == null) { return null; + } Node greater = startingNode.greater; while (greater != null && greater.id != null) { Node node = greater.greater; - if (node != null && node.id != null) + if (node != null && node.id != null) { greater = node; - else + } else { break; + } } return greater; } @@ -262,16 +268,18 @@ protected Node getGreatest(Node startingNode) { * sub-tree or NULL if startingNode has no lesser children. */ protected Node getLeast(Node startingNode) { - if (startingNode == null) + if (startingNode == null) { return null; + } Node lesser = startingNode.lesser; while (lesser != null && lesser.id != null) { Node node = lesser.lesser; - if (node != null && node.id != null) + if (node != null && node.id != null) { lesser = node; - else + } else { break; + } } return lesser; } @@ -294,7 +302,9 @@ public T remove(T value) { */ protected Node removeValue(T value) { Node nodeToRemoved = this.getNode(value); - if (nodeToRemoved != null) nodeToRemoved = removeNode(nodeToRemoved); + if (nodeToRemoved != null) { + nodeToRemoved = removeNode(nodeToRemoved); + } return nodeToRemoved; } @@ -339,12 +349,14 @@ protected Node getReplacementNode(Node nodeToRemoved) { // greatest/least on deletion if (modifications % 2 != 0) { replacement = this.getGreatest(nodeToRemoved.lesser); - if (replacement == null) + if (replacement == null) { replacement = nodeToRemoved.lesser; + } } else { replacement = this.getLeast(nodeToRemoved.greater); - if (replacement == null) + if (replacement == null) { replacement = nodeToRemoved.greater; + } } modifications++; } @@ -386,12 +398,14 @@ protected void replaceNodeWithNode(Node nodeToRemoved, Node replacementNod Node replacementParentGreater = replacementParent.greater; if (replacementParentLesser != null && replacementParentLesser.equals(replacementNode)) { replacementParent.lesser = replacementNodeGreater; - if (replacementNodeGreater != null) + if (replacementNodeGreater != null) { replacementNodeGreater.parent = replacementParent; + } } else if (replacementParentGreater != null && replacementParentGreater.equals(replacementNode)) { replacementParent.greater = replacementNodeLesser; - if (replacementNodeLesser != null) + if (replacementNodeLesser != null) { replacementNodeLesser.parent = replacementParent; + } } } } @@ -402,16 +416,19 @@ protected void replaceNodeWithNode(Node nodeToRemoved, Node replacementNod if (parent == null) { // Replacing the root node root = replacementNode; - if (root != null) + if (root != null) { root.parent = null; + } } else if (parent.lesser != null && (parent.lesser.id.compareTo(nodeToRemoved.id) == 0)) { parent.lesser = replacementNode; - if (replacementNode != null) + if (replacementNode != null) { replacementNode.parent = parent; + } } else if (parent.greater != null && (parent.greater.id.compareTo(nodeToRemoved.id) == 0)) { parent.greater = replacementNode; - if (replacementNode != null) + if (replacementNode != null) { replacementNode.parent = parent; + } } size--; } @@ -438,7 +455,9 @@ public int size() { */ @Override public boolean validate() { - if (root == null) return true; + if (root == null) { + return true; + } return validateNode(root); } @@ -456,17 +475,20 @@ protected boolean validateNode(Node node) { boolean lesserCheck = true; if (lesser != null && lesser.id != null) { lesserCheck = (lesser.id.compareTo(node.id) <= 0); - if (lesserCheck) + if (lesserCheck) { lesserCheck = validateNode(lesser); + } } - if (!lesserCheck) + if (!lesserCheck) { return false; + } boolean greaterCheck = true; if (greater != null && greater.id != null) { greaterCheck = (greater.id.compareTo(node.id) > 0); - if (greaterCheck) + if (greaterCheck) { greaterCheck = validateNode(greater); + } } return greaterCheck; } @@ -483,14 +505,17 @@ public T[] getBFS() { Node node = root; while (node != null) { values[count++] = node.id; - if (node.lesser != null) + if (node.lesser != null) { queue.add(node.lesser); - if (node.greater != null) + } + if (node.greater != null) { queue.add(node.greater); - if (!queue.isEmpty()) + } + if (!queue.isEmpty()) { node = queue.remove(); - else + } else { node = null; + } } return values; } @@ -672,10 +697,12 @@ private static > String getString(Node node, String p List> children = null; if (node.lesser != null || node.greater != null) { children = new ArrayList>(2); - if (node.lesser != null) + if (node.lesser != null) { children.add(node.lesser); - if (node.greater != null) + } + if (node.greater != null) { children.add(node.greater); + } } if (children != null) { for (int i = 0; i < children.size() - 1; i++) { @@ -747,7 +774,9 @@ private static class BinarySearchTreeIterator> implement protected BinarySearchTreeIterator(BinarySearchTree tree) { this.tree = tree; - if (tree.root!=null) toVisit.add(tree.root); + if (tree.root!=null) { + toVisit.add(tree.root); + } } /** diff --git a/src/com/jwetherell/algorithms/data_structures/Graph.java b/src/com/jwetherell/algorithms/data_structures/Graph.java index 35100660..2d645301 100644 --- a/src/com/jwetherell/algorithms/data_structures/Graph.java +++ b/src/com/jwetherell/algorithms/data_structures/Graph.java @@ -1,9 +1,9 @@ package com.jwetherell.algorithms.data_structures; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.Set; -import java.util.concurrent.CopyOnWriteArrayList; /** * Graph. Could be directed or undirected depending on the TYPE enum. A graph is @@ -16,25 +16,31 @@ */ public class Graph> { - private List> verticies = new CopyOnWriteArrayList>(); - private List> edges = new CopyOnWriteArrayList>(); + private List> verticies = new ArrayList>(); + private List> edges = new ArrayList>(); public enum TYPE { DIRECTED, UNDIRECTED - }; + } private TYPE type = TYPE.UNDIRECTED; public Graph() { } + public Graph(TYPE type) { + this(); + this.type = type; + } + public Graph(Graph g) { // Deep copies + type = g.getType(); + // Copy the vertices (which copies the edges) - for (Vertex v : g.getVerticies()) { + for (Vertex v : g.getVerticies()) this.verticies.add(new Vertex(v)); - } // Update the object references for (Vertex v : this.verticies) { @@ -48,20 +54,13 @@ public Graph(Graph g) { this.edges.add(e); } } - - type = g.getType(); } - public Graph(TYPE type) { - this(); - this.type = type; - } - - public Graph(List> verticies, List> edges) { + public Graph(Collection> verticies, Collection> edges) { this(TYPE.UNDIRECTED, verticies, edges); } - public Graph(TYPE type, List> verticies, List> edges) { + public Graph(TYPE type, Collection> verticies, Collection> edges) { this(type); this.verticies.addAll(verticies); this.edges.addAll(edges); @@ -165,10 +164,9 @@ public boolean pathTo(Vertex v) { * {@inheritDoc} */ @Override - public int compareTo(Vertex v) { - if (this.value == null || v.value == null) - return -1; - return this.value.compareTo(v.value); + public int hashCode() { + int code = this.value.hashCode() + this.weight; + return 31 * code; } /** @@ -177,22 +175,35 @@ public int compareTo(Vertex v) { @SuppressWarnings("unchecked") @Override public boolean equals(Object v1) { - if (!(v1 instanceof Vertex)) + if (!(v1 instanceof Vertex)) { return false; + } Vertex v = (Vertex) v1; boolean values = this.value.equals(v.value); - if (!values) + if (!values) { return false; + } boolean weight = this.weight == v.weight; - if (!weight) + if (!weight) { return false; + } return true; } + /** + * {@inheritDoc} + */ + @Override + public int compareTo(Vertex v) { + if (this.value == null || v.value == null) + return -1; + return this.value.compareTo(v.value); + } + /** * {@inheritDoc} */ @@ -231,7 +242,6 @@ public int getCost() { public void setCost(int cost) { this.cost = cost; - ; } public Vertex getFromVertex() { @@ -242,24 +252,12 @@ public Vertex getToVertex() { return to; } - /** - * {@inheritDoc} - */ - @Override - public int compareTo(Edge e) { - if (this.cost < e.cost) - return -1; - if (this.cost > e.cost) - return 1; - return 0; - } - /** * {@inheritDoc} */ @Override public int hashCode() { - return this.cost * (this.getFromVertex().value.hashCode() * this.getToVertex().value.hashCode()); + return 31 * (this.cost * (this.getFromVertex().value.hashCode() * this.getToVertex().value.hashCode())); } /** @@ -288,6 +286,18 @@ public boolean equals(Object e1) { return true; } + /** + * {@inheritDoc} + */ + @Override + public int compareTo(Edge e) { + if (this.cost < e.cost) + return -1; + if (this.cost > e.cost) + return 1; + return 0; + } + /** * {@inheritDoc} */ @@ -295,7 +305,7 @@ public boolean equals(Object e1) { public String toString() { StringBuilder builder = new StringBuilder(); builder.append("edge:").append(" [").append(from.value).append("]").append(" -> ").append("[") - .append(to.value).append("]").append(" = ").append(cost).append("\n"); + .append(to.value).append("]").append(" = ").append(cost).append("\n"); return builder.toString(); } } @@ -325,6 +335,33 @@ public Vertex getVertex() { return vertex; } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return 31 * (this.cost * this.vertex.hashCode()); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("rawtypes") + @Override + public boolean equals(Object e1) { + if (!(e1 instanceof CostVertexPair)) + return false; + + CostVertexPair pair = (CostVertexPair)e1; + if (this.cost != pair.cost) + return false; + + if (!this.vertex.equals(pair)) + return false; + + return true; + } + /** * {@inheritDoc} */ @@ -375,6 +412,41 @@ public Set> getPath() { return path; } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + int hash = this.cost; + for (Edge e : path) + hash *= e.cost; + return 31 * hash; + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public boolean equals(Object obj) { + if (!(obj instanceof CostPathPair)) + return false; + + CostPathPair pair = (CostPathPair)obj; + if (this.cost != pair.cost) + return false; + + Object[] e = pair.path.toArray(); + int i=0; + for (Edge e1 : path) { + Edge e2 = (Edge) e[i++]; + if (!e1.equals(e2)) + return false; + } + + return true; + } + /** * {@inheritDoc} */ @@ -388,4 +460,4 @@ public String toString() { return builder.toString(); } } -} +} \ No newline at end of file diff --git a/src/com/jwetherell/algorithms/data_structures/HashArrayMappedTrie.java b/src/com/jwetherell/algorithms/data_structures/HashArrayMappedTrie.java index 56b1f437..23f468cb 100644 --- a/src/com/jwetherell/algorithms/data_structures/HashArrayMappedTrie.java +++ b/src/com/jwetherell/algorithms/data_structures/HashArrayMappedTrie.java @@ -4,6 +4,8 @@ import java.util.List; import java.util.Map; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; + /** * A hash array mapped trie (HAMT) is an implementation of an associative * array that combines the characteristics of a hash table and an array mapped @@ -208,6 +210,8 @@ public V remove(K key) { numOfChildren = parent.getNumberOfChildren(); } } + kvNode.key = 0; + kvNode.value = null; size--; return value; } diff --git a/src/com/jwetherell/algorithms/data_structures/HashMap.java b/src/com/jwetherell/algorithms/data_structures/HashMap.java index 5d37dda9..42140f68 100644 --- a/src/com/jwetherell/algorithms/data_structures/HashMap.java +++ b/src/com/jwetherell/algorithms/data_structures/HashMap.java @@ -3,6 +3,8 @@ import java.util.LinkedList; import java.util.List; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; + /** * Hash Map backed by an array of ArrayLists. hash map is a data structure that * uses a hash function to map identifying values, known as keys, to their @@ -94,7 +96,10 @@ public V remove(K key) { if (pair.key.equals(key)) { list.remove(pair); size--; - return pair.value; + V value = pair.value; + pair.key = null; + pair.value = null; + return value; } } return null; @@ -194,6 +199,17 @@ public Pair(K key, V value) { this.value = value; } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return 31 * (this.key.hashCode()); + } + + /** + * {@inheritDoc} + */ @Override public boolean equals(Object obj) { if (obj == null) return false; diff --git a/src/com/jwetherell/algorithms/data_structures/IntervalTree.java b/src/com/jwetherell/algorithms/data_structures/IntervalTree.java index 7e98245a..3dbd0052 100644 --- a/src/com/jwetherell/algorithms/data_structures/IntervalTree.java +++ b/src/com/jwetherell/algorithms/data_structures/IntervalTree.java @@ -2,6 +2,7 @@ import java.security.InvalidParameterException; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; @@ -335,6 +336,33 @@ public IntervalData(long start, long end, Set set) { } } + /** + * Get the start of this interval + * + * @return Start of interval + */ + public long getStart() { + return start; + } + + /** + * Get the end of this interval + * + * @return End of interval + */ + public long getEnd() { + return end; + } + + /** + * Get the data set in this interval + * + * @return Unmodifiable collection of data objects + */ + public Collection getData() { + return Collections.unmodifiableCollection(this.set); + } + /** * Clear the indices. */ @@ -411,10 +439,18 @@ public IntervalData query(long start, long end) { * {@inheritDoc} */ @Override + public int hashCode() { + return 31 * ((int)(this.start + this.end)) + this.set.size(); + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + @Override public boolean equals(Object obj) { if (!(obj instanceof IntervalData)) return false; - @SuppressWarnings("unchecked") IntervalData data = (IntervalData) obj; if (this.start == data.start && this.end == data.end) { if (this.set.size() != data.set.size()) diff --git a/src/com/jwetherell/algorithms/data_structures/KdTree.java b/src/com/jwetherell/algorithms/data_structures/KdTree.java index 5cf1b998..aac6bced 100644 --- a/src/com/jwetherell/algorithms/data_structures/KdTree.java +++ b/src/com/jwetherell/algorithms/data_structures/KdTree.java @@ -34,8 +34,9 @@ public class KdTree { public int compare(XYZPoint o1, XYZPoint o2) { if (o1.x < o2.x) return -1; - if (o1.x > o2.x) + if (o1.x > o2.x) { return 1; + } return 0; } }; @@ -47,10 +48,12 @@ public int compare(XYZPoint o1, XYZPoint o2) { */ @Override public int compare(XYZPoint o1, XYZPoint o2) { - if (o1.y < o2.y) + if (o1.y < o2.y) { return -1; - if (o1.y > o2.y) + } + if (o1.y > o2.y) { return 1; + } return 0; } }; @@ -62,10 +65,12 @@ public int compare(XYZPoint o1, XYZPoint o2) { */ @Override public int compare(XYZPoint o1, XYZPoint o2) { - if (o1.z < o2.z) + if (o1.z < o2.z) { return -1; - if (o1.z > o2.z) + } + if (o1.z > o2.z) { return 1; + } return 0; } }; @@ -103,16 +108,18 @@ public KdTree(List list) { * @return node created. */ private static KdNode createNode(List list, int k, int depth) { - if (list == null || list.size() == 0) + if (list == null || list.size() == 0) { return null; + } int axis = depth % k; - if (axis == X_AXIS) + if (axis == X_AXIS) { Collections.sort(list, X_COMPARATOR); - else if (axis == Y_AXIS) + } else if (axis == Y_AXIS) { Collections.sort(list, Y_COMPARATOR); - else + } else { Collections.sort(list, Z_COMPARATOR); + } KdNode node = null; if (list.size() > 0) { @@ -122,8 +129,9 @@ else if (axis == Y_AXIS) List more = new ArrayList(list.size() - 1); // Process list to see where each non-median point lies for (int i = 0; i < list.size(); i++) { - if (i == medianIndex) + if (i == medianIndex) { continue; + } XYZPoint p = list.get(i); if (KdNode.compareTo(depth, k, p, node.id) <= 0) { less.add(p); @@ -163,8 +171,9 @@ else if (axis == Y_AXIS) * @return True if successfully added to tree. */ public boolean add(T value) { - if (value == null) + if (value == null) { return false; + } if (root == null) { root = new KdNode(value); @@ -205,8 +214,9 @@ public boolean add(T value) { * @return True if tree contains value. */ public boolean contains(T value) { - if (value == null) + if (value == null) { return false; + } KdNode node = getNode(this, value); return (node != null); @@ -222,8 +232,9 @@ public boolean contains(T value) { * @return KdNode or NULL if not found */ private static final KdNode getNode(KdTree tree, T value) { - if (tree == null || tree.root == null || value == null) + if (tree == null || tree.root == null || value == null) { return null; + } KdNode node = tree.root; while (true) { @@ -253,12 +264,14 @@ private static final KdNode getNode(KdTree tree, * @return True if value was removed from the tree. */ public boolean remove(T value) { - if (value == null) + if (value == null) { return false; + } KdNode node = getNode(this, value); - if (node == null) + if (node == null) { return false; + } KdNode parent = node.parent; if (parent != null) { @@ -286,10 +299,11 @@ public boolean remove(T value) { } else { // root List nodes = getTree(node); - if (nodes.size() > 0) + if (nodes.size() > 0) { root = createNode(nodes, node.k, node.depth); - else + } else { root = null; + } } return true; @@ -304,8 +318,9 @@ public boolean remove(T value) { */ private static final List getTree(KdNode root) { List list = new ArrayList(); - if (root == null) + if (root == null) { return list; + } if (root.lesser != null) { list.add(root.lesser.id); @@ -327,12 +342,13 @@ private static final List getTree(KdNode root) { * last nodes are equal distances. * @param value * to find neighbors of. - * @return collection of T neighbors. + * @return unmodifiable collection of T neighbors. */ @SuppressWarnings("unchecked") public Collection nearestNeighbourSearch(int K, T value) { - if (value == null) + if (value == null) { return null; + } // Map used for results TreeSet results = new TreeSet(new EuclideanComparator(value)); @@ -371,7 +387,7 @@ public Collection nearestNeighbourSearch(int K, T value) { for (KdNode kdNode : results) { collection.add((T) kdNode.id); } - return collection; + return Collections.unmodifiableCollection(collection); } private static final void searchNode(T value, KdNode node, int K, @@ -387,8 +403,9 @@ private static final void searchNode(T value, KdNode } Double nodeDistance = node.id.euclideanDistance(value); if (nodeDistance.compareTo(lastDistance) < 0) { - if (results.size() == K && lastNode != null) + if (results.size() == K && lastNode != null) { results.remove(lastNode); + } results.add(node); } else if (nodeDistance.equals(lastDistance)) { results.add(node); @@ -422,8 +439,9 @@ private static final void searchNode(T value, KdNode boolean lineIntersectsCube = ((valuePlusDistance <= nodePoint) ? true : false); // Continue down lesser branch - if (lineIntersectsCube) + if (lineIntersectsCube) { searchNode(value, lesser, K, results, examined); + } } if (greater != null && !examined.contains(greater)) { examined.add(greater); @@ -443,8 +461,9 @@ private static final void searchNode(T value, KdNode boolean lineIntersectsCube = ((valuePlusDistance >= nodePoint) ? true : false); // Continue down greater branch - if (lineIntersectsCube) + if (lineIntersectsCube) { searchNode(value, greater, K, results, examined); + } } } @@ -471,10 +490,11 @@ public EuclideanComparator(XYZPoint point) { public int compare(KdNode o1, KdNode o2) { Double d1 = point.euclideanDistance(o1.id); Double d2 = point.euclideanDistance(o2.id); - if (d1.compareTo(d2) < 0) + if (d1.compareTo(d2) < 0) { return -1; - else if (d2.compareTo(d1) < 0) + } else if (d2.compareTo(d1) < 0) { return 1; + } return o1.id.compareTo(o2.id); } }; @@ -500,22 +520,34 @@ public KdNode(int k, int depth, XYZPoint id) { public static int compareTo(int depth, int k, XYZPoint o1, XYZPoint o2) { int axis = depth % k; - if (axis == X_AXIS) + if (axis == X_AXIS) { return X_COMPARATOR.compare(o1, o2); - if (axis == Y_AXIS) + } + if (axis == Y_AXIS) { return Y_COMPARATOR.compare(o1, o2); + } return Z_COMPARATOR.compare(o1, o2); } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return 31 * (this.k + this.depth + this.id.hashCode()); + } + /** * {@inheritDoc} */ @Override public boolean equals(Object obj) { - if (obj == null) + if (obj == null) { return false; - if (!(obj instanceof KdNode)) + } + if (!(obj instanceof KdNode)) { return false; + } KdNode kdNode = (KdNode) obj; if (this.compareTo(kdNode) == 0) @@ -546,9 +578,9 @@ public String toString() { public static class XYZPoint implements Comparable { - private double x = Double.NEGATIVE_INFINITY; - private double y = Double.NEGATIVE_INFINITY; - private double z = Double.NEGATIVE_INFINITY; + public double x = Double.NEGATIVE_INFINITY; + public double y = Double.NEGATIVE_INFINITY; + public double z = Double.NEGATIVE_INFINITY; public XYZPoint(double x, double y) { this.x = x; @@ -584,17 +616,27 @@ public double euclideanDistance(XYZPoint o1) { */ private static final double euclideanDistance(XYZPoint o1, XYZPoint o2) { return Math.sqrt(Math.pow((o1.x - o2.x), 2) + Math.pow((o1.y - o2.y), 2) + Math.pow((o1.z - o2.z), 2)); - }; + } + + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + return 31 * (int)(this.x + this.y + this.z); + } /** * {@inheritDoc} */ @Override public boolean equals(Object obj) { - if (obj == null) + if (obj == null) { return false; - if (!(obj instanceof XYZPoint)) + } + if (!(obj instanceof XYZPoint)) { return false; + } XYZPoint xyzPoint = (XYZPoint) obj; return compareTo(xyzPoint) == 0; @@ -606,11 +648,13 @@ public boolean equals(Object obj) { @Override public int compareTo(XYZPoint o) { int xComp = X_COMPARATOR.compare(this, o); - if (xComp != 0) + if (xComp != 0) { return xComp; + } int yComp = Y_COMPARATOR.compare(this, o); - if (yComp != 0) + if (yComp != 0) { return yComp; + } int zComp = Z_COMPARATOR.compare(this, o); return zComp; } @@ -633,8 +677,9 @@ public String toString() { protected static class TreePrinter { public static String getString(KdTree tree) { - if (tree.root == null) + if (tree.root == null) { return "Tree has no nodes."; + } return getString(tree.root, "", true); } @@ -643,8 +688,9 @@ private static String getString(KdNode node, String prefix, boolean isTail) { if (node.parent != null) { String side = "left"; - if (node.parent.greater != null && node.id.equals(node.parent.greater.id)) + if (node.parent.greater != null && node.id.equals(node.parent.greater.id)) { side = "right"; + } builder.append(prefix + (isTail ? "└── " : "├── ") + "[" + side + "] " + "depth=" + node.depth + " id=" + node.id + "\n"); } else { @@ -653,10 +699,12 @@ private static String getString(KdNode node, String prefix, boolean isTail) { List children = null; if (node.lesser != null || node.greater != null) { children = new ArrayList(2); - if (node.lesser != null) + if (node.lesser != null) { children.add(node.lesser); - if (node.greater != null) + } + if (node.greater != null) { children.add(node.greater); + } } if (children != null) { for (int i = 0; i < children.size() - 1; i++) { diff --git a/src/com/jwetherell/algorithms/data_structures/List.java b/src/com/jwetherell/algorithms/data_structures/List.java index df737fcc..bbc04b1c 100644 --- a/src/com/jwetherell/algorithms/data_structures/List.java +++ b/src/com/jwetherell/algorithms/data_structures/List.java @@ -2,6 +2,8 @@ import java.util.Arrays; +import com.jwetherell.algorithms.data_structures.interfaces.IList; + @SuppressWarnings("unchecked") public interface List extends IList { diff --git a/src/com/jwetherell/algorithms/data_structures/Matrix.java b/src/com/jwetherell/algorithms/data_structures/Matrix.java index 781d2991..2b91d06e 100644 --- a/src/com/jwetherell/algorithms/data_structures/Matrix.java +++ b/src/com/jwetherell/algorithms/data_structures/Matrix.java @@ -1,8 +1,12 @@ package com.jwetherell.algorithms.data_structures; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Comparator; + /** - * Matrx. This Matrix is designed to be more efficient in cache. A matrix is a - * rectangular array of numbers, symbols, or expressions. + * Matrx. This Matrix implementation is designed to be more efficient + * in cache. A matrix is a rectangular array of numbers, symbols, or expressions. * * http://en.wikipedia.org/wiki/Matrix_(mathematics) * @@ -14,6 +18,49 @@ public class Matrix { private int cols = 0; private T[] matrix = null; + private final Comparator comparator = new Comparator() { + /** + * {@inheritDoc} + */ + @Override + public int compare(T o1, T o2) { + /* TODO: What if Java adds new numberic type? */ + int result = 0; + if (o1 instanceof BigDecimal || o2 instanceof BigDecimal) { + BigDecimal c1 = (BigDecimal)o1; + BigDecimal c2 = (BigDecimal)o2; + result = c1.compareTo(c2); + } else if (o1 instanceof BigInteger || o2 instanceof BigInteger) { + BigInteger c1 = (BigInteger)o1; + BigInteger c2 = (BigInteger)o2; + result = c1.compareTo(c2); + } else if (o1 instanceof Long || o2 instanceof Long) { + Long c1 = o1.longValue(); + Long c2 = o2.longValue(); + result = c1.compareTo(c2); + } else if (o1 instanceof Double || o2 instanceof Double) { + Double c1 = o1.doubleValue(); + Double c2 = o2.doubleValue(); + result = c1.compareTo(c2); + } else if (o1 instanceof Float || o2 instanceof Float) { + Float c1 = o1.floatValue(); + Float c2 = o2.floatValue(); + result = c1.compareTo(c2); + } else { + Integer c1 = o1.intValue(); + Integer c2 = o2.intValue(); + result = c1.compareTo(c2); + } + return result; + } + }; + + /** + * Matrix with 'rows' number of rows and 'cols' number of columns. + * + * @param rows Number of rows in Matrix. + * @param cols Number of columns in Matrix. + */ @SuppressWarnings("unchecked") public Matrix(int rows, int cols) { this.rows = rows; @@ -21,6 +68,24 @@ public Matrix(int rows, int cols) { this.matrix = (T[]) new Number[rows * cols]; } + /** + * Matrix with 'rows' number of rows and 'cols' number of columns, populates + * the double index matrix. + * + * @param rows Number of rows in Matrix. + * @param cols Number of columns in Matrix. + * @param matrix 2D matrix used to populate Matrix. + */ + @SuppressWarnings("unchecked") + public Matrix(int rows, int cols, T[][] matrix) { + this.rows = rows; + this.cols = cols; + this.matrix = (T[]) new Number[rows * cols]; + for (int r=0; r add(Matrix input) { for (int i = 0; i < cols; i++) { T m1 = this.get(r, c); T m2 = input.get(r, c); - Long l = m1.longValue() + m2.longValue(); - output.set(r, c, (T) l); + T result; + /* TODO: This is ugly and how to handle number overflow? */ + if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { + BigDecimal result2 = ((BigDecimal)m1).add((BigDecimal)m2); + result = (T)result2; + } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { + BigInteger result2 = ((BigInteger)m1).add((BigInteger)m2); + result = (T)result2; + } else if (m1 instanceof Long || m2 instanceof Long) { + Long result2 = (m1.longValue() + m2.longValue()); + result = (T)result2; + } else if (m1 instanceof Double || m2 instanceof Double) { + Double result2 = (m1.doubleValue() + m2.doubleValue()); + result = (T)result2; + } else if (m1 instanceof Float || m2 instanceof Float) { + Float result2 = (m1.floatValue() + m2.floatValue()); + result = (T)result2; + } else { + // Integer + Integer result2 = (m1.intValue() + m2.intValue()); + result = (T)result2; + } + output.set(r, c, result); } } } @@ -83,8 +169,29 @@ public Matrix subtract(Matrix input) { for (int i = 0; i < cols; i++) { T m1 = this.get(r, c); T m2 = input.get(r, c); - Long l = m1.longValue() - m2.longValue(); - output.set(r, c, (T) l); + T result; + /* TODO: This is ugly and how to handle number overflow? */ + if (m1 instanceof BigDecimal || m2 instanceof BigDecimal) { + BigDecimal result2 = ((BigDecimal)m1).subtract((BigDecimal)m2); + result = (T)result2; + } else if (m1 instanceof BigInteger || m2 instanceof BigInteger) { + BigInteger result2 = ((BigInteger)m1).subtract((BigInteger)m2); + result = (T)result2; + } else if (m1 instanceof Long || m2 instanceof Long) { + Long result2 = (m1.longValue() - m2.longValue()); + result = (T)result2; + } else if (m1 instanceof Double || m2 instanceof Double) { + Double result2 = (m1.doubleValue() - m2.doubleValue()); + result = (T)result2; + } else if (m1 instanceof Float || m2 instanceof Float) { + Float result2 = (m1.floatValue() - m2.floatValue()); + result = (T)result2; + } else { + // Integer + Integer result2 = (m1.intValue() - m2.intValue()); + result = (T)result2; + } + output.set(r, c, result); } } } @@ -101,12 +208,70 @@ public Matrix multiply(Matrix input) { for (int c = 0; c < output.cols; c++) { T[] row = getRow(r); T[] column = input.getColumn(c); - Long result = 0l; - for (int i = 0; i < cols; i++) { - Long l = row[i].longValue() * column[i].longValue(); - result += l; + T test = row[0]; + /* TODO: This is ugly and how to handle number overflow? */ + if (test instanceof BigDecimal) { + BigDecimal result = BigDecimal.ZERO; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + BigDecimal result2 = ((BigDecimal)m1).multiply(((BigDecimal)m2)); + result.add(result2); + } + output.set(r, c, (T)result); + } else if (test instanceof BigInteger) { + BigInteger result = BigInteger.ZERO; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + BigInteger result2 = ((BigInteger)m1).multiply(((BigInteger)m2)); + result.add(result2); + } + output.set(r, c, (T)result); + } else if (test instanceof Long) { + Long result = 0l; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + Long result2 = m1.longValue() * m2.longValue(); + result = result+result2; + } + output.set(r, c, (T)result); + } else if (test instanceof Double) { + Double result = 0d; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + Double result2 = m1.doubleValue() * m2.doubleValue(); + result = result+result2; + } + output.set(r, c, (T)result); + } else if (test instanceof Float) { + Float result = 0f; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + Float result2 = m1.floatValue() * m2.floatValue(); + result = result+result2; + } + output.set(r, c, (T)result); + } else { + // Integer + Integer result = 0; + for (int i = 0; i < cols; i++) { + T m1 = row[i]; + T m2 = column[i]; + + Integer result2 = m1.intValue() * m2.intValue(); + result = result+result2; + } + output.set(r, c, (T)result); } - output.set(r, c, (T) result); } } return output; @@ -120,6 +285,43 @@ public void copy(Matrix m) { } } + /** + * {@inheritDoc} + */ + @Override + public int hashCode() { + int hash = this.rows + this.cols; + for (T t : matrix) + hash += t.intValue(); + return 31 * hash; + } + + /** + * {@inheritDoc} + */ + @SuppressWarnings("unchecked") + @Override + public boolean equals(Object obj) { + if (obj == null) + return false; + if (!(obj instanceof Matrix)) + return false; + + Matrix m = (Matrix) obj; + if (this.rows != m.rows) + return false; + if (this.cols != m.cols) + return false; + for (int i=0; i keys = new java.util.HashSet(); Node node = root; - if (node!=null && !validate(node,"",keys)) return false; + if (node!=null && !validate(node,"",keys)) { + return false; + } return (keys.size()==size()); } private boolean validate(Node node, String string, java.util.Set keys) { StringBuilder builder = new StringBuilder(string); - if (node.string!=null) builder.append(node.string); + if (node.string!=null) { + builder.append(node.string); + } String s = builder.toString(); if (node.type == WHITE) { C c = (C)s; - if (c==null) return false; - if (keys.contains(c)) return false; + if (c==null) { + return false; + } + if (keys.contains(c)) { + return false; + } keys.add(c); } for (int i=0; i= childrenSize) return null; + if (index >= childrenSize) { + return null; + } return children[index]; } @@ -462,8 +476,9 @@ protected Node getChildBeginningWithChar(char c) { Node node = null; for (int i = 0; i < this.childrenSize; i++) { Node child = this.children[i]; - if (child.string[0] == c) + if (child.string[0] == c) { return child; + } } return node; } @@ -475,7 +490,9 @@ protected Node getChildBeginningWithChar(char c) { public String toString() { StringBuilder builder = new StringBuilder(); String output = null; - if (string != null) output = String.valueOf(string); + if (string != null) { + output = String.valueOf(string); + } builder.append("string = ").append((output != null) ? output : "NULL").append("\n"); builder.append("type = ").append(type).append("\n"); return builder.toString(); @@ -486,10 +503,14 @@ public String toString() { */ @Override public int compareTo(Node node) { - if (node == null) return -1; + if (node == null) { + return -1; + } int length = string.length; - if (node.string.length < length) length = node.string.length; + if (node.string.length < length) { + length = node.string.length; + } for (int i = 0; i < length; i++) { Character a = string[i]; Character b = node.string[i]; @@ -497,11 +518,17 @@ public int compareTo(Node node) { if (c != 0) return c; } - if (this.type == BLACK && node.type == WHITE) return -1; - else if (node.type == BLACK && this.type == WHITE) return 1; + if (this.type == BLACK && node.type == WHITE) { + return -1; + } else if (node.type == BLACK && this.type == WHITE) { + return 1; + } - if (this.getChildrenSize() < node.getChildrenSize()) return -1; - else if (this.getChildrenSize() > node.getChildrenSize()) return 1; + if (this.getChildrenSize() < node.getChildrenSize()) { + return -1; + } else if (this.getChildrenSize() > node.getChildrenSize()) { + return 1; + } return 0; } @@ -534,11 +561,9 @@ protected static String getString(Node node, String pre String thisString = null; if (node.string != null) thisString = String.valueOf(node.string); String fullString = ((previousString != null) ? previousString : "") + thisString; - builder.append(prefix - + (isTail ? "└── " : "├── ") - + ((thisString != null) ? "[" + ((node.type == WHITE) ? "white" : "black") + "] " - + ((node.type == WHITE) ? "(" + thisString + ") " + fullString : thisString) : "[" - + ((node.type == WHITE) ? "white" : "black") + "]") + "\n"); + builder.append(prefix).append(isTail ? "└── " : "├── ").append((thisString != null) ? "[" + ((node.type == WHITE) ? "white" : "black") + "] " + + ((node.type == WHITE) ? "(" + thisString + ") " + fullString : thisString) : "[" + + ((node.type == WHITE) ? "white" : "black") + "]").append("\n"); if (node.children != null) { for (int i = 0; i < node.getChildrenSize() - 1; i++) { builder.append(getString(node.getChild(i), prefix + (isTail ? " " : "│ "), thisString, false)); @@ -619,8 +644,12 @@ protected PatriciaTrieIterator(PatriciaTrie trie) { private void getNodesWhichRepresentsWords(PatriciaTrie.Node node, String string, java.util.Map nodesMap) { StringBuilder builder = new StringBuilder(string); - if (node.string!=null) builder.append(node.string); - if (node.type == PatriciaTrie.WHITE) nodesMap.put(node,builder.toString()); //Terminating + if (node.string!=null) { + builder.append(node.string); + } + if (node.type == PatriciaTrie.WHITE) { + nodesMap.put(node,builder.toString()); //Terminating + } for (int i=0; i extends IQueue { diff --git a/src/com/jwetherell/algorithms/data_structures/RadixTrie.java b/src/com/jwetherell/algorithms/data_structures/RadixTrie.java index 0dd7335e..75d1a308 100644 --- a/src/com/jwetherell/algorithms/data_structures/RadixTrie.java +++ b/src/com/jwetherell/algorithms/data_structures/RadixTrie.java @@ -1,5 +1,7 @@ package com.jwetherell.algorithms.data_structures; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; + /** * A radix trie or radix tree is a space-optimized trie data structure where * each node with only one child is merged with its child. The result is that diff --git a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java index 541b8870..3c47f82b 100644 --- a/src/com/jwetherell/algorithms/data_structures/SegmentTree.java +++ b/src/com/jwetherell/algorithms/data_structures/SegmentTree.java @@ -1,7 +1,10 @@ package com.jwetherell.algorithms.data_structures; +import java.math.BigDecimal; +import java.math.BigInteger; import java.security.InvalidParameterException; import java.util.ArrayList; +import java.util.Collection; import java.util.Collections; import java.util.Comparator; import java.util.HashSet; @@ -151,10 +154,10 @@ public int compareTo(Data d) { */ public static final class QuadrantData extends Data { + public long quad0 = 0; public long quad1 = 0; public long quad2 = 0; public long quad3 = 0; - public long quad4 = 0; public QuadrantData(long index) { super(index); @@ -167,10 +170,10 @@ public QuadrantData(long start, long end) { public QuadrantData(long index, long quad1, long quad2, long quad3, long quad4) { super(index); - this.quad1 = quad1; - this.quad2 = quad2; - this.quad3 = quad3; - this.quad4 = quad4; + this.quad0 = quad1; + this.quad1 = quad2; + this.quad2 = quad3; + this.quad3 = quad4; } /** @@ -180,10 +183,10 @@ public QuadrantData(long index, long quad1, long quad2, long quad3, long quad4) public void clear() { super.clear(); + quad0 = 0; quad1 = 0; quad2 = 0; quad3 = 0; - quad4 = 0; } /** @@ -206,10 +209,10 @@ public Data combined(Data data) { * to combined. */ private void combined(QuadrantData data) { + this.quad0 += data.quad0; this.quad1 += data.quad1; this.quad2 += data.quad2; this.quad3 += data.quad3; - this.quad4 += data.quad4; } /** @@ -218,10 +221,10 @@ private void combined(QuadrantData data) { @Override public QuadrantData copy() { QuadrantData copy = new QuadrantData(start, end); + copy.quad0 = this.quad0; copy.quad1 = this.quad1; copy.quad2 = this.quad2; copy.quad3 = this.quad3; - copy.quad4 = this.quad4; return copy; } @@ -237,14 +240,8 @@ public Data query(long start, long end) { * {@inheritDoc} */ @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append(super.toString()).append(" "); - builder.append(quad1).append(","); - builder.append(quad2).append(","); - builder.append(quad3).append(","); - builder.append(quad4); - return builder.toString(); + public int hashCode() { + return 31 * (int)(this.start + this.end + this.quad0 + this.quad1 + this.quad2 + this.quad3); } /** @@ -255,12 +252,27 @@ public boolean equals(Object obj) { if (!(obj instanceof QuadrantData)) return false; QuadrantData data = (QuadrantData) obj; - if (this.start == data.start && this.end == data.end && this.quad1 == data.quad1 - && this.quad2 == data.quad2 && this.quad3 == data.quad3 && this.quad4 == data.quad4) { + if (this.start == data.start && this.end == data.end && this.quad0 == data.quad0 + && this.quad1 == data.quad1 && this.quad2 == data.quad2 && this.quad3 == data.quad3) + { return true; } return false; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(super.toString()).append(" "); + builder.append(quad0).append(","); + builder.append(quad1).append(","); + builder.append(quad2).append(","); + builder.append(quad3); + return builder.toString(); + } } /** @@ -317,8 +329,28 @@ else if (this.maximum != null && data.maximum == null) return; else if (this.maximum == null && data.maximum != null) this.maximum = data.maximum; - else if (data.maximum.doubleValue() > this.maximum.doubleValue()) { - this.maximum = data.maximum; + else { + /* TODO: This is ugly and how to handle number overflow? */ + if (this.maximum instanceof BigDecimal || data.maximum instanceof BigDecimal) { + if (((BigDecimal)data.maximum).compareTo(((BigDecimal)this.maximum))==1) + this.maximum = data.maximum; + } else if (this.maximum instanceof BigInteger || data.maximum instanceof BigInteger) { + if (((BigInteger)data.maximum).compareTo(((BigInteger)this.maximum))==1) + this.maximum = data.maximum; + } else if (this.maximum instanceof Long || data.maximum instanceof Long) { + if (((Long)data.maximum).compareTo(((Long)this.maximum))==1) + this.maximum = data.maximum; + } else if (this.maximum instanceof Double || data.maximum instanceof Double) { + if (((Double)data.maximum).compareTo(((Double)this.maximum))==1) + this.maximum = data.maximum; + } else if (this.maximum instanceof Float || data.maximum instanceof Float) { + if (((Float)data.maximum).compareTo(((Float)this.maximum))==1) + this.maximum = data.maximum; + } else { + // Integer + if (((Integer)data.maximum).compareTo(((Integer)this.maximum))==1) + this.maximum = data.maximum; + } } } @@ -342,26 +374,35 @@ public Data query(long start, long end) { * {@inheritDoc} */ @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append(super.toString()).append(" "); - builder.append("maximum=").append(maximum); - return builder.toString(); + public int hashCode() { + return 31 * (int)(this.start + this.end + this.maximum.hashCode()); } /** * {@inheritDoc} */ + @SuppressWarnings("unchecked") @Override public boolean equals(Object obj) { if (!(obj instanceof RangeMaximumData)) return false; - @SuppressWarnings("unchecked") + RangeMaximumData data = (RangeMaximumData) obj; if (this.start == data.start && this.end == data.end && this.maximum.equals(data.maximum)) return true; return false; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(super.toString()).append(" "); + builder.append("maximum=").append(maximum); + return builder.toString(); + } } /** @@ -428,8 +469,28 @@ else if (this.minimum != null && data.minimum == null) return; else if (this.minimum == null && data.minimum != null) this.minimum = data.minimum; - else if (data.minimum.doubleValue() < this.minimum.doubleValue()) { - this.minimum = data.minimum; + else { + /* TODO: This is ugly and how to handle number overflow? */ + if (this.minimum instanceof BigDecimal || data.minimum instanceof BigDecimal) { + if (((BigDecimal)data.minimum).compareTo(((BigDecimal)this.minimum))==-1) + this.minimum = data.minimum; + } else if (this.minimum instanceof BigInteger || data.minimum instanceof BigInteger) { + if (((BigInteger)data.minimum).compareTo(((BigInteger)this.minimum))==-1) + this.minimum = data.minimum; + } else if (this.minimum instanceof Long || data.minimum instanceof Long) { + if (((Long)data.minimum).compareTo(((Long)this.minimum))==-1) + this.minimum = data.minimum; + } else if (this.minimum instanceof Double || data.minimum instanceof Double) { + if (((Double)data.minimum).compareTo(((Double)this.minimum))==-1) + this.minimum = data.minimum; + } else if (this.minimum instanceof Float || data.minimum instanceof Float) { + if (((Float)data.minimum).compareTo(((Float)this.minimum))==-1) + this.minimum = data.minimum; + } else { + // Integer + if (((Integer)data.minimum).compareTo(((Integer)this.minimum))==-1) + this.minimum = data.minimum; + } } } @@ -453,11 +514,8 @@ public Data query(long start, long end) { * {@inheritDoc} */ @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append(super.toString()).append(" "); - builder.append("minimum=").append(minimum); - return builder.toString(); + public int hashCode() { + return 31 * (int)(this.start + this.end + this.minimum.hashCode()); } /** @@ -473,6 +531,17 @@ public boolean equals(Object obj) { return true; return false; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(super.toString()).append(" "); + builder.append("minimum=").append(minimum); + return builder.toString(); + } } /** @@ -541,10 +610,27 @@ else if (this.sum != null && data.sum == null) else if (this.sum == null && data.sum != null) this.sum = data.sum; else { - Double d1 = this.sum.doubleValue(); - Double d2 = data.sum.doubleValue(); - Double r = d1 + d2; - this.sum = (N) r; + /* TODO: This is ugly and how to handle number overflow? */ + if (this.sum instanceof BigDecimal || data.sum instanceof BigDecimal) { + BigDecimal result = ((BigDecimal)this.sum).add((BigDecimal)data.sum); + this.sum = (N)result; + } else if (this.sum instanceof BigInteger || data.sum instanceof BigInteger) { + BigInteger result = ((BigInteger)this.sum).add((BigInteger)data.sum); + this.sum = (N)result; + } else if (this.sum instanceof Long || data.sum instanceof Long) { + Long result = (this.sum.longValue() + data.sum.longValue()); + this.sum = (N)result; + } else if (this.sum instanceof Double || data.sum instanceof Double) { + Double result = (this.sum.doubleValue() + data.sum.doubleValue()); + this.sum = (N)result; + } else if (this.sum instanceof Float || data.sum instanceof Float) { + Float result = (this.sum.floatValue() + data.sum.floatValue()); + this.sum = (N)result; + } else { + // Integer + Integer result = (this.sum.intValue() + data.sum.intValue()); + this.sum = (N)result; + } } } @@ -568,11 +654,8 @@ public Data query(long start, long end) { * {@inheritDoc} */ @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append(super.toString()).append(" "); - builder.append("sum=").append(sum); - return builder.toString(); + public int hashCode() { + return 31 * (int)(this.start + this.end + this.sum.hashCode()); } /** @@ -588,6 +671,17 @@ public boolean equals(Object obj) { return true; return false; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(super.toString()).append(" "); + builder.append("sum=").append(sum); + return builder.toString(); + } } /** @@ -644,6 +738,15 @@ public IntervalData(long start, long end, Set set) { } } + /** + * Get the data set in this interval + * + * @return Unmodifiable collection of data objects + */ + public Collection getData() { + return Collections.unmodifiableCollection(this.set); + } + /** * {@inheritDoc} */ @@ -709,11 +812,8 @@ public Data query(long start, long end) { * {@inheritDoc} */ @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append(super.toString()).append(" "); - builder.append("set=").append(set); - return builder.toString(); + public int hashCode() { + return 31 * (int)(this.start + this.end + this.set.size()); } /** @@ -736,6 +836,17 @@ public boolean equals(Object obj) { } return false; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append(super.toString()).append(" "); + builder.append("set=").append(set); + return builder.toString(); + } } } diff --git a/src/com/jwetherell/algorithms/data_structures/SkipList.java b/src/com/jwetherell/algorithms/data_structures/SkipList.java index 14ed90ec..d3e75440 100644 --- a/src/com/jwetherell/algorithms/data_structures/SkipList.java +++ b/src/com/jwetherell/algorithms/data_structures/SkipList.java @@ -2,6 +2,8 @@ import java.util.Random; +import com.jwetherell.algorithms.data_structures.interfaces.ISet; + /** * Skip List. A skip list is a data structure for storing a sorted list of items * using a hierarchy of linked lists that connect increasingly sparse diff --git a/src/com/jwetherell/algorithms/data_structures/SkipListMap.java b/src/com/jwetherell/algorithms/data_structures/SkipListMap.java index 868531c9..df811c23 100644 --- a/src/com/jwetherell/algorithms/data_structures/SkipListMap.java +++ b/src/com/jwetherell/algorithms/data_structures/SkipListMap.java @@ -1,6 +1,7 @@ package com.jwetherell.algorithms.data_structures; import com.jwetherell.algorithms.data_structures.SkipList.Node; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; /** * A set used to store key->values pairs, this is an implementation of an @@ -69,6 +70,8 @@ public V remove(K key) { if (node instanceof SkipListMapNode) { SkipListMapNode treeMapNode = (SkipListMapNode) node; value = treeMapNode.value; + treeMapNode.data = null; + treeMapNode.value = null; } return value; } diff --git a/src/com/jwetherell/algorithms/data_structures/Stack.java b/src/com/jwetherell/algorithms/data_structures/Stack.java index 5fcc0089..a2685e8d 100644 --- a/src/com/jwetherell/algorithms/data_structures/Stack.java +++ b/src/com/jwetherell/algorithms/data_structures/Stack.java @@ -2,6 +2,8 @@ import java.util.Arrays; +import com.jwetherell.algorithms.data_structures.interfaces.IStack; + @SuppressWarnings("unchecked") public interface Stack extends IStack { diff --git a/src/com/jwetherell/algorithms/data_structures/SuffixTree.java b/src/com/jwetherell/algorithms/data_structures/SuffixTree.java index 0a57af22..e65e62d3 100644 --- a/src/com/jwetherell/algorithms/data_structures/SuffixTree.java +++ b/src/com/jwetherell/algorithms/data_structures/SuffixTree.java @@ -8,6 +8,8 @@ import java.util.TreeMap; import java.util.TreeSet; +import com.jwetherell.algorithms.data_structures.interfaces.ISuffixTree; + /** * A suffix tree is a data structure that presents the suffixes of a given * string in a way that allows for a particularly fast implementation of many @@ -18,7 +20,7 @@ * * @author Justin Wetherell */ -public class SuffixTree { +public class SuffixTree implements ISuffixTree { private static final char DEFAULT_END_SEQ_CHAR = '$'; @@ -55,17 +57,18 @@ public SuffixTree(C seq) { public SuffixTree(C seq, char endSeq) { END_SEQ_CHAR = endSeq; StringBuilder builder = new StringBuilder(seq); - if (builder.indexOf(String.valueOf(seq)) >= 0) + if (builder.indexOf(String.valueOf(END_SEQ_CHAR)) < 0) builder.append(END_SEQ_CHAR); string = builder.toString(); int length = string.length(); characters = new char[length]; for (int i = 0; i < length; i++) { - characters[i] = string.charAt(i); + char c = string.charAt(i); + characters[i] = c; } - for (int i = 0; i < length; i++) { - addPrefix(i); + for (int j = 0; j < length; j++) { + addPrefix(j); } } @@ -446,21 +449,6 @@ public boolean equals(Object obj) { return false; } - /** - * {@inheritDoc} - */ - @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - builder.append("startNode=").append(startNode).append("\n"); - builder.append("endNode=").append(endNode).append("\n"); - builder.append("firstCharIndex=").append(firstCharIndex).append("\n"); - builder.append("lastCharIndex=").append(lastCharIndex).append("\n"); - String s = tree.string.substring(firstCharIndex, lastCharIndex + 1); - builder.append("string=").append(s).append("\n"); - return builder.toString(); - } - /** * {@inheritDoc} */ @@ -491,6 +479,21 @@ public int compareTo(Edge edge) { return 0; } + + /** + * {@inheritDoc} + */ + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("startNode=").append(startNode).append("\n"); + builder.append("endNode=").append(endNode).append("\n"); + builder.append("firstCharIndex=").append(firstCharIndex).append("\n"); + builder.append("lastCharIndex=").append(lastCharIndex).append("\n"); + String s = tree.string.substring(firstCharIndex, lastCharIndex + 1); + builder.append("string=").append(s).append("\n"); + return builder.toString(); + } } protected static class TreePrinter { diff --git a/src/com/jwetherell/algorithms/data_structures/SuffixTrie.java b/src/com/jwetherell/algorithms/data_structures/SuffixTrie.java index 640d2bec..32438139 100644 --- a/src/com/jwetherell/algorithms/data_structures/SuffixTrie.java +++ b/src/com/jwetherell/algorithms/data_structures/SuffixTrie.java @@ -4,6 +4,7 @@ import java.util.TreeSet; import com.jwetherell.algorithms.data_structures.Trie.Node; +import com.jwetherell.algorithms.data_structures.interfaces.ISuffixTree; /** * A suffix trie is a data structure that presents the suffixes of a given @@ -15,7 +16,7 @@ * * @author Justin Wetherell */ -public class SuffixTrie { +public class SuffixTrie implements ISuffixTree { private Trie tree = null; diff --git a/src/com/jwetherell/algorithms/data_structures/TreeMap.java b/src/com/jwetherell/algorithms/data_structures/TreeMap.java index c05d1581..3198e1c4 100644 --- a/src/com/jwetherell/algorithms/data_structures/TreeMap.java +++ b/src/com/jwetherell/algorithms/data_structures/TreeMap.java @@ -4,6 +4,7 @@ import java.util.List; import com.jwetherell.algorithms.data_structures.BinarySearchTree.Node; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; /** * An tree used to store key->values pairs, this is an implementation of an @@ -73,6 +74,8 @@ public V remove(K key) { if (node instanceof TreeMapNode) { TreeMapNode treeMapNode = (TreeMapNode) node; value = treeMapNode.value; + treeMapNode.id = null; + treeMapNode.value = null; } return value; } diff --git a/src/com/jwetherell/algorithms/data_structures/Trie.java b/src/com/jwetherell/algorithms/data_structures/Trie.java index 7f313ecc..dce0ee7a 100644 --- a/src/com/jwetherell/algorithms/data_structures/Trie.java +++ b/src/com/jwetherell/algorithms/data_structures/Trie.java @@ -2,6 +2,8 @@ import java.util.Arrays; +import com.jwetherell.algorithms.data_structures.interfaces.ITree; + /** * A trie, or prefix tree, is an ordered tree data structure that is used to * store an associative array where the keys are usually strings. diff --git a/src/com/jwetherell/algorithms/data_structures/TrieMap.java b/src/com/jwetherell/algorithms/data_structures/TrieMap.java index c05fa2bf..529df0a6 100644 --- a/src/com/jwetherell/algorithms/data_structures/TrieMap.java +++ b/src/com/jwetherell/algorithms/data_structures/TrieMap.java @@ -1,6 +1,7 @@ package com.jwetherell.algorithms.data_structures; import com.jwetherell.algorithms.data_structures.Trie.Node; +import com.jwetherell.algorithms.data_structures.interfaces.IMap; /** * A trie used to store key->values pairs, this is an implementation of an @@ -71,6 +72,7 @@ public V remove(K key) { if (node instanceof TrieMapNode) { TrieMapNode tmn = (TrieMapNode)node; value = tmn.value; + tmn.value = null; } trie.remove(node); } diff --git a/src/com/jwetherell/algorithms/data_structures/IHeap.java b/src/com/jwetherell/algorithms/data_structures/interfaces/IHeap.java similarity index 97% rename from src/com/jwetherell/algorithms/data_structures/IHeap.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/IHeap.java index 0dfcb876..ca70da88 100644 --- a/src/com/jwetherell/algorithms/data_structures/IHeap.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/IHeap.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * In computer science, a heap is a specialized tree-based data structure that diff --git a/src/com/jwetherell/algorithms/data_structures/IList.java b/src/com/jwetherell/algorithms/data_structures/interfaces/IList.java similarity index 95% rename from src/com/jwetherell/algorithms/data_structures/IList.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/IList.java index 26d5cfb1..345b421f 100644 --- a/src/com/jwetherell/algorithms/data_structures/IList.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/IList.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * A list or sequence is an abstract data type that implements an ordered diff --git a/src/com/jwetherell/algorithms/data_structures/IMap.java b/src/com/jwetherell/algorithms/data_structures/interfaces/IMap.java similarity index 96% rename from src/com/jwetherell/algorithms/data_structures/IMap.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/IMap.java index 0ce9a455..131d78aa 100644 --- a/src/com/jwetherell/algorithms/data_structures/IMap.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/IMap.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * In computer science, an associative array, map, or dictionary is an abstract diff --git a/src/com/jwetherell/algorithms/data_structures/IQueue.java b/src/com/jwetherell/algorithms/data_structures/interfaces/IQueue.java similarity index 97% rename from src/com/jwetherell/algorithms/data_structures/IQueue.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/IQueue.java index d1eddab0..3cf40dd8 100644 --- a/src/com/jwetherell/algorithms/data_structures/IQueue.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/IQueue.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * A queue is a particular kind of abstract data type or collection in diff --git a/src/com/jwetherell/algorithms/data_structures/ISet.java b/src/com/jwetherell/algorithms/data_structures/interfaces/ISet.java similarity index 96% rename from src/com/jwetherell/algorithms/data_structures/ISet.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/ISet.java index 28fb17ae..6929c83a 100644 --- a/src/com/jwetherell/algorithms/data_structures/ISet.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/ISet.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * In computer science, a set is an abstract data structure that can store certain values, without diff --git a/src/com/jwetherell/algorithms/data_structures/IStack.java b/src/com/jwetherell/algorithms/data_structures/interfaces/IStack.java similarity index 97% rename from src/com/jwetherell/algorithms/data_structures/IStack.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/IStack.java index d8dfd802..0a00f781 100644 --- a/src/com/jwetherell/algorithms/data_structures/IStack.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/IStack.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * A stack is a last in, first out (LIFO) abstract data type and linear diff --git a/src/com/jwetherell/algorithms/data_structures/interfaces/ISuffixTree.java b/src/com/jwetherell/algorithms/data_structures/interfaces/ISuffixTree.java new file mode 100644 index 00000000..6aec9aa3 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/ISuffixTree.java @@ -0,0 +1,30 @@ +package com.jwetherell.algorithms.data_structures.interfaces; + +import java.util.Set; + +/** + * In computer science, a suffix tree (also called PAT tree or, in an earlier form, position tree) is a compressed trie + * containing all the suffixes of the given text as their keys and positions in the text as their values. Suffix trees + * allow particularly fast implementations of many important string operations. + * + * http://en.wikipedia.org/wiki/Suffix_tree + * + * @author Justin Wetherell + */ +public interface ISuffixTree { + + /** + * Does the sub-sequence exist in the suffix tree. + * + * @param sub-sequence to locate in the tree. + * @return True if the sub-sequence exist in the tree. + */ + public boolean doesSubStringExist(C sub); + + /** + * Get all the suffixes in the tree. + * + * @return set of suffixes in the tree. + */ + public Set getSuffixes(); +} diff --git a/src/com/jwetherell/algorithms/data_structures/ITree.java b/src/com/jwetherell/algorithms/data_structures/interfaces/ITree.java similarity index 96% rename from src/com/jwetherell/algorithms/data_structures/ITree.java rename to src/com/jwetherell/algorithms/data_structures/interfaces/ITree.java index 297e41a4..a1b63cd7 100644 --- a/src/com/jwetherell/algorithms/data_structures/ITree.java +++ b/src/com/jwetherell/algorithms/data_structures/interfaces/ITree.java @@ -1,4 +1,4 @@ -package com.jwetherell.algorithms.data_structures; +package com.jwetherell.algorithms.data_structures.interfaces; /** * A tree can be defined recursively (locally) as a collection of nodes (starting at a root node), diff --git a/src/com/jwetherell/algorithms/data_structures/test/AVLTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/AVLTreeTests.java new file mode 100644 index 00000000..522f2e7d --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/AVLTreeTests.java @@ -0,0 +1,32 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.AVLTree; +import com.jwetherell.algorithms.data_structures.BinarySearchTree; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class AVLTreeTests { + + @Test + public void testAVLTree() { + TestData data = Utils.generateTestData(1000); + + String bstName = "AVL Tree"; + BinarySearchTree bst = new AVLTree(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/AllTests.java b/src/com/jwetherell/algorithms/data_structures/test/AllTests.java new file mode 100644 index 00000000..45c303f0 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/AllTests.java @@ -0,0 +1,49 @@ +package com.jwetherell.algorithms.data_structures.test; + +import org.junit.runner.JUnitCore; +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses( { + AVLTreeTests.class, + BinaryHeapTests.class, + BinarySearchTreeTests.class, + BTreeTests.class, + CompactSuffixTrieTests.class, + HashArrayMappedTreeTests.class, + HashMapTests.class, + IntervalTreeTests.class, + KdTreeTests.class, + ListTests.class, + MatrixTests.class, + PatriciaTreeTests.class, + QuadTreeTests.class, + QueueTests.class, + RadixTrieTests.class, + RedBlackTreeTests.class, + SegmentTreeTests.class, + SkipListMapTests.class, + SkipListTests.class, + SplayTreeTests.class, + StackTests.class, + SuffixTreeTests.class, + SuffixTrieTests.class, + TreapTests.class, + TreeMapTests.class, + TrieTests.class, + TrieMapTests.class + } + ) + +public class AllTests { + + /** + * @param args + */ + public static void main(String[] args) { + JUnitCore core = new JUnitCore(); + core.run(AllTests.class); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/BTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/BTreeTests.java new file mode 100644 index 00000000..0607e94d --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/BTreeTests.java @@ -0,0 +1,30 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.BTree; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class BTreeTests { + + @Test + public void testBTree() { + TestData data = Utils.generateTestData(1000); + + String bstName = "B-Tree"; + BTree bst = new BTree(2); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/BinaryHeapTests.java b/src/com/jwetherell/algorithms/data_structures/test/BinaryHeapTests.java new file mode 100644 index 00000000..d959f185 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/BinaryHeapTests.java @@ -0,0 +1,59 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.BinaryHeap; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.HeapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class BinaryHeapTests { + + @Test + public void testMinHeap() { + TestData data = Utils.generateTestData(100); + + String aNameMin = "Min-Heap [array]"; + BinaryHeap.BinaryHeapArray aHeapMin = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MIN); + Collection aCollectionMin = aHeapMin.toCollection(); + assertTrue(HeapTest.testHeap(BinaryHeap.Type.MIN, aHeapMin, Type.Integer, aNameMin, + data.unsorted, data.sorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(aCollectionMin, Type.Integer, aNameMin, + data.unsorted, data.sorted, data.invalid)); + + String tNameMin = "Min-Heap [tree]"; + BinaryHeap.BinaryHeapTree tHeapMin = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MIN); + Collection tCollectionMin = tHeapMin.toCollection(); + assertTrue(HeapTest.testHeap(BinaryHeap.Type.MIN, tHeapMin, Type.Integer, tNameMin, + data.unsorted, data.sorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(tCollectionMin, Type.Integer, tNameMin, + data.unsorted, data.sorted, data.invalid)); + } + + @Test + public void testMaxHeap() { + TestData data = Utils.generateTestData(1000); + + String aNameMax = "Max-Heap [array]"; + BinaryHeap.BinaryHeapArray aHeapMax = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MAX); + Collection aCollectionMax = aHeapMax.toCollection(); + assertTrue(HeapTest.testHeap(BinaryHeap.Type.MAX, aHeapMax, Type.Integer, aNameMax, + data.unsorted, data.sorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(aCollectionMax, Type.Integer, aNameMax, + data.unsorted, data.sorted, data.invalid)); + + String lNameMax = "Max-Heap [tree]"; + BinaryHeap.BinaryHeapTree tHeapMax = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MAX); + Collection tCollectionMax = tHeapMax.toCollection(); + assertTrue(HeapTest.testHeap(BinaryHeap.Type.MAX, tHeapMax, Type.Integer, lNameMax, + data.unsorted, data.sorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(tCollectionMax, Type.Integer, lNameMax, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/BinarySearchTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/BinarySearchTreeTests.java new file mode 100644 index 00000000..25e9fabf --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/BinarySearchTreeTests.java @@ -0,0 +1,31 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.BinarySearchTree; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class BinarySearchTreeTests { + + @Test + public void testBST() { + TestData data = Utils.generateTestData(1000); + + String bstName = "BST"; + BinarySearchTree bst = new BinarySearchTree(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/CompactSuffixTrieTests.java b/src/com/jwetherell/algorithms/data_structures/test/CompactSuffixTrieTests.java new file mode 100644 index 00000000..8b6bce27 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/CompactSuffixTrieTests.java @@ -0,0 +1,28 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.CompactSuffixTrie; + +public class CompactSuffixTrieTests { + + @Test + public void testCompactSuffixTrie() { + String bookkeeper = "bookkeeper"; + CompactSuffixTrie trie = new CompactSuffixTrie(bookkeeper); + + boolean exists = trie.doesSubStringExist(bookkeeper); + assertTrue("YIKES!! " + bookkeeper + " doesn't exists.", exists); + + String failed = "booker"; + exists = trie.doesSubStringExist(failed); + assertFalse("YIKES!! " + failed + " exists.", exists); + + String pass = "kkee"; + exists = trie.doesSubStringExist(pass); + assertTrue("YIKES!! " + pass + " doesn't exists.", exists); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/HashArrayMappedTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/HashArrayMappedTreeTests.java new file mode 100644 index 00000000..1ea2caaa --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/HashArrayMappedTreeTests.java @@ -0,0 +1,29 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.HashArrayMappedTrie; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class HashArrayMappedTreeTests { + + @Test + public void testHAMT() { + TestData data = Utils.generateTestData(1000); + + String mapName = "HAMT"; + HashArrayMappedTrie map = new HashArrayMappedTrie(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.Integer, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.Integer, mapName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/HashMapTests.java b/src/com/jwetherell/algorithms/data_structures/test/HashMapTests.java new file mode 100644 index 00000000..faf81fa5 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/HashMapTests.java @@ -0,0 +1,29 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.HashMap; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class HashMapTests { + + @Test + public void testHashMap() { + TestData data = Utils.generateTestData(1000); + + String mapName = "HashMap"; + HashMap map = new HashMap(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.Integer, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.Integer, mapName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/IntervalTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/IntervalTreeTests.java new file mode 100644 index 00000000..31168939 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/IntervalTreeTests.java @@ -0,0 +1,106 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.IntervalTree; + +public class IntervalTreeTests { + + @Test + public void testIntervalTree() { + { // Interval tree + final String RED = "RED"; + final String ORANGE = "ORANGE"; + final String GREEN = "GREEN"; + final String DARK_GREEN = "DARK_GREEN"; + final String BLUE = "BLUE"; + final String PURPLE = "PURPLE"; + final String BLACK = "BLACK"; + java.util.List> intervals = new ArrayList>(); + intervals.add((new IntervalTree.IntervalData(2, 6, RED))); + intervals.add((new IntervalTree.IntervalData(3, 5, ORANGE))); + intervals.add((new IntervalTree.IntervalData(4, 11, GREEN))); + intervals.add((new IntervalTree.IntervalData(5, 10, DARK_GREEN))); + intervals.add((new IntervalTree.IntervalData(8, 12, BLUE))); + intervals.add((new IntervalTree.IntervalData(9, 14, PURPLE))); + intervals.add((new IntervalTree.IntervalData(13, 15, BLACK))); + IntervalTree tree = new IntervalTree(intervals); + + IntervalTree.IntervalData query = tree.query(2); + assertTrue("Interval Tree query error. query=2 returned="+query, query.getData().contains(RED)); + + query = tree.query(4); // Stabbing query + assertTrue("Interval Tree query error. query=4 returned="+query, query.getData().contains(GREEN)); + + query = tree.query(9); // Stabbing query + assertTrue("Interval Tree query error. query=9 returned="+query, query.getData().contains(PURPLE)); + + query = tree.query(1, 16); // Range query + assertTrue("Interval Tree query error. query=1->16 returned="+query, (query.getData().contains(RED) && + query.getData().contains(ORANGE) && + query.getData().contains(GREEN) && + query.getData().contains(DARK_GREEN) && + query.getData().contains(BLUE) && + query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + + query = tree.query(7, 14); // Range query + assertTrue("Interval Tree query error. query=7->14 returned="+query, (query.getData().contains(GREEN) && + query.getData().contains(DARK_GREEN) && + query.getData().contains(BLUE) && + query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + + query = tree.query(14, 15); // Range query + assertTrue((query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + } + + { // Lifespan Interval tree + final String stravinsky = "Stravinsky"; + final String schoenberg = "Schoenberg"; + final String grieg = "Grieg"; + final String schubert = "Schubert"; + final String mozart = "Mozart"; + final String schuetz = "Schuetz"; + java.util.List> intervals = new ArrayList>(); + intervals.add((new IntervalTree.IntervalData(1888, 1971, stravinsky))); + intervals.add((new IntervalTree.IntervalData(1874, 1951, schoenberg))); + intervals.add((new IntervalTree.IntervalData(1843, 1907, grieg))); + intervals.add((new IntervalTree.IntervalData(1779, 1828, schubert))); + intervals.add((new IntervalTree.IntervalData(1756, 1791, mozart))); + intervals.add((new IntervalTree.IntervalData(1585, 1672, schuetz))); + IntervalTree tree = new IntervalTree(intervals); + + IntervalTree.IntervalData query = tree.query(1890); // Stabbing query + assertTrue("Interval Tree query error. query=1890 returned="+query, (query.getData().contains(stravinsky) && + query.getData().contains(schoenberg) && + query.getData().contains(grieg)) + ); + + query = tree.query(1909); // Stabbing query + assertTrue("Interval Tree query error. query=1909 returned="+query , (query.getData().contains(stravinsky) && + query.getData().contains(schoenberg)) + ); + + query = tree.query(1792, 1903); // Range query + assertTrue("Interval Tree query error. query=1792->1903 returned="+query, query.getData().contains(stravinsky) && + query.getData().contains(schoenberg) && + query.getData().contains(grieg) && + query.getData().contains(schubert) + ); + + query = tree.query(1776, 1799); // Range query + assertTrue("Interval Tree query error. query=1776->1799 returned="+query, (query.getData().contains(schubert) && + query.getData().contains(mozart)) + ); + } + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/KdTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/KdTreeTests.java new file mode 100644 index 00000000..d8ef26af --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/KdTreeTests.java @@ -0,0 +1,49 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.KdTree; + +public class KdTreeTests { + + @Test + public void testKdTree() { + java.util.List points = new ArrayList(); + KdTree.XYZPoint p1 = new KdTree.XYZPoint(2, 3); + points.add(p1); + KdTree.XYZPoint p2 = new KdTree.XYZPoint(5, 4); + points.add(p2); + KdTree.XYZPoint p3 = new KdTree.XYZPoint(9, 6); + points.add(p3); + KdTree.XYZPoint p4 = new KdTree.XYZPoint(4, 7); + points.add(p4); + KdTree.XYZPoint p5 = new KdTree.XYZPoint(8, 1); + points.add(p5); + KdTree.XYZPoint p6 = new KdTree.XYZPoint(7, 2); + points.add(p6); + KdTree kdTree = new KdTree(points); + + Collection result = kdTree.nearestNeighbourSearch(1, p3); + assertTrue("K-D Tree query error. query=(k=1, p=(9, 6)) returned="+result, result.contains(p3)); + + KdTree.XYZPoint search = new KdTree.XYZPoint(1, 4); + result = kdTree.nearestNeighbourSearch(4, search); + assertTrue("K-D Tree query error. query=(k=4, p=(1, 4)) returned="+result, (result.contains(p1) && + result.contains(p2) && + result.contains(p4) && + result.contains(p6)) + ); + + kdTree.remove(p6); + kdTree.remove(p4); + kdTree.remove(p3); + kdTree.remove(p5); + kdTree.remove(p1); + kdTree.remove(p2); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/ListTests.java b/src/com/jwetherell/algorithms/data_structures/test/ListTests.java new file mode 100644 index 00000000..de27cd81 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/ListTests.java @@ -0,0 +1,45 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.List; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.ListTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class ListTests { + + @Test + public void testArrayList() { + TestData data = Utils.generateTestData(1000); + + String aName = "List [array]"; + List.ArrayList aList = new List.ArrayList(); + Collection aCollection = aList.toCollection(); + + assertTrue(ListTest.testList(aList, aName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(aCollection, Type.Integer, aName, + data.unsorted, data.sorted, data.invalid)); + } + + @Test + public void testLinkedList() { + TestData data = Utils.generateTestData(1000); + + String lName = "List [linked]"; + List.LinkedList lList = new List.LinkedList(); + Collection lCollection = lList.toCollection(); + + assertTrue(ListTest.testList(lList, lName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(lCollection, Type.Integer, lName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/MatrixTests.java b/src/com/jwetherell/algorithms/data_structures/test/MatrixTests.java new file mode 100644 index 00000000..23d79bd2 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/MatrixTests.java @@ -0,0 +1,89 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.Matrix; + +public class MatrixTests { + + @Test + public void testMatrix() { + Matrix matrix1 = new Matrix(4, 3); + matrix1.set(0, 0, 14); + matrix1.set(0, 1, 9); + matrix1.set(0, 2, 3); + matrix1.set(1, 0, 2); + matrix1.set(1, 1, 11); + matrix1.set(1, 2, 15); + matrix1.set(2, 0, 0); + matrix1.set(2, 1, 12); + matrix1.set(2, 2, 17); + matrix1.set(3, 0, 5); + matrix1.set(3, 1, 2); + matrix1.set(3, 2, 3); + + Matrix matrix2 = new Matrix(3, 2); + matrix2.set(0, 0, 12); + matrix2.set(0, 1, 25); + matrix2.set(1, 0, 9); + matrix2.set(1, 1, 10); + matrix2.set(2, 0, 8); + matrix2.set(2, 1, 5); + + // Result of multiplication + Integer[][] array1 = new Integer[][]{{273,455}, + {243,235}, + {244,205}, + {102,160}}; + Matrix result1 = new Matrix(4,2,array1); + + Matrix matrix3 = matrix1.multiply(matrix2); + assertTrue("Matrix multiplication error. matrix3="+matrix3+" result1"+result1, matrix3.equals(result1)); + + int rows = 2; + int cols = 2; + int counter = 0; + Matrix matrix4 = new Matrix(rows, cols); + for (int r = 0; r < rows; r++) + for (int c = 0; c < cols; c++) + matrix4.set(r, c, counter++); + + // Result of subtraction + Integer[][] array2 = new Integer[][]{{0,0}, + {0,0}}; + Matrix result2 = new Matrix(2,2,array2); + + Matrix matrix5 = matrix4.subtract(matrix4); + assertTrue("Matrix subtraction error. matrix5="+matrix5+" result2"+result2, matrix5.equals(result2)); + + // Result of addition + Integer[][] array3 = new Integer[][]{{0,2}, + {4,6}}; + Matrix result3 = new Matrix(2,2,array3); + + Matrix matrix6 = matrix4.add(matrix4); + assertTrue("Matrix addition error. matrix6="+matrix6+" result3"+result3, matrix6.equals(result3)); + + Matrix matrix7 = new Matrix(2, 2); + matrix7.set(0, 0, 1); + matrix7.set(0, 1, 2); + matrix7.set(1, 0, 3); + matrix7.set(1, 1, 4); + + Matrix matrix8 = new Matrix(2, 2); + matrix8.set(0, 0, 1); + matrix8.set(0, 1, 2); + matrix8.set(1, 0, 3); + matrix8.set(1, 1, 4); + + // Result of multiplication + Integer[][] array4 = new Integer[][]{{7,10}, + {15,22}}; + Matrix result4 = new Matrix(2,2,array4); + + Matrix matrix9 = matrix7.multiply(matrix8); + assertTrue("Matrix multiplication error. matrix9="+matrix9+" result4"+result4, matrix9.equals(result4)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/PatriciaTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/PatriciaTreeTests.java new file mode 100644 index 00000000..155cff69 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/PatriciaTreeTests.java @@ -0,0 +1,31 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.PatriciaTrie; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class PatriciaTreeTests { + + @Test + public void testPatriciaTrie() { + TestData data = Utils.generateTestData(1000); + + String bstName = "PatriciaTrie"; + PatriciaTrie bst = new PatriciaTrie(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.String, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.String, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/QuadTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/QuadTreeTests.java new file mode 100644 index 00000000..5aeb140b --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/QuadTreeTests.java @@ -0,0 +1,111 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.Collections; +import java.util.Random; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.QuadTree; + +public class QuadTreeTests { + + private static final Random RANDOM = new Random(); + + @Test + public void testQuadTree() { + int size = 1000; + + java.util.Set set = new java.util.HashSet(size); + while (set.size() < size) { + float x = RANDOM.nextInt(size); + float y = RANDOM.nextInt(size); + QuadTree.XYPoint xyPoint = new QuadTree.XYPoint(x,y); + set.add(xyPoint); + } + + java.util.List query = new java.util.ArrayList(size); + for (int j=0; j tree = new QuadTree.PointRegionQuadTree(0,0,size,size); + + { + for (QuadTree.XYPoint p : set) + tree.insert(p.getX(), p.getY()); + } + + // We should find all points here (tests structure) + for (QuadTree.XYPoint p : set) { + java.util.List result = tree.queryRange(p.getX(), p.getY(), 1, 1); + assertTrue("Quad tree queryRange error. result="+result, result.size()>0); + } + + // We may not find all points here (tests query speed) + { + for (QuadTree.XYPoint p : query) + tree.queryRange(p.getX(), p.getY(), 1, 1); + } + + // Result set should not contain duplicates + java.util.List result = tree.queryRange(0, 0, size, size); + + Collections.sort(result); + QuadTree.XYPoint prev = null; + for (QuadTree.XYPoint p : result) { + assertFalse("Quad tree compare error. p="+p+" prev="+prev+" result="+result, (prev!=null && prev.equals(p))); + prev = p; + } + + { // Remove all + for (QuadTree.XYPoint p : set) { + boolean removed = tree.remove(p.getX(), p.getY()); + assertTrue("Quad tree remove error. removed="+removed+" x="+p.getX()+" y="+p.getY(), removed); + } + } + } + + { // Rectangle base quad-tree + QuadTree.MxCifQuadTree tree = new QuadTree.MxCifQuadTree(0,0,size,size,10,10); + { + for (QuadTree.XYPoint p : set) + tree.insert(p.getX(), p.getY(), 1, 1); + } + + // We should find all points here + for (QuadTree.XYPoint p : set) { + java.util.List result = tree.queryRange(p.getX(), p.getY(), 1, 1); + assertTrue("Quad tree queryRange error. result="+result, result.size()!=0); + } + + { // We may not find all points here + for (QuadTree.XYPoint p : query) + tree.queryRange(p.getX(), p.getY(), 1, 1); + } + + // Result set should not contain duplicates + java.util.List result = tree.queryRange(0, 0, size, size); + + Collections.sort(result); + QuadTree.AxisAlignedBoundingBox prev = null; + for (QuadTree.AxisAlignedBoundingBox p : result) { + assertFalse("Quad tree compare error. p="+p+" prev="+prev+" result="+result, (prev!=null && prev.equals(p))); + prev = p; + } + + { // Remove all + for (QuadTree.XYPoint p : set) { + boolean removed = tree.remove(p.getX(), p.getY(), 1, 1); + assertTrue("Quad tree remove error. removed="+removed+" x="+p.getX()+" y="+p.getY(), removed); + } + } + } + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/QueueTests.java b/src/com/jwetherell/algorithms/data_structures/test/QueueTests.java new file mode 100644 index 00000000..0fe9f3fc --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/QueueTests.java @@ -0,0 +1,45 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.Queue; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.QueueTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class QueueTests { + + @Test + public void testArrayQueue() { + TestData data = Utils.generateTestData(100); + + String aName = "Queue [array]"; + Queue.ArrayQueue aQueue = new Queue.ArrayQueue(); + Collection aCollection = aQueue.toCollection(); + + assertTrue(QueueTest.testQueue(aQueue, aName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(aCollection, Type.Integer, aName, + data.unsorted, data.sorted, data.invalid)); + } + + @Test + public void testLinkedQueue() { + TestData data = Utils.generateTestData(100); + + String lName = "Queue [linked]"; + Queue.LinkedQueue lQueue = new Queue.LinkedQueue(); + Collection lCollection = lQueue.toCollection(); + + assertTrue(QueueTest.testQueue(lQueue, lName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(lCollection, Type.Integer, lName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/RadixTrieTests.java b/src/com/jwetherell/algorithms/data_structures/test/RadixTrieTests.java new file mode 100644 index 00000000..92b7a86e --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/RadixTrieTests.java @@ -0,0 +1,30 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.RadixTrie; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class RadixTrieTests { + + @Test + public void testRadixTrie() { + TestData data = Utils.generateTestData(1000); + + String mapName = "RadixTrie"; + RadixTrie map = new RadixTrie(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.String, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.String, mapName, + data.unsorted, data.sorted, data.invalid)); + } + +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/RedBlackTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/RedBlackTreeTests.java new file mode 100644 index 00000000..15c55f74 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/RedBlackTreeTests.java @@ -0,0 +1,31 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.RedBlackTree; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class RedBlackTreeTests { + + @Test + public void testRedBlackTree() { + TestData data = Utils.generateTestData(1000); + + String bstName = "Red-Black Tree"; + RedBlackTree bst = new RedBlackTree(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java new file mode 100644 index 00000000..0c9f172c --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SegmentTreeTests.java @@ -0,0 +1,211 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.SegmentTree; +import com.jwetherell.algorithms.data_structures.SegmentTree.DynamicSegmentTree; +import com.jwetherell.algorithms.data_structures.SegmentTree.FlatSegmentTree; + +public class SegmentTreeTests { + + @Test + public void testSegmentTree() { + { // Quadrant Segment tree + java.util.List segments = new ArrayList(); + segments.add(new SegmentTree.Data.QuadrantData(0, 1, 0, 0, 0)); // first point in the 0th quadrant + segments.add(new SegmentTree.Data.QuadrantData(1, 0, 1, 0, 0)); // second point in the 1st quadrant + segments.add(new SegmentTree.Data.QuadrantData(2, 0, 0, 1, 0)); // third point in the 2nd quadrant + segments.add(new SegmentTree.Data.QuadrantData(3, 0, 0, 0, 1)); // fourth point in the 3rd quadrant + FlatSegmentTree tree = new FlatSegmentTree(segments); + + SegmentTree.Data.QuadrantData query = tree.query(0, 3); + assertTrue("Quad tree query error. query=0->3 result="+query, (query.quad0==1 && query.quad1==1 && query.quad2==1 && query.quad3==1)); + + query = tree.query(2, 3); + assertTrue("Quad tree query error. query=2->3 result="+query, (query.quad0==0 && query.quad1==0 && query.quad2==1 && query.quad3==1)); + + query = tree.query(0, 2); + assertTrue("Quad tree query error. query=0->2 result="+query, (query.quad0==1 && query.quad1==1 && query.quad2==1 && query.quad3==0)); + } + + { // Range Maximum Segment tree + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMaximumData(0, (Integer) 4)); + segments.add(new SegmentTree.Data.RangeMaximumData(1, (Integer) 2)); + segments.add(new SegmentTree.Data.RangeMaximumData(2, (Integer) 6)); + segments.add(new SegmentTree.Data.RangeMaximumData(3, (Integer) 3)); + segments.add(new SegmentTree.Data.RangeMaximumData(4, (Integer) 1)); + segments.add(new SegmentTree.Data.RangeMaximumData(5, (Integer) 5)); + segments.add(new SegmentTree.Data.RangeMaximumData(6, (Integer) 0)); + segments.add(new SegmentTree.Data.RangeMaximumData(7, 17, 7)); + segments.add(new SegmentTree.Data.RangeMaximumData(21, (Integer) 10)); + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 3); + + SegmentTree.Data.RangeMaximumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, query.maximum==7); + + query = tree.query(0, 21); + assertTrue("Segment tree query error. query=0->21 result="+query, query.maximum==10); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, query.maximum==6); + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, query.maximum==7); + } + + { // Range Minimum Segment tree + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeMinimumData(0, (Integer) 4)); + segments.add(new SegmentTree.Data.RangeMinimumData(1, (Integer) 2)); + segments.add(new SegmentTree.Data.RangeMinimumData(2, (Integer) 6)); + segments.add(new SegmentTree.Data.RangeMinimumData(3, (Integer) 3)); + segments.add(new SegmentTree.Data.RangeMinimumData(4, (Integer) 1)); + segments.add(new SegmentTree.Data.RangeMinimumData(5, (Integer) 5)); + segments.add(new SegmentTree.Data.RangeMinimumData(6, (Integer) 0)); + segments.add(new SegmentTree.Data.RangeMinimumData(17, (Integer) 7)); + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 5); + + SegmentTree.Data.RangeMinimumData query = tree.query(0, 7); + assertTrue("Segment tree query error. query=0->7 result="+query, query.minimum==0); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, query.minimum==0); + + query = tree.query(1, 3); + assertTrue("Segment tree query error. query=1->3 result="+query, query.minimum==2); + + query = tree.query(7); // stabbing + assertTrue("Segment tree query error. query=7 result="+query, query.minimum==null); + } + + { // Range Sum Segment tree + java.util.List> segments = new ArrayList>(); + segments.add(new SegmentTree.Data.RangeSumData(0, (Integer) 4)); + segments.add(new SegmentTree.Data.RangeSumData(1, (Integer) 2)); + segments.add(new SegmentTree.Data.RangeSumData(2, (Integer) 6)); + segments.add(new SegmentTree.Data.RangeSumData(3, (Integer) 3)); + segments.add(new SegmentTree.Data.RangeSumData(4, (Integer) 1)); + segments.add(new SegmentTree.Data.RangeSumData(5, (Integer) 5)); + segments.add(new SegmentTree.Data.RangeSumData(6, (Integer) 0)); + segments.add(new SegmentTree.Data.RangeSumData(17, (Integer) 7)); + FlatSegmentTree> tree = new FlatSegmentTree>(segments, 10); + + SegmentTree.Data.RangeSumData query = tree.query(0, 8); + assertTrue("Segment tree query error. query=0->8 result="+query, query.sum==21); + + query = tree.query(0, 17); + assertTrue("Segment tree query error. query=0->17 result="+query, query.sum==28); + + query = tree.query(2, 5); + assertTrue("Segment tree query error. query=2->5 result="+query, query.sum==15); + + query = tree.query(10, 17); + assertTrue("Segment tree query error. query=10->17 result="+query, query.sum==7); + + query = tree.query(16); // stabbing + assertTrue("Segment tree query error. query=16 result="+query, query.sum==null); + + query = tree.query(17); // stabbing + assertTrue("Segment tree query error. query=17 result="+query, query.sum==7); + } + + { // Interval Segment tree + final String RED = "RED"; + final String ORANGE = "ORANGE"; + final String GREEN = "GREEN"; + final String DARK_GREEN = "DARK_GREEN"; + final String BLUE = "BLUE"; + final String PURPLE = "PURPLE"; + final String BLACK = "BLACK"; + java.util.List> segments = new ArrayList>(); + segments.add((new SegmentTree.Data.IntervalData(2, 6, RED))); + segments.add((new SegmentTree.Data.IntervalData(3, 5, ORANGE))); + segments.add((new SegmentTree.Data.IntervalData(4, 11, GREEN))); + segments.add((new SegmentTree.Data.IntervalData(5, 10, DARK_GREEN))); + segments.add((new SegmentTree.Data.IntervalData(8, 12, BLUE))); + segments.add((new SegmentTree.Data.IntervalData(9, 14, PURPLE))); + segments.add((new SegmentTree.Data.IntervalData(13, 15, BLACK))); + DynamicSegmentTree> tree = new DynamicSegmentTree>(segments); + + SegmentTree.Data.IntervalData query = tree.query(2); // Stabbing + assertTrue("Segment tree query error. query=2 result="+query, query.getData().contains(RED)); + + query = tree.query(4); // Stabbing query + assertTrue("Segment tree query error. query=4 result="+query, query.getData().contains(GREEN)); + + query = tree.query(9); // Stabbing query + assertTrue("Segment tree query error. query=9 result="+query, query.getData().contains(PURPLE)); + + query = tree.query(1, 16); // Range query + assertTrue("Segment tree query error. query=1->16 result="+query, (query.getData().contains(RED) && + query.getData().contains(ORANGE) && + query.getData().contains(GREEN) && + query.getData().contains(DARK_GREEN) && + query.getData().contains(BLUE) && + query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + + query = tree.query(7, 14); // Range query + assertTrue("Segment tree query error. query=7->14 result="+query, (query.getData().contains(GREEN) && + query.getData().contains(DARK_GREEN) && + query.getData().contains(BLUE) && + query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + + query = tree.query(14, 15); // Range query + assertTrue("Segment tree query error. query=14->15 result="+query, (query.getData().contains(PURPLE) && + query.getData().contains(BLACK)) + ); + } + + { // Lifespan Interval Segment tree + final String stravinsky = "Stravinsky"; + final String schoenberg = "Schoenberg"; + final String grieg = "Grieg"; + final String schubert = "Schubert"; + final String mozart = "Mozart"; + final String schuetz = "Schuetz"; + java.util.List> segments = new ArrayList>(); + segments.add((new SegmentTree.Data.IntervalData(1888, 1971, stravinsky))); + segments.add((new SegmentTree.Data.IntervalData(1874, 1951, schoenberg))); + segments.add((new SegmentTree.Data.IntervalData(1843, 1907, grieg))); + segments.add((new SegmentTree.Data.IntervalData(1779, 1828, schubert))); + segments.add((new SegmentTree.Data.IntervalData(1756, 1791, mozart))); + segments.add((new SegmentTree.Data.IntervalData(1585, 1672, schuetz))); + DynamicSegmentTree> tree = new DynamicSegmentTree>(segments, 25); + + SegmentTree.Data.IntervalData query = tree.query(1890); // Stabbing + assertTrue("Segment tree query error. query=1890 result="+query, (query.getData().contains(stravinsky) && + query.getData().contains(schoenberg) && + query.getData().contains(grieg)) + ); + + query = tree.query(1909); // Stabbing query + assertTrue("Segment tree query error. query=1909 result="+query, (query.getData().contains(stravinsky) && + query.getData().contains(schoenberg)) + ); + + query = tree.query(1585); // Stabbing query + assertTrue("Segment tree query error. query=1585 result="+query, query.getData().contains(schuetz)); + + query = tree.query(1792, 1903); // Range query + assertTrue("Segment tree query error. query=1792->1903 result="+query, (query.getData().contains(stravinsky) && + query.getData().contains(schoenberg) && + query.getData().contains(grieg) && + query.getData().contains(schubert)) + ); + + query = tree.query(1776, 1799); // Range query + assertTrue("Segment tree query error. query=1776->1799 result="+query, (query.getData().contains(schubert) && + query.getData().contains(mozart)) + ); + } + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SkipListMapTests.java b/src/com/jwetherell/algorithms/data_structures/test/SkipListMapTests.java new file mode 100644 index 00000000..e9be474e --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SkipListMapTests.java @@ -0,0 +1,30 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.SkipListMap; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class SkipListMapTests { + + @Test + public void testSkipListMap() { + TestData data = Utils.generateTestData(1000); + + String mapName = "SkipListMap"; + SkipListMap map = new SkipListMap(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.String, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.Integer, mapName, + data.unsorted, data.sorted, data.invalid)); + } + +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SkipListTests.java b/src/com/jwetherell/algorithms/data_structures/test/SkipListTests.java new file mode 100644 index 00000000..66eb7d4b --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SkipListTests.java @@ -0,0 +1,31 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.SkipList; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.SetTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class SkipListTests { + + @Test + public void testSkipList() { + TestData data = Utils.generateTestData(1000); + + String sName = "SkipList"; + SkipList sList = new SkipList(); + Collection lCollection = sList.toCollection(); + + assertTrue(SetTest.testSet(sList, sName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(lCollection, Type.Integer, sName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SplayTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/SplayTreeTests.java new file mode 100644 index 00000000..fdf77835 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SplayTreeTests.java @@ -0,0 +1,33 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.BinarySearchTree; +import com.jwetherell.algorithms.data_structures.SplayTree; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class SplayTreeTests { + + @Test + public void testSplayTree() { + TestData data = Utils.generateTestData(1000); + + String bstName = "Splay Tree"; + BinarySearchTree bst = new SplayTree(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } + +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/StackTests.java b/src/com/jwetherell/algorithms/data_structures/test/StackTests.java new file mode 100644 index 00000000..26a08d87 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/StackTests.java @@ -0,0 +1,45 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.Stack; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.StackTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class StackTests { + + @Test + public void testArrayStack() { + TestData data = Utils.generateTestData(1000); + + String aName = "Stack [array]"; + Stack.ArrayStack aStack = new Stack.ArrayStack(); + Collection aCollection = aStack.toCollection(); + + assertTrue(StackTest.testStack(aStack, aName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(aCollection, Type.Integer, aName, + data.unsorted, data.sorted, data.invalid)); + } + + @Test + public void testLinkedStack() { + TestData data = Utils.generateTestData(1000); + + String lName = "Stack [linked]"; + Stack.LinkedStack lStack = new Stack.LinkedStack(); + Collection lCollection = lStack.toCollection(); + + assertTrue(StackTest.testStack(lStack, lName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(lCollection, Type.Integer, lName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SuffixTreeTests.java b/src/com/jwetherell/algorithms/data_structures/test/SuffixTreeTests.java new file mode 100644 index 00000000..014e14a1 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SuffixTreeTests.java @@ -0,0 +1,18 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.SuffixTree; +import com.jwetherell.algorithms.data_structures.test.common.SuffixTreeTest; + +public class SuffixTreeTests { + + @Test + public void testSuffixTree() { + String bookkeeper = "bookkeeper"; + SuffixTree tree = new SuffixTree(bookkeeper); + assertTrue(SuffixTreeTest.suffixTreeTest(tree, bookkeeper)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/SuffixTrieTests.java b/src/com/jwetherell/algorithms/data_structures/test/SuffixTrieTests.java new file mode 100644 index 00000000..0da3e6fb --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/SuffixTrieTests.java @@ -0,0 +1,18 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.SuffixTrie; +import com.jwetherell.algorithms.data_structures.test.common.SuffixTreeTest; + +public class SuffixTrieTests { + + @Test + public void testSuffixTrie() { + String bookkeeper = "bookkeeper"; + SuffixTrie trie = new SuffixTrie(bookkeeper); + assertTrue(SuffixTreeTest.suffixTreeTest(trie, bookkeeper)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/TreapTests.java b/src/com/jwetherell/algorithms/data_structures/test/TreapTests.java new file mode 100644 index 00000000..5e1fbb3f --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/TreapTests.java @@ -0,0 +1,32 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.BinarySearchTree; +import com.jwetherell.algorithms.data_structures.Treap; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class TreapTests { + + @Test + public void testTreap() { + TestData data = Utils.generateTestData(1000); + + String bstName = "Treap"; + BinarySearchTree bst = new Treap(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/TreeMapTests.java b/src/com/jwetherell/algorithms/data_structures/test/TreeMapTests.java new file mode 100644 index 00000000..fb7f430f --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/TreeMapTests.java @@ -0,0 +1,29 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.TreeMap; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class TreeMapTests { + + @Test + public void testTreeMap() { + TestData data = Utils.generateTestData(1000); + + String mapName = "TreeMap"; + TreeMap map = new TreeMap(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.String, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.Integer, mapName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/TrieMapTests.java b/src/com/jwetherell/algorithms/data_structures/test/TrieMapTests.java new file mode 100644 index 00000000..4c535b06 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/TrieMapTests.java @@ -0,0 +1,29 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.TrieMap; +import com.jwetherell.algorithms.data_structures.test.common.JavaMapTest; +import com.jwetherell.algorithms.data_structures.test.common.MapTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class TrieMapTests { + + @Test + public void testTrieMap() { + TestData data = Utils.generateTestData(1000); + + String mapName = "TrieMap"; + TrieMap map = new TrieMap(); + java.util.Map jMap = map.toMap(); + + assertTrue(MapTest.testMap(map, Type.String, mapName, + data.unsorted, data.invalid)); + assertTrue(JavaMapTest.testJavaMap(jMap, Type.String, mapName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/TrieTests.java b/src/com/jwetherell/algorithms/data_structures/test/TrieTests.java new file mode 100644 index 00000000..c21b4d04 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/TrieTests.java @@ -0,0 +1,31 @@ +package com.jwetherell.algorithms.data_structures.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Collection; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.Trie; +import com.jwetherell.algorithms.data_structures.test.common.JavaCollectionTest; +import com.jwetherell.algorithms.data_structures.test.common.TreeTest; +import com.jwetherell.algorithms.data_structures.test.common.Utils; +import com.jwetherell.algorithms.data_structures.test.common.Utils.TestData; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class TrieTests { + + @Test + public void testTrie() { + TestData data = Utils.generateTestData(1000); + + String bstName = "Trie"; + Trie bst = new Trie(); + Collection bstCollection = bst.toCollection(); + + assertTrue(TreeTest.testTree(bst, Type.String, bstName, + data.unsorted, data.invalid)); + assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.String, bstName, + data.unsorted, data.sorted, data.invalid)); + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/HeapTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/HeapTest.java new file mode 100644 index 00000000..036a01fc --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/HeapTest.java @@ -0,0 +1,194 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import java.util.Arrays; + +import com.jwetherell.algorithms.data_structures.BinaryHeap; +import com.jwetherell.algorithms.data_structures.interfaces.IHeap; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class HeapTest { + + /** + * Test the heap invariants. + * + * In computer science, a heap is a specialized tree-based data structure that satisfies the heap property: If A is a parent + * node of B then the key of node A is ordered with respect to the key of node B with the same ordering applying across the + * heap. Either the keys of parent nodes are always greater than or equal to those of the children and the highest key is in + * the root node (this kind of heap is called max heap) or the keys of parent nodes are less than or equal to those of the + * children and the lowest key is in the root node (min heap). + * + * http://en.wikipedia.org/wiki/Heap_(data_structure) + * + * @author Justin Wetherell + * + * @param heapType Type of heap (Min or Max). + * @param heap Heap to test. + * @param type Type of data in the heap (Either String or Integer). + * @param name Name used in debug. + * @param unsorted Unsorted test data. + * @param sorted Sorted test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the heap passes it's invariants tests. + */ + @SuppressWarnings("unchecked") + public static > boolean testHeap(BinaryHeap.Type heapType, IHeap heap, Type type, String name, + T[] unsorted, T[] sorted, T invalid) { + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean added = heap.add(item); + if (!heap.validate() || (heap.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (!added || !heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(heap); + return false; + } + } + + boolean contains = heap.contains(invalid); + T removed = heap.remove(invalid); + if (contains || (removed!=null)) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(heap); + return false; + } + + int size = heap.size(); + for (int i = 0; i < size; i++) { + T item = heap.removeHead(); + T correct = ((heapType == BinaryHeap.Type.MIN)?sorted[i]:sorted[sorted.length-(i+1)]); + if (type == Type.String) + correct = (T)String.valueOf(correct); + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match heap item."); + Utils.handleError(heap); + return false; + } + if (!heap.validate() || (heap.size() != unsorted.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(heap); + return false; + } + } + + // Add half, remove a quarter, add three-quarters, remove all + int quarter = unsorted.length/4; + int half = unsorted.length/2; + T[] halfArray = Arrays.copyOf(unsorted, half); + Arrays.sort(halfArray); + T[] quarterArray = (T[])new Comparable[quarter]; + T[] sortedQuarterArray = (T[])new Comparable[quarter]; //Needed for binary search + for (int i=0; i[] threeQuartersArray = new Comparable[unsorted.length-(half-quarter)]; + for (T i : unsorted) { + int index = Arrays.binarySearch(sortedQuarterArray, i); + if (heapType == BinaryHeap.Type.MIN) { + if (index>=0) { + threeQuartersArray[idx++] = i; + } else { + index = Arrays.binarySearch(halfArray, i); + if (index<0) threeQuartersArray[idx++] = i; + } + } else { + if (index>=0) { + threeQuartersArray[idx++] = i; + } else { + index = Arrays.binarySearch(halfArray, i); + if (index<0) threeQuartersArray[idx++] = i; + } + } + } + for (int i = 0; i < half; i++) { + T item = unsorted[i]; + boolean added = heap.add(item); + if (!heap.validate() || (heap.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (!added || !heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(heap); + return false; + } + } + for (int i = 0; i < quarter; i++) { + T item = heap.removeHead(); + T correct = quarterArray[i]; + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match heap item."); + Utils.handleError(heap); + return false; + } + if (!heap.validate() || (heap.size() != half-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(heap); + return false; + } + } + for (int i = 0; i < threeQuartersArray.length; i++) { + T item = (T)threeQuartersArray[i]; + boolean added = heap.add(item); + if (!heap.validate() || (heap.size() != (half-quarter)+(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (!added || !heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(heap); + return false; + } + } + for (int i = 0; i < sorted.length; i++) { + T item = heap.removeHead(); + T correct = ((heapType == BinaryHeap.Type.MIN)?sorted[i]:sorted[sorted.length-(i+1)]); + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match heap item."); + Utils.handleError(heap); + return false; + } + if (!heap.validate() || (heap.size() != sorted.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(heap); + return false; + } + if (heap.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(heap); + return false; + } + } + + if (heap.size() != 0) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(heap); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/IteratorTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/IteratorTest.java new file mode 100644 index 00000000..db4f92c6 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/IteratorTest.java @@ -0,0 +1,27 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import java.util.Iterator; + +public class IteratorTest { + + /** + * In object-oriented computer programming, an iterator is an object that enables a programmer to traverse a container. + * + * http://en.wikipedia.org/wiki/Iterator + * + * @author Justin Wetherell + * + * @param iter Iterator to test. + * @return True if iterator passes invariant tests. + */ + public static > boolean testIterator(Iterator iter) { + while (iter.hasNext()) { + T item = iter.next(); + if (item==null) { + System.err.println("Iterator failure."); + return false; + } + } + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/JavaCollectionTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/JavaCollectionTest.java new file mode 100644 index 00000000..be442f4f --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/JavaCollectionTest.java @@ -0,0 +1,321 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import java.util.Collection; + +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class JavaCollectionTest { + + /** + * In computer science, a collection or container is a grouping of some variable number of data items + * (possibly zero) that have some shared significance to the problem being solved and need to be operated + * upon together in some controlled fashion. + * + * http://en.wikipedia.org/wiki/Collection_(abstract_data_type) + * + * @author Justin Wetherell + * + * @param collection Collection to test. + * @param type Type of data in the collection (Either String or Integer). + * @param name name Name used in debug. + * @param unsorted Unsorted test data. + * @param sorted Sorted test data. + * @return True if the collection passes it's invariants tests. + */ + public static , T extends Comparable> boolean testCollection(Collection collection, Type type, String name, + T[] unsorted, T[] sorted, T invalid) { + // Make sure the collection is empty + if (!collection.isEmpty()) { + System.err.println(name+" initial isEmpty() failed."); + Utils.handleError(collection); + return false; + } + + if (collection.size()!=0) { + System.err.println(name+" initial size() failed."); + Utils.handleError(collection); + return false; + } + + addAndRemoveInOrder(collection, type, name, unsorted, invalid); + addInOrderRemoveInReverseOrder(collection, type, name, unsorted, invalid); + addInReverseOrderAndRemoveInOrder(collection, type, name, unsorted, invalid); + + addAndRemoveInOrder(collection, type, name, sorted, invalid); + addInOrderRemoveInReverseOrder(collection, type, name, sorted, invalid); + addInReverseOrderAndRemoveInOrder(collection, type, name, sorted, invalid); + + // Make sure the collection is empty + if (!collection.isEmpty()) { + System.err.println(name+" initial isEmpty() failed."); + Utils.handleError(collection); + return false; + } + + if (collection.size()!=0) { + System.err.println(name+" initial size() failed."); + Utils.handleError(collection); + return false; + } + + return true; + } + + @SuppressWarnings({ "unchecked", "cast" }) + private static , T extends Comparable> boolean addAndRemoveInOrder(Collection collection, Type type, String name, + T[] data, T _invalid) { + T invalid = _invalid; + if (type == Type.String) + invalid = (T)String.valueOf(_invalid); + + // Add and remove in order (from index zero to length) + for (int i = 0; i < data.length; i++) { + C item = null; + if (type==Type.Integer) { + item = (C)data[i]; + } else if (type==Type.String) { + item = (C)String.valueOf(data[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" addAndRemoveInOrder add failed."); + Utils.handleError(collection); + return false; + } + } + + for (int i = 0; i < data.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + boolean contains = collection.contains(item); + if (!contains) { + System.err.println(name+" addAndRemoveInOrder contains failed."); + Utils.handleError(collection); + return false; + } + } + + boolean contains = collection.contains((T)invalid); + boolean removed = collection.remove((T)invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(collection); + return false; + } + + for (int i = 0; i < data.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + removed = collection.remove(item); + if (!removed) { + System.err.println(name+" addAndRemoveInOrder remove failed."); + Utils.handleError(collection); + return false; + } + } + + if (!collection.isEmpty()) { + System.err.println(name+" addAndRemoveInOrder isEmpty() failed."); + Utils.handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" addAndRemoveInOrder size() failed."); + Utils.handleError(collection); + return false; + } + + if (collection instanceof java.util.List && + (!ListIteratorTest.testListIterator(((java.util.List)collection).listIterator(), + data, + data.length)) + ) { + System.err.println(name+" addAndRemoveInOrder list iterator failed."); + Utils.handleError(collection); + return false; + } + + return true; + } + + @SuppressWarnings({ "unchecked", "cast" }) + private static , T extends Comparable> boolean addInReverseOrderAndRemoveInOrder(Collection collection, Type type, String name, + T[] data, T _invalid) { + T invalid = _invalid; + if (type == Type.String) + invalid = (T)String.valueOf(_invalid); + + // Add in reverse (from index length-1 to zero) order and then remove in order (from index zero to length) + for (int i = data.length - 1; i >= 0; i--) { + C item = null; + if (type==Type.Integer) { + item = (C)data[i]; + } else if (type==Type.String) { + item = (C)String.valueOf(data[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder add failed."); + Utils.handleError(collection); + return false; + } + } + + boolean contains = collection.contains((T)invalid); + boolean removed = collection.remove((T)invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(collection); + return false; + } + + if (!IteratorTest.testIterator(collection.iterator())) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder iterator failed."); + Utils.handleError(collection); + return false; + } + + for (int i = 0; i < data.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + contains = collection.contains(item); + if (!contains) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder contains failed."); + Utils.handleError(collection); + return false; + } + } + + for (int i = 0; i < data.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + removed = collection.remove(item); + if (!removed) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder remove failed."); + Utils.handleError(collection); + return false; + } + } + + if (!collection.isEmpty()) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder isEmpty() failed."); + Utils.handleError(collection); + return false; + } + + if (collection.size()!=0) { + System.err.println(name+" addInReverseOrderAndRemoveInOrder size() failed."); + Utils.handleError(collection); + return false; + } + + return true; + } + + @SuppressWarnings({ "unchecked", "cast" }) + public static , T extends Comparable> boolean addInOrderRemoveInReverseOrder(Collection collection, Type type, String name, + T[] data, T _invalid) { + T invalid = _invalid; + if (type == Type.String) + invalid = (T)String.valueOf(_invalid); + + // Add in order (from index zero to length) and then remove in reverse (from index length-1 to zero) order + for (int i = 0; i < data.length; i++) { + C item = null; + if (type==Type.Integer) { + item = (C)data[i]; + } else if (type==Type.String) { + item = (C)String.valueOf(data[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" addInOrderRemoveInReverseOrder add failed."); + Utils.handleError(collection); + return false; + } + } + + boolean contains = collection.contains((T)invalid); + boolean removed = collection.remove((T)invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(collection); + return false; + } + + if (!IteratorTest.testIterator(collection.iterator())) { + System.err.println(name+" addInOrderRemoveInReverseOrder iterator failed."); + Utils.handleError(collection); + return false; + } + + for (int i = 0; i < data.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + contains = collection.contains(item); + if (!contains) { + System.err.println(name+" addInOrderRemoveInReverseOrder contains failed."); + Utils.handleError(collection); + return false; + } + } + + for (int i = data.length - 1; i >= 0; i--) { + T item = null; + if (type==Type.Integer) { + item = (T)data[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(data[i]); + } + removed = collection.remove(item); + if (!removed) { + System.err.println(name+" addInOrderRemoveInReverseOrder remove failed."); + Utils.handleError(collection); + return false; + } + } + + if (!collection.isEmpty()) { + System.err.println(name+" addInOrderRemoveInReverseOrder isEmpty() failed."); + Utils.handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" addInOrderRemoveInReverseOrder size() failed."); + Utils.handleError(collection); + return false; + } + + if (collection instanceof java.util.List && + (!ListIteratorTest.testListIterator(((java.util.List)collection).listIterator(), + data, + data.length)) + ) { + System.err.println(name+" addInOrderRemoveInReverseOrder list iterator failed."); + Utils.handleError(collection); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/JavaMapTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/JavaMapTest.java new file mode 100644 index 00000000..cda747d2 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/JavaMapTest.java @@ -0,0 +1,368 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class JavaMapTest { + + /** + * In computer science, an associative array, map, symbol table, or dictionary is an abstract data + * type composed of a collection of (key, value) pairs, such that each possible key appears at most + * once in the collection. + * + * http://en.wikipedia.org/wiki/Associative_array + * + * @author Justin Wetherell + * + * @param map Map to test. + * @param type Type of data in the map (Either String or Integer). + * @param name Name used in debug. + * @param unsorted Unsorted test data. + * @param sorted Sorted test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the map passes it's invariants tests. + */ + public static > boolean testJavaMap(java.util.Map map, Type type, String name, + T[] unsorted, T[] sorted, T invalid) { + // Make sure the map is empty + if (!map.isEmpty()) { + System.err.println(name+" initial isEmpty() failed."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" initial size() failed."); + Utils.handleError(map); + return false; + } + + addInOrderAndRemoveInOrder(map, type, name, + unsorted, invalid); + addInReverseOrderAndRemoveInReverseOrder(map, type, name, + unsorted, invalid); + addInOrderAndRemoveInReverseOrder(map, type, name, + unsorted, invalid); + + addInOrderAndRemoveInOrder(map, type, name, sorted, invalid); + addInReverseOrderAndRemoveInReverseOrder(map, type, name, + sorted, invalid); + addInOrderAndRemoveInReverseOrder(map, type, name, + sorted, invalid); + + return true; + } + + @SuppressWarnings("unchecked") + private static > boolean addInOrderAndRemoveInOrder(java.util.Map map, Type keyType, String name, + T[] data, T invalid) + { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)invalid; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(invalid); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + for (T item : data) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + + } + + if (!testMapEntrySet(map, keyType, data)) return false; + + if (!map.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" unsorted size() failed."); + Utils.handleError(map); + return false; + } + return true; + } + + @SuppressWarnings("unchecked") + private static > boolean addInReverseOrderAndRemoveInReverseOrder(java.util.Map map, Type keyType, String name, + T[] data, T invalid) + { + for (int i = data.length - 1; i >= 0; i--) { + T item = data[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)invalid; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(invalid); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + for (T item : data) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + + for (int i = data.length - 1; i >= 0; i--) { + T item = data[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + } + + if (!map.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" unsorted size() failed."); + Utils.handleError(map); + return false; + } + return true; + } + + @SuppressWarnings("unchecked") + private static > boolean addInOrderAndRemoveInReverseOrder(java.util.Map map, Type keyType, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)invalid; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(invalid); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" sorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + for (T item : data) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + + for (int i = data.length - 1; i >= 0; i--) { + T item = data[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + } + + if (!testMapEntrySet(map, keyType, data)) return false; + + if (!map.isEmpty()) { + System.err.println(name+" sorted isEmpty() failed."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" sorted size() failed."); + Utils.handleError(map); + return false; + } + return true; + } + + @SuppressWarnings("unchecked") + private static > boolean testMapEntrySet(java.util.Map map, Type keyType, + T[] data) { + { // Test keys + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + + java.util.Set set = map.keySet(); + for (int i = 0; i < data.length; i++) { + T key = data[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)key; + } else if (keyType == Type.String) { + k = (K)String.valueOf(key); + } + if (!set.contains(k)) { + System.err.println("MayEntry contains() failure."); + Utils.handleError(map); + return false; + } + } + + java.util.Iterator keyIter = set.iterator(); + while (keyIter.hasNext()) { + keyIter.next(); + keyIter.remove(); + } + + if (!map.isEmpty()) { + System.err.println("MayEntry isEmpty() failure."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println("MayEntry size()!=0 failure."); + Utils.handleError(map); + return false; + } + } + + { // Test values + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + + java.util.Collection collection = map.values(); + for (int i = 0; i < data.length; i++) { + T value = data[i]; + V v = null; + // These are reversed on purpose + if (keyType == Type.Integer) { + v = (V)String.valueOf(value); + } else if (keyType == Type.String) { + v = (V)value; + } + if (!collection.contains(v)) { + System.err.println("MayEntry contains() failure."); + Utils.handleError(map); + return false; + } + } + + java.util.Iterator valueIter = collection.iterator(); + while (valueIter.hasNext()) { + valueIter.next(); + valueIter.remove(); + } + + if (!map.isEmpty()) { + System.err.println("MayEntry isEmpty() failure."); + Utils.handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println("MayEntry size()!=0 failure."); + Utils.handleError(map); + return false; + } + } + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/ListIteratorTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/ListIteratorTest.java new file mode 100644 index 00000000..918e8ddd --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/ListIteratorTest.java @@ -0,0 +1,117 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import java.util.ListIterator; +import java.util.NoSuchElementException; + +public class ListIteratorTest { + + /** + * An iterator for lists that allows the programmer to traverse the list in either direction, + * modify the list during iteration, and obtain the iterator's current position in the list. + * + * http://en.wikipedia.org/wiki/Iterator + * + * @author Justin Wetherell + * + * @param iter List iterator to test. + * @param data Test data to test against. + * @param size Size of the test data. + * @return True if list iterator passes it's invariant tests. + */ + public static > boolean testListIterator(ListIterator iter, + T[] data, int size) { + // Make sure you catch going prev at the start + boolean exceptionThrown = false; + try { + iter.previous(); + } catch (NoSuchElementException e) { + exceptionThrown = true; + } + if (!exceptionThrown) { + System.err.println("ListIterator exception failure."); + return false; + } + + for (int i = 0; i < data.length; i++) { + T t = data[i]; + iter.add(t); + } + while (iter.hasPrevious()) iter.previous(); + + int i = 0; + while (iter.hasNext()) { + T item = iter.next(); + int idx = iter.nextIndex(); + if (idx!=++i) { + System.err.println("ListIterator index failure."); + return false; + } + if (item==null) { + System.err.println("ListIterator item is null."); + return false; + } + } + + // We should be at the end of the collection, this should fail + exceptionThrown = false; + try { + iter.next(); + } catch (NoSuchElementException e) { + exceptionThrown = true; + } + if (!exceptionThrown) { + System.err.println("ListIterator exception failure."); + return false; + } + + //This should be list.size + iter.nextIndex(); + int listSize = iter.nextIndex(); + if (listSize!=size) { + System.err.println("ListIterator ARRAY_SIZE failure."); + return false; + } + + i--; + while (iter.hasPrevious()) { + T item = iter.previous(); + int idx = iter.previousIndex(); + if (idx!=--i) { + System.err.println("ListIterator index failure."); + return false; + } + if (item==null) { + System.err.println("ListIterator item is null."); + return false; + } + } + + // We should be at the beginning of the collection, this should fail + exceptionThrown = false; + try { + iter.previous(); + } catch (NoSuchElementException e) { + exceptionThrown = true; + } + if (!exceptionThrown) { + System.err.println("ListIterator exception failure."); + return false; + } + + // This should be negative one + iter.previousIndex(); + int negOne = iter.previousIndex(); + if (negOne!=-1) { + System.err.println("ListIterator negative_one failure."); + return false; + } + + // Remove all using iterator + while (iter.hasNext()) { + iter.next(); + iter.remove(); + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/ListTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/ListTest.java new file mode 100644 index 00000000..3baf1857 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/ListTest.java @@ -0,0 +1,130 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.IList; + +public class ListTest { + + /** + * In computer science, a list or sequence is an abstract data type that implements a + * finite ordered collection of values, where the same value may occur more than once. + * + * http://en.wikipedia.org/wiki/List_(abstract_data_type) + * + * @author Justin Wetherell + * + * @param list List to test. + * @param name Name used in debug. + * @param data Test data. + * @param invalid Invalid data which should not exist in the data. + * @return + */ + public static > boolean testList(IList list, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + boolean added = list.add(item); + if ((!list.validate() || (list.size() != i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!added || !list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(list); + return false; + } + } + + boolean contains = list.contains(invalid); + boolean removed = list.remove(invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(list); + return false; + } + + int size = list.size(); + for (int i = 0; i < size; i++) { + T item = data[i]; + removed = list.remove(item); + if ((!list.validate() || (list.size() != data.length-(i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!removed || list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(list); + return false; + } + } + + // Add half, remove a quarter, add three-quarters, remove all + int quarter = data.length/4; + int half = data.length/2; + for (int i = 0; i < half; i++) { + T item = data[i]; + boolean added = list.add(item); + if ((!list.validate() || (list.size() != i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!added || !list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(list); + return false; + } + } + for (int i = (half-1); i >= quarter; i--) { + T item = data[i]; + removed = list.remove(item); + if ((!list.validate() || (list.size() != i))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!removed || list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(list); + return false; + } + } + for (int i = quarter; i < data.length; i++) { + T item = data[i]; + boolean added = list.add(item); + if ((!list.validate() || (list.size() != i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!added || !list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(list); + return false; + } + } + for (int i = data.length-1; i >= 0; i--) { + T item = data[i]; + removed = list.remove(item); + if ((!list.validate() || (list.size() != i))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(list); + return false; + } + if ((!removed || list.contains(item))) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(list); + return false; + } + } + + if ((list.size() != 0)) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(list); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/MapTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/MapTest.java new file mode 100644 index 00000000..90e30e42 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/MapTest.java @@ -0,0 +1,184 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.IMap; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class MapTest { + + /** + * In computer science, an associative array, map, symbol table, or dictionary is an abstract data + * type composed of a collection of (key, value) pairs, such that each possible key appears at most + * once in the collection. + * + * http://en.wikipedia.org/wiki/Associative_array + * + * @author Justin Wetherell + * + * @param map Map to test. + * @param type Type of data in the map (Either String or Integer). + * @param name Name used in debug. + * @param data test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the map passes it's invariants tests. + */ + @SuppressWarnings("unchecked") + public static > boolean testMap(IMap map, Type type, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (type == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (type == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + V added = map.put(k,v); + if ((!map.validate() || (map.size() != (i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if ((added!=null || !map.contains(k))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists."); + Utils.handleError(map); + return false; + } + } + + K invalidKey = null; + if (type == Type.Integer) { + invalidKey = (K)invalid; + } else if (type == Type.String) { + invalidKey = (K)String.valueOf(invalid); + } + boolean contains = map.contains(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(map); + return false; + } + + for (int i = 0; i < data.length; i++) { + T item = data[i]; + K k = null; + if (type == Type.Integer) { + k = (K)item; + } else if (type == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if ((!map.validate() || (map.size() != (data.length-(i+1))))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if (map.contains(k)) { + System.err.println(name+" YIKES!! " + item + " still exists."); + Utils.handleError(map); + return false; + } + } + + // Add half, remove a quarter, add three-quarters, remove all + int quarter = data.length/4; + int half = data.length/2; + for (int i = 0; i < half; i++) { + T item = data[i]; + K k = null; + V v = null; + if (type == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (type == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + V added = map.put(k,v); + if ((!map.validate() || (map.size() != (i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if ((added!=null || !map.contains(k))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists."); + Utils.handleError(map); + return false; + } + } + for (int i = (half-1); i >= quarter; i--) { + T item = data[i]; + K k = null; + if (type == Type.Integer) { + k = (K)item; + } else if (type == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if ((!map.validate() || (map.size() != i))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if ((removed==null || map.contains(k))) { + System.err.println(name+" YIKES!! " + item + " still exists."); + Utils.handleError(map); + return false; + } + } + for (int i = quarter; i < data.length; i++) { + T item = data[i]; + K k = null; + V v = null; + if (type == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (type == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + V added = map.put(k,v); + if ((!map.validate() || (map.size() != (i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if ((added!=null || !map.contains(k))) { + System.err.println(name+" YIKES!! " + item + " doesn't exists."); + Utils.handleError(map); + return false; + } + } + for (int i = data.length-1; i >= 0; i--) { + T item = data[i]; + K k = null; + if (type == Type.Integer) { + k = (K)item; + } else if (type == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if ((!map.validate() || (map.size() != i))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(map); + return false; + } + if ((removed==null || map.contains(k))) { + System.err.println(name+" YIKES!! " + item + " still exists."); + Utils.handleError(map); + return false; + } + } + + if ((map.size() != 0)) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(map); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/QueueTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/QueueTest.java new file mode 100644 index 00000000..1bc7fedb --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/QueueTest.java @@ -0,0 +1,170 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.IQueue; + +public class QueueTest { + + /** + * In computer science, a queue is a particular kind of abstract data type or collection in which + * the entities in the collection are kept in order and the principal (or only) operations on the + * collection are the addition of entities to the rear terminal position, known as enqueue, and removal + * of entities from the front terminal position, known as dequeue. This makes the queue a First-In-First-Out + * (FIFO) data structure. In a FIFO data structure, the first element added to the queue will be the first + * one to be removed. + * + * http://en.wikipedia.org/wiki/Queue_(abstract_data_type) + * + * @author Justin Wetherell + * + * @param queue Queue to test. + * @param name Name used in debug. + * @param data Test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return Trus if the Queue passes all it's invariants. + */ + public static > boolean testQueue(IQueue queue, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + boolean added = queue.offer(item); + if (!queue.validate() || (queue.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (!added || !queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(queue); + return false; + } + } + + boolean contains = queue.contains(invalid); + boolean removed = queue.remove(invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(queue); + return false; + } + + int size = queue.size(); + for (int i = 0; i < size; i++) { + T item = queue.poll(); + T correct = data[i]; + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match FIFO item."); + Utils.handleError(queue); + return false; + } + if (!queue.validate() || (queue.size() != data.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(queue); + return false; + } + } + + // Add half, remove a quarter, add three-quarters + int quarter = data.length/4; + int half = data.length/2; + int changeOver = half-quarter; + for (int i = 0; i < half; i++) { + T item = data[i]; + boolean added = queue.offer(item); + if (!queue.validate() || (queue.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (!added || !queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(queue); + return false; + } + } + for (int i = 0; i < quarter; i++) { + T item = queue.poll(); + T correct = data[i]; + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match FIFO item."); + Utils.handleError(queue); + return false; + } + if (!queue.validate() || (queue.size() != (half-(i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(queue); + return false; + } + } + for (int i = 0; i < quarter; i++) { + T item = data[i]; + boolean added = queue.offer(item); + if (!queue.validate() || (queue.size() != ((half-quarter)+(i+1)))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (!added || !queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(queue); + return false; + } + } + for (int i = half; i < data.length; i++) { + T item = data[i]; + boolean added = queue.offer(item); + if (!queue.validate() || (queue.size() != (i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(queue); + return false; + } + if (!added || !queue.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(queue); + return false; + } + } + for (int i = 0; i < data.length; i++) { + T item = queue.poll(); + int idx = i; + if (idx < changeOver) { + idx = quarter+i; + } else if (idx>=changeOver && idx + * + * @param set Set to test. + * @param name Name to use in debug. + * @param data Test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the set passes it's invariants tests. + */ + public static > boolean testSet(ISet set, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + boolean added = set.add(item); + if (!set.validate() || (set.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if (!added || !set.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(set); + return false; + } + } + + boolean contains = set.contains(invalid); + boolean removed = set.remove(invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(set); + return false; + } + + int size = set.size(); + for (int i = 0; i < size; i++) { + T item = data[i]; + removed = set.remove(item); + if (!set.validate() || (set.size() != data.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if (!removed || set.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(set); + return false; + } + } + + // Add half, remove a quarter, add three-quarters, remove all + int quarter = data.length/4; + int half = data.length/2; + for (int i = 0; i < half; i++) { + T item = data[i]; + boolean added = set.add(item); + if (!set.validate() || (set.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if (!added || !set.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(set); + return false; + } + } + for (int i = (half-1); i >= quarter; i--) { + T item = data[i]; + removed = set.remove(item); + if (!set.validate() || (set.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if (!removed || set.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(set); + return false; + } + } + for (int i = quarter; i < data.length; i++) { + T item = data[i]; + boolean added = set.add(item); + if (!set.validate() || (set.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if (!added || !set.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(set); + return false; + } + } + for (int i = data.length-1; i >= 0; i--) { + T item = data[i]; + removed = set.remove(item); + if (!set.validate() || (set.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(set); + return false; + } + if ((!removed || set.contains(item))) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(set); + return false; + } + } + + if (set.size() != 0) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(set); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/StackTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/StackTest.java new file mode 100644 index 00000000..95797069 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/StackTest.java @@ -0,0 +1,146 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.IStack; + +public class StackTest { + + /** + * In computer science, a stack is a particular kind of abstract data type or collection + * in which the principal (or only) operations on the collection are the addition of an + * entity to the collection, known as push and removal of an entity, known as pop. + * + * http://en.wikipedia.org/wiki/Stack_(abstract_data_type) + * + * @author Justin Wetherell + * + * @param stack Stack to test. + * @param name Name to use in debug. + * @param data Test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the stack passes it's invariants tests. + */ + public static > boolean testStack(IStack stack, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T item = data[i]; + boolean added = stack.push(item); + if (!stack.validate() || (stack.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (!added || item==null || !stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(stack); + return false; + } + } + + boolean contains = stack.contains(invalid); + boolean removed = stack.remove(invalid); + if (contains || removed) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(stack); + return false; + } + + int size = stack.size(); + for (int i = 0; i < size; i++) { + T item = stack.pop(); + T correct = data[data.length-(i+1)]; + if ((item.compareTo(correct)!=0)) { + System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); + Utils.handleError(stack); + return false; + } + if (!stack.validate() || (stack.size() != data.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(stack); + return false; + } + } + + // Add half, remove a quarter, add three-quarters, remove all + int quarter = data.length/4; + int half = data.length/2; + for (int i = 0; i < half; i++) { + T item = data[i]; + boolean added = stack.push(item); + if (!stack.validate() || (stack.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (!added || item==null || !stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(stack); + return false; + } + } + for (int i = (half-1); i >= quarter; i--) { + T item = stack.pop(); + T correct = data[i]; + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); + Utils.handleError(stack); + return false; + } + if (!stack.validate() || (stack.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(stack); + return false; + } + } + for (int i = quarter; i < data.length; i++) { + T item = data[i]; + boolean added = stack.push(item); + if (!stack.validate() || (stack.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (!added || item==null || !stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(stack); + return false; + } + } + for (int i = data.length-1; i >= 0; i--) { + T item = stack.pop(); + T correct = data[i]; + if (item.compareTo(correct)!=0) { + System.err.println(name+" YIKES!! " + item + " does not match LIFO item."); + Utils.handleError(stack); + return false; + } + if (!stack.validate() || (stack.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(stack); + return false; + } + if (stack.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(stack); + return false; + } + } + + if (stack.size() != 0) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(stack); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/SuffixTreeTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/SuffixTreeTest.java new file mode 100644 index 00000000..0acc3ff9 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/SuffixTreeTest.java @@ -0,0 +1,44 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.ISuffixTree; + +public class SuffixTreeTest { + + /** + * In computer science, a suffix tree (also called PAT tree or, in an earlier + * form, position tree) is a compressed trie containing all the suffixes of + * the given text as their keys and positions in the text as their values. + * Suffix trees allow particularly fast implementations of many important + * string operations. + * + * @param tree Suffix tree to test. + * @param test String to use in testing the suffix tree. + * @return True if the suffix tree passes it's invariants tests. + */ + public static boolean suffixTreeTest(ISuffixTree tree, String test) { + boolean exists = tree.doesSubStringExist(test); + if (!exists) { + System.err.println("YIKES!! " + test + " doesn't exists."); + Utils.handleError(tree); + return false; + } + + String failed = test+"Z"; + exists = tree.doesSubStringExist(failed); + if (exists) { + System.err.println("YIKES!! " + failed + " exists."); + Utils.handleError(tree); + return false; + } + + String pass = test.substring(0, 6); + exists = tree.doesSubStringExist(pass); + if (!exists) { + System.err.println("YIKES!! " + pass + " doesn't exists."); + Utils.handleError(tree); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/TreeTest.java b/src/com/jwetherell/algorithms/data_structures/test/common/TreeTest.java new file mode 100644 index 00000000..2f25b084 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/TreeTest.java @@ -0,0 +1,176 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import com.jwetherell.algorithms.data_structures.interfaces.ITree; +import com.jwetherell.algorithms.data_structures.test.common.Utils.Type; + +public class TreeTest { + + /** + * In computer science, a tree is a widely used abstract data type (ADT) or data structure implementing this ADT + * that simulates a hierarchical tree structure, with a root value and subtrees of children, represented as a set + * of linked nodes. + * + * http://en.wikipedia.org/wiki/Tree_(data_structure) + * + * @author Justin Wetherell + * + * @param tree Tree to test. + * @param type Type of data in the heap (Either String or Integer). + * @param name Name used in debug. + * @param data Test data. + * @param invalid Invalid data which isn't in the data-structure. + * @return True if the tree passes it's invariants tests. + */ + @SuppressWarnings("unchecked") + public static , T extends Comparable> boolean testTree(ITree tree, Type type, String name, + T[] data, T invalid) { + for (int i = 0; i < data.length; i++) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + boolean added = tree.add(item); + if (!tree.validate() || (tree.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (!added || !tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(tree); + return false; + } + } + + C invalidItem = null; + if (type == Type.Integer) { + invalidItem = (C)invalid; + } else if (type == Type.String) { + invalidItem = (C)String.valueOf(invalid); + } + boolean contains = tree.contains(invalidItem); + C removed = tree.remove(invalidItem); + if (contains || removed!=null) { + System.err.println(name+" invalidity check. contains=" + contains + " removed=" + removed); + Utils.handleError(tree); + return false; + } + + int size = tree.size(); + for (int i = 0; i < size; i++) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + removed = tree.remove(item); + if (!tree.validate() || (tree.size() != data.length-(i+1))) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (removed==null || tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been removed."); + Utils.handleError(tree); + return false; + } + } + + // Add half, remove a quarter, add three-quarters + int quarter = data.length/4; + int half = data.length/2; + for (int i = 0; i < half; i++) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + boolean added = tree.add(item); + if (!tree.validate() || (tree.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (!added || !tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(tree); + return false; + } + } + for (int i = (half-1); i >= quarter; i--) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + removed = tree.remove(item); + if (!tree.validate() || (tree.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (removed==null || tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(tree); + return false; + } + } + for (int i = quarter; i < data.length; i++) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + boolean added = tree.add(item); + if (!tree.validate() || (tree.size() != i+1)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (!added || !tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " doesn't exists but has been added."); + Utils.handleError(tree); + return false; + } + } + for (int i = data.length-1; i >= 0; i--) { + T value = data[i]; + C item = null; + if (type == Type.Integer) { + item = (C)value; + } else if (type == Type.String) { + item = (C)String.valueOf(value); + } + removed = tree.remove(item); + if (!tree.validate() || (tree.size() != i)) { + System.err.println(name+" YIKES!! " + item + " caused a size mismatch."); + Utils.handleError(tree); + return false; + } + if (removed==null || tree.contains(item)) { + System.err.println(name+" YIKES!! " + item + " still exists but it has been remove."); + Utils.handleError(tree); + return false; + } + } + + if (tree.size() != 0) { + System.err.println(name+" YIKES!! a size mismatch."); + Utils.handleError(tree); + return false; + } + + return true; + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/test/common/Utils.java b/src/com/jwetherell/algorithms/data_structures/test/common/Utils.java new file mode 100644 index 00000000..50d25466 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/test/common/Utils.java @@ -0,0 +1,63 @@ +package com.jwetherell.algorithms.data_structures.test.common; + +import java.util.Arrays; +import java.util.Random; + +public class Utils { + + public static enum Type {Integer, String}; + + public static void handleError(Object obj) { + System.err.println(obj.toString()); + throw new RuntimeException("Error in test."); + } + + private static final Random RANDOM = new Random(); + + public static TestData generateTestData(int data_size) { + TestData data = new TestData(data_size); + + StringBuilder builder = new StringBuilder(); + data.unsorted = new Integer[data_size]; + java.util.Set set = new java.util.HashSet(); + builder.append("Array="); + for (int i = 0; i < data_size; i++) { + Integer j = RANDOM.nextInt(data.random_size); + // Make sure there are no duplicates + boolean found = true; + while (found) { + if (set.contains(j)) { + j = RANDOM.nextInt(data.random_size); + } else { + data.unsorted[i] = j; + set.add(j); + found = false; + } + } + data.unsorted[i] = j; + if (i!=data_size-1) builder.append(j).append(','); + } + set.clear(); + set = null; + builder.append('\n'); + data.string = builder.toString(); + + data.sorted = Arrays.copyOf(data.unsorted, data.unsorted.length); + Arrays.sort(data.sorted); + + return data; + } + + public static class TestData { + public int random_size = 0; + public int invalid = 0; + public Integer[] unsorted = null; + public Integer[] sorted = null; + public String string = null; + + public TestData(int size) { + this.random_size = 1000 * size; + this.invalid = random_size + 10; + } + } +} diff --git a/src/com/jwetherell/algorithms/data_structures/timing/DataStructuresTiming.java b/src/com/jwetherell/algorithms/data_structures/timing/DataStructuresTiming.java new file mode 100644 index 00000000..8ae0a5b2 --- /dev/null +++ b/src/com/jwetherell/algorithms/data_structures/timing/DataStructuresTiming.java @@ -0,0 +1,1717 @@ +package com.jwetherell.algorithms.data_structures.timing; + +import java.text.DecimalFormat; +import java.util.Arrays; +import java.util.Collection; +import java.util.Comparator; +import java.util.Formatter; +import java.util.Locale; +import java.util.NavigableSet; +import java.util.Random; +import java.util.concurrent.ConcurrentSkipListMap; +import java.util.concurrent.ConcurrentSkipListSet; + +import com.jwetherell.algorithms.data_structures.AVLTree; +import com.jwetherell.algorithms.data_structures.BTree; +import com.jwetherell.algorithms.data_structures.BinaryHeap; +import com.jwetherell.algorithms.data_structures.BinarySearchTree; +import com.jwetherell.algorithms.data_structures.HashArrayMappedTrie; +import com.jwetherell.algorithms.data_structures.HashMap; +import com.jwetherell.algorithms.data_structures.List; +import com.jwetherell.algorithms.data_structures.PatriciaTrie; +import com.jwetherell.algorithms.data_structures.Queue; +import com.jwetherell.algorithms.data_structures.RadixTrie; +import com.jwetherell.algorithms.data_structures.RedBlackTree; +import com.jwetherell.algorithms.data_structures.SkipList; +import com.jwetherell.algorithms.data_structures.SkipListMap; +import com.jwetherell.algorithms.data_structures.SplayTree; +import com.jwetherell.algorithms.data_structures.Stack; +import com.jwetherell.algorithms.data_structures.Treap; +import com.jwetherell.algorithms.data_structures.TreeMap; +import com.jwetherell.algorithms.data_structures.Trie; +import com.jwetherell.algorithms.data_structures.TrieMap; + +@SuppressWarnings("unchecked") +public class DataStructuresTiming { + + private static final int NUMBER_OF_TESTS = 3; + private static final Random RANDOM = new Random(); + private static final int ARRAY_SIZE = 1000; + private static final int RANDOM_SIZE = 1000 * ARRAY_SIZE; + private static final Integer INVALID = RANDOM_SIZE + 10; + private static final DecimalFormat FORMAT = new DecimalFormat("0.##"); + + private static Integer[] unsorted = null; + private static Integer[] sorted = null; + private static String string = null; + + private static int debug = 1; // Debug level. 0=None, 1=Time and Memory (if enabled), 2=Time, Memory, data structure debug + private static boolean debugTime = true; // How much time to: add all, remove all, add all items in reverse order, remove all + private static boolean debugMemory = true; // How much memory is used by the data structure + + private static final int TESTS = 38; // Max number of dynamic data structures to test + private static final String[] testNames = new String[TESTS]; // Array to hold the test names + private static final long[][] testResults = new long[TESTS][]; // Array to hold the test results + private static int testIndex = 0; // Index into the tests + private static int testNumber = 0; // Number of aggregate tests which have been run + + private static enum Type {Integer, String}; + + public static void main(String[] args) { + System.out.println("Starting tests."); + boolean passed = false; + for (int i = 0; i < NUMBER_OF_TESTS; i++) { + try { + passed = runTests(); + } catch (NullPointerException e) { + System.err.println(string); + throw e; + } + if (!passed) break; + } + if (passed) System.out.println("Tests finished. All passed."); + else System.err.println("Tests finished. Detected a failure."); + } + + private static void generateTestData() { + System.out.println("Generating data."); + StringBuilder builder = new StringBuilder(); + builder.append("Array="); + unsorted = new Integer[ARRAY_SIZE]; + java.util.Set set = new java.util.HashSet(); + for (int i = 0; i < ARRAY_SIZE; i++) { + Integer j = RANDOM.nextInt(RANDOM_SIZE); + // Make sure there are no duplicates + boolean found = true; + while (found) { + if (set.contains(j)) { + j = RANDOM.nextInt(RANDOM_SIZE); + } else { + unsorted[i] = j; + set.add(j); + found = false; + } + } + unsorted[i] = j; + if (i!=ARRAY_SIZE-1) builder.append(j).append(','); + } + set.clear(); + set = null; + builder.append('\n'); + string = builder.toString(); + if (debug > 1) System.out.println(string); + + sorted = Arrays.copyOf(unsorted, unsorted.length); + Arrays.sort(sorted); + + System.out.println("Generated data."); + } + + private static boolean runTests() { + testIndex = 0; + testNumber++; + + generateTestData(); + + boolean passed = true; + + // Trees + + passed = testJavaRedBlackIntegerTree(); + if (!passed) { + System.err.println("Java Red-Black [Integer] failed."); + return false; + } + + passed = testRedBlackTree(); + if (!passed) { + System.err.println("Red-Black Tree failed."); + return false; + } + + passed = testAVLTree(); + if (!passed) { + System.err.println("AVL Tree failed."); + return false; + } + + passed = testSplayTree(); + if (!passed) { + System.err.println("Splay Tree failed."); + return false; + } + + passed = testBTree(); + if (!passed) { + System.err.println("B-Tree failed."); + return false; + } + + passed = testTreap(); + if (!passed) { + System.err.println("Treap failed."); + return false; + } + + passed = testBST(); + if (!passed) { + System.err.println("BST failed."); + return false; + } + + passed = testJavaRedBlackStringTree(); + if (!passed) { + System.err.println("Java Red-Black [String] failed."); + return false; + } + + passed = testTrie(); + if (!passed) { + System.err.println("Trie failed."); + return false; + } + + passed = testPatriciaTrie(); + if (!passed) { + System.err.println("Patricia Trie failed."); + return false; + } + + // Sets + + passed = testJavaSkipList(); + if (!passed) { + System.err.println("Java's Skip List failed."); + return false; + } + + passed = testSkipList(); + if (!passed) { + System.err.println("Skip List failed."); + return false; + } + + // Heaps + + passed = testJavaMinHeap(); + if (!passed) { + System.err.println("Java Min-Heap failed."); + return false; + } + + passed = testMinHeap(); + if (!passed) { + System.err.println("Min-Heap failed."); + return false; + } + + passed = testJavaMaxHeap(); + if (!passed) { + System.err.println("Java Max-Heap failed."); + return false; + } + + passed = testMaxHeap(); + if (!passed) { + System.err.println("Max-Heap failed."); + return false; + } + + // Lists + + passed = testJavaArrayList(); + if (!passed) { + System.err.println("Java List failed."); + return false; + } + + passed = testArrayList(); + if (!passed) { + System.err.println("List failed."); + return false; + } + + passed = testJavaLinkedList(); + if (!passed) { + System.err.println("Java List failed."); + return false; + } + + passed = testLinkedList(); + if (!passed) { + System.err.println("List failed."); + return false; + } + + // Queues + + passed = testJavaArrayQueue(); + if (!passed) { + System.err.println("Java Queue failed."); + return false; + } + + passed = testArrayQueue(); + if (!passed) { + System.err.println("Queue failed."); + return false; + } + + passed = testJavaLinkedQueue(); + if (!passed) { + System.err.println("Java Queue failed."); + return false; + } + + passed = testLinkedQueue(); + if (!passed) { + System.err.println("Queue failed."); + return false; + } + + // Stacks + + passed = testJavaStack(); + if (!passed) { + System.err.println("Java Stack failed."); + return false; + } + + passed = testArrayStack(); + if (!passed) { + System.err.println("Stack failed."); + return false; + } + + passed = testLinkedStack(); + if (!passed) { + System.err.println("Stack failed."); + return false; + } + + // Maps + + passed = testJavaHashMap(); + if (!passed) { + System.err.println("Java Hash Map failed."); + return false; + } + + passed = testHashMap(); + if (!passed) { + System.err.println("Hash Map failed."); + return false; + } + + passed = testJavaTreeMap(); + if (!passed) { + System.err.println("Java Tree Map failed."); + return false; + } + + passed = testTreeMap(); + if (!passed) { + System.err.println("Tree Map failed."); + return false; + } + + passed = testTrieMap(); + if (!passed) { + System.err.println("Trie Map failed."); + return false; + } + + passed = testRadixTrie(); + if (!passed) { + System.err.println("Radix Trie failed."); + return false; + } + + passed = testJavaSkipListMap(); + if (!passed) { + System.err.println("Java's Skip List Map failed."); + return false; + } + + passed = testSkipListMap(); + if (!passed) { + System.err.println("Skip List Map failed."); + return false; + } + + passed = testHAMT(); + if (!passed) { + System.err.println("HAMT failed."); + return false; + } + + if (debugTime && debugMemory) { + String results = getTestResults(testNumber, testNames, testResults); + System.out.println(results); + } + + return true; + } + + private static void handleError(Object obj) { + System.err.println(string); + System.err.println(obj.toString()); + throw new RuntimeException("Error in test."); + } + + private static boolean testAVLTree() { + String bstName = "AVL Tree"; + BinarySearchTree bst = new AVLTree(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testBTree() { + String bstName = "B-Tree"; + BTree bst = new BTree(2); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testBST() { + String bstName = "BST"; + BinarySearchTree bst = new BinarySearchTree(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testMinHeap() { + String aNameMin = "Min-Heap [array]"; + BinaryHeap.BinaryHeapArray aHeapMin = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MIN); + Collection aCollectionMin = aHeapMin.toCollection(); + if (!testJavaCollection(aCollectionMin,Type.Integer,aNameMin)) return false; + + String tNameMin = "Min-Heap [tree]"; + BinaryHeap.BinaryHeapTree tHeapMin = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MIN); + Collection tCollectionMin = tHeapMin.toCollection(); + if (!testJavaCollection(tCollectionMin,Type.Integer,tNameMin)) return false; + + return true; + } + + private static boolean testMaxHeap() { + String aNameMax = "Max-Heap [array]"; + BinaryHeap.BinaryHeapArray aHeapMax = new BinaryHeap.BinaryHeapArray(BinaryHeap.Type.MAX); + Collection aCollectionMax = aHeapMax.toCollection(); + if (!testJavaCollection(aCollectionMax,Type.Integer,aNameMax)) return false; + + String lNameMax = "Max-Heap [tree]"; + BinaryHeap.BinaryHeapTree tHeapMax = new BinaryHeap.BinaryHeapTree(BinaryHeap.Type.MAX); + Collection tCollectionMax = tHeapMax.toCollection(); + if (!testJavaCollection(tCollectionMax,Type.Integer,lNameMax)) return false; + + return true; + } + + private static boolean testHashMap() { + String mapName = "HashMap"; + HashMap map = new HashMap(unsorted.length/2); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.Integer,mapName)) return false; + return true; + } + + private static boolean testHAMT() { + String mapName = "HAMT"; + HashArrayMappedTrie map = new HashArrayMappedTrie(); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.Integer,mapName)) return false; + return true; + } + + private static boolean testJavaHashMap() { + String mapName = "Java's HashMap"; + java.util.Map map = new java.util.HashMap(unsorted.length/2); + + if (!testJavaMap(map,Type.Integer,mapName)) return false; + return true; + } + + private static boolean testJavaMinHeap() { + java.util.PriorityQueue minArrayHeap = new java.util.PriorityQueue(10, + new Comparator() { + + @Override + public int compare(Integer arg0, Integer arg1) { + if (arg0.compareTo(arg1) < 0) + return -1; + else if (arg1.compareTo(arg0) < 0) + return 1; + return 0; + } + }); + if (!testJavaCollection(minArrayHeap,Type.Integer,"Java's Min-Heap [array]")) return false; + + return true; + } + + private static boolean testJavaMaxHeap() { + java.util.PriorityQueue maxArrayHeap = new java.util.PriorityQueue(10, + new Comparator() { + + @Override + public int compare(Integer arg0, Integer arg1) { + if (arg0.compareTo(arg1) > 0) + return -1; + else if (arg1.compareTo(arg0) > 0) + return 1; + return 0; + } + }); + if (!testJavaCollection(maxArrayHeap,Type.Integer,"Java's Max-Heap [array]")) return false; + return true; + } + + private static boolean testJavaArrayList() { + if (!testJavaCollection(new java.util.ArrayList(),Type.Integer,"Java's List [array]")) return false; + return true; + } + + private static boolean testJavaLinkedList() { + if (!testJavaCollection(new java.util.LinkedList(),Type.Integer,"Java's List [linked]")) return false; + return true; + } + + private static boolean testJavaArrayQueue() { + String aName = "Java's Queue [array]"; + java.util.Deque aCollection = new java.util.ArrayDeque(); + + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testJavaLinkedQueue() { + String lName = "Java's Queue [linked]"; + java.util.Deque lCollection = new java.util.LinkedList(); + + if (!testJavaCollection(lCollection,Type.Integer,lName)) return false; + return true; + } + + private static boolean testJavaRedBlackIntegerTree() { + String aName = "Java's Red-Black Tree [Integer]"; + java.util.TreeSet aCollection = new java.util.TreeSet(); + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testJavaRedBlackStringTree() { + String aName = "Java's Red-Black Tree [String]"; + java.util.TreeSet aCollection = new java.util.TreeSet(); + if (!testJavaCollection(aCollection,Type.String,aName)) return false; + return true; + } + + private static boolean testJavaStack() { + String aName = "Java's Stack [array]"; + java.util.Stack aCollection = new java.util.Stack(); + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testJavaTreeMap() { + String mapName = "Java's TreeMap"; + java.util.Map map = new java.util.TreeMap(); + + if (!testJavaMap(map,Type.String,mapName)) return false; + return true; + } + + private static boolean testArrayList() { + String aName = "List [array]"; + List.ArrayList aList = new List.ArrayList(); + Collection aCollection = aList.toCollection(); + + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testLinkedList() { + String lName = "List [linked]"; + List.LinkedList lList = new List.LinkedList(); + Collection lCollection = lList.toCollection(); + + if (!testJavaCollection(lCollection,Type.Integer,lName)) return false; + return true; + } + + private static boolean testPatriciaTrie() { + String bstName = "PatriciaTrie"; + PatriciaTrie bst = new PatriciaTrie(); + Collection bstCollection = bst.toCollection(); + + + if (!testJavaCollection(bstCollection,Type.String,bstName)) return false; + return true; + } + + private static boolean testArrayQueue() { + String aName = "Queue [array]"; + Queue.ArrayQueue aQueue = new Queue.ArrayQueue(); + Collection aCollection = aQueue.toCollection(); + + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testLinkedQueue() { + String lName = "Queue [linked]"; + Queue.LinkedQueue lQueue = new Queue.LinkedQueue(); + Collection lCollection = lQueue.toCollection(); + + if (!testJavaCollection(lCollection,Type.Integer,lName)) return false; + return true; + } + + private static boolean testRadixTrie() { + String mapName = "RadixTrie"; + RadixTrie map = new RadixTrie(); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.String,mapName)) return false; + return true; + } + + private static boolean testRedBlackTree() { + String bstName = "Red-Black Tree"; + RedBlackTree bst = new RedBlackTree(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testJavaSkipList() { + String sName = "Java's SkipList"; + NavigableSet sList = new ConcurrentSkipListSet(); + Collection lCollection = sList; + + if (!testJavaCollection(lCollection,Type.Integer,sName)) return false; + return true; + } + + private static boolean testSkipList() { + String sName = "SkipList"; + SkipList sList = new SkipList(); + Collection lCollection = sList.toCollection(); + + if (!testJavaCollection(lCollection,Type.Integer,sName)) return false; + return true; + } + + private static boolean testSplayTree() { + String bstName = "Splay Tree"; + BinarySearchTree bst = new SplayTree(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testArrayStack() { + String aName = "Stack [array]"; + Stack.ArrayStack aStack = new Stack.ArrayStack(); + Collection aCollection = aStack.toCollection(); + + if (!testJavaCollection(aCollection,Type.Integer,aName)) return false; + return true; + } + + private static boolean testLinkedStack() { + String lName = "Stack [linked]"; + Stack.LinkedStack lStack = new Stack.LinkedStack(); + Collection lCollection = lStack.toCollection(); + + if (!testJavaCollection(lCollection,Type.Integer,lName)) return false; + return true; + } + + private static boolean testTreap() { + String bstName = "Treap"; + BinarySearchTree bst = new Treap(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.Integer,bstName)) return false; + return true; + } + + private static boolean testTreeMap() { + String mapName = "TreeMap"; + TreeMap map = new TreeMap(); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.Integer,mapName)) return false; + return true; + } + + private static boolean testTrie() { + String bstName = "Trie"; + Trie bst = new Trie(); + Collection bstCollection = bst.toCollection(); + + if (!testJavaCollection(bstCollection,Type.String,bstName)) return false; + return true; + } + + private static boolean testTrieMap() { + String mapName = "TrieMap"; + TrieMap map = new TrieMap(); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.String,mapName)) return false; + return true; + } + + private static boolean testJavaSkipListMap() { + String mapName = "Java's SkipListMap"; + ConcurrentSkipListMap map = new ConcurrentSkipListMap(); + + if (!testJavaMap(map,Type.Integer,mapName)) return false; + return true; + } + + private static boolean testSkipListMap() { + String mapName = "SkipListMap"; + SkipListMap map = new SkipListMap(); + java.util.Map jMap = map.toMap(); + + if (!testJavaMap(jMap,Type.Integer,mapName)) return false; + return true; + } + + private static > boolean testJavaCollection(Collection collection, Type type, String name) { + // Make sure the collection is empty + if (!collection.isEmpty()) { + System.err.println(name+" initial isEmpty() failed."); + handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" initial size() failed."); + handleError(collection); + return false; + } + + long sortedCount = 0; + long unsortedCount = 0; + + long addTime = 0L; + long removeTime = 0L; + + long beforeAddTime = 0L; + long afterAddTime = 0L; + long beforeRemoveTime = 0L; + long afterRemoveTime = 0L; + + long memory = 0L; + + long beforeMemory = 0L; + long afterMemory = 0L; + + long lookupTime = 0L; + + long beforeLookupTime = 0L; + long afterLookupTime = 0L; + + if (debug > 1) System.out.println(name); + testNames[testIndex] = name; + + unsortedCount++; + { // UNSORTED: Add and remove in order (from index zero to length) + beforeMemory = 0L; + afterMemory = 0L; + beforeAddTime = 0L; + afterAddTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" unsorted add failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterAddTime = System.nanoTime(); + addTime += afterAddTime - beforeAddTime; + if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + if (debug > 1) System.out.println(collection.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean contains = collection.contains(item); + if (!contains) { + System.err.println(name+" unsorted contains failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveTime = 0L; + afterRemoveTime = 0L; + if (debugTime) beforeRemoveTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean removed = collection.remove(item); + if (!removed) { + System.err.println(name+" unsorted remove failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterRemoveTime = System.nanoTime(); + removeTime += afterRemoveTime - beforeRemoveTime; + if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); + } + + if (!collection.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" unsorted size() failed."); + handleError(collection); + return false; + } + } + + unsortedCount++; + { // UNSORTED: Add in reverse (from index length-1 to zero) order and then remove in order (from index zero to length) + beforeMemory = 0L; + afterMemory = 0L; + beforeAddTime = 0L; + afterAddTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddTime = System.nanoTime(); + for (int i = unsorted.length - 1; i >= 0; i--) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" unsorted add failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterAddTime = System.nanoTime(); + addTime += afterAddTime - beforeAddTime; + if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + if (debug > 1) System.out.println(collection.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean contains = collection.contains(item); + if (!contains) { + System.err.println(name+" unsorted contains failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveTime = 0L; + afterRemoveTime = 0L; + if (debugTime) beforeRemoveTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)unsorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(unsorted[i]); + } + boolean removed = collection.remove(item); + if (!removed) { + System.err.println(name+" unsorted remove failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterRemoveTime = System.nanoTime(); + removeTime += afterRemoveTime - beforeRemoveTime; + if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); + } + + if (!collection.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" unsorted size() failed."); + handleError(collection); + return false; + } + } + + long addSortedTime = 0L; + long removeSortedTime = 0L; + + long beforeAddSortedTime = 0L; + long afterAddSortedTime = 0L; + + long beforeRemoveSortedTime = 0L; + long afterRemoveSortedTime = 0L; + + sortedCount++; + { // SORTED: Add and remove in order (from index zero to length) + beforeMemory = 0L; + afterMemory = 0L; + beforeAddSortedTime = 0L; + afterAddSortedTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" sorted add failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterAddSortedTime = System.nanoTime(); + addSortedTime += afterAddSortedTime - beforeAddSortedTime; + if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + if (debug > 1) System.out.println(collection.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean contains = collection.contains(item); + if (!contains) { + System.err.println(name+" sorted contains failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveSortedTime = 0L; + afterRemoveSortedTime = 0L; + if (debugTime) beforeRemoveSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean removed = collection.remove(item); + if (!removed) { + System.err.println(name+" sorted remove failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterRemoveSortedTime = System.nanoTime(); + removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; + if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); + } + + if (!collection.isEmpty()) { + System.err.println(name+" sorted isEmpty() failed."); + handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" sorted size() failed."); + handleError(collection); + return false; + } + } + + sortedCount++; + { // SORTED: Add in order (from index zero to length) and then remove in reverse (from index length-1 to zero) order + beforeMemory = 0L; + afterMemory = 0L; + beforeAddSortedTime = 0L; + afterAddSortedTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean added = collection.add(item); + if (!added) { + System.err.println(name+" sorted add failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterAddSortedTime = System.nanoTime(); + addSortedTime += afterAddSortedTime - beforeAddSortedTime; + if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + if (debug > 1) System.out.println(collection.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean contains = collection.contains(item); + if (!contains) { + System.err.println(name+" sorted contains failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveSortedTime = 0L; + afterRemoveSortedTime = 0L; + if (debugTime) beforeRemoveSortedTime = System.nanoTime(); + for (int i = sorted.length - 1; i >= 0; i--) { + T item = null; + if (type==Type.Integer) { + item = (T)sorted[i]; + } else if (type==Type.String) { + item = (T)String.valueOf(sorted[i]); + } + boolean removed = collection.remove(item); + if (!removed) { + System.err.println(name+" sorted remove failed."); + handleError(collection); + return false; + } + } + if (debugTime) { + afterRemoveSortedTime = System.nanoTime(); + removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; + if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); + } + + if (!collection.isEmpty()) { + System.err.println(name+" sorted isEmpty() failed."); + handleError(collection); + return false; + } + if (collection.size()!=0) { + System.err.println(name+" sorted size() failed."); + handleError(collection); + return false; + } + } + + if (testResults[testIndex] == null) testResults[testIndex] = new long[6]; + testResults[testIndex][0] += addTime / unsortedCount; + testResults[testIndex][1] += removeTime / unsortedCount; + testResults[testIndex][2] += addSortedTime / sortedCount; + testResults[testIndex][3] += removeSortedTime / sortedCount; + testResults[testIndex][4] += lookupTime / (unsortedCount + sortedCount); + testResults[testIndex++][5] += memory / (unsortedCount + sortedCount); + + if (debug > 1) System.out.println(); + + return true; + } + + private static boolean testJavaMap(java.util.Map map, Type keyType, String name) { + // Make sure the map is empty + if (!map.isEmpty()) { + System.err.println(name+" initial isEmpty() failed."); + handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" initial size() failed."); + handleError(map); + return false; + } + + long sortedCount = 0; + long unsortedCount = 0; + + long addTime = 0L; + long removeTime = 0L; + + long beforeAddTime = 0L; + long afterAddTime = 0L; + long beforeRemoveTime = 0L; + long afterRemoveTime = 0L; + + long memory = 0L; + + long beforeMemory = 0L; + long afterMemory = 0L; + + long lookupTime = 0L; + + long beforeLookupTime = 0L; + long afterLookupTime = 0L; + + if (debug > 1) System.out.println(name); + testNames[testIndex] = name; + + unsortedCount++; + { + beforeMemory = 0L; + afterMemory = 0L; + beforeAddTime = 0L; + afterAddTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + Integer item = unsorted[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + if (debugTime) { + afterAddTime = System.nanoTime(); + addTime += afterAddTime - beforeAddTime; + if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)INVALID; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(INVALID); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + if (debug > 1) System.out.println(map.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (Integer item : unsorted) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + if (debugTime) beforeRemoveTime = System.nanoTime(); + for (int i = 0; i < unsorted.length; i++) { + Integer item = unsorted[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + + } + if (debugTime) { + afterRemoveTime = System.nanoTime(); + removeTime += afterRemoveTime - beforeRemoveTime; + if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); + } + + if (!map.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" unsorted size() failed."); + handleError(map); + return false; + } + } + + unsortedCount++; + { + beforeMemory = 0L; + afterMemory = 0L; + beforeAddTime = 0L; + afterAddTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddTime = System.nanoTime(); + for (int i = unsorted.length - 1; i >= 0; i--) { + Integer item = unsorted[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + if (debugTime) { + afterAddTime = System.nanoTime(); + addTime += afterAddTime - beforeAddTime; + if (debug > 0) System.out.println(name+" unsorted add time = " + (addTime / unsortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" unsorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)INVALID; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(INVALID); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" unsorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + if (debug > 1) System.out.println(map.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (Integer item : unsorted) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" unsorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveTime = 0L; + afterRemoveTime = 0L; + if (debugTime) beforeRemoveTime = System.nanoTime(); + for (int i = unsorted.length - 1; i >= 0; i--) { + Integer item = unsorted[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + } + if (debugTime) { + afterRemoveTime = System.nanoTime(); + removeTime += afterRemoveTime - beforeRemoveTime; + if (debug > 0) System.out.println(name+" unsorted remove time = " + (removeTime / unsortedCount) + " ns"); + } + + if (!map.isEmpty()) { + System.err.println(name+" unsorted isEmpty() failed."); + handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" unsorted size() failed."); + handleError(map); + return false; + } + } + + long addSortedTime = 0L; + long removeSortedTime = 0L; + + long beforeAddSortedTime = 0L; + long afterAddSortedTime = 0L; + + long beforeRemoveSortedTime = 0L; + long afterRemoveSortedTime = 0L; + + sortedCount++; + { // sorted + beforeMemory = 0L; + afterMemory = 0L; + beforeAddSortedTime = 0L; + afterAddSortedTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + Integer item = sorted[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + if (debugTime) { + afterAddSortedTime = System.nanoTime(); + addSortedTime += afterAddSortedTime - beforeAddSortedTime; + if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)INVALID; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(INVALID); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" sorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + if (debug > 1) System.out.println(map.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (Integer item : sorted) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveSortedTime = 0L; + afterRemoveSortedTime = 0L; + if (debugTime) beforeRemoveSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + Integer item = sorted[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + } + if (debugTime) { + afterRemoveSortedTime = System.nanoTime(); + removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; + if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); + } + + if (!map.isEmpty()) { + System.err.println(name+" sorted isEmpty() failed."); + handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" sorted size() failed."); + handleError(map); + return false; + } + } + + sortedCount++; + { // sorted + beforeMemory = 0L; + afterMemory = 0L; + beforeAddSortedTime = 0L; + afterAddSortedTime = 0L; + if (debugMemory) beforeMemory = DataStructuresTiming.getMemoryUse(); + if (debugTime) beforeAddSortedTime = System.nanoTime(); + for (int i = 0; i < sorted.length; i++) { + Integer item = sorted[i]; + K k = null; + V v = null; + if (keyType == Type.Integer) { + k = (K)item; + v = (V)String.valueOf(item); + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + v = (V)item; + } + map.put(k, v); + } + if (debugTime) { + afterAddSortedTime = System.nanoTime(); + addSortedTime += afterAddSortedTime - beforeAddSortedTime; + if (debug > 0) System.out.println(name+" sorted add time = " + (addSortedTime / sortedCount) + " ns"); + } + if (debugMemory) { + afterMemory = DataStructuresTiming.getMemoryUse(); + memory += afterMemory - beforeMemory; + if (debug > 0) System.out.println(name+" sorted memory use = " + (memory / (unsortedCount+sortedCount)) + " bytes"); + } + + K invalidKey = null; + if (keyType == Type.Integer) { + invalidKey = (K)INVALID; + } else if (keyType == Type.String) { + invalidKey = (K)String.valueOf(INVALID); + } + boolean contains = map.containsKey(invalidKey); + V removed = map.remove(invalidKey); + if (contains || (removed!=null)) { + System.err.println(name+" sorted invalidity check. contains=" + contains + " removed=" + removed); + return false; + } + + if (debug > 1) System.out.println(map.toString()); + + beforeLookupTime = 0L; + afterLookupTime = 0L; + if (debugTime) beforeLookupTime = System.nanoTime(); + for (Integer item : sorted) { + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + map.containsKey(k); + } + if (debugTime) { + afterLookupTime = System.nanoTime(); + lookupTime += afterLookupTime - beforeLookupTime; + if (debug > 0) System.out.println(name+" sorted lookup time = " + (lookupTime / (unsortedCount+sortedCount)) + " ns"); + } + + beforeRemoveSortedTime = 0L; + afterRemoveSortedTime = 0L; + if (debugTime) beforeRemoveSortedTime = System.nanoTime(); + for (int i = sorted.length - 1; i >= 0; i--) { + Integer item = sorted[i]; + K k = null; + if (keyType == Type.Integer) { + k = (K)item; + } else if (keyType == Type.String) { + k = (K)String.valueOf(item); + } + removed = map.remove(k); + if (removed==null) { + System.err.println(name+" unsorted invalidity check. removed=" + removed); + return false; + } + } + if (debugTime) { + afterRemoveSortedTime = System.nanoTime(); + removeSortedTime += afterRemoveSortedTime - beforeRemoveSortedTime; + if (debug > 0) System.out.println(name+" sorted remove time = " + (removeSortedTime / sortedCount) + " ns"); + } + + if (!map.isEmpty()) { + System.err.println(name+" sorted isEmpty() failed."); + handleError(map); + return false; + } + if (map.size()!=0) { + System.err.println(name+" sorted size() failed."); + handleError(map); + return false; + } + + } + + if (testResults[testIndex] == null) testResults[testIndex] = new long[6]; + testResults[testIndex][0] += addTime / unsortedCount; + testResults[testIndex][1] += removeTime / unsortedCount; + testResults[testIndex][2] += addSortedTime / sortedCount; + testResults[testIndex][3] += removeSortedTime / sortedCount; + testResults[testIndex][4] += lookupTime / (unsortedCount + sortedCount); + testResults[testIndex++][5] += memory / (unsortedCount + sortedCount); + + if (debug > 1) System.out.println(); + + return true; + } + + private static final String getTestResults(int testNumber, String[] names, long[][] results) { + StringBuilder resultsBuilder = new StringBuilder(); + String format = "%-32s %-10s %-15s %-15s %-20s %-15s %-15s\n"; + Formatter formatter = new Formatter(resultsBuilder, Locale.US); + formatter.format(format, "Data Structure", "Add time", "Remove time", "Sorted add time", "Sorted remove time", "Lookup time", "Size"); + + double KB = 1000; + double MB = 1000 * KB; + + double MILLIS = 1000000; + double SECOND = 1000; + double MINUTES = 60 * SECOND; + + for (int i=0; i MINUTES) { + addTime /= MINUTES; + addTimeString = FORMAT.format(addTime) + " m"; + } else if (addTime > SECOND) { + addTime /= SECOND; + addTimeString = FORMAT.format(addTime) + " s"; + } else { + addTimeString = FORMAT.format(addTime) + " ms"; + } + + double removeTime = result[1] / MILLIS; + removeTime /= testNumber; + String removeTimeString = null; + if (removeTime > MINUTES) { + removeTime /= MINUTES; + removeTimeString = FORMAT.format(removeTime) + " m"; + } else if (removeTime > SECOND) { + removeTime /= SECOND; + removeTimeString = FORMAT.format(removeTime) + " s"; + } else { + removeTimeString = FORMAT.format(removeTime) + " ms"; + } + + // sorted + double addSortedTime = result[2] / MILLIS; + addSortedTime /= testNumber; + String sortedAddTimeString = null; + if (addSortedTime > MINUTES) { + addSortedTime /= MINUTES; + sortedAddTimeString = FORMAT.format(addSortedTime) + " m"; + } else if (addSortedTime > SECOND) { + addSortedTime /= SECOND; + sortedAddTimeString = FORMAT.format(addSortedTime) + " s"; + } else { + sortedAddTimeString = FORMAT.format(addSortedTime) + " ms"; + } + + double removeSortedTime = result[3] / MILLIS; + removeSortedTime /= testNumber; + String sortedRemoveTimeString = null; + if (removeSortedTime > MINUTES) { + removeSortedTime /= MINUTES; + sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " m"; + } else if (removeSortedTime > SECOND) { + removeSortedTime /= SECOND; + sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " s"; + } else { + sortedRemoveTimeString = FORMAT.format(removeSortedTime) + " ms"; + } + + double lookupTime = result[4] / MILLIS; + lookupTime /= testNumber; + String lookupTimeString = null; + if (lookupTime > MINUTES) { + lookupTime /= MINUTES; + lookupTimeString = FORMAT.format(lookupTime) + " m"; + } else if (lookupTime > SECOND) { + lookupTime /= SECOND; + lookupTimeString = FORMAT.format(lookupTime) + " s"; + } else { + lookupTimeString = FORMAT.format(lookupTime) + " ms"; + } + + double size = result[5]; + size /= testNumber; + String sizeString = null; + if (size > MB) { + size = size / MB; + sizeString = FORMAT.format(size) + " MB"; + } else if (size > KB) { + size = size / KB; + sizeString = FORMAT.format(size) + " KB"; + } else { + sizeString = FORMAT.format(size) + " Bytes"; + } + + formatter.format(format, name, addTimeString, removeTimeString, sortedAddTimeString, sortedRemoveTimeString, lookupTimeString, sizeString); + } + } + formatter.close(); + + return resultsBuilder.toString(); + } + + private static final long getMemoryUse() { + putOutTheGarbage(); + long totalMemory = Runtime.getRuntime().totalMemory(); + + putOutTheGarbage(); + long freeMemory = Runtime.getRuntime().freeMemory(); + + return (totalMemory - freeMemory); + } + + private static final void putOutTheGarbage() { + collectGarbage(); + collectGarbage(); + collectGarbage(); + } + + private static final long fSLEEP_INTERVAL = 100; + + private static final void collectGarbage() { + try { + System.gc(); + Thread.sleep(fSLEEP_INTERVAL); + System.runFinalization(); + Thread.sleep(fSLEEP_INTERVAL); + } catch (InterruptedException ex) { + ex.printStackTrace(); + } + } +} diff --git a/src/com/jwetherell/algorithms/graph/BellmanFord.java b/src/com/jwetherell/algorithms/graph/BellmanFord.java index 21c837e0..8b802f69 100644 --- a/src/com/jwetherell/algorithms/graph/BellmanFord.java +++ b/src/com/jwetherell/algorithms/graph/BellmanFord.java @@ -4,7 +4,6 @@ import java.util.LinkedHashSet; import java.util.Map; import java.util.Set; -import java.util.TreeMap; import com.jwetherell.algorithms.data_structures.Graph; @@ -21,7 +20,6 @@ public class BellmanFord { private static Map, Graph.CostVertexPair> costs = null; private static Map, Set>> paths = null; - private static boolean containsNegativeWeightCycle = false; private BellmanFord() { } @@ -37,39 +35,35 @@ public static Map, Graph.CostPathPair> getShortes return map; } - public static Graph.CostPathPair getShortestPath(Graph g, Graph.Vertex start, Graph.Vertex end) { - if (g == null) + public static Graph.CostPathPair getShortestPath(Graph graph, Graph.Vertex start, Graph.Vertex end) { + if (graph == null) throw (new NullPointerException("Graph must be non-NULL.")); // Reset variables costs = null; paths = null; - containsNegativeWeightCycle = false; - paths = new TreeMap, Set>>(); - for (Graph.Vertex v : g.getVerticies()) { + paths = new HashMap, Set>>(); + for (Graph.Vertex v : graph.getVerticies()) paths.put(v, new LinkedHashSet>()); - } - costs = new TreeMap, Graph.CostVertexPair>(); - for (Graph.Vertex v : g.getVerticies()) { + costs = new HashMap, Graph.CostVertexPair>(); + for (Graph.Vertex v : graph.getVerticies()) if (v.equals(start)) costs.put(v, new Graph.CostVertexPair(0, v)); else costs.put(v, new Graph.CostVertexPair(Integer.MAX_VALUE, v)); - } boolean negativeCycleCheck = false; - for (int i = 0; i < (g.getVerticies().size()); i++) { + for (int i = 0; i < graph.getVerticies().size(); i++) { - // If it's the last vertices perform a negative weight cycle check. - // The graph should be - // finished by the size()-1 time through this loop. - if (i == (g.getVerticies().size() - 1)) + // If it's the last vertices, perform a negative weight cycle check. + // The graph should be finished by the size()-1 time through this loop. + if (i == (graph.getVerticies().size() - 1)) negativeCycleCheck = true; // Compute costs to all vertices - for (Graph.Edge e : g.getEdges()) { + for (Graph.Edge e : graph.getEdges()) { Graph.CostVertexPair pair = costs.get(e.getToVertex()); Graph.CostVertexPair lowestCostToThisVertex = costs.get(e.getFromVertex()); @@ -83,7 +77,6 @@ public static Graph.CostPathPair getShortestPath(Graph g, Grap if (negativeCycleCheck) { // Uhh ohh... negative weight cycle System.out.println("Graph contains a negative weight cycle."); - containsNegativeWeightCycle = true; return null; } // Found a shorter path to a reachable vertex @@ -103,8 +96,4 @@ public static Graph.CostPathPair getShortestPath(Graph g, Grap } return null; } - - public static boolean containsNegativeWeightCycle() { - return containsNegativeWeightCycle; - } } diff --git a/src/com/jwetherell/algorithms/graph/CycleDetection.java b/src/com/jwetherell/algorithms/graph/CycleDetection.java index 7d8c0369..4bce0d36 100644 --- a/src/com/jwetherell/algorithms/graph/CycleDetection.java +++ b/src/com/jwetherell/algorithms/graph/CycleDetection.java @@ -6,20 +6,34 @@ import com.jwetherell.algorithms.data_structures.Graph; +/** + * Cycle detection in an undirected graph using depth first search. + * + * @author Justin Wetherell + */ public class CycleDetection { private static Set> visitedVerticies = new HashSet>(); private static Set> visitedEdges = new HashSet>(); - private CycleDetection() { - }; + private CycleDetection() { } + + /** + * Cycle detection on a unidrected graph. + * + * @param graph Graph + * @return true if a cycle exists + */ + public static boolean detect(Graph graph) { + if (graph == null) + throw new IllegalArgumentException("Graph is NULL."); + + if (graph.getType() != Graph.TYPE.UNDIRECTED) + throw new IllegalArgumentException("Graph is needs to be Undirected."); - public static boolean detect(Graph g) { - if (g == null) - return false; visitedVerticies.clear(); visitedEdges.clear(); - List> verticies = g.getVerticies(); + List> verticies = graph.getVerticies(); if (verticies == null || verticies.size() == 0) return false; @@ -40,8 +54,7 @@ private static final boolean depthFirstSearch(Graph.Vertex vertex) { boolean result = false; if (to != null && !visitedEdges.contains(edge)) { visitedEdges.add(edge); - Graph.Edge recip = new Graph.Edge(edge.getCost(), edge.getToVertex(), - edge.getFromVertex()); + Graph.Edge recip = new Graph.Edge(edge.getCost(), edge.getToVertex(), edge.getFromVertex()); visitedEdges.add(recip); result = depthFirstSearch(to); } diff --git a/src/com/jwetherell/algorithms/graph/Dijkstra.java b/src/com/jwetherell/algorithms/graph/Dijkstra.java index ba140ee6..1337f6c3 100644 --- a/src/com/jwetherell/algorithms/graph/Dijkstra.java +++ b/src/com/jwetherell/algorithms/graph/Dijkstra.java @@ -7,7 +7,6 @@ import java.util.PriorityQueue; import java.util.Queue; import java.util.Set; -import java.util.TreeMap; import com.jwetherell.algorithms.data_structures.Graph; @@ -39,8 +38,8 @@ public static Map, Graph.CostPathPair> getShortes return map; } - public static Graph.CostPathPair getShortestPath(Graph g, Graph.Vertex start, Graph.Vertex end) { - if (g == null) + public static Graph.CostPathPair getShortestPath(Graph graph, Graph.Vertex start, Graph.Vertex end) { + if (graph == null) throw (new NullPointerException("Graph must be non-NULL.")); // Reset variables @@ -49,17 +48,16 @@ public static Graph.CostPathPair getShortestPath(Graph g, Grap unvisited = null; // Dijkstra's algorithm only works on positive cost graphs - boolean hasNegativeEdge = checkForNegativeEdges(g.getVerticies()); + boolean hasNegativeEdge = checkForNegativeEdges(graph.getVerticies()); if (hasNegativeEdge) throw (new IllegalArgumentException("Negative cost Edges are not allowed.")); - paths = new TreeMap, Set>>(); - for (Graph.Vertex v : g.getVerticies()) { + paths = new HashMap, Set>>(); + for (Graph.Vertex v : graph.getVerticies()) paths.put(v, new LinkedHashSet>()); - } - costs = new TreeMap, Graph.CostVertexPair>(); - for (Graph.Vertex v : g.getVerticies()) { + costs = new HashMap, Graph.CostVertexPair>(); + for (Graph.Vertex v : graph.getVerticies()) { if (v.equals(start)) costs.put(v, new Graph.CostVertexPair(0, v)); else @@ -67,28 +65,39 @@ public static Graph.CostPathPair getShortestPath(Graph g, Grap } unvisited = new PriorityQueue>(); - unvisited.addAll(costs.values()); // Shallow copy + unvisited.addAll(costs.values()); // Shallow copy which is O(n log n) Graph.Vertex vertex = start; while (true) { - // Compute costs from current vertex to all reachable vertices which - // haven't been visited + // Compute costs from current vertex to all reachable vertices which haven't been visited for (Graph.Edge e : vertex.getEdges()) { - Graph.CostVertexPair pair = costs.get(e.getToVertex()); - Graph.CostVertexPair lowestCostToThisVertex = costs.get(vertex); + Graph.CostVertexPair pair = costs.get(e.getToVertex()); // O(log n) + Graph.CostVertexPair lowestCostToThisVertex = costs.get(vertex); // O(log n) int cost = lowestCostToThisVertex.getCost() + e.getCost(); if (pair.getCost() == Integer.MAX_VALUE) { // Haven't seen this vertex yet pair.setCost(cost); - Set> set = paths.get(e.getToVertex()); - set.addAll(paths.get(e.getFromVertex())); + + // Need to remove the pair and re-insert, so the priority queue keeps it's invariants + unvisited.remove(pair); // O(n) + unvisited.add(pair); // O(log n) + + // Update the paths + Set> set = paths.get(e.getToVertex()); // O(log n) + set.addAll(paths.get(e.getFromVertex())); // O(log n) set.add(e); } else if (cost < pair.getCost()) { // Found a shorter path to a reachable vertex pair.setCost(cost); - Set> set = paths.get(e.getToVertex()); + + // Need to remove the pair and re-insert, so the priority queue keeps it's invariants + unvisited.remove(pair); // O(n) + unvisited.add(pair); // O(log n) + + // Update the paths + Set> set = paths.get(e.getToVertex()); // O(log n) set.clear(); - set.addAll(paths.get(e.getFromVertex())); + set.addAll(paths.get(e.getFromVertex())); // O(log n) set.add(e); } } @@ -98,9 +107,8 @@ public static Graph.CostPathPair getShortestPath(Graph g, Grap // If we are looking for shortest path, we found it. break; } else if (unvisited.size() > 0) { - // If there are other vertices to visit (which haven't been - // visited yet) - Graph.CostVertexPair pair = unvisited.remove(); + // If there are other vertices to visit (which haven't been visited yet) + Graph.CostVertexPair pair = unvisited.remove(); // O(log n) vertex = pair.getVertex(); if (pair.getCost() == Integer.MAX_VALUE) { // If the only edge left to explore has MAX_VALUE then it diff --git a/src/com/jwetherell/algorithms/graph/FloydWarshall.java b/src/com/jwetherell/algorithms/graph/FloydWarshall.java index 10e45b13..4f32f924 100644 --- a/src/com/jwetherell/algorithms/graph/FloydWarshall.java +++ b/src/com/jwetherell/algorithms/graph/FloydWarshall.java @@ -19,11 +19,13 @@ public class FloydWarshall { private FloydWarshall() { } - public static Map, Map, Integer>> getAllPairsShortestPaths( - Graph g) { + public static Map, Map, Integer>> getAllPairsShortestPaths(Graph graph) { + if (graph == null) + throw (new NullPointerException("Graph must be non-NULL.")); + Map, Map, Integer>> allShortestPaths = new HashMap, Map, Integer>>(); - List> vertices = g.getVerticies(); + List> vertices = graph.getVerticies(); int[][] sums = new int[vertices.size()][vertices.size()]; for (int i = 0; i < sums.length; i++) { @@ -32,7 +34,7 @@ public static Map, Map, Integer>> ge } } - List> edges = g.getEdges(); + List> edges = graph.getEdges(); for (Graph.Edge e : edges) { int indexOfFrom = vertices.indexOf(e.getFromVertex()); int indexOfTo = vertices.indexOf(e.getToVertex()); diff --git a/src/com/jwetherell/algorithms/graph/Johnson.java b/src/com/jwetherell/algorithms/graph/Johnson.java index 721e18d4..c57b3d37 100644 --- a/src/com/jwetherell/algorithms/graph/Johnson.java +++ b/src/com/jwetherell/algorithms/graph/Johnson.java @@ -17,57 +17,63 @@ */ public class Johnson { - private Johnson() { - } + private Johnson() { } + + public static Map, Map, Set>>> getAllPairsShortestPaths(Graph g) { + if (g == null) + throw (new NullPointerException("Graph must be non-NULL.")); - public static Map, Map, Set>>> getAllPairsShortestPaths( - Graph g) { - Map, Map, Set>>> allShortestPaths = new HashMap, Map, Set>>>(); + Map, Map, Set>>> allShortestPaths = + new HashMap, Map, Set>>>(); + + // First, a new node 'connector' is added to the graph, connected by zero-weight edges to each of the other nodes. + Graph graph = new Graph(g); + Graph.Vertex connector = new Graph.Vertex(Integer.MAX_VALUE); + graph.getVerticies().add(connector); // Add the connector Vertex to all edges. for (Graph.Vertex v : g.getVerticies()) { - Graph graph = new Graph(g); // Clone the original - // graph - Graph.Vertex connector = new Graph.Vertex(Integer.MAX_VALUE); // Make - // new - // Vertex - // that - // connects - // to - // all - // Vertices - graph.getVerticies().add(connector); - int indexOfV = graph.getVerticies().indexOf(v); - Graph.Edge e = new Graph.Edge(0, connector, graph.getVerticies().get(indexOfV)); - connector.addEdge(e); - graph.getEdges().add(e); + Graph.Edge edge = new Graph.Edge(0, connector, graph.getVerticies().get(indexOfV)); + connector.addEdge(edge); + graph.getEdges().add(edge); + } - Map, Graph.CostPathPair> costs = BellmanFord.getShortestPaths(graph, - connector); - if (BellmanFord.containsNegativeWeightCycle()) { - System.out.println("Graph contains a negative weight cycle. Cannot compute shortest path."); - return null; - } - for (Graph.Vertex v2 : costs.keySet()) { - int index = graph.getVerticies().indexOf(v2); - Graph.Vertex vertexToAdjust = graph.getVerticies().get(index); - Graph.CostPathPair pair = costs.get(v2); - vertexToAdjust.setWeight(pair.getCost()); - } + // Second, the Bellman–Ford algorithm is used, starting from the new vertex 'connector', to find for each vertex v + // the minimum weight h(v) of a path from 'connector' to v. If this step detects a negative cycle, the algorithm is terminated. + Map, Graph.CostPathPair> costs = BellmanFord.getShortestPaths(graph, connector); + if (costs==null) { + System.out.println("Graph contains a negative weight cycle. Cannot compute shortest path."); + return null; + } - for (Graph.Edge e2 : graph.getEdges()) { - int startCost = e2.getFromVertex().getWeight(); - int endCode = e2.getToVertex().getWeight(); - int adjCost = e2.getCost() + startCost - endCode; - e2.setCost(adjCost); - } + // Next the edges of the original graph are reweighted using the values computed by the Bellman–Ford algorithm: an edge + // from u to v, having length w(u,v), is given the new length w(u,v) + h(u) − h(v). + for (Graph.Edge e : graph.getEdges()) { + int weight = e.getCost(); + Graph.Vertex u = e.getFromVertex(); + Graph.Vertex v = e.getToVertex(); + + // Don't worry about the connector + if (u.equals(connector) || v.equals(connector)) continue; - int index = graph.getVerticies().indexOf(connector); - graph.getVerticies().remove(index); - index = graph.getEdges().indexOf(e); - graph.getEdges().remove(index); + // Adjust the costs + int uCost = costs.get(u).getCost(); + int vCost = costs.get(v).getCost(); + int newWeight = weight+uCost-vCost; + e.setCost(newWeight); + } + // Finally, 'connector' is removed, and Dijkstra's algorithm is used to find the shortest paths from each node s to every + // other vertex in the reweighted graph. + int indexOfConnector = graph.getVerticies().indexOf(connector); + graph.getVerticies().remove(indexOfConnector); + for (Graph.Edge e : connector.getEdges()) { + int indexOfConnectorEdge = graph.getEdges().indexOf(e); + graph.getEdges().remove(indexOfConnectorEdge); + } + + for (Graph.Vertex v : g.getVerticies()) { Map, Graph.CostPathPair> costPaths = Dijkstra.getShortestPaths(graph, v); Map, Set>> paths = new HashMap, Set>>(); for (Graph.Vertex v2 : costPaths.keySet()) { @@ -76,6 +82,7 @@ public static Map, Map, Set getMinimumSpanningTree(Graph g, Graph.Vertex start) { - if (g == null) + public static Graph.CostPathPair getMinimumSpanningTree(Graph graph, Graph.Vertex start) { + if (graph == null) throw (new NullPointerException("Graph must be non-NULL.")); // Reset variables @@ -36,12 +36,13 @@ public static Graph.CostPathPair getMinimumSpanningTree(Graph edgesAvailable = null; // Prim's algorithm only works on undirected graphs - if (g.getType() == Graph.TYPE.DIRECTED) throw (new IllegalArgumentException("Undirected graphs only.")); + if (graph.getType() == Graph.TYPE.DIRECTED) + throw (new IllegalArgumentException("Undirected graphs only.")); path = new LinkedHashSet>(); unvisited = new ArrayList>(); - unvisited.addAll(g.getVerticies()); + unvisited.addAll(graph.getVerticies()); unvisited.remove(start); edgesAvailable = new PriorityQueue>(); diff --git a/src/com/jwetherell/algorithms/graph/TopologicalSort.java b/src/com/jwetherell/algorithms/graph/TopologicalSort.java index 2b7cc49c..ae448852 100644 --- a/src/com/jwetherell/algorithms/graph/TopologicalSort.java +++ b/src/com/jwetherell/algorithms/graph/TopologicalSort.java @@ -2,6 +2,7 @@ import java.util.ArrayList; import java.util.List; +import java.util.concurrent.CopyOnWriteArrayList; import com.jwetherell.algorithms.data_structures.Graph; @@ -14,33 +15,47 @@ */ public class TopologicalSort { - private TopologicalSort() { - }; + private TopologicalSort() { } + /** + * Performs a topological sort on a directed graph. Returns NULL if a cycle is detected. + * + * @param graph + * @return Sorted List of Vertices or NULL if graph has a cycle + */ public static final List> sort(Graph graph) { + if (graph == null) + throw new IllegalArgumentException("Graph is NULL."); + + if (graph.getType() != Graph.TYPE.DIRECTED) + throw new IllegalArgumentException("Cannot perform a topological sort on a non-directed graph. graph type = "+graph.getType()); + List> sorted = new ArrayList>(); List> noOutgoing = new ArrayList>(); + + List> edges = new CopyOnWriteArrayList>(); + edges.addAll(graph.getEdges()); + for (Graph.Vertex v : graph.getVerticies()) { - if (v.getEdges().size() == 0) { + if (v.getEdges().size() == 0) noOutgoing.add(v); - } } while (noOutgoing.size() > 0) { Graph.Vertex v = noOutgoing.remove(0); sorted.add(v); - for (Graph.Edge e : graph.getEdges()) { + for (Graph.Edge e : edges) { Graph.Vertex v2 = e.getFromVertex(); Graph.Vertex v3 = e.getToVertex(); if (v3.equals(v)) { - graph.getEdges().remove(e); + edges.remove(e); v2.getEdges().remove(e); } if (v2.getEdges().size() == 0) noOutgoing.add(v2); } } - if (graph.getEdges().size() > 0) - System.out.println("cycle detected"); + if (edges.size() > 0) + return null; return sorted; } } diff --git a/src/com/jwetherell/algorithms/graph/test/Graphs.java b/src/com/jwetherell/algorithms/graph/test/Graphs.java new file mode 100644 index 00000000..70c6654b --- /dev/null +++ b/src/com/jwetherell/algorithms/graph/test/Graphs.java @@ -0,0 +1,924 @@ +package com.jwetherell.algorithms.graph.test; + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.junit.Test; + +import com.jwetherell.algorithms.data_structures.Graph; +import com.jwetherell.algorithms.data_structures.Graph.Edge; +import com.jwetherell.algorithms.data_structures.Graph.Vertex; +import com.jwetherell.algorithms.graph.BellmanFord; +import com.jwetherell.algorithms.graph.CycleDetection; +import com.jwetherell.algorithms.graph.Dijkstra; +import com.jwetherell.algorithms.graph.FloydWarshall; +import com.jwetherell.algorithms.graph.Johnson; +import com.jwetherell.algorithms.graph.Prim; +import com.jwetherell.algorithms.graph.TopologicalSort; + +public class Graphs { + + private static int debug = 0; // Debug level. 0=None, 1=Some + + // Undirected + private static class UndirectedGraph { + List> verticies = new ArrayList>(); + Graph.Vertex v1 = new Graph.Vertex(1); + Graph.Vertex v2 = new Graph.Vertex(2); + Graph.Vertex v3 = new Graph.Vertex(3); + Graph.Vertex v4 = new Graph.Vertex(4); + Graph.Vertex v5 = new Graph.Vertex(5); + Graph.Vertex v6 = new Graph.Vertex(6); + { + verticies.add(v1); + verticies.add(v2); + verticies.add(v3); + verticies.add(v4); + verticies.add(v5); + verticies.add(v6); + } + + List> edges = new ArrayList>(); + Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); + Graph.Edge e1_3 = new Graph.Edge(9, v1, v3); + Graph.Edge e1_6 = new Graph.Edge(14, v1, v6); + Graph.Edge e2_3 = new Graph.Edge(10, v2, v3); + Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); + Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); + Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); + Graph.Edge e5_6 = new Graph.Edge(9, v5, v6); + Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); + { + edges.add(e1_2); + edges.add(e1_3); + edges.add(e1_6); + edges.add(e2_3); + edges.add(e2_4); + edges.add(e3_4); + edges.add(e3_6); + edges.add(e5_6); + edges.add(e4_5); + } + + Graph graph = new Graph(verticies, edges); + } + private UndirectedGraph undirected = new UndirectedGraph(); + + // Ideal undirected path + private Map, Graph.CostPathPair> idealUndirectedPath = new HashMap, Graph.CostPathPair>(); + { + { + int cost = 11; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_3); + set.add(undirected.e3_6); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v6, path); + } + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_3); + set.add(undirected.e3_6); + set.add(new Graph.Edge(9, undirected.v6, undirected.v5)); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v5, path); + } + { + int cost = 9; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_3); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v3, path); + } + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_3); + set.add(undirected.e3_4); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v4, path); + } + { + int cost = 7; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_2); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v2, path); + } + { + int cost = 0; + Set> set = new LinkedHashSet>(); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealUndirectedPath.put(undirected.v1, path); + } + } + + // Ideal undirected PathPair + private Graph.CostPathPair idealUndirectedPathPair = null; + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_3); + set.add(undirected.e3_6); + set.add(new Graph.Edge(9, undirected.v6, undirected.v5)); + idealUndirectedPathPair = new Graph.CostPathPair(cost, set); + } + + // Directed + private static class DirectedGraph { + List> verticies = new ArrayList>(); + Graph.Vertex v1 = new Graph.Vertex(1); + Graph.Vertex v2 = new Graph.Vertex(2); + Graph.Vertex v3 = new Graph.Vertex(3); + Graph.Vertex v4 = new Graph.Vertex(4); + Graph.Vertex v5 = new Graph.Vertex(5); + Graph.Vertex v6 = new Graph.Vertex(6); + Graph.Vertex v7 = new Graph.Vertex(7); + { + verticies.add(v1); + verticies.add(v2); + verticies.add(v3); + verticies.add(v4); + verticies.add(v5); + verticies.add(v6); + verticies.add(v7); + } + + List> edges = new ArrayList>(); + Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); + Graph.Edge e1_3 = new Graph.Edge(9, v1, v3); + Graph.Edge e1_6 = new Graph.Edge(14, v1, v6); + Graph.Edge e2_3 = new Graph.Edge(10, v2, v3); + Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); + Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); + Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); + Graph.Edge e6_5 = new Graph.Edge(9, v6, v5); + Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); + Graph.Edge e4_7 = new Graph.Edge(16, v4, v7); + { + edges.add(e1_2); + edges.add(e1_3); + edges.add(e1_6); + edges.add(e2_3); + edges.add(e2_4); + edges.add(e3_4); + edges.add(e3_6); + edges.add(e6_5); + edges.add(e4_5); + edges.add(e4_7); + } + + Graph graph = new Graph(Graph.TYPE.DIRECTED, verticies, edges); + } + private DirectedGraph directed = new DirectedGraph(); + + // Ideal directed path + private Map, Graph.CostPathPair> idealDirectedPath = new HashMap, Graph.CostPathPair>(); + { + { + int cost = 11; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + set.add(directed.e3_6); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v6, path); + } + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + set.add(directed.e3_6); + set.add(new Graph.Edge(9, directed.v6, directed.v5)); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v5, path); + } + { + int cost = 36; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + set.add(directed.e3_4); + set.add(directed.e4_7); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v7, path); + } + { + int cost = 9; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v3, path); + } + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + set.add(directed.e3_4); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v4, path); + } + { + int cost = 7; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_2); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v2, path); + } + { + int cost = 0; + Set> set = new LinkedHashSet>(); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedPath.put(directed.v1, path); + } + } + + // Ideal directed Path Pair + private Graph.CostPathPair idealPathPair = null; + { + int cost = 20; + Set> set = new LinkedHashSet>(); + set.add(directed.e1_3); + set.add(directed.e3_6); + set.add(new Graph.Edge(9, directed.v6, directed.v5)); + idealPathPair = new Graph.CostPathPair(cost, set); + } + + // Directed with negative weights + private static class DirectedWithNegativeWeights { + List> verticies = new ArrayList>(); + Graph.Vertex v1 = new Graph.Vertex(1); + Graph.Vertex v2 = new Graph.Vertex(2); + Graph.Vertex v3 = new Graph.Vertex(3); + Graph.Vertex v4 = new Graph.Vertex(4); + { + verticies.add(v1); + verticies.add(v2); + verticies.add(v3); + verticies.add(v4); + } + + List> edges = new ArrayList>(); + Graph.Edge e1_4 = new Graph.Edge(2, v1, v4); + Graph.Edge e2_1 = new Graph.Edge(6, v2, v1); + Graph.Edge e2_3 = new Graph.Edge(3, v2, v3); + Graph.Edge e3_1 = new Graph.Edge(4, v3, v1); + Graph.Edge e3_4 = new Graph.Edge(5, v3, v4); + Graph.Edge e4_2 = new Graph.Edge(-7, v4, v2); + Graph.Edge e4_3 = new Graph.Edge(-3, v4, v3); + { + edges.add(e1_4); + edges.add(e2_1); + edges.add(e2_3); + edges.add(e3_1); + edges.add(e3_4); + edges.add(e4_2); + edges.add(e4_3); + } + + Graph graph = new Graph(Graph.TYPE.DIRECTED, verticies, edges); + } + private DirectedWithNegativeWeights directedWithNegWeights = new DirectedWithNegativeWeights(); + + // Ideal directed with negative weight path + private Map, Graph.CostPathPair> idealDirectedNegWeight = new HashMap, Graph.CostPathPair>(); + { + { + int cost = -2; + Set> set = new LinkedHashSet>(); + set.add(directedWithNegWeights.e1_4); + set.add(directedWithNegWeights.e4_2); + set.add(directedWithNegWeights.e2_3); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedNegWeight.put(directedWithNegWeights.v3, path); + } + { + int cost = 2; + Set> set = new LinkedHashSet>(); + set.add(directedWithNegWeights.e1_4); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedNegWeight.put(directedWithNegWeights.v4, path); + } + { + int cost = -5; + Set> set = new LinkedHashSet>(); + set.add(directedWithNegWeights.e1_4); + set.add(directedWithNegWeights.e4_2); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedNegWeight.put(directedWithNegWeights.v2, path); + } + { + int cost = 0; + Set> set = new LinkedHashSet>(); + Graph.CostPathPair path = new Graph.CostPathPair(cost, set); + idealDirectedNegWeight.put(directedWithNegWeights.v1, path); + } + } + + // Ideal pair + Graph.CostPathPair idealDirectedWithNegWeightsPathPair = null; + { + int cost = -2; + Set> set = new LinkedHashSet>(); + set.add(directedWithNegWeights.e1_4); + set.add(directedWithNegWeights.e4_2); + set.add(directedWithNegWeights.e2_3); + idealDirectedWithNegWeightsPathPair = new Graph.CostPathPair(cost, set); + } + + @Test + public void testDijstraUndirected() { + if (debug > 0) System.out.println("Undirected Graph."); + + Graph.Vertex start = undirected.v1; + Graph.Vertex end = undirected.v5; + + { // UNDIRECTED GRAPH + if (debug > 0) System.out.println("Dijstra's shortest paths of the undirected graph from " + start.getValue()+" to all."); + Map, Graph.CostPathPair> map1 = Dijkstra.getShortestPaths(undirected.graph, start); + if (debug > 0) System.out.println(getPathMapString(start, map1)); + + // Compare results + for (Graph.Vertex v : map1.keySet()) { + Graph.CostPathPair path1 = map1.get(v); + Graph.CostPathPair path2 = idealUndirectedPath.get(v); + assertTrue("Dijstra's shortest path error. path1="+path1+" path2="+path2, path1.equals(path2)); + } + if (debug > 0) System.out.println("Dijstra's shortest path worked correctly."); + + if (debug > 0) System.out.println("Dijstra's shortest path of the undirected graph from " + start.getValue() + " to " + end.getValue()+"."); + Graph.CostPathPair pair1 = Dijkstra.getShortestPath(undirected.graph, start, end); + assertTrue("No path from " + start.getValue() + " to " + end.getValue(), (pair1 != null)); + if (debug > 0) System.out.println(pair1.toString()); + + assertTrue("Dijstra's shortest path error. pair="+pair1+" pair="+idealUndirectedPathPair, pair1.equals(idealUndirectedPathPair)); + if (debug > 0) System.out.println("Dijstra's shortest path worked correctly"); + } + } + + @Test + public void testBellmanFordUndirected() { + if (debug > 0) System.out.println("Undirected Graph."); + + Graph.Vertex start = undirected.v1; + Graph.Vertex end = undirected.v5; + + { + if (debug > 0) System.out.println("Bellman-Ford's shortest paths of the undirected graph from " + start.getValue()+" to all."); + Map, Graph.CostPathPair> map2 = BellmanFord.getShortestPaths(undirected.graph, start); + if (debug > 0) System.out.println(getPathMapString(start, map2)); + + // Compare results + for (Graph.Vertex v : map2.keySet()) { + Graph.CostPathPair path1 = map2.get(v); + Graph.CostPathPair path2 = idealUndirectedPath.get(v); + assertTrue("Bellman-Ford's shortest path error. path1="+path1+" path2="+path2, path1.equals(path2)); + } + if (debug>0) System.out.println("Bellman-Ford's shortest path worked correctly."); + + if (debug>0) System.out.println("Bellman-Ford's shortest path of the undirected graph from " + start.getValue() + " to " + end.getValue()+"."); + Graph.CostPathPair pair2 = BellmanFord.getShortestPath(undirected.graph, start, end); + assertTrue("Bellman-Ford's shortest path error. pair="+pair2+" result="+idealUndirectedPathPair, pair2.equals(idealUndirectedPathPair)); + if (debug>0) System.out.println("Bellman-Ford's shortest path worked correctly"); + } + } + + @Test + public void testPrimUndirected() { + if (debug > 0) System.out.println(undirected.toString()); + + { + Graph.Vertex start = undirected.v1; + + if (debug > 0) System.out.println("Prim's minimum spanning tree of the undirected graph starting from vertex " + start.getValue()+"."); + Graph.CostPathPair resultMST = Prim.getMinimumSpanningTree(undirected.graph, start); + if (debug > 0) System.out.println(resultMST.toString()); + { + // Ideal MST + int cost = 33; + Set> set = new LinkedHashSet>(); + set.add(undirected.e1_2); + set.add(undirected.e1_3); + set.add(undirected.e3_6); + set.add(new Graph.Edge(9, undirected.v6, undirected.v5)); + set.add(new Graph.Edge(6, undirected.v5, undirected.v4)); + Graph.CostPathPair idealMST = new Graph.CostPathPair(cost, set); + + assertTrue("Prim's minimum spanning tree error. resultMST="+resultMST+" idealMST="+idealMST, resultMST.equals(idealMST)); + if (debug > 0) System.out.println("Prim's minimum spanning tree worked correctly"); + } + + // Prim on a graph with cycles + List> cyclicVerticies = new ArrayList>(); + Graph.Vertex cv1 = new Graph.Vertex(1); + cyclicVerticies.add(cv1); + Graph.Vertex cv2 = new Graph.Vertex(2); + cyclicVerticies.add(cv2); + Graph.Vertex cv3 = new Graph.Vertex(3); + cyclicVerticies.add(cv3); + Graph.Vertex cv4 = new Graph.Vertex(4); + cyclicVerticies.add(cv4); + Graph.Vertex cv5 = new Graph.Vertex(5); + cyclicVerticies.add(cv5); + + List> cyclicEdges = new ArrayList>(); + Graph.Edge ce1_2 = new Graph.Edge(3, cv1, cv2); + cyclicEdges.add(ce1_2); + Graph.Edge ce2_3 = new Graph.Edge(2, cv2, cv3); + cyclicEdges.add(ce2_3); + Graph.Edge ce3_4 = new Graph.Edge(4, cv3, cv4); + cyclicEdges.add(ce3_4); + Graph.Edge ce4_1 = new Graph.Edge(1, cv4, cv1); + cyclicEdges.add(ce4_1); + Graph.Edge ce4_5 = new Graph.Edge(1, cv4, cv5); + cyclicEdges.add(ce4_5); + + Graph cyclicUndirected = new Graph(cyclicVerticies, cyclicEdges); + if (debug > 0) System.out.println(cyclicUndirected.toString()); + + start = cv1; + + if (debug > 0) System.out.println("Prim's minimum spanning tree of a cyclic undirected graph from " + start.getValue()); + Graph.CostPathPair pair4 = Prim.getMinimumSpanningTree(cyclicUndirected, start); + if (debug > 0) System.out.println(pair4.toString()); + { + // Ideal MST + int cost = 7; + Set> set = new LinkedHashSet>(); + set.add(new Graph.Edge(1, undirected.v1, undirected.v4)); + set.add(ce4_5); + set.add(ce1_2); + set.add(ce2_3); + Graph.CostPathPair result4 = new Graph.CostPathPair(cost, set); + + assertTrue("Prim's minimum spanning tree error. pair4="+pair4+" result4="+result4, pair4.equals(result4)); + if (debug > 0) System.out.println("Prim's minimum spanning tree worked correctly"); + } + } + } + + @Test + public void testDijstraDirected() { + if (debug>0) System.out.println(directed.toString()); + + Graph.Vertex start = directed.v1; + Graph.Vertex end = directed.v5; + + if (debug>0) System.out.println("Dijstra's shortest paths of the directed graph from "+start.getValue()+" to all."); + Map, Graph.CostPathPair> map1 = Dijkstra.getShortestPaths(directed.graph, start); + if (debug>0) System.out.println(getPathMapString(start, map1)); + + // Compare results + for (Graph.Vertex v : map1.keySet()) { + Graph.CostPathPair path1 = map1.get(v); + Graph.CostPathPair path2 = idealDirectedPath.get(v); + assertTrue("Dijstra's shortest path error. path1="+path1+" path2="+path2, path1.equals(path2)); + } + if (debug>0) System.out.println("Dijstra's shortest path worked correctly."); + + if (debug>0) System.out.println("Dijstra's shortest path of the directed graph from "+start.getValue()+" to "+end.getValue()+"."); + Graph.CostPathPair pair1 = Dijkstra.getShortestPath(directed.graph, start, end); + assertTrue("No path from "+start.getValue()+" to "+end.getValue(), (pair1!=null)); + + // Compare pair + assertTrue("Dijstra's shortest path error. pair1="+pair1+" idealPathPair="+idealPathPair, pair1.equals(idealPathPair)); + if (debug>0) System.out.println("Dijstra's shortest path worked correctly"); + } + + @Test + public void testBellmanFordDirected() { + Graph.Vertex start = directed.v1; + Graph.Vertex end = directed.v5; + + if (debug>0) System.out.println("Bellman-Ford's shortest paths of the directed graph from "+start.getValue()+" to all."); + Map, Graph.CostPathPair> map2 = BellmanFord.getShortestPaths(directed.graph, start); + if (debug>0) System.out.println(getPathMapString(start, map2)); + + // Compare results + for (Graph.Vertex v : map2.keySet()) { + Graph.CostPathPair path1 = map2.get(v); + Graph.CostPathPair path2 = idealDirectedPath.get(v); + assertTrue("Bellman-Ford's shortest path error. path1="+path1+" path2="+path2, path1.equals(path2)); + } + if (debug>0) System.out.println("Bellman-Ford's shortest path worked correctly."); + + if (debug>0) System.out.println("Bellman-Ford's shortest path of the directed graph from "+start.getValue()+" to "+end.getValue()+"."); + Graph.CostPathPair pair2 = BellmanFord.getShortestPath(directed.graph, start, end); + assertTrue("No path from "+start.getValue()+" to "+end.getValue(), pair2!=null); + + // Compare pair + assertTrue("Bellman-Ford's shortest path error. pair2="+pair2+" idealPathPair="+idealPathPair, pair2.equals(idealPathPair)); + if (debug>0) System.out.println("Bellman-Ford's shortest path worked correctly"); + } + + @Test + public void testDijstraDirectedWihtNegativeWeights() { + { // DIRECTED GRAPH (WITH NEGATIVE WEIGHTS) + if (debug > 0) System.out.println("Directed Graph with Negative Weights."); + + if (debug > 0) System.out.println(directedWithNegWeights.toString()); + + Graph.Vertex start = directedWithNegWeights.v1; + Graph.Vertex end = directedWithNegWeights.v3; + + if (debug > 0) System.out.println("Bellman-Ford's shortest paths of the directed graph with negative weight from " + start.getValue()+" to all."); + Map, Graph.CostPathPair> map1 = BellmanFord.getShortestPaths(directedWithNegWeights.graph, start); + if (debug > 0) System.out.println(getPathMapString(start, map1)); + + // Compare results + for (Graph.Vertex v : map1.keySet()) { + Graph.CostPathPair path1 = map1.get(v); + Graph.CostPathPair path2 = idealDirectedNegWeight.get(v); + assertTrue("Bellman-Ford's shortest path error. path1="+path1+" path2="+path2, path1.equals(path2)); + } + if (debug > 0) System.out.println("Bellman-Ford's shortest path worked correctly."); + + if (debug > 0) System.out.println("Bellman-Ford's shortest path of the directed graph from with negative weight " + start.getValue() + " to " + end.getValue()+ "."); + Graph.CostPathPair pair1 = BellmanFord.getShortestPath(directedWithNegWeights.graph, start, end); + assertTrue("No path from " + start.getValue() + " to " + end.getValue(), pair1 != null); + + // Compare pair + assertTrue("Bellman-Ford's shortest path error. pair1="+pair1+" result2="+idealDirectedWithNegWeightsPathPair, pair1.equals(idealDirectedWithNegWeightsPathPair)); + if (debug > 0) System.out.println("Bellman-Ford's shortest path worked correctly"); + } + } + + @Test + @SuppressWarnings("unchecked") + public void testJohnonsonsAllPairsShortestPathOnDirecteWithNegWeights() { + { + if (debug > 0) System.out.println("Johnson's all-pairs shortest path of the directed graph with negative weight."); + Map, Map, Set>>> path1 = Johnson.getAllPairsShortestPaths(directedWithNegWeights.graph); + if (debug > 0) System.out.println(getPathMapString(path1)); + assertTrue("Directed graph contains a negative weight cycle.", (path1 != null)); + + Map, Map, Set>>> result3 = new HashMap, Map, Set>>>(); + { + { // vertex 3 + Map, Set>> m = new HashMap, Set>>(); + Set> s3 = new LinkedHashSet>(); + m.put(directedWithNegWeights.v3, s3); + Set> s4 = new LinkedHashSet>(); + s4.add(directedWithNegWeights.e3_4); + m.put(directedWithNegWeights.v4, s4); + Set> s2 = new LinkedHashSet>(); + s2.add(directedWithNegWeights.e3_4); + s2.add(directedWithNegWeights.e4_2); + m.put(directedWithNegWeights.v2, s2); + Set> s1 = new LinkedHashSet>(); + s1.add(directedWithNegWeights.e3_1); + m.put(directedWithNegWeights.v1, s1); + result3.put(directedWithNegWeights.v3, m); + } + { // vertex 4 + Map, Set>> m = new HashMap, Set>>(); + Set> s3 = new LinkedHashSet>(); + s3.add(directedWithNegWeights.e4_2); + s3.add(directedWithNegWeights.e2_3); + m.put(directedWithNegWeights.v3, s3); + Set> s4 = new LinkedHashSet>(); + s4.add(directedWithNegWeights.e4_2); + s4.add(directedWithNegWeights.e2_3); + s4.add(directedWithNegWeights.e3_4); + m.put(directedWithNegWeights.v4, s4); + Set> s2 = new LinkedHashSet>(); + s2.add(directedWithNegWeights.e4_2); + m.put(directedWithNegWeights.v2, s2); + Set> s1 = new LinkedHashSet>(); + s1.add(directedWithNegWeights.e4_2); + s1.add(directedWithNegWeights.e2_1); + m.put(directedWithNegWeights.v1, s1); + result3.put(directedWithNegWeights.v4, m); + } + { // vertex 2 + Map, Set>> m = new HashMap, Set>>(); + Set> s3 = new LinkedHashSet>(); + s3.add(directedWithNegWeights.e2_3); + m.put(directedWithNegWeights.v3, s3); + Set> s4 = new LinkedHashSet>(); + s4.add(directedWithNegWeights.e2_1); + s4.add(directedWithNegWeights.e1_4); + m.put(directedWithNegWeights.v4, s4); + Set> s2 = new LinkedHashSet>(); + m.put(directedWithNegWeights.v2, s2); + Set> s1 = new LinkedHashSet>(); + s1.add(directedWithNegWeights.e2_1); + m.put(directedWithNegWeights.v1, s1); + result3.put(directedWithNegWeights.v2, m); + } + { // vertex 1 + Map, Set>> m = new HashMap, Set>>(); + Set> s3 = new LinkedHashSet>(); + s3.add(directedWithNegWeights.e1_4); + s3.add(directedWithNegWeights.e4_2); + s3.add(directedWithNegWeights.e2_3); + m.put(directedWithNegWeights.v3, s3); + Set> s4 = new LinkedHashSet>(); + s4.add(directedWithNegWeights.e1_4); + m.put(directedWithNegWeights.v4, s4); + Set> s2 = new LinkedHashSet>(); + s2.add(directedWithNegWeights.e1_4); + s2.add(directedWithNegWeights.e4_2); + m.put(directedWithNegWeights.v2, s2); + Set> s1 = new LinkedHashSet>(); + s1.add(directedWithNegWeights.e1_4); + m.put(directedWithNegWeights.v1, s1); + result3.put(directedWithNegWeights.v1, m); + } + } + + // Compare results + for (Vertex vertex1 : path1.keySet()) { + Map, Set>> m1 = path1.get(vertex1); + Map, Set>> m2 = result3.get(vertex1); + for (Vertex vertex2 : m1.keySet()) { + Set> set3 = m1.get(vertex2); + Set> set4 = m2.get(vertex2); + Object[] objs1 = set3.toArray(); + Object[] objs2 = set4.toArray(); + int size = objs1.length; + for (int i=0; i e1 = (Edge)objs1[i]; + Edge e2 = (Edge)objs2[i]; + assertTrue("Johnson's all-pairs shortest path error. e1.from="+e1.getFromVertex()+" e2.from="+e2.getFromVertex(), + e1.getFromVertex().equals(e2.getFromVertex())); + assertTrue("Johnson's all-pairs shortest path error. e1.to="+e1.getToVertex()+" e2.to="+e2.getToVertex(), + e1.getToVertex().equals(e2.getToVertex())); + } + } + } + if (debug > 0) System.out.println("Johnson's all-pairs shortest path worked correctly."); + } + } + + @Test + public void testFloydWarshallonDirectedWithNegWeights() { + { + if (debug > 0) System.out.println("Floyd-Warshall's all-pairs shortest path weights of the directed graph with negative weight."); + Map, Map, Integer>> pathWeights = FloydWarshall.getAllPairsShortestPaths(directedWithNegWeights.graph); + if (debug > 0) System.out.println(getWeightMapString(pathWeights)); + + Map, Map, Integer>> result4 = new HashMap, Map, Integer>>(); + { + // Ideal weights + { // Vertex 3 + Map, Integer> m = new HashMap, Integer>(); + { + // Vertex 3 + m.put(directedWithNegWeights.v3, 0); + // Vertex 4 + m.put(directedWithNegWeights.v4, 5); + // Vertex 2 + m.put(directedWithNegWeights.v2, -2); + // Vertex 1 + m.put(directedWithNegWeights.v1, 4); + } + result4.put(directedWithNegWeights.v3, m); + } + { // Vertex 4 + Map, Integer> m = new HashMap, Integer>(); + { + // Vertex 3 + m.put(directedWithNegWeights.v3, -4); + // Vertex 4 + m.put(directedWithNegWeights.v4, 0); + // Vertex 2 + m.put(directedWithNegWeights.v2, -7); + // Vertex 1 + m.put(directedWithNegWeights.v1, -1); + } + result4.put(directedWithNegWeights.v4, m); + } + { // Vertex 2 + Map, Integer> m = new HashMap, Integer>(); + { + // Vertex 3 + m.put(directedWithNegWeights.v3, 3); + // Vertex 4 + m.put(directedWithNegWeights.v4, 8); + // Vertex 2 + m.put(directedWithNegWeights.v2, 0); + // Vertex 1 + m.put(directedWithNegWeights.v1, 6); + } + result4.put(directedWithNegWeights.v2, m); + } + { // Vertex 1 + Map, Integer> m = new HashMap, Integer>(); + { + // Vertex 3 + m.put(directedWithNegWeights.v3, -2); + // Vertex 4 + m.put(directedWithNegWeights.v4, 2); + // Vertex 2 + m.put(directedWithNegWeights.v2, -5); + // Vertex 1 + m.put(directedWithNegWeights.v1, 0); + } + result4.put(directedWithNegWeights.v1, m); + } + } + + // Compare results + for (Vertex vertex1 : pathWeights.keySet()) { + Map, Integer> m1 = pathWeights.get(vertex1); + Map, Integer> m2 = result4.get(vertex1); + for (Vertex v : m1.keySet()) { + int i1 = m1.get(v); + int i2 = m2.get(v); + assertTrue("Floyd-Warshall's all-pairs shortest path weights error. i1="+i1+" i2="+i2, i1 == i2); + } + + } + if (debug > 0) System.out.println("Floyd-Warshall's all-pairs shortest path worked correctly."); + } + } + + @Test + public void cycleCheckOnUndirected() { + { // UNDIRECTED GRAPH + if (debug > 0) System.out.println("Undirected Graph cycle check."); + List> cycledVerticies = new ArrayList>(); + Graph.Vertex cv1 = new Graph.Vertex(1); + cycledVerticies.add(cv1); + Graph.Vertex cv2 = new Graph.Vertex(2); + cycledVerticies.add(cv2); + Graph.Vertex cv3 = new Graph.Vertex(3); + cycledVerticies.add(cv3); + Graph.Vertex cv4 = new Graph.Vertex(4); + cycledVerticies.add(cv4); + Graph.Vertex cv5 = new Graph.Vertex(5); + cycledVerticies.add(cv5); + Graph.Vertex cv6 = new Graph.Vertex(6); + cycledVerticies.add(cv6); + + List> cycledEdges = new ArrayList>(); + Graph.Edge ce1_2 = new Graph.Edge(7, cv1, cv2); + cycledEdges.add(ce1_2); + Graph.Edge ce2_4 = new Graph.Edge(15, cv2, cv4); + cycledEdges.add(ce2_4); + Graph.Edge ce3_4 = new Graph.Edge(11, cv3, cv4); + cycledEdges.add(ce3_4); + Graph.Edge ce3_6 = new Graph.Edge(2, cv3, cv6); + cycledEdges.add(ce3_6); + Graph.Edge ce5_6 = new Graph.Edge(9, cv5, cv6); + cycledEdges.add(ce5_6); + Graph.Edge ce4_5 = new Graph.Edge(6, cv4, cv5); + cycledEdges.add(ce4_5); + + Graph undirectedWithCycle = new Graph(cycledVerticies, cycledEdges); + if (debug > 0) System.out.println(undirectedWithCycle.toString()); + + if (debug > 0) System.out.println("Cycle detection of the undirected graph with a cycle."); + boolean result = CycleDetection.detect(undirectedWithCycle); + assertTrue("Cycle detection error.", result); + if (debug > 0) System.out.println("Cycle detection worked correctly."); + + List> verticies = new ArrayList>(); + Graph.Vertex v1 = new Graph.Vertex(1); + verticies.add(v1); + Graph.Vertex v2 = new Graph.Vertex(2); + verticies.add(v2); + Graph.Vertex v3 = new Graph.Vertex(3); + verticies.add(v3); + Graph.Vertex v4 = new Graph.Vertex(4); + verticies.add(v4); + Graph.Vertex v5 = new Graph.Vertex(5); + verticies.add(v5); + Graph.Vertex v6 = new Graph.Vertex(6); + verticies.add(v6); + + List> edges = new ArrayList>(); + Graph.Edge e1_2 = new Graph.Edge(7, v1, v2); + edges.add(e1_2); + Graph.Edge e2_4 = new Graph.Edge(15, v2, v4); + edges.add(e2_4); + Graph.Edge e3_4 = new Graph.Edge(11, v3, v4); + edges.add(e3_4); + Graph.Edge e3_6 = new Graph.Edge(2, v3, v6); + edges.add(e3_6); + Graph.Edge e4_5 = new Graph.Edge(6, v4, v5); + edges.add(e4_5); + + Graph undirectedWithoutCycle = new Graph(verticies, edges); + if (debug > 0) System.out.println(undirectedWithoutCycle.toString()); + + if (debug > 0) System.out.println("Cycle detection of the undirected graph without a cycle."); + result = CycleDetection.detect(undirectedWithoutCycle); + assertFalse("Cycle detection error.", result); + if (debug > 0) System.out.println("Cycle detection worked correctly."); + } + } + + @SuppressWarnings("unchecked") + @Test + public void topologicalSortOnDirectedGraph() { + { // DIRECTED GRAPH + if (debug > 0) System.out.println("Directed Graph topological sort."); + List> verticies = new ArrayList>(); + Graph.Vertex cv1 = new Graph.Vertex(1); + verticies.add(cv1); + Graph.Vertex cv2 = new Graph.Vertex(2); + verticies.add(cv2); + Graph.Vertex cv3 = new Graph.Vertex(3); + verticies.add(cv3); + Graph.Vertex cv4 = new Graph.Vertex(4); + verticies.add(cv4); + Graph.Vertex cv5 = new Graph.Vertex(5); + verticies.add(cv5); + Graph.Vertex cv6 = new Graph.Vertex(6); + verticies.add(cv6); + + List> edges = new ArrayList>(); + Graph.Edge ce1_2 = new Graph.Edge(1, cv1, cv2); + edges.add(ce1_2); + Graph.Edge ce2_4 = new Graph.Edge(2, cv2, cv4); + edges.add(ce2_4); + Graph.Edge ce4_3 = new Graph.Edge(3, cv4, cv3); + edges.add(ce4_3); + Graph.Edge ce3_6 = new Graph.Edge(4, cv3, cv6); + edges.add(ce3_6); + Graph.Edge ce5_6 = new Graph.Edge(5, cv5, cv6); + edges.add(ce5_6); + Graph.Edge ce4_5 = new Graph.Edge(6, cv4, cv5); + edges.add(ce4_5); + + Graph directed = new Graph(Graph.TYPE.DIRECTED, verticies, edges); + if (debug > 0) System.out.println(directed.toString()); + + System.out.println("Topological sort of the directed graph."); + List> results = TopologicalSort.sort(directed); + if (debug > 0) System.out.println("result=" + results); + assertTrue("Topological sort error. results="+results, results.size()!=0); + + List> results2 = new ArrayList>(results.size()); + { // Ideal sort + results2.add(cv6); + results2.add(cv3); + results2.add(cv5); + results2.add(cv4); + results2.add(cv2); + results2.add(cv1); + } + + // Compare results + { + Object[] objs1 = results.toArray(); + Object[] objs2 = results2.toArray(); + int size = objs1.length; + for (int i=0; i v1 = (Graph.Vertex) objs1[i]; + Graph.Vertex v2 = (Graph.Vertex) objs2[i]; + assertTrue("Topological sort error. v1="+v1+" v2", v1.equals(v2)); + } + } + if (debug > 0) System.out.println("Topological sort worked correctly."); + + if (debug > 0) System.out.println(); + } + } + + private static final String getPathMapString(Graph.Vertex start, Map, Graph.CostPathPair> map) { + StringBuilder builder = new StringBuilder(); + for (Graph.Vertex v : map.keySet()) { + Graph.CostPathPair pair = map.get(v); + builder.append("From ").append(start.getValue()).append(" to vertex=").append(v.getValue()).append("\n"); + if (pair != null) + builder.append(pair.toString()).append("\n"); + + } + return builder.toString(); + } + + private static final String getPathMapString(Map, Map, Set>>> paths) { + StringBuilder builder = new StringBuilder(); + for (Graph.Vertex v : paths.keySet()) { + Map, Set>> map = paths.get(v); + for (Graph.Vertex v2 : map.keySet()) { + builder.append("From=").append(v.getValue()).append(" to=").append(v2.getValue()).append("\n"); + Set> path = map.get(v2); + builder.append(path).append("\n"); + } + } + return builder.toString(); + } + + private static final String getWeightMapString(Map, Map, Integer>> paths) { + StringBuilder builder = new StringBuilder(); + for (Graph.Vertex v : paths.keySet()) { + Map, Integer> map = paths.get(v); + for (Graph.Vertex v2 : map.keySet()) { + builder.append("From=").append(v.getValue()).append(" to=").append(v2.getValue()).append("\n"); + Integer weight = map.get(v2); + builder.append(weight).append("\n"); + } + } + return builder.toString(); + } +} diff --git a/src/com/jwetherell/algorithms/mathematics/Distance.java b/src/com/jwetherell/algorithms/mathematics/Distance.java index 8a4b310e..ef8e47ee 100644 --- a/src/com/jwetherell/algorithms/mathematics/Distance.java +++ b/src/com/jwetherell/algorithms/mathematics/Distance.java @@ -2,8 +2,7 @@ public class Distance { - private Distance() { - } + private Distance() { } /* * Chess distance @@ -13,7 +12,7 @@ public static final long chebyshevDistance(long[] point1, long[] point2) { long y1 = point1[1]; long x2 = point2[0]; long y2 = point2[1]; - return (int) Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2)); + return Math.max(Math.abs(x1 - x2), Math.abs(y1 - y2)); } public static final double squaredDistance(double x1, double y1, double x2, double y2) { diff --git a/src/com/jwetherell/algorithms/mathematics/Primes.java b/src/com/jwetherell/algorithms/mathematics/Primes.java index b633f0d3..a694b0ac 100644 --- a/src/com/jwetherell/algorithms/mathematics/Primes.java +++ b/src/com/jwetherell/algorithms/mathematics/Primes.java @@ -1,5 +1,6 @@ package com.jwetherell.algorithms.mathematics; +import java.util.Arrays; import java.util.HashMap; import java.util.Map; @@ -74,13 +75,15 @@ public static final boolean isPrime(long value) { public static final boolean sieveOfEratosthenes(int number) { if (sieve == null || number >= sieve.length) { int start = 2; - if (sieve == null) - sieve = new boolean[number]; - else - start = sieve.length; - for (int i = start; Math.pow(i, 2) < sieve.length; i++) { + if (sieve == null) { + sieve = new boolean[number+1]; + } else if (number >= sieve.length) { + sieve = Arrays.copyOf(sieve, number+1); + } + + for (int i = start; i < Math.sqrt(number); i++) { if (!sieve[i]) { - for (int j = (int) Math.pow(i, 2); j < sieve.length; j += i) { + for (int j = i*2; j <= number; j += i) { sieve[j] = true; } } diff --git a/src/com/jwetherell/algorithms/mathematics/test/Mathematics.java b/src/com/jwetherell/algorithms/mathematics/test/Mathematics.java new file mode 100644 index 00000000..05375d84 --- /dev/null +++ b/src/com/jwetherell/algorithms/mathematics/test/Mathematics.java @@ -0,0 +1,179 @@ +package com.jwetherell.algorithms.mathematics.test; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.HashMap; +import java.util.Map; +import java.util.Random; + +import org.junit.Test; + +import com.jwetherell.algorithms.mathematics.Distance; +import com.jwetherell.algorithms.mathematics.Division; +import com.jwetherell.algorithms.mathematics.Knapsack; +import com.jwetherell.algorithms.mathematics.Multiplication; +import com.jwetherell.algorithms.mathematics.Primes; + +public class Mathematics { + + private static final int MIN = 1; + private static final int MAX = 1000; + + private static final Random RANDOM = new Random(); + private static int nextRandomInt(int min, int max) { + // nextInt is normally exclusive of the top value, + // so add 1 to make it inclusive + return RANDOM.nextInt((max - min) + 1) + min; + } + + @Test + public void multiplication() { + int a = nextRandomInt(MIN, MAX); + int b = nextRandomInt(MIN, MAX); + long result = Multiplication.multiplyUsingLoop(a, b); + long check = Multiplication.multiplication(a, b); + assertTrue("Multiplication using a loop. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Multiplication.multiplyUsingRecursion(a, b); + check = Multiplication.multiplication(a, b); + assertTrue("Multiplication using recursion. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Multiplication.multiplyUsingShift(a, b); + check = Multiplication.multiplication(a, b); + assertTrue("Multiplication using shifts. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Multiplication.multiplyUsingLogs(a, b); + check = Multiplication.multiplication(a, b); + assertTrue("Multiplication using logs. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + } + + @Test + public void division() { + int a = nextRandomInt(MIN, MAX); + int b = nextRandomInt(a, MAX); + long result = Division.divisionUsingLoop(a, b); + long check = Division.division(a, b); + assertTrue("Division using a loop. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Division.divisionUsingRecursion(a, b); + check = Division.division(a, b); + assertTrue("Division using recursion. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Division.divisionUsingShift(a, b); + check = Division.division(a, b); + assertTrue("Division using shifts. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Division.divisionUsingLogs(a, b); + check = Division.division(a, b); + assertTrue("Division using logs. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + + result = Division.divisionUsingMultiplication(a, b); + check = Division.division(a, b); + assertTrue("Division using multiplication. a=" + a + " b=" + b + " result=" + result + " check=" + check, (result == check)); + } + + @Test + public void knapsack() { + int[] values = { 7, 4, 8, 6, 2, 5 }; + int[] weights = { 2, 3, 5, 4, 2, 3 }; + int capacity = 9; + int[] result = Knapsack.zeroOneKnapsack(values, weights, capacity); + int[] check = new int[]{5,3,0}; + for (int i=0; i Integer.MIN_VALUE. number="+x); StringBuilder builder = new StringBuilder(); if (x==0) { //Zero is a special case @@ -195,6 +201,7 @@ public static final String toEnglish(int x) { boolean thousand = false; if (x<0) { builder.append("negative "); + // Make the number positive x = x * -1; } int m = x / BILLION; diff --git a/src/com/jwetherell/algorithms/numbers/Longs.java b/src/com/jwetherell/algorithms/numbers/Longs.java index dc642a85..ac38f2a9 100644 --- a/src/com/jwetherell/algorithms/numbers/Longs.java +++ b/src/com/jwetherell/algorithms/numbers/Longs.java @@ -5,6 +5,7 @@ public class Longs { public static final String toBinaryUsingDivideAndModulus(long longNumber) { + if (longNumber<0) throw new IllegalArgumentException("Method argument cannot be negative. number="+longNumber); StringBuilder builder = new StringBuilder(); long temp = 0l; while (longNumber > 0) { @@ -16,6 +17,7 @@ public static final String toBinaryUsingDivideAndModulus(long longNumber) { } public static final String toBinaryUsingShiftsAndModulus(long longNumber) { + if (longNumber<0) throw new IllegalArgumentException("Method argument cannot be negative. number="+longNumber); StringBuilder builder = new StringBuilder(); long temp = 0l; while (longNumber > 0) { @@ -27,6 +29,7 @@ public static final String toBinaryUsingShiftsAndModulus(long longNumber) { } public static final String toBinaryUsingBigDecimal(long longNumber) { + if (longNumber<0) throw new IllegalArgumentException("Method argument cannot be negative. number="+longNumber); StringBuilder builder = new StringBuilder(); BigDecimal zero = new BigDecimal(0); BigDecimal two = new BigDecimal(2); diff --git a/src/com/jwetherell/algorithms/numbers/test/Numbers.java b/src/com/jwetherell/algorithms/numbers/test/Numbers.java new file mode 100644 index 00000000..547c9024 --- /dev/null +++ b/src/com/jwetherell/algorithms/numbers/test/Numbers.java @@ -0,0 +1,129 @@ +package com.jwetherell.algorithms.numbers.test; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.Random; + +import org.junit.Test; + +import com.jwetherell.algorithms.numbers.Integers; +import com.jwetherell.algorithms.numbers.Longs; + +public class Numbers { + + private static final Random RANDOM = new Random(); + + @Test + public void testGCD() { + int x = 1989; + int y = 867; + int gcd = Integers.euclidsGreatestCommonDivsor(x, y); + int check = 51; + assertTrue("Euclids GCD error. expected="+check+" got="+gcd, (gcd==check)); + + x = 567; + y = 56; + gcd = Integers.euclidsGreatestCommonDivsor(x, y); + check = 7; + assertTrue("Euclids GCD error. expected="+check+" got="+gcd, (gcd==check)); + + x = 10002345; + y = 67885; + gcd = Integers.euclidsGreatestCommonDivsor(x, y); + check = 5; + assertTrue("Euclids GCD error. expected="+check+" got="+gcd, (gcd==check)); + } + + @Test + public void testPowerOf2() { + int is = 256; + int isNot = 1673; + + boolean isPowOf2is = Integers.powerOfTwoUsingBits(is); + boolean isPowOf2isNot = Integers.powerOfTwoUsingBits(isNot); + assertTrue("Is power of 2 using bits error", isPowOf2is); + assertFalse("Is power of 2 using bits error", isPowOf2isNot); + + isPowOf2is = Integers.powerOfTwoUsingLog(is); + isPowOf2isNot = Integers.powerOfTwoUsingLog(isNot); + assertTrue("Is power of 2 using logarithm error", isPowOf2is); + assertFalse("Is power of 2 using logarithm error", isPowOf2isNot); + + isPowOf2is = Integers.powerOfTwoUsingLoop(is); + isPowOf2isNot = Integers.powerOfTwoUsingLoop(isNot); + assertTrue("Is power of 2 using loops error", isPowOf2is); + assertFalse("Is power of 2 using loops error", isPowOf2isNot); + + isPowOf2is = Integers.powerOfTwoUsingRecursion(is); + isPowOf2isNot = Integers.powerOfTwoUsingRecursion(isNot); + assertTrue("Is power of 2 using recursion error", isPowOf2is); + assertFalse("Is power of 2 using recursion error", isPowOf2isNot); + } + + @Test + public void testIntegerToBinaryString() { + int a = Math.abs(RANDOM.nextInt()); + String check = Integer.toBinaryString(a); + + String result1 = Integers.toBinaryUsingBigDecimal(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot=\n"+result1+"\n", (check.equals(result1))); + + String result2 = Integers.toBinaryUsingDivideAndDouble(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot="+result2+"\n", (check.equals(result2))); + + String result3 = Integers.toBinaryUsingDivideAndModulus(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot="+result3+"\n", (check.equals(result3))); + + String result4 = Integers.toBinaryUsingShiftsAndModulus(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot="+result4+"\n", (check.equals(result4))); + } + + @Test + public void testLongToBinaryString() { + long a = Math.abs(RANDOM.nextLong()); + String check = Long.toBinaryString(a); + + String result1 = Longs.toBinaryUsingBigDecimal(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot=\n"+result1+"\n", (check.equals(result1))); + + String result2 = Longs.toBinaryUsingDivideAndModulus(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot=\n"+result2+"\n", (check.equals(result2))); + + String result3 = Longs.toBinaryUsingShiftsAndModulus(a); + assertTrue("toBinary using BigDecimal error. random="+a+" expected=\n"+check+"\ngot=\n"+result3+"\n", (check.equals(result3))); + } + + @Test + public void testToEnglish() { + int a = -1001; + String check = "negative one-thousand one"; + String english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + + a = -1; + check = "negative one"; + english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + + a = 0; + check = "zero"; + english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + + a = 199; + check = "one-hundred ninty-nine"; + english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + + a = Integer.MAX_VALUE; // 2,147,483,647 + check = "two-billion one-hundred fourty-seven-million four-hundred eighty-three-thousand six-hundred fourty-seven"; + english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + + a = Integer.MIN_VALUE+1; // -2,147,483,647 + check = "negative two-billion one-hundred fourty-seven-million four-hundred eighty-three-thousand six-hundred fourty-seven"; + english = Integers.toEnglish(a); + assertTrue("toEnglish error. a="+a+" expected="+check+" got="+english, (check.equals(english))); + } +} diff --git a/src/com/jwetherell/algorithms/Numbers.java b/src/com/jwetherell/algorithms/numbers/timing/NumbersTiming.java similarity index 68% rename from src/com/jwetherell/algorithms/Numbers.java rename to src/com/jwetherell/algorithms/numbers/timing/NumbersTiming.java index feb6d594..3f0b539e 100644 --- a/src/com/jwetherell/algorithms/Numbers.java +++ b/src/com/jwetherell/algorithms/numbers/timing/NumbersTiming.java @@ -1,11 +1,11 @@ -package com.jwetherell.algorithms; +package com.jwetherell.algorithms.numbers.timing; import java.text.DecimalFormat; import com.jwetherell.algorithms.numbers.Integers; import com.jwetherell.algorithms.numbers.Longs; -public class Numbers { +public class NumbersTiming { private static final DecimalFormat FORMAT = new DecimalFormat("#.######"); @@ -15,84 +15,78 @@ public static void main(String[] args) { int a = Integer.MAX_VALUE; System.out.println("Integer to binary string using division and modulus."); long before = System.nanoTime(); - String result = Integers.toBinaryUsingDivideAndModulus(a); + Integers.toBinaryUsingDivideAndModulus(a); long after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Integer to binary string using shifts and modulus."); before = System.nanoTime(); - result = Integers.toBinaryUsingShiftsAndModulus(a); + Integers.toBinaryUsingShiftsAndModulus(a); after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Integer to binary string using BigDecimal."); before = System.nanoTime(); - result = Integers.toBinaryUsingBigDecimal(a); + Integers.toBinaryUsingBigDecimal(a); after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Integer to binary string using divide and double."); before = System.nanoTime(); - result = Integers.toBinaryUsingDivideAndDouble(a); + Integers.toBinaryUsingDivideAndDouble(a); after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Euclid's Greatest Common Divisor."); int x = 1989; int y = 867; before = System.nanoTime(); - int gcd = Integers.euclidsGreatestCommonDivsor(x, y); + Integers.euclidsGreatestCommonDivsor(x, y); after = System.nanoTime(); - System.out.println("x=" + x + " " + "y=" + y + " " + gcd); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); a = (int) Math.pow(2, 30); System.out.println("Power of 2 using loop."); before = System.nanoTime(); - boolean isPowOf2 = Integers.powerOfTwoUsingLoop(a); + Integers.powerOfTwoUsingLoop(a); after = System.nanoTime(); - System.out.println("a=" + a + " is a power of 2? " + isPowOf2); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Power of 2 using recursion."); before = System.nanoTime(); - isPowOf2 = Integers.powerOfTwoUsingRecursion(a); + Integers.powerOfTwoUsingRecursion(a); after = System.nanoTime(); - System.out.println("a=" + a + " is a power of 2? " + isPowOf2); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Power of 2 using logarithm."); before = System.nanoTime(); - isPowOf2 = Integers.powerOfTwoUsingLog(a); + Integers.powerOfTwoUsingLog(a); after = System.nanoTime(); - System.out.println("a=" + a + " is a power of 2? " + isPowOf2); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Power of 2 using bits."); before = System.nanoTime(); - isPowOf2 = Integers.powerOfTwoUsingBits(a); + Integers.powerOfTwoUsingBits(a); after = System.nanoTime(); - System.out.println("a=" + a + " is a power of 2? " + isPowOf2); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); - System.gc(); - - System.out.println("Integer to English"); - for (int i=-1001; i<=1001; i++) { - System.out.println(Integers.toEnglish(i)); - } System.out.println(); + System.gc(); } // Longs @@ -100,26 +94,26 @@ public static void main(String[] args) { long a = Long.MAX_VALUE; System.out.println("Long to binary string using division and modulus."); long before = System.nanoTime(); - String result = Longs.toBinaryUsingDivideAndModulus(a); + Longs.toBinaryUsingDivideAndModulus(a); long after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Long to binary string using shifts and modulus."); before = System.nanoTime(); - result = Longs.toBinaryUsingShiftsAndModulus(a); + Longs.toBinaryUsingShiftsAndModulus(a); after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Long to binary string using BigDecimal."); before = System.nanoTime(); - result = Longs.toBinaryUsingBigDecimal(a); + Longs.toBinaryUsingBigDecimal(a); after = System.nanoTime(); - System.out.println("a=" + a + " " + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); } } diff --git a/src/com/jwetherell/algorithms/search/BinarySearch.java b/src/com/jwetherell/algorithms/search/BinarySearch.java index 5c731430..7ec85d01 100644 --- a/src/com/jwetherell/algorithms/search/BinarySearch.java +++ b/src/com/jwetherell/algorithms/search/BinarySearch.java @@ -19,8 +19,9 @@ public static final int find(int value, int[] array, boolean optimize) { private static int recursiveFind(int value, int start, int end, boolean optimize) { if (start == end) { int lastValue = sorted[start]; // start==end - if (value == lastValue) + if (value == lastValue) { return start; // start==end + } return Integer.MAX_VALUE; } @@ -29,23 +30,27 @@ private static int recursiveFind(int value, int start, int end, boolean optimize int middle = low + ((high - low) / 2); int middleValue = sorted[middle]; - if (value == middleValue) + if (value == middleValue) { return middle; + } if (value > middleValue) { - if (optimize && (end - middle) <= SWITCH_TO_BRUTE_FORCE) + if (optimize && (end - middle) <= SWITCH_TO_BRUTE_FORCE) { return linearSearch(value, middle + 1, end); + } return recursiveFind(value, middle + 1, end, optimize); } - if (optimize && (end - middle) <= SWITCH_TO_BRUTE_FORCE) + if (optimize && (end - middle) <= SWITCH_TO_BRUTE_FORCE) { return linearSearch(value, start, middle - 1); + } return recursiveFind(value, start, middle - 1, optimize); } private static final int linearSearch(int value, int start, int end) { for (int i = start; i <= end; i++) { int iValue = sorted[i]; - if (value == iValue) + if (value == iValue) { return i; + } } return Integer.MAX_VALUE; } diff --git a/src/com/jwetherell/algorithms/search/test/Search.java b/src/com/jwetherell/algorithms/search/test/Search.java new file mode 100644 index 00000000..39d94d8d --- /dev/null +++ b/src/com/jwetherell/algorithms/search/test/Search.java @@ -0,0 +1,66 @@ +package com.jwetherell.algorithms.search.test; + +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +import com.jwetherell.algorithms.search.BinarySearch; +import com.jwetherell.algorithms.search.InterpolationSearch; +import com.jwetherell.algorithms.search.LinearSearch; +import com.jwetherell.algorithms.search.QuickSelect; + +public class Search { + + private static final int SIZE = 9999; + private static final int offset = 123; + + private static int[] sorted = new int[SIZE]; + static { + for (int i = offset; i> void sortHeap(T[] unsorted) { while (true) { int left = (i * 2) + 1; if (left >= index) // node has no left child + { break; + } int right = left + 1; - if (right >= index) { // node has a left child, but no right - // child - if (unsorted[left].compareTo(unsorted[i]) > 0) - swap(left, i, unsorted); // if - // left - // child - // is - // greater - // than - // node + if (right >= index) { // node has a left child, but no right child + if (unsorted[left].compareTo(unsorted[i]) > 0) { + swap(left, i, unsorted); // if left child is greater than node + } break; } T ithElement = unsorted[i]; T leftElement = unsorted[left]; T rightElement = unsorted[right]; if (ithElement.compareTo(leftElement) < 0) { // (left > i) - if (unsorted[left].compareTo(rightElement) > 0) { // (left > - // right) + if (unsorted[left].compareTo(rightElement) > 0) { // (left > right) swap(left, i, unsorted); i = left; continue; diff --git a/src/com/jwetherell/algorithms/sorts/InsertionSort.java b/src/com/jwetherell/algorithms/sorts/InsertionSort.java index e29fc521..c402d8d3 100644 --- a/src/com/jwetherell/algorithms/sorts/InsertionSort.java +++ b/src/com/jwetherell/algorithms/sorts/InsertionSort.java @@ -4,7 +4,11 @@ * Insertion sort is a simple sorting algorithm: a comparison sort in which the * sorted array (or list) is built one entry at a time. It is much less * efficient on large lists than more advanced algorithms such as quicksort, - * heapsort, or merge sort. Family: Insertion. Space: In-place. Stable: True. + * heapsort, or merge sort. + * + * Family: Insertion. + * Space: In-place. + * Stable: True. * * Average case = O(n^2) Worst case = O(n^2) Best case = O(n) * diff --git a/src/com/jwetherell/algorithms/sorts/MergeSort.java b/src/com/jwetherell/algorithms/sorts/MergeSort.java index 38ffcced..0e3e174b 100644 --- a/src/com/jwetherell/algorithms/sorts/MergeSort.java +++ b/src/com/jwetherell/algorithms/sorts/MergeSort.java @@ -3,8 +3,11 @@ /** * Merge sort is an O(n log n) comparison-based sorting algorithm. Most * implementations produce a stable sort, which means that the implementation - * preserves the input order of equal elements in the sorted output. Family: - * Merging. Space: In-place. Stable: True. + * preserves the input order of equal elements in the sorted output. + * + * Family: Merging. + * Space: In-place. + * Stable: True. * * Average case = O(n*log n) Worst case = O(n*log n) Best case = O(n*log n) * diff --git a/src/com/jwetherell/algorithms/sorts/QuickSort.java b/src/com/jwetherell/algorithms/sorts/QuickSort.java index e7593270..1be2c4c2 100644 --- a/src/com/jwetherell/algorithms/sorts/QuickSort.java +++ b/src/com/jwetherell/algorithms/sorts/QuickSort.java @@ -3,10 +3,13 @@ import java.util.Random; /** - * Quicksort is a sorting algorithm which, on average, makes comparisons to sort - * n items. In the worst case, it makes comparisons, though this behavior is - * rare. Quicksort is often faster in practice than other algorithms. Family: - * Divide and conquer. Space: In-place. Stable: False. + * Quicksort is a sorting algorithm which, on average, makes O(n*log n) comparisons to sort + * n items. In the worst case, it makes O(n^2) comparisons, though this behavior is + * rare. Quicksort is often faster in practice than other algorithms. + * + * Family: Divide and conquer. + * Space: In-place. + * Stable: False. * * Average case = O(n) Worst case = O(n^2) Best case = O(n*log n) * diff --git a/src/com/jwetherell/algorithms/sorts/RadixSort.java b/src/com/jwetherell/algorithms/sorts/RadixSort.java index 9506c0f7..df0b00fa 100644 --- a/src/com/jwetherell/algorithms/sorts/RadixSort.java +++ b/src/com/jwetherell/algorithms/sorts/RadixSort.java @@ -8,11 +8,14 @@ * same significant position and value. A positional notation is required, but * because integers can represent strings of characters (e.g., names or dates) * and specially formatted floating point numbers, radix sort is not limited to - * integers. Family: Bucket. Space: 10 Buckets with at most n integers per - * bucket. Stable: True. + * integers. * - * Average case = O(n*k) Worst case = O(n*k) Best case = O(n*k) NOTE: n is the - * number of digits and k is the average bucket size + * Family: Bucket. + * Space: 10 Buckets with at most n integers per bucket. + * Stable: True. + * + * Average case = O(n*k) Worst case = O(n*k) Best case = O(n*k) + * NOTE: n is the number of digits and k is the average bucket size * * http://en.wikipedia.org/wiki/Radix_sort * @@ -28,10 +31,8 @@ private RadixSort() { public static Integer[] sort(Integer[] unsorted) { int[][] buckets = new int[NUMBER_OF_BUCKETS][10]; for (int i = 0; i < NUMBER_OF_BUCKETS; i++) - buckets[i][0] = 1; // Size is one since the size is stored in first - // element - int numberOfDigits = getMaxNumberOfDigits(unsorted); // Max number of - // digits + buckets[i][0] = 1; // Size is one since the size is stored in first element + int numberOfDigits = getMaxNumberOfDigits(unsorted); // Max number of digits int divisor = 1; for (int n = 0; n < numberOfDigits; n++) { int digit = 0; diff --git a/src/com/jwetherell/algorithms/sorts/test/Sorts.java b/src/com/jwetherell/algorithms/sorts/test/Sorts.java new file mode 100644 index 00000000..598d74d1 --- /dev/null +++ b/src/com/jwetherell/algorithms/sorts/test/Sorts.java @@ -0,0 +1,183 @@ +package com.jwetherell.algorithms.sorts.test; + +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; +import java.util.Random; + +import com.sun.deploy.util.ArrayUtil; +import org.junit.Test; + +import com.jwetherell.algorithms.sorts.AmericanFlagSort; +import com.jwetherell.algorithms.sorts.BubbleSort; +import com.jwetherell.algorithms.sorts.CountingSort; +import com.jwetherell.algorithms.sorts.HeapSort; +import com.jwetherell.algorithms.sorts.InsertionSort; +import com.jwetherell.algorithms.sorts.MergeSort; +import com.jwetherell.algorithms.sorts.QuickSort; +import com.jwetherell.algorithms.sorts.RadixSort; +import com.jwetherell.algorithms.sorts.ShellSort; + +public class Sorts { + + private static final Random RANDOM = new Random(); + private static final int SIZE = 10; + + private static Integer[] unsorted = null; + private static Integer[] sorted = null; + private static Integer[] reverse = null; + + static { + unsorted = new Integer[SIZE]; + int i = 0; + while (i < unsorted.length) { + int j = RANDOM.nextInt(unsorted.length * 10); + unsorted[i++] = j; + } + + sorted = new Integer[SIZE]; + for (i = 0; i < sorted.length; i++) { + sorted[i] = i; + } + + reverse = new Integer[SIZE]; + for (i = (reverse.length - 1); i >= 0; i--) { + reverse[i] = (SIZE - 1) - i; + } + } + + @Test + public void testInsertionSorts() { + // Insertion sort + Integer[] result = InsertionSort.sort(unsorted.clone()); + System.out.println(Arrays.toString(result)); + result = InsertionSort.sort(sorted.clone()); + assertTrue("Inerstion sort sorted error. result="+print(result), check(result)); + result = InsertionSort.sort(reverse.clone()); + assertTrue("Inerstion sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testBubbleSorts() { + // Bubble sort + Integer[] result = BubbleSort.sort(unsorted.clone()); + assertTrue("Bubble sort unsorted error. result="+print(result), check(result)); + result = BubbleSort.sort(sorted.clone()); + assertTrue("Bubble sort sorted error. result="+print(result), check(result)); + result = BubbleSort.sort(reverse.clone()); + assertTrue("Bubble sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testShellsSorts() { + int[] shells = new int[] { 10, 5, 3, 1 }; + // Shell's sort + Integer[] result = ShellSort.sort(shells, unsorted.clone()); + assertTrue("Shell's sort unsorted error. result="+print(result), check(result)); + result = ShellSort.sort(shells, sorted.clone()); + assertTrue("Shell's sort sorted error. result="+print(result), check(result)); + result = ShellSort.sort(shells, reverse.clone()); + assertTrue("Shell's sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testMergeSorts() { + // Merge sort + Integer[] result = MergeSort.sort(unsorted.clone()); + assertTrue("Merge sort unsorted error. result="+print(result), check(result)); + result = MergeSort.sort(sorted.clone()); + assertTrue("Merge sort sorted error. result="+print(result), check(result)); + result = MergeSort.sort(reverse.clone()); + assertTrue("merge sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testQuickSorts() { + // Quicksort + Integer[] result = QuickSort.sort(QuickSort.PIVOT_TYPE.FIRST, unsorted.clone()); + assertTrue("Quick sort pivot firt unsorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.FIRST, sorted.clone()); + assertTrue("Quick sort pivot firt sorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.FIRST, reverse.clone()); + assertTrue("Quick sort pivot firt reverse error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.MIDDLE, unsorted.clone()); + assertTrue("Quick sort pivot middle unsorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.MIDDLE, sorted.clone()); + assertTrue("Quick sort pivot middle sorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.MIDDLE, reverse.clone()); + assertTrue("Quick sort pivot middle reverse error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.RANDOM, unsorted.clone()); + assertTrue("Quick sort pivot random unsorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.RANDOM, sorted.clone()); + assertTrue("Quick sort pivot random sorted error. result="+print(result), check(result)); + result = QuickSort.sort(QuickSort.PIVOT_TYPE.RANDOM, reverse.clone()); + assertTrue("Quick sort pivot random reverse error. result="+print(result), check(result)); + } + + @Test + public void testHeapSorts() { + // Heapsort + Integer[] result = HeapSort.sort(unsorted.clone()); + assertTrue("Heap sort unsorted error. result="+print(result), check(result)); + result = HeapSort.sort(sorted.clone()); + assertTrue("Heap sort sorted error. result="+print(result), check(result)); + result = HeapSort.sort(reverse.clone()); + assertTrue("Heap sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testCountingSorts() { + // Counting sort + Integer[] result = CountingSort.sort(unsorted.clone()); + assertTrue("Counting sort unsorted error. result="+print(result), check(result)); + result = CountingSort.sort(sorted.clone()); + assertTrue("Counting sort sorted error. result="+print(result), check(result)); + result = CountingSort.sort(reverse.clone()); + assertTrue("Counting sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testRadixSorts() { + // Radix sort + Integer[] result = RadixSort.sort(unsorted.clone()); + assertTrue("Radix sort unsorted error. result="+print(result), check(result)); + result = RadixSort.sort(sorted.clone()); + assertTrue("Radix sort sorted error. result="+print(result), check(result)); + result = RadixSort.sort(reverse.clone()); + assertTrue("Radix sort reverse error. result="+print(result), check(result)); + } + + @Test + public void testAmericanFlagSorts() { + // American Flag sort + Integer[] result = AmericanFlagSort.sort(unsorted.clone()); + assertTrue("American flag sort unsorted error. result="+print(result), check(result)); + result = AmericanFlagSort.sort(sorted.clone()); + assertTrue("American flag sort sorted error. result="+print(result), check(result)); + result = AmericanFlagSort.sort(reverse.clone()); + assertTrue("American flag sort reverse error. result="+print(result), check(result)); + } + + private static final boolean check(Integer[] array) { + for (int i = 1; iarray[i]) { + return false; + } + } + return true; + } + + private static final String print(Integer[] array) { + return print(array, 0, array.length); + } + + private static final String print(Integer[] array, int start, int length) { + final Integer[] clone = array.clone(); + StringBuilder builder = new StringBuilder(); + for (int i = 0; i= 0; i--) { - builder.append(temp[i]); + builder.append(temp[i]).append(' '); } - return builder.toString(); + return builder.toString().trim(); } public static final String reverseWordsInPlace(String string) { diff --git a/src/com/jwetherell/algorithms/strings/test/Strings.java b/src/com/jwetherell/algorithms/strings/test/Strings.java new file mode 100644 index 00000000..b52a11aa --- /dev/null +++ b/src/com/jwetherell/algorithms/strings/test/Strings.java @@ -0,0 +1,97 @@ +package com.jwetherell.algorithms.strings.test; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; + +import org.junit.Test; + +import com.jwetherell.algorithms.strings.StringFunctions; + +public class Strings { + + @Test + public void testReverseCharsInString() { + // REVERSE CHARS IN A STRING + String string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; + String check = "zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA"; + String result = StringFunctions.reverseWithStringConcat(string); + assertTrue("Reverse With String Concat error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWithStringBuilder(string); + assertTrue("Reverse With String String Builder error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWithStringBuilderBuiltinMethod(string); + assertTrue("Reverse With Built-in error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWithSwaps(string); + assertTrue("Reverse With Swaps error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWithXOR(string); + assertTrue("Reverse With XOR error. expect="+check+" got="+result, check.equals(result)); + } + + @Test + public void testReverseWordsInString() { + // REVERSE WORDS IN A STRING + String string = "Could you pretty please reverse this sentence"; + String check = "sentence this reverse please pretty you Could"; + String result = StringFunctions.reverseWordsByCharWithAdditionalStorage(string); + assertTrue("Reverse Words By Char w/ Additional Storage error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWordsUsingStringTokenizerWithAdditionalStorage(string); + assertTrue("Reverse Words Using String Tokenizer w/ Additional Storage error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWordsUsingSplitWithAdditionalStorage(string); + assertTrue("Reverse Words Using Split w/ Additional Storage error. expect="+check+" got="+result, check.equals(result)); + + result = StringFunctions.reverseWordsInPlace(string); + assertTrue("Reverse Words In-Place error. expect="+check+" got="+result, check.equals(result)); + } + + @Test + public void testIsPalinDrone() { + // PALINDROME + String string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; + boolean result = StringFunctions.isPalindromeWithAdditionalStorage(string); + assertFalse("Is Palindrome With Additional Storage error. expected=false got="+result, result); + + result = StringFunctions.isPalindromeInPlace(string); + assertFalse("Is Palindrome In Place error. expected=false got="+result, result); + + string = "ABCDEFGHIJKKJIHGFEDCBA"; + result = StringFunctions.isPalindromeWithAdditionalStorage(string); + assertTrue("Is Palindrome With Additional Storage error. expected=true got="+result, result); + + result = StringFunctions.isPalindromeInPlace(string); + assertTrue("Is Palindrome In Place error. expected=true got="+result, result); + } + + @Test + public void testGenerateSubSets() { + // COMBINATIONS + String string = "abc"; + String[] check = new String[] {"", "c", "b", "cb", "a", "ca", "ba", "cba"}; + String[] result = StringFunctions.generateSubsets(string); + assertTrue("Generate Subsets error. expected="+print(check)+" got="+print(result), Arrays.equals(check, result)); + } + + @Test + public void testEditDistance() { + // Edit Distance + String string1 = "kitten"; + String string2 = "sitting"; + int check = 3; + int result = StringFunctions.levenshteinDistance(string1, string2); + assertTrue("Edit Distance error. expected="+check+" got="+result, (check==result)); + } + + private static final String print(String[] strings) { + StringBuilder builder = new StringBuilder(); + for (String s : strings) { + builder.append(s).append(' '); + } + return builder.toString(); + } +} diff --git a/src/com/jwetherell/algorithms/Strings.java b/src/com/jwetherell/algorithms/strings/timing/StringsTiming.java similarity index 67% rename from src/com/jwetherell/algorithms/Strings.java rename to src/com/jwetherell/algorithms/strings/timing/StringsTiming.java index ccb607a3..3851af88 100644 --- a/src/com/jwetherell/algorithms/Strings.java +++ b/src/com/jwetherell/algorithms/strings/timing/StringsTiming.java @@ -1,10 +1,10 @@ -package com.jwetherell.algorithms; +package com.jwetherell.algorithms.strings.timing; import java.text.DecimalFormat; import com.jwetherell.algorithms.strings.StringFunctions; -public class Strings { +public class StringsTiming { private static final DecimalFormat FORMAT = new DecimalFormat("#.######"); @@ -14,41 +14,40 @@ public static void main(String[] args) { String string = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; System.out.println("Reversing a string using concatination."); long before = System.nanoTime(); - String result = StringFunctions.reverseWithStringConcat(string); + StringFunctions.reverseWithStringConcat(string); long after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string with a StringBuilder."); before = System.nanoTime(); - result = StringFunctions.reverseWithStringBuilder(string); + StringFunctions.reverseWithStringBuilder(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string with StringBuilder built-in reverse method."); before = System.nanoTime(); - result = StringFunctions.reverseWithStringBuilderBuiltinMethod(string); + StringFunctions.reverseWithStringBuilderBuiltinMethod(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string with swaps."); before = System.nanoTime(); - result = StringFunctions.reverseWithSwaps(string); + StringFunctions.reverseWithSwaps(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string with XOR."); before = System.nanoTime(); - result = StringFunctions.reverseWithXOR(string); + StringFunctions.reverseWithXOR(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); System.out.println(); System.gc(); @@ -59,33 +58,32 @@ public static void main(String[] args) { String string = "Could you pretty please reverse this sentence"; System.out.println("Reversing a string using additional array."); long before = System.nanoTime(); - String result = StringFunctions.reverseWordsByCharWithAdditionalStorage(string); + StringFunctions.reverseWordsByCharWithAdditionalStorage(string); long after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string using StringTokenizer with additional storage."); before = System.nanoTime(); - result = StringFunctions.reverseWordsUsingStringTokenizerWithAdditionalStorage(string); + StringFunctions.reverseWordsUsingStringTokenizerWithAdditionalStorage(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string using split with additional storage."); before = System.nanoTime(); - result = StringFunctions.reverseWordsUsingStringTokenizerWithAdditionalStorage(string); + StringFunctions.reverseWordsUsingStringTokenizerWithAdditionalStorage(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); System.out.println("Reversing a string in-place."); before = System.nanoTime(); - result = StringFunctions.reverseWordsInPlace(string); + StringFunctions.reverseWordsInPlace(string); after = System.nanoTime(); - System.out.println("before=" + string + " after=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); System.out.println(); System.gc(); @@ -96,32 +94,33 @@ public static void main(String[] args) { String string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; System.out.println("Is Palindrome with additional storage?"); long before = System.nanoTime(); - boolean result = StringFunctions.isPalindromeWithAdditionalStorage(string); + StringFunctions.isPalindromeWithAdditionalStorage(string); long after = System.nanoTime(); - System.out.println("string=" + string + " isPalindrome=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); + System.out.println("Is Palindrome in-place?"); before = System.nanoTime(); - result = StringFunctions.isPalindromeInPlace(string); + StringFunctions.isPalindromeInPlace(string); after = System.nanoTime(); - System.out.println("string=" + string + " isPalindrome=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); string = "ABCDEFGHIJKLMNOPQRSTUVWXYZZYXWVUTSRQPONMLKJIHGFEDCBA"; System.out.println("Is Palindrome with additional storage?"); before = System.nanoTime(); - result = StringFunctions.isPalindromeWithAdditionalStorage(string); + StringFunctions.isPalindromeWithAdditionalStorage(string); after = System.nanoTime(); - System.out.println("string=" + string + " isPalindrome=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); + System.out.println(); System.gc(); + System.out.println("Is Palindrome in-place?"); before = System.nanoTime(); - result = StringFunctions.isPalindromeInPlace(string); + StringFunctions.isPalindromeInPlace(string); after = System.nanoTime(); - System.out.println("string=" + string + " isPalindrome=" + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); System.out.println(); System.gc(); @@ -132,9 +131,8 @@ public static void main(String[] args) { String string = "abc"; System.out.println("All possible subsets."); long before = System.nanoTime(); - String[] result = StringFunctions.generateSubsets(string); + StringFunctions.generateSubsets(string); long after = System.nanoTime(); - System.out.println("string=" + string + " subsets=" + result.length); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); System.out.println(); System.gc(); @@ -146,10 +144,8 @@ public static void main(String[] args) { String string2 = "sitting"; System.out.println("Edit Distance"); long before = System.nanoTime(); - int result = StringFunctions.levenshteinDistance(string1, string2); + StringFunctions.levenshteinDistance(string1, string2); long after = System.nanoTime(); - System.out.println("string1='" + string1 + "' string2='" + string2 + "' edit (levenshtein) distance=" - + result); System.out.println("Computed in " + FORMAT.format(after - before) + " ns"); System.out.println(); System.gc(); diff --git a/test.txt b/test.txt deleted file mode 100644 index e69de29b..00000000