Update Tree Traversal C#. (#209)

june128 · zsparal · commit 6d02784f5e59 · 2018-07-04T07:19:41.000+02:00
* Restructure code by removing the Node class. Remove CreateAllChildren method and make the constructor do it instead.

* Inline temp variables of DFSSTack and BFSQueue.
diff --git a/chapters/tree_traversal/code/cs/Program.cs b/chapters/tree_traversal/code/cs/Program.cs
@@ -17,6 +17,7 @@ static void Main(string[] args)
             tree.BFSQueue();
             Console.WriteLine("DFSRecursivePostorder");
             tree.DFSRecursivePostorder();
+
             // Uncommenting the following 2 lines will result in an exception thrown because at least one Node of the Tree has more than 2 children and therefor a DFSRecursiveInorderBinary doesn't work.
             // Console.WriteLine("DFSRecursiveInorder (fail)");
             // tree.DFSRecursiveInorderBinary();
diff --git a/chapters/tree_traversal/code/cs/Tree.cs b/chapters/tree_traversal/code/cs/Tree.cs
@@ -6,111 +6,106 @@ namespace TreeTraversal
 {
     public class Tree
     {
-        private class Node
+        public int Id { get; private set; }
+        private List<Tree> _children = new List<Tree>();
+
+        public Tree(int depthCount, int childrenCount)
         {
-            public List<Node> Children { get; set; } = new List<Node>();
-            public int Id { get; set; }
+            this.Id = 1;
 
-            public Node(int id) => this.Id = id;
+            if (!(depthCount <= 1))
+            {
+                for (int i = 0; i < childrenCount; i++)
+                    this._children.Add(new Tree(this.Id * 10 + i + 1, depthCount - 1, childrenCount));
+            }
         }
 
-        private Node root;
-
-        public Tree(int depthCount, int childrenCount)
+        private Tree(int id, int depthCount, int childrenCount)
         {
-            root = new Node(1);
-            CreateAllChildren(root, depthCount, childrenCount);
+            this.Id = id;
+
+            if (!(depthCount <= 1))
+            {
+                for (int i = 0; i < childrenCount; i++)
+                    this._children.Add(new Tree(this.Id * 10 + i + 1, depthCount - 1, childrenCount));
+            }
         }
 
         public void DFSRecursive()
         {
-            DFSRecursive(root);
+            DFSRecursive(this);
 
-            void DFSRecursive(Node node)
+            void DFSRecursive(Tree tree)
             {
-                Console.WriteLine(node.Id);
+                Console.WriteLine(tree.Id);
 
-                foreach (var c in node.Children)
+                foreach (var c in tree._children)
                     DFSRecursive(c);
             }
         }
 
         public void DFSRecursivePostorder()
         {
-            DFSRecursivePostorder(root);
+            DFSRecursivePostorder(this);
 
-            void DFSRecursivePostorder(Node node)
+            void DFSRecursivePostorder(Tree tree)
             {
-                foreach (var c in node.Children)
+                foreach (var c in tree._children)
                     DFSRecursivePostorder(c);
 
-                Console.WriteLine(node.Id);
+                Console.WriteLine(tree.Id);
             }
         }
 
         public void DFSRecursiveInorderBinary()
         {
-            DFSRecursiveInorderBinary(root);
+            DFSRecursiveInorderBinary(this);
 
             // This assumes only 2 children
-            void DFSRecursiveInorderBinary(Node node)
+            void DFSRecursiveInorderBinary(Tree tree)
             {
-                if (node.Children.Count > 2)
-                     throw new Exception("Not binary tree!");
+                if (tree._children.Count > 2)
+                    throw new Exception("Not binary tree!");
 
-                if (node.Children.Count > 0)
+                if (tree._children.Count > 0)
                 {
-                    DFSRecursiveInorderBinary(node.Children[0]);
-                    Console.WriteLine(node.Id);
-                    DFSRecursiveInorderBinary(node.Children[1]);
+                    DFSRecursiveInorderBinary(tree._children[0]);
+                    Console.WriteLine(tree.Id);
+                    DFSRecursiveInorderBinary(tree._children[1]);
                 }
                 else
-                    Console.WriteLine(node.Id);
+                    Console.WriteLine(tree.Id);
             }
         }
 
         public void DFSStack()
         {
-            var stack = new Stack<Node>();
-            stack.Push(root);
-            Node temp;
+            var stack = new Stack<Tree>();
+            stack.Push(this);
 
             while (stack.Count != 0)
             {
                 Console.WriteLine(stack.Peek().Id);
-                temp = stack.Pop();
+                var temp = stack.Pop();
 
-                foreach (var c in temp.Children)
+                foreach (var c in temp._children)
                     stack.Push(c);
             }
         }
 
         public void BFSQueue()
         {
-            var queue = new Queue<Node>();
-            queue.Enqueue(root);
-            Node temp;
+            var queue = new Queue<Tree>();
+            queue.Enqueue(this);
 
             while (queue.Count != 0)
             {
                 Console.WriteLine(queue.Peek().Id);
-                temp = queue.Dequeue();
+                var temp = queue.Dequeue();
 
-                foreach (var c in temp.Children)
+                foreach (var c in temp._children)
                     queue.Enqueue(c);
             }
         }
-
-        private void CreateAllChildren(Node node, int rowCount, int childrenCount)
-        {
-            if (rowCount <= 1)
-                return;
-
-            for (int i = 0; i < childrenCount; i++)
-            {
-                node.Children.Add(new Node(node.Id * 10 + i + 1));
-                CreateAllChildren(node.Children[i], rowCount - 1, childrenCount);
-            }
-        }
     }
 }
diff --git a/chapters/tree_traversal/tree_traversal.md b/chapters/tree_traversal/tree_traversal.md
@@ -8,7 +8,7 @@ Trees are naturally recursive data structures, and because of this, we cannot ac
 {% sample lang="cpp" %}
 [import:15-18, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:9-15, lang:"csharp"](code/cs/Tree.cs)
+[import:7-11, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:7-11, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -35,7 +35,7 @@ Because of this, the most straightforward way to traverse the tree might be recu
 {% sample lang="cpp" %}
 [import:20-27, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:25-36, lang:"csharp"](code/cs/Tree.cs)
+[import:34-45, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:37-45, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -71,7 +71,7 @@ Now, in this case the first element searched through is still the root of the tr
 This has not been implemented in your chosen language, so here is the Julia code
 [import:18-26, lang:"julia"](code/julia/Tree.jl)
 {% sample lang="cs" %}
-[import:38-49, lang:"csharp"](code/cs/Tree.cs)
+[import:47-58, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:47-53, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -103,7 +103,7 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 This has not been implemented in your chosen language, so here is the Julia code
 [import:28-43, lang:"julia"](code/julia/Tree.jl)
 {% sample lang="cs" %}
-[import:51-70, lang:"csharp"](code/cs/Tree.cs)
+[import:60-79, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:55-73, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -144,7 +144,7 @@ In code, it looks like this:
 {% sample lang="cpp" %}
 [import:29-45, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:72-86, lang:"csharp"](code/cs/Tree.cs)
+[import:81-94, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:75-93, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}
@@ -177,7 +177,7 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 {% sample lang="cpp" %}
 [import:47-61, lang:"c_cpp"](code/c++/tree_example.cpp)
 {% sample lang="cs" %}
-[import:88-102, lang:"csharp"](code/cs/Tree.cs)
+[import:96-109, lang:"csharp"](code/cs/Tree.cs)
 {% sample lang="c" %}
 [import:95-113, lang:"c_cpp"](code/c/tree_traversal.c)
 {% sample lang="java" %}

Original file line number	Diff line number	Diff line change
`@@ -6,111 +6,106 @@ namespace TreeTraversal`
`6`	`6`	`{`
`7`	`7`	`public class Tree`
`8`	`8`	`{`
`9`		`- private class Node`
	`9`	`+ public int Id { get; private set; }`
	`10`	`+ private List<Tree> _children = new List<Tree>();`
	`11`	`+`
	`12`	`+ public Tree(int depthCount, int childrenCount)`
`10`	`13`	`{`
`11`		`- public List<Node> Children { get; set; } = new List<Node>();`
`12`		`- public int Id { get; set; }`
	`14`	`+ this.Id = 1;`
`13`	`15`
`14`		`- public Node(int id) => this.Id = id;`
	`16`	`+ if (!(depthCount <= 1))`
	`17`	`+ {`
	`18`	`+ for (int i = 0; i < childrenCount; i++)`
	`19`	`+ this._children.Add(new Tree(this.Id * 10 + i + 1, depthCount - 1, childrenCount));`
	`20`	`+ }`
`15`	`21`	`}`
`16`	`22`
`17`		`- private Node root;`
`18`		`-`
`19`		`- public Tree(int depthCount, int childrenCount)`
	`23`	`+ private Tree(int id, int depthCount, int childrenCount)`
`20`	`24`	`{`
`21`		`- root = new Node(1);`
`22`		`- CreateAllChildren(root, depthCount, childrenCount);`
	`25`	`+ this.Id = id;`
	`26`	`+`
	`27`	`+ if (!(depthCount <= 1))`
	`28`	`+ {`
	`29`	`+ for (int i = 0; i < childrenCount; i++)`
	`30`	`+ this._children.Add(new Tree(this.Id * 10 + i + 1, depthCount - 1, childrenCount));`
	`31`	`+ }`
`23`	`32`	`}`
`24`	`33`
`25`	`34`	`public void DFSRecursive()`
`26`	`35`	`{`
`27`		`- DFSRecursive(root);`
	`36`	`+ DFSRecursive(this);`
`28`	`37`
`29`		`- void DFSRecursive(Node node)`
	`38`	`+ void DFSRecursive(Tree tree)`
`30`	`39`	`{`
`31`		`- Console.WriteLine(node.Id);`
	`40`	`+ Console.WriteLine(tree.Id);`
`32`	`41`
`33`		`- foreach (var c in node.Children)`
	`42`	`+ foreach (var c in tree._children)`
`34`	`43`	`DFSRecursive(c);`
`35`	`44`	`}`
`36`	`45`	`}`
`37`	`46`
`38`	`47`	`public void DFSRecursivePostorder()`
`39`	`48`	`{`
`40`		`- DFSRecursivePostorder(root);`
	`49`	`+ DFSRecursivePostorder(this);`
`41`	`50`
`42`		`- void DFSRecursivePostorder(Node node)`
	`51`	`+ void DFSRecursivePostorder(Tree tree)`
`43`	`52`	`{`
`44`		`- foreach (var c in node.Children)`
	`53`	`+ foreach (var c in tree._children)`
`45`	`54`	`DFSRecursivePostorder(c);`
`46`	`55`
`47`		`- Console.WriteLine(node.Id);`
	`56`	`+ Console.WriteLine(tree.Id);`
`48`	`57`	`}`
`49`	`58`	`}`
`50`	`59`
`51`	`60`	`public void DFSRecursiveInorderBinary()`
`52`	`61`	`{`
`53`		`- DFSRecursiveInorderBinary(root);`
	`62`	`+ DFSRecursiveInorderBinary(this);`
`54`	`63`
`55`	`64`	`// This assumes only 2 children`
`56`		`- void DFSRecursiveInorderBinary(Node node)`
	`65`	`+ void DFSRecursiveInorderBinary(Tree tree)`
`57`	`66`	`{`
`58`		`- if (node.Children.Count > 2)`
`59`		`- throw new Exception("Not binary tree!");`
	`67`	`+ if (tree._children.Count > 2)`
	`68`	`+ throw new Exception("Not binary tree!");`
`60`	`69`
`61`		`- if (node.Children.Count > 0)`
	`70`	`+ if (tree._children.Count > 0)`
`62`	`71`	`{`
`63`		`- DFSRecursiveInorderBinary(node.Children[0]);`
`64`		`- Console.WriteLine(node.Id);`
`65`		`- DFSRecursiveInorderBinary(node.Children[1]);`
	`72`	`+ DFSRecursiveInorderBinary(tree._children[0]);`
	`73`	`+ Console.WriteLine(tree.Id);`
	`74`	`+ DFSRecursiveInorderBinary(tree._children[1]);`
`66`	`75`	`}`
`67`	`76`	`else`
`68`		`- Console.WriteLine(node.Id);`
	`77`	`+ Console.WriteLine(tree.Id);`
`69`	`78`	`}`
`70`	`79`	`}`
`71`	`80`
`72`	`81`	`public void DFSStack()`
`73`	`82`	`{`
`74`		`- var stack = new Stack<Node>();`
`75`		`- stack.Push(root);`
`76`		`- Node temp;`
	`83`	`+ var stack = new Stack<Tree>();`
	`84`	`+ stack.Push(this);`
`77`	`85`
`78`	`86`	`while (stack.Count != 0)`
`79`	`87`	`{`
`80`	`88`	`Console.WriteLine(stack.Peek().Id);`
`81`		`- temp = stack.Pop();`
	`89`	`+ var temp = stack.Pop();`
`82`	`90`
`83`		`- foreach (var c in temp.Children)`
	`91`	`+ foreach (var c in temp._children)`
`84`	`92`	`stack.Push(c);`
`85`	`93`	`}`
`86`	`94`	`}`
`87`	`95`
`88`	`96`	`public void BFSQueue()`
`89`	`97`	`{`
`90`		`- var queue = new Queue<Node>();`
`91`		`- queue.Enqueue(root);`
`92`		`- Node temp;`
	`98`	`+ var queue = new Queue<Tree>();`
	`99`	`+ queue.Enqueue(this);`
`93`	`100`
`94`	`101`	`while (queue.Count != 0)`
`95`	`102`	`{`
`96`	`103`	`Console.WriteLine(queue.Peek().Id);`
`97`		`- temp = queue.Dequeue();`
	`104`	`+ var temp = queue.Dequeue();`
`98`	`105`
`99`		`- foreach (var c in temp.Children)`
	`106`	`+ foreach (var c in temp._children)`
`100`	`107`	`queue.Enqueue(c);`
`101`	`108`	`}`
`102`	`109`	`}`
`103`		`-`
`104`		`- private void CreateAllChildren(Node node, int rowCount, int childrenCount)`
`105`		`- {`
`106`		`- if (rowCount <= 1)`
`107`		`- return;`
`108`		`-`
`109`		`- for (int i = 0; i < childrenCount; i++)`
`110`		`- {`
`111`		`- node.Children.Add(new Node(node.Id * 10 + i + 1));`
`112`		`- CreateAllChildren(node.Children[i], rowCount - 1, childrenCount);`
`113`		`- }`
`114`		`- }`
`115`	`110`	`}`
`116`	`111`	`}`