Updated red black tree to return the correct node in the "removeNode" method.

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

Author: phishman3579

src/com/jwetherell/algorithms/DataStructures.java

@@ -1989,7 +1989,7 @@ private static <T extends Comparable<T>> boolean testTree(ITree<T> tree, Type ty
                 return false;
             }
             if (validateContents && (removed==null || tree.contains(item))) {
-                System.err.println(name+" YIKES!! " + item + " still exists but it has been remove.");
+                System.err.println(name+" YIKES!! " + item + " still exists but it has been removed.");
                 handleError(tree);
                 return false;
             }

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

@@ -282,7 +282,7 @@ protected Node<T> getLeast(Node<T> startingNode) {
     @Override
     public T remove(T value) {
         Node<T> nodeToRemove = this.removeValue(value);
-        return ((nodeToRemove!=null)?value:null);
+        return ((nodeToRemove!=null)?nodeToRemove.id:null);
     }
 
     /**
@@ -294,7 +294,7 @@ public T remove(T value) {
      */
     protected Node<T> removeValue(T value) {
         Node<T> nodeToRemoved = this.getNode(value);
-        if (nodeToRemoved != null) removeNode(nodeToRemoved);
+        if (nodeToRemoved != null) nodeToRemoved = removeNode(nodeToRemoved);
         return nodeToRemoved;
     }
 
@@ -303,12 +303,16 @@ protected Node<T> removeValue(T value) {
      * 
      * @param nodeToRemoved
      *            Node<T> to remove from the tree.
+     * @return nodeRemove
+     *            Node<T> removed from the tree, it can be different
+     *            then the parameter in some cases.
      */
-    protected void removeNode(Node<T> nodeToRemoved) {
+    protected Node<T> removeNode(Node<T> nodeToRemoved) {
         if (nodeToRemoved != null) {
             Node<T> replacementNode = this.getReplacementNode(nodeToRemoved);
             replaceNodeWithNode(nodeToRemoved, replacementNode);
         }
+        return nodeToRemoved;
     }
 
     /**

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

@@ -177,62 +177,61 @@ private void balanceAfterInsert(RedBlackNode<T> node) {
      * {@inheritDoc}
      */
     @Override
-    protected Node<T> removeValue(T value) {
-        RedBlackNode<T> nodeRemoved = (RedBlackNode<T>) super.getNode(value);
-        removeNode(nodeRemoved);
-        return nodeRemoved;
-    }
+    protected Node<T> removeNode(Node<T> node) {
+        RedBlackNode<T> nodeToRemoved = (RedBlackNode<T>)node;
+        if (nodeToRemoved == null) return nodeToRemoved;
 
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    protected void removeNode(Node<T> node) {
-        RedBlackNode<T> nodeRemoved = (RedBlackNode<T>)node;
-        if (nodeRemoved == null) return;
-
-        if (nodeRemoved.isLeaf()) {
+        if (nodeToRemoved.isLeaf()) {
             // No children
-            nodeRemoved.id = null;
-            if (nodeRemoved.parent == null) {
+            nodeToRemoved.id = null;
+            if (nodeToRemoved.parent == null) {
                 root = null;
             } else {
-                nodeRemoved.id = null;
-                nodeRemoved.color = BLACK;
-                nodeRemoved.lesser = null;
-                nodeRemoved.greater = null;
+                nodeToRemoved.id = null;
+                nodeToRemoved.color = BLACK;
+                nodeToRemoved.lesser = null;
+                nodeToRemoved.greater = null;
             }
         } else {
+            // Keep the id and assign it to the replacement node
+            T id = nodeToRemoved.id;
+
             // At least one child
-            RedBlackNode<T> lesser = (RedBlackNode<T>) nodeRemoved.lesser;
-            RedBlackNode<T> greater = (RedBlackNode<T>) nodeRemoved.greater;
+            RedBlackNode<T> lesser = (RedBlackNode<T>) nodeToRemoved.lesser;
+            RedBlackNode<T> greater = (RedBlackNode<T>) nodeToRemoved.greater;
             if (lesser.id != null && greater.id != null) {
                 // Two children
                 RedBlackNode<T> greatestInLesser = (RedBlackNode<T>) this.getGreatest(lesser);
                 if (greatestInLesser == null || greatestInLesser.id == null) greatestInLesser = lesser;
                 // Replace node with greatest in his lesser tree, which leaves
                 // us with only one child
-                replaceValueOnly(nodeRemoved, greatestInLesser);
-                nodeRemoved = greatestInLesser;
+                replaceValueOnly(nodeToRemoved, greatestInLesser);
+                nodeToRemoved = greatestInLesser;
             }
 
             // Handle one child
-            RedBlackNode<T> child = (RedBlackNode<T>) ((nodeRemoved.lesser.id != null) ? nodeRemoved.lesser : nodeRemoved.greater);
-            if (nodeRemoved.color == BLACK) {
-                if (child.color == BLACK) nodeRemoved.color = RED;
-                boolean result = balanceAfterDelete(nodeRemoved);
-                if (!result) return;
+            RedBlackNode<T> child = (RedBlackNode<T>) ((nodeToRemoved.lesser.id != null) ? nodeToRemoved.lesser : nodeToRemoved.greater);
+            if (nodeToRemoved.color == BLACK) {
+                if (child.color == BLACK) nodeToRemoved.color = RED;
+                boolean result = balanceAfterDelete(nodeToRemoved);
+                if (!result) return nodeToRemoved;
             }
-            replaceWithChild(nodeRemoved, child);
-            if (root.equals(nodeRemoved)) {
+            // Replacing node with child
+            replaceWithChild(nodeToRemoved, child);
+            // Add the id to the child because it represents the node 
+            // that was removed.
+            child.id = id;
+            if (root.equals(nodeToRemoved)) {
                 root.parent = null;
                 ((RedBlackNode<T>)root).color = BLACK;
                 // If we replaced the root with a leaf, just null out root
-                if (nodeRemoved.isLeaf()) root = null;
+                if (nodeToRemoved.isLeaf()) root = null;
             }
+            nodeToRemoved = child;
         }
 
         size--;
+        return nodeToRemoved;
     }
 
     /**

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

@@ -87,7 +87,6 @@ public int size() {
     @Override
     public boolean validate() {
         if (list==null) return true;
-        if (!list.validate()) return false;
 
         java.util.Set<K> keys = new java.util.HashSet<K>();
         Node<K> node = list.head;