SICP学习笔记 第二章 （2.2）（上）

闭包：通过闭包组合起数据对象得到的结果本身还可以通过同样的操作再进行组合。

　　(In general, an operation for combining data objects ststisfies the closure property if the results of combining things with that operation can themselves be combined using the same operation.)

序列（sequence）：如图所示，序列由一个序对（pair）的链表（list）表示。每个序对的 car 部分对应于这个链中的条目， cdr 则是链中下一个序对。最后一个序对的 cdr 用一个不是序对的值表示，标明序列的结束。

基本过程：

(list <a1> ... <an>)
等价于
(cons <a1>
      (cons ...
                (cons <an> nil) ... )))

基本谓词：

(pair? <argument>) ;检查其参数是否为序对

部分习题：

exercise 2.17

(define (last-pair items)    
    (cond ((null? items) '())
          ((null? (cdr items)) items)
          (else (last-pair (cdr items)))))

 exercise 2.18

(define (reverse items)
    (define (reverse-iter items result)
        (if (null? items)
            result
            (reverse-iter (cdr items)
                          (cons (car items) result))))
    (reverse-iter items '()))

 exercise 2.19

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))
(define (cc amount coin-values)
    (cond ((= amount 0) 1)
          ((or (< amount 0) (no-more? coin-values)) 0)
          (else (+ (cc amount
                       (except-first-denomination coin-values))
                   (cc (- amount 
                          (first-denomination coin-values))
                       (coin-values)))))
(define (no-more? items)
    (null? items))
(define (first-denomination items)
    (car items))
(define (except-first-denomination items)
    (cdr items))

exercise 2.20

(define (get-item items filter)
    (if (null? items)
        '()
        (if (filter (car items))
            (cons (car items)
                  (get-item (cdr items) filter))
            (get-item (cdr items) filter))))
(define (same-parity first . others)
    (cons first
          (get-item others 
                    (lambda (x) (even? (bitwise-xor first x)))))) 

 exercise 2.23

(define (for-each proc items)
    (cond ((null? items) #t)
          (else (proc (car items))
                (for-each proc (cdr items)))))

 exercise 2.26

 exercise 2.27

根据 reverse procedure 修改而来。

(define (deep-reverse x)
    (define (deep-reverse-iter x result)
        (cond ((null? x) result)
              ((not (pair? x)) x)
              (else (deep-reverse-iter (cdr x)
                                       (cons (deep-reverse (car x))
                                             result)))))
    (deep-reverse-iter x '()))

 exercise 2.28

(define (not-pair? x)
    (not (pair? x)))
(define (fringe x)
    (define (iter x result)
        (cond ((null? x) result)
              ((not-pair? x) (cons x result))
              (else (iter (car x)
                          (iter (cdr x) result)))))
    (iter x '()))

 章节2.2.3中的 enumerate-tree

(define (fringe tree)
    (cond ((null? tree) '())
          ((not (pair? tree)) (list tree))
          (else (append (fringe (car tree))
                        (fringe (cdr tree))))))

exercise 2.29

a) 选择函数

(define (left-branch mobile)
    (car mobile))
(define (right-branch mobile)
    (cadr mobile))
(define (branch-length branch)
    (car branch))
(define (branch-structure branch)
    (cadr branch))

 b) total-weight

(define (total-weight mobile)
    (define (branch-iter branch)
        (if (not-pair? branch)
            branch
            (let ((structure (branch-structure branch)))
              (if (not-pair? structure)
                  structure
                  (total-weight structure)))))
    (if (not-pair? mobile); add this for balance procedure
        mobile
        (+ (branch-iter (left-branch mobile))
           (branch-iter (right-branch mobile)))))

 c) balance?

(define (balance? mobile)
    (define (moment branch)
        (if (not-pair? branch)
            0
            (let ((length (branch-length branch))
                  (weight (total-weight (branch-structure branch))))
              (* length weight))))
    (cond ((not-pair? mobile) #t)
          ((= (moment (left-branch mobile))
              (moment (right-branch mobile)))
           (balance-iter (branch-structure (left-branch mobile)))
           (balance-iter (branch-structure (right-branch mobile))))
           (else #f)))

 d) 用 list 和 cons 构造的不同在于， (cdr <list>) 的结果依然是一个 list，所以在选择函数 right-branch 中要用 cadr 才能得到正确的第二个元素，branch-structure 也是同样的道理。所以当构造方式由 list 变为 cons 时，只要修改以上提到的两个选择函数的实现就可以了。

exercise 2.30

(define (square-tree tree)
    (cond ((null? tree) '())
          ((not (pair? tree)) (* tree tree))
          (else (cons (square-tree (car tree))
                      (square-tree (cdr tree))))))

(define (square-tree tree)
    (map (lambda (sub-tree)
           (if (pair? sub-tree)
               (square-tree sub-tree)
               (* sub-tree sub-tree)))
         tree))

 exercise 2.31

(define (tree-map proc tree)
    (cond ((null? tree) '())
          ((not (pair? tree)) (proc tree))
          (else (cons (tree-map (car tree))
                      (tree-map (cdr tree))))))
(define (square-tree tree)
    (tree-map square tree)

 exercise 2.32

(define (subsets s)
    (if (null? s)
        '()
        (let ((rest (subsets (cdr s))))
          (append rest (map (lambda (x) (cons (car s) x))
                            rest)))))