Refactored three functions in order to reduce Cyclomatic complexity

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

@@ -182,8 +182,9 @@ protected void heapUp(int idx) {
                 nodeIndex = parentIndex;
             }
         }
+
+        private void heapDownMax(int index) {
 
-        protected void heapDown(int index) {
             T value = this.array[index];
             if (value==null)
                 return;
@@ -197,39 +198,79 @@ protected void heapDown(int index) {
                 // Nothing to do here
                 return;
             }
+            T nodeToMove = null;
+            int nodeToMoveIndex = -1;
+            if (left != null && right != null && value.compareTo(left) < 0 && (value.compareTo(right) < 0)) {
+                // Both children are greater than node
+                if ((right!=null) && (right.compareTo(left) > 0)) {
+                    // Right is greater than left
+                    nodeToMove = right;
+                    nodeToMoveIndex = rightIndex;
+                } else if ((left!=null) && (left.compareTo(right) > 0)){
+                    // Left is greater than right
+                    nodeToMove = left;
+                    nodeToMoveIndex = leftIndex;
+                } else {
+                    // Both children are equal, use right
+                    nodeToMove = right;
+                    nodeToMoveIndex = rightIndex;
+                }
+            } else if (right != null && (value.compareTo(right) < 0)) {
+                // Right is greater than node
+                nodeToMove = right;
+                nodeToMoveIndex = rightIndex;
+            } else if (left != null && (value.compareTo(left) < 0)) {
+                // Left is greater than node
+                nodeToMove = left;
+                nodeToMoveIndex = leftIndex;
+            }
+            // No node to move, stop recursion
+            if (nodeToMove == null)
+                return;
+
+            // Re-factor heap sub-tree
+            this.array[nodeToMoveIndex] = value;
+            this.array[index] = nodeToMove;
+
+            heapDownMax(nodeToMoveIndex);
+        }
 
+        private void heapDownMin(int index) {
+            T value = this.array[index];
+            if (value==null)
+                return;
+            int leftIndex = getLeftIndex(index);
+            int rightIndex = getRightIndex(index);
+            T left = (leftIndex != Integer.MIN_VALUE && leftIndex < this.size) ? this.array[leftIndex] : null;
+            T right = (rightIndex != Integer.MIN_VALUE && rightIndex < this.size) ? this.array[rightIndex] : null;
+
+            if (left == null && right == null) {
+                // Nothing to do here
+                return;
+            }
             T nodeToMove = null;
             int nodeToMoveIndex = -1;
-            if ((type == Type.MIN && left != null && right != null && value.compareTo(left) > 0 && value.compareTo(right) > 0)
-                || (type == Type.MAX && left != null && right != null && value.compareTo(left) < 0 && value.compareTo(right) < 0)) {
-                // Both children are greater/lesser than node
-                if ((right!=null) && 
-                    ((type == Type.MIN && (right.compareTo(left) < 0)) || ((type == Type.MAX && right.compareTo(left) > 0)))
-                ) {
-                    // Right is greater/lesser than left
+            if (left != null && right != null && value.compareTo(left) > 0 && value.compareTo(right) > 0) {
+                // Both children are lesser than node
+                if ((right!=null) && (right.compareTo(left) < 0)){
+                    // Right is lesser than left
                     nodeToMove = right;
                     nodeToMoveIndex = rightIndex;
-                } else if ((left!=null) && 
-                           ((type == Type.MIN && left.compareTo(right) < 0) || (type == Type.MAX && left.compareTo(right) > 0))
-                ) {
-                    // Left is greater/lesser than right
+                } else if ((left!=null) && (left.compareTo(right) < 0)){
+                    // Left is lesser than right
                     nodeToMove = left;
                     nodeToMoveIndex = leftIndex;
                 } else {
                     // Both children are equal, use right
                     nodeToMove = right;
                     nodeToMoveIndex = rightIndex;
                 }
-            } else if ((type == Type.MIN && right != null && value.compareTo(right) > 0)
-                       || (type == Type.MAX && right != null && value.compareTo(right) < 0)
-            ) {
-                // Right is greater/lesser than node
+            } else if (right != null && (value.compareTo(right) > 0)){
+                // Right is lesser than node
                 nodeToMove = right;
                 nodeToMoveIndex = rightIndex;
-            } else if ((type == Type.MIN && left != null && value.compareTo(left) > 0)
-                       || (type == Type.MAX && left != null && value.compareTo(left) < 0)
-            ) {
-                // Left is greater/lesser than node
+            } else if (left != null && (value.compareTo(left) > 0)) {
+                // Left is lesser than node
                 nodeToMove = left;
                 nodeToMoveIndex = leftIndex;
             }
@@ -241,7 +282,17 @@ protected void heapDown(int index) {
             this.array[nodeToMoveIndex] = value;
             this.array[index] = nodeToMove;
 
-            heapDown(nodeToMoveIndex);
+            heapDownMin(nodeToMoveIndex);
+        }
+
+
+        protected void heapDown(int index) {
+            if (type == Type.MIN){
+                heapDownMin(index);
+            }
+            else{
+                heapDownMax(index);
+            }
         }
 
         // Grow the array by 50%

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

@@ -354,37 +354,97 @@ protected void replaceNodeWithNode(Node<T> nodeToRemoved, Node<T> replacementNod
             Node<T> replacementNodeLesser = replacementNode.lesser;
             Node<T> replacementNodeGreater = replacementNode.greater;
 
-            // Replace replacementNode's branches with nodeToRemove's branches
-            Node<T> nodeToRemoveLesser = nodeToRemoved.lesser;
-            if (nodeToRemoveLesser != null && nodeToRemoveLesser != replacementNode) {
-                replacementNode.lesser = nodeToRemoveLesser;
-                nodeToRemoveLesser.parent = replacementNode;
-            }
-            Node<T> nodeToRemoveGreater = nodeToRemoved.greater;
-            if (nodeToRemoveGreater != null && nodeToRemoveGreater != replacementNode) {
-                replacementNode.greater = nodeToRemoveGreater;
-                nodeToRemoveGreater.parent = replacementNode;
-            }
+            // Replace replacementNode's branches with nodeToRemove's branches.
+            replaceBranches(nodeToRemoved, replacementNode);
 
-            // Remove link from replacementNode's parent to replacement
-            Node<T> replacementParent = replacementNode.parent;
-            if (replacementParent != null && replacementParent != nodeToRemoved) {
-                Node<T> replacementParentLesser = replacementParent.lesser;
-                Node<T> replacementParentGreater = replacementParent.greater;
-                if (replacementParentLesser != null && replacementParentLesser == replacementNode) {
-                    replacementParent.lesser = replacementNodeGreater;
-                    if (replacementNodeGreater != null)
-                        replacementNodeGreater.parent = replacementParent;
-                } else if (replacementParentGreater != null && replacementParentGreater == replacementNode) {
-                    replacementParent.greater = replacementNodeLesser;
-                    if (replacementNodeLesser != null)
-                        replacementNodeLesser.parent = replacementParent;
-                }
+            // Remove link from replacementNode's parent to replacement.
+            removeLinkFromParentOfReplacement(nodeToRemoved, replacementNode, replacementNodeLesser, replacementNodeGreater);
+        }
+
+        // Update the link in the tree from the nodeToRemoved to the replacementNode.
+        updateLink(nodeToRemoved, replacementNode);
+        size--;
+    }
+
+    /**
+     * Replace replacementNode's branches with nodeToRemove's branches.
+     * (Primarily a helper function for replaceNodeWithNode.)
+     * 
+     * @param nodeToRemoved
+     *            the node with the branches that should be moved to replacementNode
+     * @param replacementNode
+     *            the node which should receive the branches from nodeToRemoved
+     */  
+    private void replaceBranches(Node<T> nodeToRemoved, Node<T> replacementNode) {
+        Node<T> nodeToRemoveLesser = nodeToRemoved.lesser;
+        if (nodeToRemoveLesser != null && nodeToRemoveLesser != replacementNode) {
+            replacementNode.lesser = nodeToRemoveLesser;
+            nodeToRemoveLesser.parent = replacementNode;
+        }
+        Node<T> nodeToRemoveGreater = nodeToRemoved.greater;
+        if (nodeToRemoveGreater != null && nodeToRemoveGreater != replacementNode) {
+            replacementNode.greater = nodeToRemoveGreater;
+            nodeToRemoveGreater.parent = replacementNode;
+        }
+    }
+
+
+    /**
+     * Remove link from replacementNode's parent to replacement.
+     * (Primarily a helper function for replaceNodeWithNode.)
+     * 
+     * @param nodeToRemoved
+     *            Node<T> to remove replace in the tree. nodeToRemoved should
+     *            NOT be NULL.
+     * @param replacementNode
+     *            Node<T> to replace nodeToRemoved in the tree. replacementNode
+     *            can be NULL.
+     */  
+
+    /**
+     * Remove the link from replacementNode's parent to replacementNode.
+     * (Primarily a helper function for replaceNodeWithNode.)
+     * 
+     * @param nodeToRemoved
+     *            Node<T> to remove replace in the tree. nodeToRemoved should
+     *            NOT be NULL.
+     * @param replacementNode
+     *            Node<T> to replace nodeToRemoved in the tree. replacementNode
+     *            can be NULL.
+     * @param replacementNodeLesser 
+     *            replacementNode's previous lesser child
+     * @param replacementNodeGreater
+     *            replacementNode's previous greater child
+     */
+    private void removeLinkFromParentOfReplacement(Node<T> nodeToRemoved, Node<T> replacementNode, Node<T> replacementNodeLesser, Node<T> replacementNodeGreater) {
+        Node<T> replacementParent = replacementNode.parent;
+        if (replacementParent != null && replacementParent != nodeToRemoved) {
+            Node<T> replacementParentLesser = replacementParent.lesser;
+            Node<T> replacementParentGreater = replacementParent.greater;
+            if (replacementParentLesser != null && replacementParentLesser == replacementNode) {
+                replacementParent.lesser = replacementNodeGreater;
+                if (replacementNodeGreater != null)
+                    replacementNodeGreater.parent = replacementParent;
+            } else if (replacementParentGreater != null && replacementParentGreater == replacementNode) {
+                replacementParent.greater = replacementNodeLesser;
+                if (replacementNodeLesser != null)
+                    replacementNodeLesser.parent = replacementParent;
             }
         }
+    }
 
-        // Update the link in the tree from the nodeToRemoved to the
-        // replacementNode
+    /**
+     * Update the link in the tree from the nodeToRemoved to the replacementNode.
+     * (Primarily a helper function for replaceNodeWithNode.)
+     * 
+     * @param nodeToRemoved
+     *            Node<T> to remove replace in the tree. nodeToRemoved should
+     *            NOT be NULL.
+     * @param replacementNode
+     *            Node<T> to replace nodeToRemoved in the tree. replacementNode
+     *            can be NULL.
+     */  
+    private void updateLink(Node<T> nodeToRemoved, Node<T> replacementNode) {
         Node<T> parent = nodeToRemoved.parent;
         if (parent == null) {
             // Replacing the root node
@@ -400,8 +460,8 @@ protected void replaceNodeWithNode(Node<T> nodeToRemoved, Node<T> replacementNod
             if (replacementNode != null)
                 replacementNode.parent = parent;
         }
-        size--;
     }
+
 
     /**
      * {@inheritDoc}