diff --git a/contents/tree_traversal/code/matlab/tree.m b/contents/tree_traversal/code/matlab/tree.m
new file mode 100644
index 000000000..69d6ee856
--- /dev/null
+++ b/contents/tree_traversal/code/matlab/tree.m
@@ -0,0 +1,150 @@
+main()
+
+%% Functions
+
+function root = create_tree()
+ node = @(k,v) containers.Map(k,v);
+
+ node2 = node(2, {{}}); node3 = node(3, {{}}); node4 = node(4, {{}});
+ node6 = node(6, {{}}); node7 = node(7, {{}}); node8 = node(8, {{}});
+ node10 = node(10, {{}}); node11 = node(11, {{}}); node12 = node(12, {{}});
+
+ node1 = node(1, {node2, node3, node4});
+ node5 = node(5, {node6, node7, node8});
+ node9 = node(9, {node10, node11, node12});
+
+ root = node(0, {node1, node5, node9});
+end
+
+function root = create_btree()
+ node = @(k,v) containers.Map(k,v);
+
+ node2 = node(2, {{}}); node3 = node(3, {{}});
+ node5 = node(5, {{}}); node6 = node(6, {{}});
+
+ node1 = node(1, {node2, node3});
+ node4 = node(4, {node5, node6});
+
+ root = node(0, {node1, node4});
+end
+
+function DFS_recursive(n)
+
+ cell_index = @(a, b) a{b};
+ ID = cell_index(keys(n), 1);
+
+ fprintf('%u ', ID);
+
+ children = cell_index(values(n), 1);
+ for i = children
+ child = i{1};
+ if ~isempty(child)
+ DFS_recursive(child);
+ end
+ end
+end
+
+function DFS_recursive_postorder(n)
+
+ cell_index = @(a, b) a{b};
+
+ children = cell_index(values(n), 1);
+ for i = children
+ child = i{1};
+ if ~isempty(child)
+ DFS_recursive_postorder(child);
+ end
+ end
+
+ ID = cell_index(keys(n), 1);
+ fprintf('%u ', ID);
+
+end
+
+function DFS_recursive_inorder_btree(n)
+
+ cell_index = @(a, b) a{b};
+ ID = cell_index(keys(n), 1);
+ children = cell_index(values(n), 1);
+
+ if length(children) == 2
+ DFS_recursive_inorder_btree(children{1})
+ fprintf('%u ', ID)
+ DFS_recursive_inorder_btree(children{2})
+ elseif length(children) == 1
+ if ~isempty(children{1})
+ DFS_recursive_inorder_btree(children{1})
+ end
+ fprintf('%u ', ID)
+ else
+ fprintf("Not a binary tree!")
+ end
+end
+
+function DFS_stack(n)
+
+ cell_index = @(a, b) a{b};
+ node_stack = {n};
+
+ while ~isempty(node_stack)
+
+ parent = node_stack{end};
+ node_stack(end) = [];
+
+ ID = cell_index(keys(parent), 1);
+ fprintf('%u ', ID);
+
+ children = cell_index(values(parent), 1);
+
+ for i = flip(children)
+ child = i{1};
+ if ~isempty(child)
+ node_stack = {node_stack{:} child};
+ end
+ end
+ end
+end
+
+function BFS_queue(n)
+
+ cell_index = @(a, b) a{b};
+ node_queue = {n};
+
+ while ~isempty(node_queue)
+ next_nodes = {};
+ for parent_cell = node_queue
+ parent = parent_cell{1};
+ ID = cell_index(keys(parent), 1);
+ fprintf('%u ', ID);
+ children = cell_index(values(parent), 1);
+ for i = children
+ child = i{1};
+ if ~isempty(child)
+ next_nodes = {next_nodes{:}, child};
+ end
+ end
+ end
+ node_queue = next_nodes;
+ end
+end
+
+function main()
+ root = create_tree();
+ rootb = create_btree();
+
+ fprintf('\nDFS Recursive\n')
+ DFS_recursive(root)
+
+ fprintf('\nDFS Recursive Postorder\n')
+ DFS_recursive_postorder(root)
+
+ fprintf('\nDFS Recursive Inorder Binary Tree\n')
+ DFS_recursive_inorder_btree(rootb)
+
+ fprintf('\nDFS Stack\n')
+ DFS_stack(root)
+
+ fprintf('\nBFS Queue\n')
+ BFS_queue(root)
+ fprintf('\n')
+end
\ No newline at end of file
diff --git a/contents/tree_traversal/tree_traversal.md b/contents/tree_traversal/tree_traversal.md
index 41beb58a2..46891aaef 100644
--- a/contents/tree_traversal/tree_traversal.md
+++ b/contents/tree_traversal/tree_traversal.md
@@ -38,6 +38,8 @@ As a note, a `node` struct is not necessary in javascript, so this is an example
[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)
+{% sample lang="m" %}
+[import:6-6, lang:"matlab"](code/matlab/tree.m)
{% 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:
@@ -77,6 +79,8 @@ Because of this, the most straightforward way to traverse the tree might be recu
[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)
+{% sample lang="m" %}
+[import:31-45, lang:"matlab"](code/matlab/tree.m)
{% 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:
@@ -125,6 +129,8 @@ Now, in this case the first element searched through is still the root of the tr
[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)
+{% sample lang="m" %}
+[import:47-62, lang:"matlab"](code/matlab/tree.m)
{% endmethod %}
@@ -168,12 +174,13 @@ In this case, the first node visited is at the bottom of the tree and moves up t
[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)
+{% sample lang="m" %}
+[import:64-82, lang:"matlab"](code/matlab/tree.m)
{% endmethod %}
-
- 
-
-
+
+
+
The order here seems to be some mix of the other 2 methods and works through the binary tree from left to right.
@@ -221,6 +228,8 @@ In code, it looks like this:
[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)
+{% sample lang="m" %}
+[import:84-106, lang:"matlab"](code/matlab/tree.m)
{% endmethod %}
All this said, there are a few details about DFS that might not be ideal, 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:
@@ -266,6 +275,8 @@ And this is exactly what Breadth-First Search (BFS) does! On top of that, it can
[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)
+{% sample lang="m" %}
+[import:108-129, lang:"matlab"](code/matlab/tree.m)
{% endmethod %}
## Video Explanation
@@ -324,6 +335,8 @@ The code snippets were taken from this [Scratch project](https://scratch.mit.edu
[import, lang:"asm-x64"](code/asm-x64/tree_traversal.s)
{% sample lang="emojic" %}
[import, lang:"emojicode"](code/emojicode/tree_traversal.emojic)
+{% sample lang="m" %}
+[import, lang:"matlab"](code/matlab/tree.m)
{% endmethod %}