Question

我试图在Lisp中遍历一棵树。到目前为止，我设法建立了Postorder遍历，但是为了让我感到头痛......

树的格式是：

 A
/ \
B  C          (A 2 B 0 C 2 D 0 E 0)
  / \
 D   E   

 (defun traverseTreeMain (l)
  (traverseTree l nil)
)

(defun traverseTree (l lc)
 (cond
  ((and (null l) (null lc)) nil)

  ((null l) (append nil (traverseTree lc nil)))

  ((=(cadr l) 0) (append   (list (car l))  (traverseTree (cddr l) lc)  ))

  ((= (cadr l) 1) (append nil  (traverseTree (cddr l)   
                                                        (append (   list (car l)   (- (cadr l) 1)   ) lc)
                                )   
                    )
    )

   (t (append nil (traverseTree (cddr l) (append lc (list (car l) (- (cadr     l)                                                   1))))))
)
)
;;run: (traverseTreeMain '(A 2 B 0 C 2 D 0 E 0))  --POSTORDER
;;=> (B D E C A)

Answer 1

这里可能的方法是首先用预编号表示法构造树。为了表示二叉树节点，我们可以使用三元素列表（三元组）。三元组中的第一项是符号：A，B，...接下来的两个元素是左右引用。

现在，如何改变语法：

(A 2 B 0 C 2 D 0 E 0)

进入一棵树？一种方法是首先反转语法：

(reverse '(A 2 B 0 C 2 D 0 E 0)) -> (0 E 0 D 2 C 0 B 2 A)

现在，我们将此视为一个用简单的基于堆栈的语言编写的小型计算机程序，其中包含两个指令：数字和符号。我们从左到右扫描语法。当我们看到一个数字时，我们将它推到堆栈上。当我们看到一个符号时，我们会弹出堆栈的顶部，这应该是一个数字。然后，这个数字告诉我们从堆栈中弹出多少个节点：0,1或2.我们按照我们的说法做，并从符号构造一个树，以及许多子节点。然后我们把树放在堆栈上。代码：

(defun build-tree (syntax)
  (let ((rs (reverse syntax))
        (stack))
    (dolist (item rs (pop stack))  ;; heart of the interpreter loop
      (cond ((integerp item) (push item stack))  ;; integer instruction
            ((symbolp item) (let ((num (pop stack)))  ;; sym instruction
                              ;; construct node using backquote, and
                              ;; put it on the stack.
                              (push `(,item ,@(loop repeat num
                                                    collect (pop stack)))
                                    stack)))))))

请注意(pop stack)中的dolist表达式计算dolist的结果值，这是函数的返回值。当我们完成解释语法时，完整的树是堆栈中剩下的唯一项目，因此我们将其弹出。

没有努力处理语法中的任何错误;我们假设语法是树的无错误描述。

注意：解释器中的cond可以由typecase或etypecase替换。

测试：

(build-tree '(A 2 B 0 C 2 D 0 E 0)) -> (A (B) (C (D) (E)))

其他案例：

(build-tree nil) -> NIL

(build-tree '(B 0)) -> (B)

看起来不错。该树根植于A，有两个孩子(B)和(C (D) (E))。 (B)表示没有孩子的B节点，所以Forth ...原谅双关语！

这样得到的结构可以轻松地以任何顺序行走。

这是preorder遍历，使用回调函数处理节点中的符号。 “访问”意味着将符号传递给回调。函数的用户指定了一个执行某些操作的函数，比如收集传递给回调的符号：

(defun preorder (tree callback-fn)
  (when (consp tree)
    (preorder (second tree) callback-fn) ;; process children first
    (preorder (third tree) callback-fn)
    (funcall callback-fn (first tree)))) ;; then visit parent

测试：

(let ((output))
   (preorder (build-tree '(A 2 B 0 C 2 D 0 E 0))
             (lambda (item) (push item output)))
   (nreverse output))

--> (B D E C A) ;; correct

回调lambda将收到的项目推送到输出列表中，然后破坏性地反转。

对读者来说，这是一项微不足道的练习。

Answer 2

通过调整此问题的解决方案可以找到另一种解决方案：Transforming trees in lisp，需要将树从您的符号转换为列表符号(node left-child right-child)。

以下是解决方案：

(defun inorder(l)
  (if (null l)
      nil
      (inorder-sequence l)))

(defun inorder-sequence(l)
  (case (cadr l)
    (0 (values (list (car l)) (cddr l)))
    (1 (multiple-value-bind (left-subtree rest-of-list) (inorder-sequence (cddr l))
          (values (nconc left-subtree (list (car l))) rest-of-list)))
    (t (multiple-value-bind (left-subtree rest-of-list) (inorder-sequence (cddr l))
          (multiple-value-bind (right-subtree rest-of-rest) (inorder-sequence rest-of-list)
             (values (nconc left-subtree (list (car l)) right-subtree) rest-of-rest))))))

每次调用时的辅助函数inorder-sequence接收列表的其余部分，并返回几个值：

包含竞争当前递归调用的部分的序列的列表，
包含必须分析的其余元素的列表。

这样，在每个递归步骤中，函数本身可以使用第二个值来生成相对有序的。

请注意，此方法适用于任何类型的元素作为树的节点，包括整数。

在lisp中进行顺序遍历

2 个答案: