SICP_3.27

(define false #f)
(define true #t)

(define (make-table)
  (let ((local-table (list '*table*)))

     (define (assoc key records)
      (cond ((null? records) false)
            ((equal? (caar records) key) (car records))
            (else (assoc key (cdr records)))))

    (define (lookup keys)
      (define (lookup-helper keys table)
        (let ((subtable (assoc (car keys) (cdr table))))
          (if subtable
              (if (null? (cdr keys))
                  (cdr subtable)
                  (lookup-helper (cdr keys) subtable))
              false)))
      (lookup-helper keys local-table))

    (define (insert! keys value)
      (define (insert-helper! keys table)
        (if (null? table)
            (if (null? (cdr keys))
                (cons (car keys) value)
                (list (car keys) (insert-helper! (cdr keys) '())))
            (let ((sub (assoc (car keys) (cdr table))))
              (if sub
                  (if (null? (cdr keys))
                      (set-cdr! sub value)
                      (insert-helper! (cdr keys) sub))
                  (if (null? (cdr keys))
                      (set-cdr! table (cons (cons (car keys) value) (cdr table)))
                      (set-cdr! table (cons
                                       (list (car keys)(insert-helper! (cdr keys) '()))
                                       ;;可以直接用（insert-helper! keys '()）
                                       (cdr table))))))))
      (insert-helper! keys local-table)
      'ok)
  
    (define (dispatch m)
      (cond ((eq? m 'lookup-proc) lookup)
            ((eq? m 'insert-proc) insert!)
            (else (error "Unknow operation --TABLE" m))))

    dispatch))

(define (lookup x table)
  (let ((keys (list x)))
    ((table 'lookup-proc) keys)))

(define (insert! x result table)
  (let ((keys (list x)))
    ((table 'insert-proc) keys result)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(define (memoize f)
  (let ((table (make-table)))
    (lambda (x)
      (let ((previously-computed-result (lookup x table)))
        (or previously-computed-result
            (let ((result (f x)))
              (insert! x result table)
              result))))))


(define memo-fib
  (memoize (lambda (n)
             (cond ((= n 0) 0)
                   ((= n 1) 1)
                   (else (+ (memo-fib (- n 1))
                            (memo-fib (- n 2))))))))


(memo-fib 0)

简单的定义为

（memoize fib）

能工作，但这样并没有意义，因为这样定义在处理 fib（n-2）和fib（n-1）时就是普通fib函数了

步数：

在计算fib（n）时 需要fib（n-1）和fib（n-2）而fib（n-1）的值需要fib（n-2）的值，如使用记忆法，则fib（n-2），fib（n-3）已事先存在表中。所以事先

要计算fib（n-2），一直到达n=0 和 n=1时整个表都被填满，总的来看就是求一遍fib（2）到fib（n-1）所以需要O(n)步来计算fib（n）。