Tree 如何使用apply-in-scheme编写树映射函数

写完后：

(define (tree-accumulate tree)
  (if (pair? tree)
      (apply + (car tree) (map tree-accumulate (cdr tree)))
(+ tree)))

例： （树累积’（11（1（1（11）11）11（11（11щщ））） ==>18

如何编写树映射函数，以便您可以编写：

(define (tree-accumulate tree)
        (tree-map + tree))

尝试：

(define (tree-map f tree)
  (if (pair? tree)
      (apply + (car tree) (map (tree-map (cdr tree)) )
      (f tree)))

但问题是如何将f参数放入：（map（treemap（cdrtree））

---

要使应用程序仍然有效？

好吧，这样的函数不会被称为

map

。它实际上更像是一个

折叠

，类似于or。因此，这里有一个使用

树折叠

函数的

树累积

的可能定义：

(define (tree-accumulate tree)
  (tree-foldl + 0 tree))

作为第二个参数的

0

是基本情况，用于树中没有叶子的情况。可以这样定义

tree foldl

函数：

;; (Treeof A) is one of:
;;  - A
;;  - (Listof (Treeof A))
;; Where the A type can't include lists.

;; tree-foldl : [A B -> B] B (Treeof A) -> B
;; Where the A type can't include lists.
(define (tree-foldl f base tree)
  (cond [(not (list? tree))
         (f tree base)]
        [else
         (tree-foldl/list f base tree)]))

;; tree-foldl/list : [A B -> B] B (Listof (Treeof A)) -> B
;; Where the A type can't include lists.
(define (tree-foldl/list f base tree)
  (cond [(empty? tree)
         base]
        [else
         (tree-foldl/list f
                          (tree-foldl f base (first tree))
                          (rest tree))]))

(define (tree-map f tree)
  (if (pair? tree)
      (cons (f (car tree)) (map (lambda (t) (tree-map f t)) (cdr tree)))
      (f tree)))

使用此定义的

树累积

> (tree-accumulate '(1 1 1 (1 (1 (1 1 1) 1 1) 1 1 (1 1 1 (1 1 1)))))
18

---

如前所述，这不是一张地图，而是一个褶皱

然而，您只需要在另一个函数中“包装”递归应用程序，这样就可以传递

f

on:

(define (tree-fold f tree)
  (if (pair? tree)
      (apply f (car tree) (map (lambda (t) (tree-fold f t)) (cdr tree)))
      (f tree)))

实际地图可能如下所示：

;; (Treeof A) is one of:
;;  - A
;;  - (Listof (Treeof A))
;; Where the A type can't include lists.

;; tree-foldl : [A B -> B] B (Treeof A) -> B
;; Where the A type can't include lists.
(define (tree-foldl f base tree)
  (cond [(not (list? tree))
         (f tree base)]
        [else
         (tree-foldl/list f base tree)]))

;; tree-foldl/list : [A B -> B] B (Listof (Treeof A)) -> B
;; Where the A type can't include lists.
(define (tree-foldl/list f base tree)
  (cond [(empty? tree)
         base]
        [else
         (tree-foldl/list f
                          (tree-foldl f base (first tree))
                          (rest tree))]))

(define (tree-map f tree)
  (if (pair? tree)
      (cons (f (car tree)) (map (lambda (t) (tree-map f t)) (cdr tree)))
      (f tree)))

---

这与其说是一张地图，还不如说是一张折叠图（正如回答中提到的那样）。看看其中包含的treeduce（tree reduce）函数，我认为它可以满足您的需求。后续：