Question

几天前我遇到的一个有趣的问题：是否有一个优雅的函数式编程解决方案来从列表中构建（节点标记的）二叉树？

生成的树应该是左平衡的，即树中的每个节点级别应该完全填充，或者在最低级别的情况下，从左到右填充。此外，树的水平顺序遍历（即从上到下，从左到右）应该给出原始列表。

示例：列表1,2,3,4,5应该导致

          1
    2         3
 4    5

显而易见的解决方案是将列表转换为数组，将第0个值分配给根，然后递归地为节点n，为子项提供值2n+1和{{1 }}

但我想知道：是否有更多“功能”方式不需要辅助阵列？

Answer 1

在rsr5计划中表达的想法

我最初的想法涉及一个无限树，其节点是带有值和树的函数，并将该值插入到找到该函数的同一位置的树中。然后，您可以执行fold2，就像列表上的递归和函数树的level-oder横向一样，将连续函数应用于连续的列表元素以累积二叉树。（但只适用于懒惰评估）

虽然看起来有点笨拙，但我将这个想法修改为一个数据树，可以输入到像（＆＃39; l＆＃39; r＆＃39; l）这样的函数或者可以告诉我去哪里的东西插入和索引。

(define (insert-new ls-and-rs tree)
  (cond ((or (empty-tree?) (null? ls-and-rs))
         (if (and (empty-tree?) (null? ls-and-rs))
             (make-tree x emptyTree emptyTree)
             (error "insert-new can only insert at emptyree")))
        ((sybol=? (car ls-and-rs) 'l)
         (make-tree (node tree) 
                    (insert-new (cdr ls-and-rs) 
                                (left-tree tree)) 
                    (right-tree tree)))
        ((sybol=? (car ls-and-rs) 'r)
         (make-tree (node tree) 
                    (left-tree tree) 
                    (insert-new (cdr ls-and-rs) 
                                (right-tree tree))))
        (else (error "insert-new expected 'l or 'r, recieved " 
                     (car ls-and-rs))))))

然后我看到你可以从索引本身构建它。索引，如果1是树的头部。否则，如果奇怪，它就是节点的右分支。如果它甚至是左分支。它的父母的索引总是孩子的楼层除以2。根据这些知识，您可以构建仅带索引的插入器或访问器。

(define (branch-order i)
  (let loop ((i i) (accum '()))
    (cond ((i = 1) accum)
          ((odd? i) (loop (quotient i 2) (cons 'r accum)))
          (else     (loop (quotient i 2) (cons 'l accum))))))

从那里它是一个简单的递归

 (define (list->tree list)
   (let loop ((list list) (i 1) (tree emptyTree))
     (cond ((null? list) tree)
           (else (loop (cdr list)
                       (+ i 1)
                       (insert-new (branch-order i) tree))))))

当然最简单的方法是你可以接受最小深度的二叉树。深度树除了它的节点和分支之外还列出了它的最小深度。然后插入插入到左子树中，除非右子树的最小深度小于左子树的最小深度。

(define (list->d-tree list)
  (fold-left (flip balanced-insert) emptyTree list))

(define (balanced-insert x d-tree)
  (cond ((= 0 (d-d-tree d-tree)) 
        (mk-d-tree x emptyTree emptyTree)
       ((= 1 (- (d-d-tree d-tree) (d-d-tree (l-d-tree d-tree))))
        (mk-d-tree (n-d-tree d-tree)
                   (balanced-insert x (l-d-tree d-tree))
                   (r-d-tree d-dtree)))
      (else 
       (mk-d-tree (n-d-tree d-tree)
                  (l-d-tree d-tree)
                  (balanced-insert x (r-d-tree d-dtree))))))

(define (mk-d-tree n l r)
 (let ((d-l (d-d-tree l))
       (d-r (d-d-tree r)))
 (list n l r (+ 1 (min d-l d-r)))))
(define (n-d-tree d-tree)
 (car d-tree))
(define (l-d-tree d-tree)
 (cadr d-tree))
(define (r-d-tree d-tree)
 (caddr d-tree))
(define (d-d-tree d-tree)
 (if emptyTree? d-tree)
     0
     (cadddr d-tree)))
(define (emptyTree? tree)
       (null? tree))
(define emptyTree '())

(define (flip f)
 (lambda (a b)
   (f b a)))

TLdr;使用最小深度树并插入最左边的最小深度。

从列表构建二叉树（预订）

1 个答案: