set count

justcoding121 · justcoding121 · commit 1c9ecdedc350 · 2018-10-26T17:29:24.000-04:00
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/AvlTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/AvlTree.cs
@@ -14,7 +14,7 @@ public class AVLTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable
 
         internal AVLTreeNode<T> Root { get; set; }
 
-        public int Count { get; private set; }
+        public int Count => Root == null ? 0 : Root.Count;
 
         /// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations
         /// at the cost of additional space.</param>
@@ -41,7 +41,6 @@ public AVLTree(IEnumerable<T> sortedKeys, bool enableNodeLookUp = false)
             Root = (AVLTreeNode<T>)ToBST(nodes);
             recomputeHeight(Root);
             assignCount(Root);
-            Count = nodes.Length;
         }
 
      
@@ -81,12 +80,12 @@ public void Insert(T value)
                 {
                     nodeLookUp[value] = Root;
                 }
-                Count++;
+
                 return;
             }
 
             insert(Root, value);
-            Count++;
+
         }
 
         /// <summary>
@@ -158,7 +157,6 @@ public void Delete(T value)
                 nodeLookUp.Remove(value);
             }
 
-            Count--;
         }
 
         
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/BST.cs b/src/Advanced.Algorithms/DataStructures/Tree/BST.cs
@@ -12,7 +12,7 @@ public class BST<T> : BSTBase<T>, IEnumerable<T> where T : IComparable
     {
         internal BSTNode<T> Root { get; set; }
 
-        public int Count { get; private set; }
+        public int Count => Root == null ? 0 : Root.Count;
 
         public BST() { }
 
@@ -26,7 +26,6 @@ public BST(IEnumerable<T> sortedKeys) : this()
             var nodes = sortedKeys.Select(x => new BSTNode<T>(null, x)).ToArray();
             Root = (BSTNode<T>)ToBST(nodes);
             assignCount(Root);
-            Count = nodes.Length;
         }
 
         /// <summary>
@@ -67,13 +66,10 @@ internal BSTNode<T> InsertAndReturnNewNode(T value)
             if (Root == null)
             {
                 Root = new BSTNode<T>(null, value);
-                Count++;
                 return Root;
             }
 
             var newNode = insert(Root, value);
-            Count++;
-
             return newNode;
         }
 
@@ -86,13 +82,11 @@ public void Insert(T value)
             if (Root == null)
             {
                 Root = new BSTNode<T>(null, value);
-                Count++;
                 return;
             }
 
             var newNode = insert(Root, value);
             newNode.UpdateCounts(true);
-            Count++;
         }
 
         //worst O(n) for unbalanced tree
@@ -148,7 +142,6 @@ public void Delete(T value)
 
             var deleted = delete(Root, value);
             deleted.UpdateCounts(true);
-            Count--;
         }
 
         //worst O(n) for unbalanced tree
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/SplayTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/SplayTree.cs
@@ -11,9 +11,7 @@ namespace Advanced.Algorithms.DataStructures
     public class SplayTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable
     {
         internal SplayTreeNode<T> Root { get; set; }
-
-        public int Count { get; private set; }
-
+        public int Count => Root == null ? 0 : Root.Count;
         public SplayTree() { }
 
         /// <summary>
@@ -27,7 +25,6 @@ public SplayTree(IEnumerable<T> collection) : this()
             var nodes = collection.Select(x => new SplayTreeNode<T>(null, x)).ToArray();
             Root = (SplayTreeNode<T>)ToBST(nodes);
             assignCount(Root);
-            Count = nodes.Length;
         }
 
         /// <summary>
@@ -70,13 +67,11 @@ public void Insert(T value)
             if (Root == null)
             {
                 Root = new SplayTreeNode<T>(null, value);
-                Count++;
                 return;
             }
 
             var newNode = insert(Root, value);
             splay(newNode);
-            Count++;
         }
 
         //O(log(n)) always
@@ -129,7 +124,6 @@ public void Delete(T value)
             }
 
             delete(Root, value);
-            Count--;
         }
 
         //O(log(n)) worst O(n) for unbalanced tree
diff --git a/src/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs b/src/Advanced.Algorithms/DataStructures/Tree/TreapTree.cs
@@ -12,7 +12,7 @@ public class TreapTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable
     {
         private Random rndGenerator = new Random();
         internal TreapTreeNode<T> Root { get; set; }
-        public int Count { get; private set; }
+        public int Count => Root == null ? 0 : Root.Count;
 
         public TreapTree() { }
 
@@ -26,7 +26,6 @@ public TreapTree(IEnumerable<T> collection) : this()
             ValidateCollection(collection);
             var nodes = collection.Select(x => new TreapTreeNode<T>(null, x, rndGenerator.Next())).ToArray();
             Root = (TreapTreeNode<T>)ToBST(nodes);
-            Count = nodes.Length;
             assignCount(Root);
             heapify(Root);
         }
@@ -70,14 +69,12 @@ public void Insert(T value)
             if (Root == null)
             {
                 Root = new TreapTreeNode<T>(null, value, rndGenerator.Next());
-                Count++;
                 return;
             }
 
             var newNode = insert(Root, value);
 
             heapify(newNode);
-            Count++;
         }
 
         //O(log(n)) always
@@ -130,7 +127,6 @@ public void Delete(T value)
             }
 
             delete(Root, value);
-            Count--;
         }
 
         //O(log(n)) worst O(n) for unbalanced tree

Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public class AVLTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable`
`14`	`14`
`15`	`15`	`internal AVLTreeNode<T> Root { get; set; }`
`16`	`16`
`17`		`- public int Count { get; private set; }`
	`17`	`+ public int Count => Root == null ? 0 : Root.Count;`
`18`	`18`
`19`	`19`	`/// <param name="enableNodeLookUp">Enabling lookup will fasten deletion/insertion/exists operations`
`20`	`20`	`/// at the cost of additional space.</param>`
`@@ -41,7 +41,6 @@ public AVLTree(IEnumerable<T> sortedKeys, bool enableNodeLookUp = false)`
`41`	`41`	`Root = (AVLTreeNode<T>)ToBST(nodes);`
`42`	`42`	`recomputeHeight(Root);`
`43`	`43`	`assignCount(Root);`
`44`		`- Count = nodes.Length;`
`45`	`44`	`}`
`46`	`45`
`47`	`46`
`@@ -81,12 +80,12 @@ public void Insert(T value)`
`81`	`80`	`{`
`82`	`81`	`nodeLookUp[value] = Root;`
`83`	`82`	`}`
`84`		`- Count++;`
	`83`	`+`
`85`	`84`	`return;`
`86`	`85`	`}`
`87`	`86`
`88`	`87`	`insert(Root, value);`
`89`		`- Count++;`
	`88`	`+`
`90`	`89`	`}`
`91`	`90`
`92`	`91`	`/// <summary>`
`@@ -158,7 +157,6 @@ public void Delete(T value)`
`158`	`157`	`nodeLookUp.Remove(value);`
`159`	`158`	`}`
`160`	`159`
`161`		`- Count--;`
`162`	`160`	`}`
`163`	`161`
`164`	`162`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public class BST<T> : BSTBase<T>, IEnumerable<T> where T : IComparable`
`12`	`12`	`{`
`13`	`13`	`internal BSTNode<T> Root { get; set; }`
`14`	`14`
`15`		`- public int Count { get; private set; }`
	`15`	`+ public int Count => Root == null ? 0 : Root.Count;`
`16`	`16`
`17`	`17`	`public BST() { }`
`18`	`18`
`@@ -26,7 +26,6 @@ public BST(IEnumerable<T> sortedKeys) : this()`
`26`	`26`	`var nodes = sortedKeys.Select(x => new BSTNode<T>(null, x)).ToArray();`
`27`	`27`	`Root = (BSTNode<T>)ToBST(nodes);`
`28`	`28`	`assignCount(Root);`
`29`		`- Count = nodes.Length;`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`/// <summary>`
`@@ -67,13 +66,10 @@ internal BSTNode<T> InsertAndReturnNewNode(T value)`
`67`	`66`	`if (Root == null)`
`68`	`67`	`{`
`69`	`68`	`Root = new BSTNode<T>(null, value);`
`70`		`- Count++;`
`71`	`69`	`return Root;`
`72`	`70`	`}`
`73`	`71`
`74`	`72`	`var newNode = insert(Root, value);`
`75`		`- Count++;`
`76`		`-`
`77`	`73`	`return newNode;`
`78`	`74`	`}`
`79`	`75`
`@@ -86,13 +82,11 @@ public void Insert(T value)`
`86`	`82`	`if (Root == null)`
`87`	`83`	`{`
`88`	`84`	`Root = new BSTNode<T>(null, value);`
`89`		`- Count++;`
`90`	`85`	`return;`
`91`	`86`	`}`
`92`	`87`
`93`	`88`	`var newNode = insert(Root, value);`
`94`	`89`	`newNode.UpdateCounts(true);`
`95`		`- Count++;`
`96`	`90`	`}`
`97`	`91`
`98`	`92`	`//worst O(n) for unbalanced tree`
`@@ -148,7 +142,6 @@ public void Delete(T value)`
`148`	`142`
`149`	`143`	`var deleted = delete(Root, value);`
`150`	`144`	`deleted.UpdateCounts(true);`
`151`		`- Count--;`
`152`	`145`	`}`
`153`	`146`
`154`	`147`	`//worst O(n) for unbalanced tree`
Original file line number	Diff line number	Diff line change
`@@ -11,9 +11,7 @@ namespace Advanced.Algorithms.DataStructures`
`11`	`11`	`public class SplayTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable`
`12`	`12`	`{`
`13`	`13`	`internal SplayTreeNode<T> Root { get; set; }`
`14`		`-`
`15`		`- public int Count { get; private set; }`
`16`		`-`
	`14`	`+ public int Count => Root == null ? 0 : Root.Count;`
`17`	`15`	`public SplayTree() { }`
`18`	`16`
`19`	`17`	`/// <summary>`
`@@ -27,7 +25,6 @@ public SplayTree(IEnumerable<T> collection) : this()`
`27`	`25`	`var nodes = collection.Select(x => new SplayTreeNode<T>(null, x)).ToArray();`
`28`	`26`	`Root = (SplayTreeNode<T>)ToBST(nodes);`
`29`	`27`	`assignCount(Root);`
`30`		`- Count = nodes.Length;`
`31`	`28`	`}`
`32`	`29`
`33`	`30`	`/// <summary>`
`@@ -70,13 +67,11 @@ public void Insert(T value)`
`70`	`67`	`if (Root == null)`
`71`	`68`	`{`
`72`	`69`	`Root = new SplayTreeNode<T>(null, value);`
`73`		`- Count++;`
`74`	`70`	`return;`
`75`	`71`	`}`
`76`	`72`
`77`	`73`	`var newNode = insert(Root, value);`
`78`	`74`	`splay(newNode);`
`79`		`- Count++;`
`80`	`75`	`}`
`81`	`76`
`82`	`77`	`//O(log(n)) always`
`@@ -129,7 +124,6 @@ public void Delete(T value)`
`129`	`124`	`}`
`130`	`125`
`131`	`126`	`delete(Root, value);`
`132`		`- Count--;`
`133`	`127`	`}`
`134`	`128`
`135`	`129`	`//O(log(n)) worst O(n) for unbalanced tree`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public class TreapTree<T> : BSTBase<T>, IEnumerable<T> where T : IComparable`
`12`	`12`	`{`
`13`	`13`	`private Random rndGenerator = new Random();`
`14`	`14`	`internal TreapTreeNode<T> Root { get; set; }`
`15`		`- public int Count { get; private set; }`
	`15`	`+ public int Count => Root == null ? 0 : Root.Count;`
`16`	`16`
`17`	`17`	`public TreapTree() { }`
`18`	`18`
`@@ -26,7 +26,6 @@ public TreapTree(IEnumerable<T> collection) : this()`
`26`	`26`	`ValidateCollection(collection);`
`27`	`27`	`var nodes = collection.Select(x => new TreapTreeNode<T>(null, x, rndGenerator.Next())).ToArray();`
`28`	`28`	`Root = (TreapTreeNode<T>)ToBST(nodes);`
`29`		`- Count = nodes.Length;`
`30`	`29`	`assignCount(Root);`
`31`	`30`	`heapify(Root);`
`32`	`31`	`}`
`@@ -70,14 +69,12 @@ public void Insert(T value)`
`70`	`69`	`if (Root == null)`
`71`	`70`	`{`
`72`	`71`	`Root = new TreapTreeNode<T>(null, value, rndGenerator.Next());`
`73`		`- Count++;`
`74`	`72`	`return;`
`75`	`73`	`}`
`76`	`74`
`77`	`75`	`var newNode = insert(Root, value);`
`78`	`76`
`79`	`77`	`heapify(newNode);`
`80`		`- Count++;`
`81`	`78`	`}`
`82`	`79`
`83`	`80`	`//O(log(n)) always`
`@@ -130,7 +127,6 @@ public void Delete(T value)`
`130`	`127`	`}`
`131`	`128`
`132`	`129`	`delete(Root, value);`
`133`		`- Count--;`
`134`	`130`	`}`
`135`	`131`
`136`	`132`	`//O(log(n)) worst O(n) for unbalanced tree`