Tree Traversal in Common Lisp (algorithm-archivists#623)

Author: Trashtalk217

contents/tree_traversal/code/clisp/tree-traversal.lisp

@@ -0,0 +1,93 @@
+;;;; Tree traversal in Common Lisp
+
+(defstruct node data children)
+
+(defun dfs-recursive (node)
+  "A depth first approach for printing out all values in a tree."
+  (when (node-data node)
+    (format t "~a " (node-data node)))
+  (loop for child in (node-children node) do
+    (dfs-recursive child)))
+
+(defun dfs-recursive-postorder (node)
+  "A depth first approach for printing out all values in a tree starting from the bottom."
+  (loop for child in (node-children node) do
+    (dfs-recursive-postorder child))
+  (when (node-data node)
+    (format t "~a "  (node-data node))))
+
+(defun dfs-recursive-inorder-btree (node)
+  "A depth first search approach for printing all values in a binary tree."
+  (case (length (node-children node))
+    (2
+     (dfs-recursive-inorder-btree (first (node-children node)))
+     (format t "~a " (node-data node))
+     (dfs-recursive-inorder-btree (second (node-children node))))
+    (1
+     (dfs-recursive-inorder-btree (first (node-children node)))
+     (format t "~a " (node-data node)))
+    (0
+     (format t "~a " (node-data node)))
+    (t
+     (print "Invalid binary tree."))))
+
+(defun dfs-stack (node)
+  "A depth first approach for printing out all values in a tree using a stack."
+  (loop
+    with stack = (list node)
+    with temp = nil
+    while (> (length stack) 0) do
+    (format t "~a " (node-data (first stack)))
+    (setf temp (pop stack))
+    (loop for child in (node-children temp) do
+      (push child stack))))
+
+(defun bfs-queue (node)
+  "A breadth first search approach for printing out all values in a tree."
+  (loop
+    with queue = (list node)
+    with temp = nil
+    while (> (length queue) 0) do
+    (format t "~a " (node-data (first queue)))
+    (setf temp (pop queue))
+    ;; If the queue is empty, the queue should be filled with the children nodes.
+    (if (eql queue nil)
+        (setf queue (node-children temp))
+        (nconc queue (node-children temp)))))
+
+(defun make-tree (num-rows num-child)
+  "Creates a simple tree, where every node has 'num-child' children and is 'num-rows' deep."
+  ;; A tree with 0 rows can't be created.
+  (if (eql num-rows 1)
+      (make-node
+       :data 1
+       :children nil)
+      (make-node
+       :data num-rows
+       :children (loop repeat num-child collect (make-tree (1- num-rows) num-child)))))
+
+;; A tree for testing
+(defvar tree (make-tree 3 3))
+
+;; A binary tree for testing
+(defvar binary-tree (make-tree 3 2))
+
+;; Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
+(dfs-recursive tree)
+(format t "~%")
+
+;; Should print: 1 1 1 2 1 1 1 2 1 1 1 2 3
+(dfs-recursive-postorder tree)
+(format t "~%")
+
+;; Should print: 1 2 1 3 1 2 1
+(dfs-recursive-inorder-btree binary-tree)
+(format t "~%")
+
+;; Should print: 3 2 1 1 1 2 1 1 1 2 1 1 1
+(dfs-stack tree)
+(format t "~%")
+
+;; Should print: 3 2 2 2 1 1 1 1 1 1 1 1 1
+(bfs-queue tree)
+(format t "~%")

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="lisp" %}
+[import:3-3, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:6-6, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
@@ -79,6 +81,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="lisp" %}
+[import:5-10, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:31-45, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
@@ -129,6 +133,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="lisp" %}
+[import:12-17, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:47-62, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
@@ -174,13 +180,15 @@ 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="lisp" %}
+[import:19-32, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:64-82, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
 
-<p>	
-    <img  class="center" src="res/DFS_in.png" width="500" />	
-</p>	
+<p>
+    <img  class="center" src="res/DFS_in.png" width="500" />
+</p>
 
 The order here seems to be some mix of the other 2 methods and works through the binary tree from left to right.
 
@@ -228,6 +236,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="lisp" %}
+[import:34-43, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:84-106, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
@@ -275,6 +285,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="lisp" %}
+[import:45-56, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import:108-129, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}
@@ -335,6 +347,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="lisp" %}
+[import, lang:"lisp"](code/clisp/tree-traversal.lisp)
 {% sample lang="m" %}
 [import, lang:"matlab"](code/matlab/tree.m)
 {% endmethod %}