Updated the Skip List to extend Set instead of List since it doesn't contain duplicates.

git-svn-id: https://java-algorithms-implementation.googlecode.com/svn/trunk@424 032fbc0f-8cab-eb90-e552-f08422b9a96a

Author: phishman3579

src/com/jwetherell/algorithms/DataStructures.java

@@ -11,9 +11,11 @@
 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.ConcurrentSkipListSet;
 
 import com.jwetherell.algorithms.data_structures.AVLTree;
 import com.jwetherell.algorithms.data_structures.BTree;
@@ -28,6 +30,7 @@
 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;
@@ -80,7 +83,7 @@ public class DataStructures {
     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 = 34; // Max number of dynamic data structures to test
+    private static final int TESTS = 35; // 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
@@ -254,6 +257,12 @@ private static boolean runTests() {
             return false;
         }
 
+        passed = testJavaSkipList();
+        if (!passed) {
+            System.err.println("Java's Skip List failed.");
+            return false;
+        }
+
         passed = testSkipList();
         if (!passed) {
             System.err.println("Skip List failed.");
@@ -1568,12 +1577,20 @@ private static boolean testSegmentTree() {
         return true;
     }
 
+    private static boolean testJavaSkipList() {
+        String sName = "Java's SkipList";
+        NavigableSet<Integer> sList = new ConcurrentSkipListSet<Integer>();
+        Collection<Integer> lCollection = sList;
+        if(!testJavaCollection(lCollection,Type.Integer,sName)) return false;
+        return true;
+    }
+
     private static boolean testSkipList() {
         String sName = "SkipList";
         SkipList<Integer> sList = new SkipList<Integer>();
         Collection<Integer> lCollection = sList.toCollection();
 
-        if((validateStructure||validateContents) && !testList(sList,sName)) return false;
+        if((validateStructure||validateContents) && !testSet(sList,sName)) return false;
         if(!testJavaCollection(lCollection,Type.Integer,sName)) return false;
         return true;
     }
@@ -2586,6 +2603,120 @@ private static <T extends Comparable<T>> boolean testList(IList<T> list, String
         return true;
     }
 
+    /**
+     * Tests the actual list operations
+     * 
+     * @param list to test.
+     * @return True is works as a list structure.
+     */
+    private static <T extends Comparable<T>> boolean testSet(ISet<T> list, String name) {
+        for (int i = 0; i < unsorted.length; i++) {
+            T item = (T)unsorted[i];
+            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 && !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);
+        if (contains) {
+            System.err.println(name+" invalidity check. contains=" + contains);
+            handleError(list);
+            return false;
+        }
+
+        int size = list.size();
+        for (int i = 0; i < size; i++) {
+            T item = (T)unsorted[i];
+            boolean 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];
+            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 && !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];
+            boolean 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];
+            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 && !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];
+            boolean 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;
+    }
+
     private static <T extends Comparable<T>> boolean testJavaCollection(Collection<T> collection, Type type, String name) {
         // Make sure the collection is empty
         if (!collection.isEmpty()) {

src/com/jwetherell/algorithms/data_structures/ISet.java

@@ -0,0 +1,67 @@
+package com.jwetherell.algorithms.data_structures;
+
+/**
+ * In computer science, a set is an abstract data structure that can store certain values, without 
+ * any particular order, and no repeated values. It is a computer implementation of the mathematical 
+ * concept of a finite set. Unlike most other collection types, rather than retrieving a specific 
+ * element from a set, one typically tests a value for membership in a set.
+ * 
+ * http://en.wikipedia.org/wiki/Set_(abstract_data_type)
+ * 
+ * @author Justin Wetherell <phishman3579@gmail.com>
+ */
+public interface ISet<T> {
+
+    /**
+     * Add value to set.
+     * 
+     * @param value to add.
+     * @return True if added.
+     */
+    public boolean add(T value);
+
+    /**
+     * Remove value from set.
+     * 
+     * @param value to remove.
+     * @return True if removed.
+     */
+    public boolean remove(T value);
+
+    /**
+     * Does the set contain value.
+     * 
+     * @param value to search set for.
+     * @return True if set contains value.
+     */
+    public boolean contains(T value);
+
+    /**
+     * Size of the set.
+     * 
+     * @return size of the set.
+     */
+    public int size();
+
+    /**
+     * Validate the set according to the invariants.
+     * 
+     * @return True if the set is valid.
+     */
+    public boolean validate();
+
+    /**
+     * Get this Set as a Java compatible Set
+     * 
+     * @return Java compatible Set
+     */
+    public java.util.Set<T> toSet();
+
+    /**
+     * Get this Set as a Java compatible Collection
+     * 
+     * @return Java compatible Collection
+     */
+    public java.util.Collection<T> toCollection();
+
+}