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)

Author: june128

contents/tree_traversal/code/emojicode/tree_traversal.emojic

@@ -6,22 +6,14 @@
     1 ➡️ 🖍id
     🍨🍆 ➡️ 🖍children
 
-    ↪️ ❎ depth_count ◀️🙌 1❗️ 🍇
-      🔂 i 🆕⏩⏩ 0 children_count❗️ 🍇
-        🐻 children 🆕🌲⭐️ 🤜id ✖️ 10 ➕ i ➕ 1🤛 🤜depth_count ➖ 1🤛 children_count❗️❗️
-      🍉
-    🍉
+    🌌🐕 depth_count children_count❗️
   🍉
 
   🔐 🆕 ⭐️ given_id 🔢 depth_count 🔢 children_count 🔢 🍇
     given_id ➡️ 🖍id
     🍨🍆 ➡️ 🖍children
 
-    ↪️ ❎ depth_count ◀️🙌 1❗️ 🍇
-      🔂 i 🆕⏩⏩ 0 children_count❗️ 🍇
-        🐻 children 🆕🌲⭐️ 🤜id ✖️ 10 ➕ i ➕ 1🤛 🤜depth_count ➖ 1🤛 children_count❗️❗️
-      🍉
-    🍉
+    🌌🐕 depth_count children_count❗️
   🍉
 
   ❗️ 🆔 ➡️ 🔢 🍇
@@ -100,6 +92,14 @@
       🍉
     🍉
   🍉
+
+  🔐 ❗️ 🌌 depth_count 🔢 children_count 🔢 🍇
+    ↪️ ❎ depth_count ◀️🙌 1❗️ 🍇
+      🔂 i 🆕⏩⏩ 0 children_count❗️ 🍇
+        🐻 children 🆕🌲⭐️ 🤜id ✖️ 10 ➕ i ➕ 1🤛 🤜depth_count ➖ 1🤛 children_count❗️❗️
+      🍉
+    🍉
+  🍉
 🍉
 
 🏁 🍇

contents/tree_traversal/tree_traversal.md

@@ -73,7 +73,7 @@ Because of this, the most straightforward way to traverse the tree might be recu
 {% sample lang="go" %}
 [import:10-15, lang:"golang"](code/golang/treetraversal.go)
 {% sample lang="emojic" %}
-[import:35-42, lang:"emojicode"](code/emojicode/tree_traversal.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:
@@ -119,7 +119,7 @@ Now, in this case the first element searched through is still the root of the tr
 {% sample lang="go" %}
 [import:17-22, lang:"golang"](code/golang/treetraversal.go)
 {% sample lang="emojic" %}
-[import:44-51, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+[import:36-43, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 <p>
@@ -160,7 +160,7 @@ In this case, the first node visited is at the bottom of the tree and moves up t
 {% sample lang="go" %}
 [import:24-38, lang:"golang"](code/golang/treetraversal.go)
 {% sample lang="emojic" %}
-[import:53-68, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+[import:45-60, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 <p>
@@ -211,7 +211,7 @@ In code, it looks like this:
 {% sample lang="go" %}
 [import:40-49, lang:"golang"](code/golang/treetraversal.go)
 {% sample lang="emojic" %}
-[import:70-85, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+[import:62-77, 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:
@@ -254,7 +254,7 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
 {% sample lang="go" %}
 [import:51-60, lang:"golang"](code/golang/treetraversal.go)
 {% sample lang="emojic" %}
-[import:87-102, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+[import:79-94, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
 {% endmethod %}
 
 ## Example Code