Tree 从列表（预排序）构建二叉树

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

生成的树应该是左平衡的，即树中的每一级节点都应该完全填充，如果是最低的节点，则从左到右填充。此外，树的水平顺序遍历（即从上到下，从左到右）应给出原始列表

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

          1
    2         3
 4    5

显而易见的解决方案是将列表转换为数组，将第0个值赋给根，然后递归地，对于节点

n

，将值

2n+1

和

2n+2

赋给子节点

---

但我想知道：有没有一种更“实用”的方式不需要辅助数组呢？

rsr5方案中表达的想法

我最初的想法涉及到一棵无限树，它的节点是函数，它接受一个值和一棵树，并将该值插入到该树中函数所在的位置。然后，您可以对列表和函数树的水平顺序或横向执行类似折叠的递归，将连续函数应用于连续列表元素以累加二叉树。（但仅适用于惰性计算）

看起来有点笨拙，所以我把想法改成了一棵数据树，它可以被提供给函数（'l'r'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是树的头，则为索引。否则，如果它是奇数，它就是节点的右分支。如果它是一个左分支。父对象的索引总是子对象的楼层除以二。根据这些知识，您可以仅使用索引构建插入器或访问器

(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 2 4 5 3）一个预排序树看起来像（1）（2（3（）（））（4（）（））（5（）），也许你指的是级别排序？或者我有什么错误吗？我不太明白（我真的不擅长阅读类似Lisp的程序），但我会接受答案，稍后再考虑。谢谢！现在回到这里，我也没有把它说得最清楚。第一个例子看起来并不完整和正确。主要思想是在cdr列表时跟踪索引，并使用索引生成插入之前在树漫游中需要执行的转弯列表第二种方法使用树中的额外数据元素来指导插入决策。