Initial data commit
This commit is contained in:
Ingy döt Net
parent
72d218235f
commit
f23f22d71c
199087 changed files with 3378941 additions and 0 deletions
40
Task/Tree-traversal/JavaScript/tree-traversal-1.js
Normal file
40
Task/Tree-traversal/JavaScript/tree-traversal-1.js
Normal file
|
|
@ -0,0 +1,40 @@
|
|||
function BinaryTree(value, left, right) {
|
||||
this.value = value;
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
BinaryTree.prototype.preorder = function(f) {this.walk(f,['this','left','right'])}
|
||||
BinaryTree.prototype.inorder = function(f) {this.walk(f,['left','this','right'])}
|
||||
BinaryTree.prototype.postorder = function(f) {this.walk(f,['left','right','this'])}
|
||||
BinaryTree.prototype.walk = function(func, order) {
|
||||
for (var i in order)
|
||||
switch (order[i]) {
|
||||
case "this": func(this.value); break;
|
||||
case "left": if (this.left) this.left.walk(func, order); break;
|
||||
case "right": if (this.right) this.right.walk(func, order); break;
|
||||
}
|
||||
}
|
||||
BinaryTree.prototype.levelorder = function(func) {
|
||||
var queue = [this];
|
||||
while (queue.length != 0) {
|
||||
var node = queue.shift();
|
||||
func(node.value);
|
||||
if (node.left) queue.push(node.left);
|
||||
if (node.right) queue.push(node.right);
|
||||
}
|
||||
}
|
||||
|
||||
// convenience function for creating a binary tree
|
||||
function createBinaryTreeFromArray(ary) {
|
||||
var left = null, right = null;
|
||||
if (ary[1]) left = createBinaryTreeFromArray(ary[1]);
|
||||
if (ary[2]) right = createBinaryTreeFromArray(ary[2]);
|
||||
return new BinaryTree(ary[0], left, right);
|
||||
}
|
||||
|
||||
var tree = createBinaryTreeFromArray([1, [2, [4, [7]], [5]], [3, [6, [8],[9]]]]);
|
||||
|
||||
print("*** preorder ***"); tree.preorder(print);
|
||||
print("*** inorder ***"); tree.inorder(print);
|
||||
print("*** postorder ***"); tree.postorder(print);
|
||||
print("*** levelorder ***"); tree.levelorder(print);
|
||||
89
Task/Tree-traversal/JavaScript/tree-traversal-2.js
Normal file
89
Task/Tree-traversal/JavaScript/tree-traversal-2.js
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
(function () {
|
||||
|
||||
function preorder(n) {
|
||||
return [n[v]].concat(
|
||||
n[l] ? preorder(n[l]) : []
|
||||
).concat(
|
||||
n[r] ? preorder(n[r]) : []
|
||||
);
|
||||
}
|
||||
|
||||
function inorder(n) {
|
||||
return (
|
||||
n[l] ? inorder(n[l]) : []
|
||||
).concat(
|
||||
n[v]
|
||||
).concat(
|
||||
n[r] ? inorder(n[r]) : []
|
||||
);
|
||||
}
|
||||
|
||||
function postorder(n) {
|
||||
return (
|
||||
n[l] ? postorder(n[l]) : []
|
||||
).concat(
|
||||
n[r] ? postorder(n[r]) : []
|
||||
).concat(
|
||||
n[v]
|
||||
);
|
||||
}
|
||||
|
||||
function levelorder(n) {
|
||||
return (function loop(x) {
|
||||
return x.length ? (
|
||||
x[0] ? (
|
||||
[x[0][v]].concat(
|
||||
loop(
|
||||
x.slice(1).concat(
|
||||
[x[0][l], x[0][r]]
|
||||
)
|
||||
)
|
||||
)
|
||||
) : loop(x.slice(1))
|
||||
) : [];
|
||||
})([n]);
|
||||
}
|
||||
|
||||
var v = 0,
|
||||
l = 1,
|
||||
r = 2,
|
||||
|
||||
tree = [1,
|
||||
[2,
|
||||
[4,
|
||||
[7]
|
||||
],
|
||||
[5]
|
||||
],
|
||||
[3,
|
||||
[6,
|
||||
[8],
|
||||
[9]
|
||||
]
|
||||
]
|
||||
],
|
||||
|
||||
lstTest = [["Traversal", "Nodes visited"]].concat(
|
||||
[preorder, inorder, postorder, levelorder].map(
|
||||
function (f) {
|
||||
return [f.name, f(tree)];
|
||||
}
|
||||
)
|
||||
);
|
||||
|
||||
// [[a]] -> bool -> s -> s
|
||||
function wikiTable(lstRows, blnHeaderRow, strStyle) {
|
||||
return '{| class="wikitable" ' + (
|
||||
strStyle ? 'style="' + strStyle + '"' : ''
|
||||
) + lstRows.map(function (lstRow, iRow) {
|
||||
var strDelim = ((blnHeaderRow && !iRow) ? '!' : '|');
|
||||
|
||||
return '\n|-\n' + strDelim + ' ' + lstRow.map(function (v) {
|
||||
return typeof v === 'undefined' ? ' ' : v;
|
||||
}).join(' ' + strDelim + strDelim + ' ');
|
||||
}).join('') + '\n|}';
|
||||
}
|
||||
|
||||
return wikiTable(lstTest, true) + '\n\n' + JSON.stringify(lstTest);
|
||||
|
||||
})();
|
||||
3
Task/Tree-traversal/JavaScript/tree-traversal-3.js
Normal file
3
Task/Tree-traversal/JavaScript/tree-traversal-3.js
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
[["Traversal","Nodes visited"],
|
||||
["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]],["levelorder",[1,2,3,4,5,6,7,8,9]]]
|
||||
121
Task/Tree-traversal/JavaScript/tree-traversal-4.js
Normal file
121
Task/Tree-traversal/JavaScript/tree-traversal-4.js
Normal file
|
|
@ -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
|
||||
);
|
||||
}, {});
|
||||
|
||||
})();
|
||||
4
Task/Tree-traversal/JavaScript/tree-traversal-5.js
Normal file
4
Task/Tree-traversal/JavaScript/tree-traversal-5.js
Normal file
|
|
@ -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]}
|
||||
128
Task/Tree-traversal/JavaScript/tree-traversal-6.js
Normal file
128
Task/Tree-traversal/JavaScript/tree-traversal-6.js
Normal file
|
|
@ -0,0 +1,128 @@
|
|||
(() => {
|
||||
"use strict";
|
||||
|
||||
// preorder :: a -> [[a]] -> [a]
|
||||
const preorder = x =>
|
||||
xs => [x, ...xs.flat()];
|
||||
|
||||
|
||||
// inorder :: a -> [[a]] -> [a]
|
||||
const inorder = x =>
|
||||
xs => Boolean(xs.length) ? (
|
||||
[...xs[0], x, ...xs.slice(1).flat()]
|
||||
) : [x];
|
||||
|
||||
|
||||
// postorder :: a -> [[a]] -> [a]
|
||||
const postorder = x =>
|
||||
xs => [...xs.flat(), x];
|
||||
|
||||
|
||||
// levelOrder :: Tree a -> [a]
|
||||
const levelOrder = tree =>
|
||||
levels(tree).flat();
|
||||
|
||||
|
||||
// ------------------------TEST------------------------
|
||||
// main :: IO ()
|
||||
const main = () => {
|
||||
const tree = Node(1)([
|
||||
Node(2)([
|
||||
Node(4)([
|
||||
Node(7)([])
|
||||
]),
|
||||
Node(5)([])
|
||||
]),
|
||||
Node(3)([
|
||||
Node(6)([
|
||||
Node(8)([]),
|
||||
Node(9)([])
|
||||
])
|
||||
])
|
||||
]);
|
||||
|
||||
// Generated by code in Rosetta Code
|
||||
// task: 'Visualize a tree'
|
||||
console.log([
|
||||
" + 4 - 7",
|
||||
" + 2 ¦",
|
||||
" ¦ + 5",
|
||||
" 1 ¦",
|
||||
" ¦ + 8",
|
||||
" + 3 - 6 ¦",
|
||||
" + 9"
|
||||
].join("\n"));
|
||||
|
||||
[preorder, inorder, postorder]
|
||||
.forEach(f => console.log(
|
||||
justifyRight(11)(" ")(`${f.name}:`),
|
||||
foldTree(f)(
|
||||
tree
|
||||
)
|
||||
));
|
||||
|
||||
console.log(
|
||||
`levelOrder: ${levelOrder(tree)}`
|
||||
);
|
||||
};
|
||||
|
||||
// ---------------------- TREES ----------------------
|
||||
|
||||
// Node :: a -> [Tree a] -> Tree a
|
||||
const Node = v =>
|
||||
// Constructor for a Tree node which connects a
|
||||
// value of some kind to a list of zero or
|
||||
// more child trees.
|
||||
xs => ({
|
||||
type: "Node",
|
||||
root: v,
|
||||
nest: xs || []
|
||||
});
|
||||
|
||||
|
||||
// foldTree :: (a -> [b] -> b) -> Tree a -> b
|
||||
const foldTree = f => {
|
||||
// The catamorphism on trees. A summary
|
||||
// value obtained by a depth-first fold.
|
||||
const go = tree => f(
|
||||
tree.root
|
||||
)(
|
||||
tree.nest.map(go)
|
||||
);
|
||||
|
||||
return go;
|
||||
};
|
||||
|
||||
|
||||
// levels :: Tree a -> [[a]]
|
||||
const levels = tree => {
|
||||
// A list of lists, grouping the root
|
||||
// values of each level of the tree.
|
||||
const go = (a, node) => {
|
||||
const [h, ...t] = 0 < a.length ? a : [
|
||||
[]
|
||||
];
|
||||
|
||||
return [
|
||||
[node.root, ...h],
|
||||
...node.nest.reduceRight(go, t)
|
||||
];
|
||||
};
|
||||
|
||||
return go([], tree);
|
||||
};
|
||||
|
||||
|
||||
// --------------------- GENERIC ---------------------
|
||||
|
||||
// justifyRight :: Int -> Char -> String -> String
|
||||
const justifyRight = n =>
|
||||
// The string s, preceded by enough padding (with
|
||||
// the character c) to reach the string length n.
|
||||
c => s => Boolean(s) ? (
|
||||
s.padStart(n, c)
|
||||
) : "";
|
||||
|
||||
// MAIN ---
|
||||
return main();
|
||||
})();
|
||||
Loading…
Add table
Add a link
Reference in a new issue