Enhance the code of TreeTraversal and EuclideanAlgorithm for C# (#120)

* Add all additional methods from TreeTraversalMdAdditional to TreeTraversal. Fix incorrect ConsoleWriteLine. Use local functions. Create constructor for Node, which takes an id. Remove unnecessary curly braces. Remove redundant CreateTree method and just put the code into the constructor. Remove unnecessary comment. Remove the now redundant TreeTraversalMdAdditional. Sort the methods so that they have the same order as in the text.

* Delete redundant EuclideanAlgorithmMdAdditional.

* Make EuclideanAlgorithm non-static.

* Make file be "ASCII text" instead of "UTF-8 Unicode (with BOM) text, with CRLF line terminators".

* Provide explanation for commented lines of code.

Author: june128

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/EuclideanAlgorithmMdAdditional/EuclideanAlgorithmMdAdditional.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/code/cs/EuclideanAlgorithmMdAdditional/Program.cs

@@ -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/euclidean_algorithm/code/cs/EuclideanAlgorithm/Program.cs chapters/euclidean_algorithm/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/euclidean_algorithm/euclidean.md

@@ -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);
-            }
-        }
     }
 }