Add Tree Traversal in Emojicode

This is a combination of 5 commits.
This is the 1st commit message:

Add Tree Traversal in Emojicode

This is the 2nd commit message:

Remove unnecessary 🤜🤛.

This was suggested by thbwd:
"No need to wrap 🤜children_count🤛 into 🤜🤛actually."
(https://github.com/algorithm-archivists/algorithm-archive/pull/
471#discussion_r223291032)

This is the 3rd commit message:

Extract shared logic into a method.

This was suggested by thbwd:
"This is shared logic. I’d recommend you extract it into a method."
(https://github.com/algorithm-archivists/algorithm-archive/pull/
471#discussion_r223291140)

This is the 4th commit message:

Use documentation comments.

This was suggested by thbwd:
"Shouldn’t these be documentation comments? https://www.emojicode.org/
docs/reference/documentation.html"
(https://github.com/algorithm-archivists/algorithm-archive/pull/
471#discussion_r223291281)

This is the 5th commit message:

Add error as a potential return value for DFS RI Binary

To be able to return an error and to apply suggestion by thbwd
(https://github.com/algorithm-archivists/algorithm-archive/pull/
471#discussion_r223597592) the following changes were made:
- Declare an enum to hold the error value.
- Rewrite the Depth-First Search Recursive Inorder Binary method to
return an optional holding the enum and adjust the returns according
to that.
- Call the rewritten method and check, if the returned optional holds
error. If it does: Print out the error message defined in the enum.

Signed-off-by: Julian Schacher <jspp@posteo.net>

Author: june128

contents/tree_traversal/code/emojicode/tree_traversal.emojic

@@ -0,0 +1,143 @@
+🦃 ⏹ 🍇
+  🔘 ⏫
+
+  ❗️ 🔡 ➡️ 🔡 🍇
+    ↪️ 🐕 🙌 🆕⏹⏫❗️ 🍇
+      ↩️ 🔤The given tree is not binary!🔤
+    🍉
+    ↩️ 🔤🔤
+  🍉
+🍉
+
+🐇 🌲 🍇
+  🖍🆕 id 🔢
+  🖍🆕 children 🍨🐚🌲🍆
+
+  🆕 depth_count 🔢 children_count 🔢 🍇
+    1 ➡️ 🖍id
+    🍨🍆 ➡️ 🖍children
+
+    🌌🐕 depth_count children_count❗️
+  🍉
+
+  🔐 🆕 ⭐️ given_id 🔢 depth_count 🔢 children_count 🔢 🍇
+    given_id ➡️ 🖍id
+    🍨🍆 ➡️ 🖍children
+
+    🌌🐕 depth_count children_count❗️
+  🍉
+
+  ❗️ 🆔 ➡️ 🔢 🍇
+    ↩️ id
+  🍉
+
+  ❗️ 🧒 ➡️ 🍨🐚🌲🍆 🍇
+    ↩️ children
+  🍉
+
+  📗 Depth-First Search Recursive pre-order 📗
+  ❗️ 🌀 🍇
+    😀 🔡 id 10❗️❗️
+
+    🔂 child children 🍇
+      🌀 child❗️
+    🍉
+  🍉
+
+  📗 Depth-First Search Recursive post-order 📗
+  ❗️ 🍥 🍇
+    🔂 child children 🍇
+      🍥 child❗️
+    🍉
+
+    😀 🔡 id 10❗️❗️
+  🍉
+
+  📗
+    Depth-First Search Recursive Inorder Binary
+    This assumes only 2 children.
+  📗
+  ❗️ 🍭 ➡️ 🍬⏹ 🍇
+    ↪️ 🐔 children❗️ ▶️ 2 🍇
+      ↩️ 🆕⏹⏫❗️
+    🍉
+
+    ↪️ 🐔 children❗️ ▶️ 0 🍇
+      🍭🐽 children 0❗️❗️
+      😀 🔡 id 10❗️❗️
+      🍭🐽 children 1❗️❗️
+    🍉
+    🙅 🍇
+      😀 🔡 id 10❗️❗️
+    🍉
+    ↩️ 🤷‍♀️
+  🍉
+
+  📗 Depth-First Search Stack 📗
+  ❗️ 🥞 🍇
+    🍨 🐕 🍆 ➡️ stack
+
+    🔁 ❎ 🐔 stack❗️ 🙌  0❗️ 🍇
+      🐽 stack 🐔 stack❗️ ➖ 1❗️ ➡️ temp
+      🐨 stack 🐔 stack❗️ ➖ 1❗️
+
+      😀 🔡 🆔 temp❗️ 10❗️❗️
+
+      🧒 temp❗️ ➡️ temp_children
+      🔂 child temp_children 🍇
+        🐻 stack child❗️
+      🍉
+    🍉
+  🍉
+
+  📗 Breadth-First Search Queue 📗
+  ❗️ 🏢 🍇
+    🍨 🐕 🍆 ➡️ queue
+
+    🔁 ❎ 🐔 queue❗️ 🙌  0❗️ 🍇
+      🐽 queue 0❗️ ➡️ temp
+      🐨 queue 0❗️
+
+      😀 🔡 🆔 temp❗️ 10❗️❗️
+
+      🧒 temp❗️ ➡️ temp_children
+      🔂 child temp_children 🍇
+        🐻 queue child❗️
+      🍉
+    🍉
+  🍉
+
+  🔐 ❗️ 🌌 depth_count 🔢 children_count 🔢 🍇
+    ↪️ ❎ depth_count ◀️🙌 1❗️ 🍇
+      🔂 i 🆕⏩⏩ 0 children_count❗️ 🍇
+        🐻 children 🆕🌲⭐️ 🤜id ✖️ 10 ➕ i ➕ 1🤛 🤜depth_count ➖ 1🤛 children_count❗️❗️
+      🍉
+    🍉
+  🍉
+🍉
+
+🏁 🍇
+  🆕🌲🆕 3 3❗️ ➡️ tree
+  😀 🔤Tree Traversal🔤️❗️
+  😀 🔤🌀  - Depth-First Search Recursive pre-order🔤❗️
+  🌀tree❗️
+  😀 🔤🍥  - Depth-First Search Recursive post-order🔤❗️
+  🍥tree❗️
+  😀 🔤🥞  - Depth-First Search Stack🔤❗️
+  🥞tree❗️
+  😀 🔤🏢  - Breadth-First Search Queue🔤❗️
+  🏢tree❗️
+
+  😀 🔤🍭  - Depth-First Search Recursive Inorder Binary - Error🔤❗️
+  💭 Calling the Depth-First Search Recursive Inorder Binary method here does
+  💭 result in an error, since "tree" is not a binary tree.
+  ️↪️ 🍭tree❗️ ➡️ return 🍇
+    😀 🔡return❗❗️️
+  🍉
+
+  🆕🌲🆕 3 2❗️ ➡️ binary_tree
+  😀 🔤🍭  - Depth-First Search Recursive Inorder Binary🔤❗️
+  ️↪️ 🍭binary_tree❗️ ➡️ return 🍇
+    😀 🔡return❗❗️️
+  🍉
+🍉

contents/tree_traversal/tree_traversal.md

@@ -36,6 +36,8 @@ As a note, a `node` struct is not necessary in javascript, so this is an example
 [import:5-8, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:24-27, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:1-3, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 Because of this, the most straightforward way to traverse the tree might be recursive. This naturally leads us to the Depth-First Search (DFS) method:
@@ -74,6 +76,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
 [import:10-15, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:290-314, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:27-34, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 At least to me, this makes a lot of sense. We fight recursion with recursion! First, we first output the node we are on and then we call `DFS_recursive(...)` on each of its children nodes. This method of tree traversal does what its name implies: it goes to the depths of the tree first before going through the rest of the branches. In this case, the ordering looks like:
@@ -120,6 +124,8 @@ Now, in this case the first element searched through is still the root of the tr
 [import:17-22, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:316-344, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:36-43, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 <p>
@@ -161,6 +167,8 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 [import:24-38, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:346-396, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:45-62, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 <p>
@@ -212,6 +220,8 @@ In code, it looks like this:
 [import:40-49, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:398-445, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:64-79, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 All this said, there are a few details about DFS that might not be idea, depending on the situation. For example, if we use DFS on an incredibly long tree, we will spend a lot of time going further and further down a single branch without searching the rest of the data structure. In addition, it is not the natural way humans would order a tree if asked to number all the nodes from top to bottom. I would argue a more natural traversal order would look something like this:
@@ -255,6 +265,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 [import:51-60, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import:447-498, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import:81-96, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 ## Example Code
@@ -300,6 +312,8 @@ The code snippets were taken from this [Scratch project](https://scratch.mit.edu
 [import, lang:"go"](code/golang/treetraversal.go)
 {% sample lang="asm-x64" %}
 [import, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
+{% sample lang="emojic" %}
+[import, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}