optimize trees by eliminating recursion when possible

Author: justcoding121

Advanced.Algorithms/DataStructures/Tree/FenwickTree.cs

@@ -8,8 +8,8 @@ namespace Advanced.Algorithms.DataStructures
     /// <typeparam name="T"></typeparam>
     public class FenwickTree<T>
     {
-        private int length => Tree.Length - 1;
-        private T[] Tree;
+        private int length => tree.Length - 1;
+        private T[] tree;
 
         /// <summary>
         /// add operation on generic type
@@ -29,23 +29,23 @@ public FenwickTree(T[] input, Func<T, T, T> sumOperation)
             }
 
             this.sumOperation = sumOperation;
-            Construct(input);
+            construct(input);
         }
 
         /// <summary>
         /// construct fenwick tree from input array
         /// </summary>
         /// <param name="input"></param>
-        private void Construct(T[] input)
+        private void construct(T[] input)
         {
-            Tree = new T[input.Length + 1];
+            tree = new T[input.Length + 1];
 
             for (var i = 0; i < input.Length; i++)
             {
                 var j = i + 1;
                 while (j < input.Length)
                 {
-                    Tree[j] = sumOperation(Tree[j], input[i]);
+                    tree[j] = sumOperation(tree[j], input[i]);
                     j = getNextIndex(j);
                 }
             }
@@ -70,7 +70,7 @@ public T GetPrefixSum(int endIndex)
 
             while (currentIndex > 0)
             {
-                sum = sumOperation(sum, Tree[currentIndex]);
+                sum = sumOperation(sum, tree[currentIndex]);
                 currentIndex = getParentIndex(currentIndex);
             }
 

Advanced.Algorithms/DataStructures/Tree/IntervalTree.cs

@@ -55,7 +55,7 @@ public void Insert(T[] value)
             var currentTree = tree;
             //get all overlaps
             //and insert next dimension value to each overlapping node
-            for (int i = 0; i < dimensions; i++)
+            for (var i = 0; i < dimensions; i++)
             {
                 currentTree = currentTree.Insert(value[i]).tree;
             }
@@ -102,8 +102,8 @@ private void DeleteRecursive(RangeTree<T> tree, T[] value, int currentDimension,
 
             //delete node if next dimension has no elements
             //or when this is the last dimension and we found element
-            if (found && ((currentDimension + 1 == dimensions)
-                || (node.tree.Count == 0 && currentDimension + 1 < dimensions)))
+            if (node != null && found && (currentDimension + 1 == dimensions
+                                          || node.tree.Count == 0 && currentDimension + 1 < dimensions))
             {
                 tree.Delete(value[currentDimension]);
             }
@@ -121,7 +121,7 @@ public List<T[]> GetInRange(T[] start, T[] end)
             validateDimensions(start);
             validateDimensions(end);
 
-            return GetInRange(tree, start, end, 0);
+            return getInRange(tree, start, end, 0);
 
         }
 
@@ -133,7 +133,7 @@ public List<T[]> GetInRange(T[] start, T[] end)
         /// <param name="end"></param>
         /// <param name="dimension"></param>
         /// <returns></returns>
-        private List<T[]> GetInRange(
+        private List<T[]> getInRange(
             RangeTree<T> currentTree,
             T[] start, T[] end, int dimension)
         {
@@ -158,7 +158,7 @@ private List<T[]> GetInRange(
 
                 foreach (var node in nodes)
                 {
-                    var nextDimResult = GetInRange(node.tree, start, end, dimension + 1);
+                    var nextDimResult = getInRange(node.tree, start, end, dimension + 1);
 
                     foreach (var nextResult in nextDimResult)
                     {
@@ -176,15 +176,17 @@ private List<T[]> GetInRange(
         /// validate dimensions for point length
         /// </summary>
         /// <param name="start"></param>
-        /// <param name="end"></param>
         private void validateDimensions(T[] start)
         {
-            if (start.Length != dimensions)
+            if (start == null)
             {
-                throw new Exception(string.Format("Expecting {0} points.",
-                    dimensions));
+                throw new ArgumentNullException(nameof(start));
             }
 
+            if (start.Length != dimensions)
+            {
+                throw new Exception($"Expecting {dimensions} points.");
+            }
         }
     }
 
@@ -221,25 +223,27 @@ internal void Delete(T value)
 
         internal List<RangeTreeNode<T>> GetInRange(T start, T end)
         {
-            return GetInRange(new List<RangeTreeNode<T>>(),
+            return getInRange(new List<RangeTreeNode<T>>(),
                 new System.Collections.Generic.Dictionary<RedBlackTreeNode<RangeTreeNode<T>>, bool>(),
                 tree.Root, start, end);
         }
 
-        private List<RangeTreeNode<T>> GetInRange(List<RangeTreeNode<T>> result, System.Collections.Generic.Dictionary<RedBlackTreeNode<RangeTreeNode<T>>, bool> visited,
+        private List<RangeTreeNode<T>> getInRange(List<RangeTreeNode<T>> result, System.Collections.Generic.Dictionary<RedBlackTreeNode<RangeTreeNode<T>>, bool> visited,
             RedBlackTreeNode<RangeTreeNode<T>> currentNode,
             T start, T end)
         {
 
             if (currentNode.IsLeaf)
             {
                 //start is less than current node
-                if (InRange(currentNode, start, end))
+                if (!inRange(currentNode, start, end))
                 {
-                    foreach (var v in currentNode.Values)
-                    {
-                        result.Add(v);
-                    }
+                    return result;
+                }
+
+                foreach (var v in currentNode.Values)
+                {
+                    result.Add(v);
                 }
             }
             //if start is less than current
@@ -250,13 +254,13 @@ private List<RangeTreeNode<T>> GetInRange(List<RangeTreeNode<T>> result, System.
                 {
                     if (currentNode.Left != null)
                     {
-                        GetInRange(result, visited, currentNode.Left, start, end);
+                        getInRange(result, visited, currentNode.Left, start, end);
                     }
 
 
                     //start is less than current node
                     if (!visited.ContainsKey(currentNode)
-                        && InRange(currentNode, start, end))
+                        && inRange(currentNode, start, end))
                     {
                         foreach (var v in currentNode.Values)
                         {
@@ -269,24 +273,29 @@ private List<RangeTreeNode<T>> GetInRange(List<RangeTreeNode<T>> result, System.
                 //if start is greater than current
                 //and end is greater than current
                 //move right
-                if (end.CompareTo(currentNode.Value.Data) >= 0)
+                if (end.CompareTo(currentNode.Value.Data) < 0)
+                {
+                    return result;
+                }
+
                 {
                     if (currentNode.Right != null)
                     {
-                        GetInRange(result, visited, currentNode.Right, start, end);
+                        getInRange(result, visited, currentNode.Right, start, end);
                     }
 
                     //start is less than current node
-                    if (!visited.ContainsKey(currentNode)
-                        && InRange(currentNode, start, end))
+                    if (visited.ContainsKey(currentNode) || !inRange(currentNode, start, end))
                     {
-                        foreach (var v in currentNode.Values)
-                        {
-                            result.Add(v);
-                        }
+                        return result;
+                    }
 
-                        visited.Add(currentNode, false);
+                    foreach (var v in currentNode.Values)
+                    {
+                        result.Add(v);
                     }
+
+                    visited.Add(currentNode, false);
                 }
             }
 
@@ -300,7 +309,7 @@ private List<RangeTreeNode<T>> GetInRange(List<RangeTreeNode<T>> result, System.
         /// <param name="start"></param>
         /// <param name="end"></param>
         /// <returns></returns>
-        private bool InRange(RedBlackTreeNode<RangeTreeNode<T>> currentNode, T start, T end)
+        private bool inRange(RedBlackTreeNode<RangeTreeNode<T>> currentNode, T start, T end)
         {
             //start is less than current & end is greater than current
             return start.CompareTo(currentNode.Value.Data) <= 0