2016 Update

Task/Tree-traversal/JavaScript/tree-traversal-4.js

@@ -0,0 +1,121 @@
+(function () {
+    'use strict';
+
+    // 'preorder' | 'inorder' | 'postorder' | 'level-order'
+
+    // traverse :: String -> Tree {value: a, nest: [Tree]} -> [a]
+    function traverse(strOrderName, dctTree) {
+        var strName = strOrderName.toLowerCase();
+
+        if (strName.startsWith('level')) {
+
+            // LEVEL-ORDER
+            return levelOrder([dctTree]);
+
+        } else if (strName.startsWith('in')) {
+            var lstNest = dctTree.nest;
+
+            if ((lstNest ? lstNest.length : 0) < 3) {
+                var left = lstNest[0] || [],
+                    right = lstNest[1] || [],
+
+                    lstLeft = left.nest ? (
+                        traverse(strName, left)
+                    ) : (left.value || []),
+                    lstRight = right.nest ? (
+                        traverse(strName, right)
+                    ) : (right.value || []);
+
+                return (lstLeft !== undefined && lstRight !== undefined) ?
+
+                    // IN-ORDER
+                    (lstLeft instanceof Array ? lstLeft : [lstLeft])
+                    .concat(dctTree.value)
+                    .concat(lstRight) : undefined;
+
+            } else { // in-order only defined here for binary trees
+                return undefined;
+            }
+
+        } else {
+            var lstTraversed = concatMap(function (x) {
+                return traverse(strName, x);
+            }, (dctTree.nest || []));
+
+            return (
+                strName.startsWith('pre') ? (
+
+                    // PRE-ORDER
+                    [dctTree.value].concat(lstTraversed)
+
+                ) : strName.startsWith('post') ? (
+
+                    // POST-ORDER
+                    lstTraversed.concat(dctTree.value)
+
+                ) : []
+            );
+        }
+    }
+
+    // levelOrder :: [Tree {value: a, nest: [Tree]}] -> [a]
+    function levelOrder(lstTree) {
+        var lngTree = lstTree.length,
+            head = lngTree ? lstTree[0] : undefined,
+            tail = lstTree.slice(1);
+
+        // Recursively take any value found in the head node
+        // of the remaining tail, deferring any child nodes
+        // of that head to the end of the tail
+        return lngTree ? (
+            head ? (
+                [head.value].concat(
+                    levelOrder(
+                        tail
+                        .concat(head.nest || [])
+                    )
+                )
+            ) : levelOrder(tail)
+        ) : [];
+    }
+
+    // concatMap :: (a -> [b]) -> [a] -> [b]
+    function concatMap(f, xs) {
+        return [].concat.apply([], xs.map(f));
+    }
+
+    var dctTree = {
+        value: 1,
+        nest: [{
+            value: 2,
+            nest: [{
+                value: 4,
+                nest: [{
+                    value: 7
+                }]
+            }, {
+                value: 5
+            }]
+        }, {
+            value: 3,
+            nest: [{
+                value: 6,
+                nest: [{
+                    value: 8
+                }, {
+                    value: 9
+                }]
+            }]
+        }]
+    };
+
+
+    return ['preorder', 'inorder', 'postorder', 'level-order']
+        .reduce(function (a, k) {
+            return (
+                a[k] = traverse(k, dctTree),
+                a
+            );
+        }, {});
+
+})();

Task/Tree-traversal/JavaScript/tree-traversal-5.js

@@ -0,0 +1,4 @@
+{"preorder":[1, 2, 4, 7, 5, 3, 6, 8, 9],
+"inorder":[7, 4, 2, 5, 1, 8, 6, 9, 3],
+"postorder":[7, 4, 5, 2, 8, 9, 6, 3, 1],
+"level-order":[1, 2, 3, 4, 5, 6, 7, 8, 9]}