Enhance the code of TreeTraversal and EuclideanAlgorithm for C#

chapters/euclidean_algorithm/code/cs/EuclideanAlgorithm/EuclideanAlgorithm.cs → chapters/euclidean_algorithm/code/cs/EuclideanAlgorithm.cs

@@ -3,9 +3,9 @@
 
 namespace EuclideanAlgorithm
 {
-    public static class EuclideanAlgorithm
+    public class EuclideanAlgorithm
     {
-        public static int EuclidSub(int a, int b)
+        public int EuclidSub(int a, int b)
         {
             // Math.Abs for negative number support
             a = Math.Abs(a);
@@ -22,7 +22,7 @@ public static int EuclidSub(int a, int b)
             return a;
         }
 
-        public static int EuclidMod(int a, int b)
+        public int EuclidMod(int a, int b)
         {
             // Math.Abs for negative number support
             a = Math.Abs(a);

chapters/euclidean_algorithm/code/cs/EuclideanAlgorithm/Program.cs → chapters/euclidean_algorithm/code/cs/Program.cs

@@ -8,8 +8,9 @@ class Program
         static void Main(string[] args)
         {
             Console.WriteLine("EuclideanAlgorithm");
-            int check = EuclideanAlgorithm.EuclidMod(64 * 67, 64 * 81);
-            int check2 = EuclideanAlgorithm.EuclidSub(128 * 12, 128 * 77);
+            var euclideanAlgorithm = new EuclideanAlgorithm();
+            int check = euclideanAlgorithm.EuclidMod(64 * 67, 64 * 81);
+            int check2 = euclideanAlgorithm.EuclidSub(128 * 12, 128 * 77);
 
             Console.WriteLine(check);
             Console.WriteLine(check2);

chapters/euclidean_algorithm/euclidean.md

@@ -8,7 +8,7 @@ The algorithm is a simple way to find the *greatest common divisor* (GCD) of two
 {% sample lang="c" %}
 [import:17-30, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:6-17, lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional/EuclideanAlgorithmMdAdditional.cs)
+[import:8-23, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
 {% sample lang="clj" %}
 [import:2-8, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
@@ -39,7 +39,7 @@ Modern implementations, though, often use the modulus operator (%) like so
 {% sample lang="c" %}
 [import:4-16, lang="c_cpp"](code/c/euclidean_example.c)
 {% sample lang="cs" %}
-[import:19-29, lang="csharp"](code/cs/EuclideanAlgorithmMdAdditional/EuclideanAlgorithmMdAdditional.cs)
+[import:25-39, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
 {% sample lang="clj" %}
 [import:9-13, lang="clojure"](code/clojure/euclidean_example.clj)
 {% sample lang="cpp" %}
@@ -75,9 +75,9 @@ The Euclidean Algorithm is truly fundamental to many other algorithms throughout
 {% sample lang="cs" %}
 ### C# #
 EuclideanAlgorithm.cs
-[import, lang="csharp"](code/cs/EuclideanAlgorithm/EuclideanAlgorithm.cs)
+[import, lang="csharp"](code/cs/EuclideanAlgorithm.cs)
 Program.cs
-[import, lang="csharp"](code/cs/EuclideanAlgorithm/Program.cs)
+[import, lang="csharp"](code/cs/Program.cs)
 {% sample lang="clj" %}
 ### Clojure
 [import 2-20, lang="clojure"](code/clojure/euclidean_example.clj)

chapters/tree_traversal/code/cs/Program.cs

@@ -0,0 +1,28 @@
+// submitted by Julian Schacher (jspp)
+using System;
+
+namespace TreeTraversal
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("TreeTraversal");
+            var tree = new Tree(3, 3);
+            Console.WriteLine("DFSRecursive:");
+            tree.DFSRecursive();
+            Console.WriteLine("DFSStack:");
+            tree.DFSStack();
+            Console.WriteLine("BFSQueue:");
+            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();
+            tree = new Tree(3, 2);
+            Console.WriteLine("DFSRecursiveInorder (succeed)");
+            tree.DFSRecursiveInorderBinary();
+        }
+    }
+}

chapters/tree_traversal/code/cs/Tree/Tree.cs → chapters/tree_traversal/code/cs/Tree.cs

@@ -10,27 +10,63 @@ private class Node
         {
             public List<Node> Children { get; set; } = new List<Node>();
             public int Id { get; set; }
+
+            public Node(int id) => this.Id = id;
         }
 
         private Node root;
 
         public Tree(int depthCount, int childrenCount)
         {
-            CreateTree(depthCount, childrenCount);
+            root = new Node(1);
+            CreateAllChildren(root, depthCount, childrenCount);
         }
 
-        public void CreateTree(int depthCount, int childrenCount)
+        public void DFSRecursive()
         {
-            root = new Node
+            DFSRecursive(root);
+
+            void DFSRecursive(Node node)
             {
-                Id = 1
-            };
-            CreateAllChildren(root, depthCount, childrenCount);
+                Console.WriteLine(node.Id);
+
+                foreach (var c in node.Children)
+                    DFSRecursive(c);
+            }
         }
 
-        public void StartDFSRecursive()
+        public void DFSRecursivePostorder()
         {
-            DFSRecursive(root);
+            DFSRecursivePostorder(root);
+
+            void DFSRecursivePostorder(Node node)
+            {
+                foreach (var c in node.Children)
+                    DFSRecursivePostorder(c);
+
+                Console.WriteLine(node.Id);
+            }
+        }
+
+        public void DFSRecursiveInorderBinary()
+        {
+            DFSRecursiveInorderBinary(root);
+
+            // This assumes only 2 children
+            void DFSRecursiveInorderBinary(Node node)
+            {
+                if (node.Children.Count > 2)
+                     throw new Exception("Not binary tree!");
+
+                if (node.Children.Count > 0)
+                {
+                    DFSRecursiveInorderBinary(node.Children[0]);
+                    Console.WriteLine(node.Id);
+                    DFSRecursiveInorderBinary(node.Children[1]);
+                }
+                else
+                    Console.WriteLine(node.Id);
+            }
         }
 
         public void DFSStack()
@@ -45,9 +81,7 @@ public void DFSStack()
                 temp = stack.Pop();
 
                 foreach (var c in temp.Children)
-                {
                     stack.Push(c);
-                }
             }
         }
 
@@ -63,9 +97,7 @@ public void BFSQueue()
                 temp = queue.Dequeue();
 
                 foreach (var c in temp.Children)
-                {
                     queue.Enqueue(c);
-                }
             }
         }
 
@@ -76,22 +108,9 @@ private void CreateAllChildren(Node node, int rowCount, int childrenCount)
 
             for (int i = 0; i < childrenCount; i++)
             {
-                node.Children.Add(new Node
-                {
-                    Id = node.Id * 10 + i + 1
-                });
+                node.Children.Add(new Node(node.Id * 10 + i + 1));
                 CreateAllChildren(node.Children[i], rowCount - 1, childrenCount);
             }
         }
-
-        private void DFSRecursive(Node node)
-        {
-            Console.WriteLine(node.Id);
-
-            foreach (var c in node.Children)
-            {
-                DFSRecursive(c);
-            }
-        }
     }
 }