adding new implementations of Tree Traversal and file for euclidean algorithm

Author: leios

SUMMARY.md

@@ -13,6 +13,7 @@
     * [Taylor Series](chapters/mathematical_background/taylor_series.md)
 * [Fundamental Algorithms](chapters/fundamental_algorithms/fundamental_algorithms.md)
     * [Tree Traversal](chapters/fundamental_algorithms/tree_traversal.md)
+    * [Euclidean Algorithm](chapters/fundamental_algorithms/euclidean_algorithm/euclidean.md)
 * [Computational Mathematics](chapters/computational_mathematics/computational_mathematics.md)
     * [Matrix Methods](chapters/computational_mathematics/matrix_methods/matrix_methods.md)
         * [Gaussian Elimination](chapters/computational_mathematics/matrix_methods/gaussian_elimination.md)

chapters/fundamental_algorithms/euclidean_algorithm/euclidean.md

@@ -0,0 +1,25 @@
+<script>
+MathJax.Hub.Queue(["Typeset",MathJax.Hub]);
+</script>
+$$ 
+\newcommand{\d}{\mathrm{d}}
+\newcommand{\bff}{\boldsymbol{f}}
+\newcommand{\bfg}{\boldsymbol{g}}
+\newcommand{\bfp}{\boldsymbol{p}}
+\newcommand{\bfq}{\boldsymbol{q}}
+\newcommand{\bfx}{\boldsymbol{x}}
+\newcommand{\bfu}{\boldsymbol{u}}
+\newcommand{\bfv}{\boldsymbol{v}}
+\newcommand{\bfA}{\boldsymbol{A}}
+\newcommand{\bfB}{\boldsymbol{B}}
+\newcommand{\bfC}{\boldsymbol{C}}
+\newcommand{\bfM}{\boldsymbol{M}}
+\newcommand{\bfJ}{\boldsymbol{J}}
+\newcommand{\bfR}{\boldsymbol{R}}
+\newcommand{\bfT}{\boldsymbol{T}}
+\newcommand{\bfomega}{\boldsymbol{\omega}}
+\newcommand{\bftau}{\boldsymbol{\tau}}
+$$
+
+# Euclidean Algorithm
+

chapters/fundamental_algorithms/scratch_tree.png

@@ -328,6 +328,94 @@ def main():
 main()
 ```
 
+#### Python 2
+```python
+# Depth-First and Breadth-First Traversal
+# Submitted by Matthew Giallourakis 
+from collections import deque
+ 
+class node():
+    "Create the node structure"
+    def __init__(self, value, left, right):
+        self.value = value
+        self.left = left
+        self.right = right
+ 
+def make_tree(root,nums):
+    "Makes a binary search tree from a list of numbers"
+    for num in nums:
+        temp_node = root
+        new_node = node(value=num, left=None, right=None)
+        while True:
+            if num < temp_node.value:
+                if temp_node.left is None:
+                    temp_node.left = new_node
+                    break
+                else:
+                    temp_node = temp_node.left
+            elif num > temp_node.value:
+                if temp_node.right is None:
+                    temp_node.right = new_node
+                    break
+                else:
+                    temp_node = temp_node.right
+ 
+def depth_first_search(root):
+    "Traverses through a tree depth-first by putting nodes on a stack"
+    stack = deque()
+    result_list = []
+    stack.append(root)
+    while len(stack) != 0:
+        # Take off the node at the top of the stack, add it to the list
+        temp_node = stack.pop()
+        result_list.append(temp_node.value)
+        # Add the children of that node to the top of the stack
+        if temp_node.right is not None:
+            stack.append(temp_node.right)
+        if temp_node.left is not None:
+            stack.append(temp_node.left)
+    return result_list
+ 
+ 
+def breadth_first_search(root):
+    "Traverses through a tree breadth-first by putting nodes into a queue"
+    queue = deque()
+    result_list = []
+    queue.append(root)
+    while len(queue) != 0:
+        # Take off the node at the top of the queue, add it to the list
+        temp_node = queue.pop()
+        result_list.append(temp_node.value)
+        # Add the children of that node to the bottom of the queue
+        if temp_node.left is not None:
+            queue.appendleft(temp_node.left)
+        if temp_node.right is not None:
+            queue.appendleft(temp_node.right)
+    return result_list
+ 
+ 
+def main():
+    nums = [5,8,6,9,2,1,3]
+    root = node(value=nums.pop(0),left=None,right=None)
+    make_tree(root,nums)
+    #     Tree Structure
+    #           5
+    #       2       8
+    #     1   3   6   9
+    #              
+ 
+    print("Depth First:",depth_first_search(root))
+    # prints [5, 2, 1, 3, 8, 6, 9]
+     
+    print("Breadth First:",breadth_first_search(root))
+    # prints [5, 2, 8, 1, 3, 6, 9]
+     
+ 
+if __name__ == '__main__':
+    main()
+ 
+```
+
 ### C
 
 ```c
@@ -672,3 +760,43 @@ BFS_queue(root);
 </body>
 <html>
 ```
+
+#### Haskell
+```hs
+--- Submitted by Jie
+data Tree a = Empty
+            | Node {node :: a,
+                    forest :: [Tree a]}
+                       deriving (Show)
+
+dfs :: Tree a -> [a]
+dfs Empty = []
+dfs (Node x ts) = x : concatMap dfs ts
+
+bfs :: Tree a -> [a]
+bfs Empty = []
+bfs (Node x ts) = x : go ts
+  where go [] = []
+        go ts = map node ts ++ go (concatMap forest ts)
+
+main = do
+  print $ dfs testTree
+  print $ bfs testTree
+
+testTree :: Tree Int
+testTree = Node 1 [Node 2 [Node 3 [],
+                           Node 4 [ Node 5 []]],
+                   Node 6 [Node 7 [],
+                           Node 8 [ Node 9 [Node 10 [Node 11 []],
+                                            Node 12 []]],
+                           Node 13 [Node 14 []]],
+                   Node 15 []]
+
+```
+
+#### Scratch
+Submitted by Jie
+
+[https://scratch.mit.edu/projects/174017753/](https://scratch.mit.edu/projects/174017753/)
+
+![Scratch Tree Traversal](scratch_tree.png)