递归计算LISP中二叉树的深度

Question

我有以下二叉树

一种 / \ 乙丙 / \ 德

在 Lisp (A 2 B 0 C 2 D 0 E 0) 中表示为一个列表，其中字母是节点名称，数字是子节点的数量（0 表示无，1 表示一个节点，2 表示两个节点）。我需要递归地找到从根节点到树的叶深度（二叉树的深度）的最高值。我对 Lisp 很陌生，我不知道如何实现它。到目前为止，这是我设法提出的：

（定义深度（树） “返回参数树的深度。” （检查类型树列表） （如果（=（第二棵树）0） 0 (1+ (get-btree-max-depth (cddr 树))))) (defun get-btree-max-depth (btree) "返回最大深度 论点树。” （检查类型 btree 列表） (如果 (= (第二个 btree) 0) 0 （最大（深度（cddr btree）） (get-btree-max-depth (cddr btree)))))

但它不能正常工作。我也浏览了类似的帖子，但没有发现任何有用的东西可以帮助我。有人可以给我一个建议来帮助解决这个问题吗？谢谢！

附：这是我将在大学展示的一个小项目的一部分，也是我自己在 Lisp 中变得更好的方式（我看到许多类似的帖子都有问题，询问帖子是否与家庭作业有关）。 :)

Answer 1

这个怎么样？不需要对树进行转换。

(defun depth-rec (tree)
  (labels ((depth-rec-aux (depth)             ; self-recursive function
             (if (null tree)                  ; no more nodes
                 depth                        ;   -> return the current depth
               (let ((n (second tree)))       ; number of subnodes
                 (pop tree) (pop tree)        ; remove the current node
                 (case n
                   (0 (1+ depth))                     ; no subnode,  1+depth
                   (1 (depth-rec-aux (1+ depth)))     ; one subnode, its depth+1
                   (2 (max (depth-rec-aux (1+ depth)) ; two subnodes, their max
                           (depth-rec-aux (1+ depth)))))))))
    (depth-rec-aux 0)))                       ; start depth is 0

另一个版本：

(defun depth-rec (tree &aux (max 0))
  (labels ((depth-rec-aux (depth)
             (when tree
               (pop tree)
               (let ((n (pop tree)))
                 (if (zerop n)
                     (setf max (max max (1+ depth)))
                   (loop repeat n do (depth-rec-aux (1+ depth))))))))
    (depth-rec-aux 0))
  max)

Answer 2

我会先将列表转换为树：

(defun tlist->tree (tlist)
  "Transforms a tree represented as a kind of plist into a tree.
   A tree like:
               A
              / \
             B   C
            /   / \
           F   D   E
   would have a tlist representation of (A 2 B 1 F 0 C 2 D 0 E 0).
   The tree representation would be (A (B (F)) (C (D) (E)))"
  (let (tree)
    (push (pop tlist) tree)
    (dotimes (i (pop tlist))
      (multiple-value-bind (subnode rest-tlist) (tlist->tree tlist)
        (push subnode tree)
        (setf tlist rest-tlist)))
    (values (nreverse tree) tlist)))

我想知道你是否不能从这个树表示开始。

然后，在树表示中找到树的深度是一个简单的递归单线。

Answer 3

这是一种延续传递风格：

(defun oddtree-height (oddtree)
  (suboddtree-height oddtree
                     #'(lambda (h remainder)
                         (if (null remainder) h nil))))

(defun suboddtree-height (oddtree c)
  (max-height-of-suboddtrees (cadr oddtree)
                             0
                             (cddr oddtree)
                             #'(lambda (h remainder)
                                 (funcall c (+ h 1) remainder))))

(defun max-height-of-suboddtrees (n best oddtree c)
  (if (= n 0)
      (funcall c best oddtree)
    (suboddtree-height oddtree
                       #'(lambda (h remainder)
                           (max-height-of-suboddtrees (- n 1) (max best h) remainder c)))))

Answer 4

使用 Artelius 和 Svante 的回答，我设法解决了这个问题。这是代码，也许它会对其他有需要的人有所帮助。

(defun btree-max-depth (btree) "返回最大深度 的二叉树。” （检查类型 btree 列表） （如果（空 btree） 0; () 成员的最大深度 （最大（深度（第一个 btree）） (btree-max-depth (rest btree))))) （定义深度（树） “返回参数树的深度。” （如果（原子树） 0;原子树的深度为 0 (1+ (btree-max-depth 树))))

感谢 Artelius 和 Svante 的帮助！