SICP_2.63-2.65

#lang racket

(define (entry tree) (car tree))

(define (left-branch tree) (cadr tree))

(define (right-branch tree) (caddr tree))

(define (make-tree entry left right)
  (list entry left right))

(define (tree->list-1 tree)
  (if (null? tree)
      '()
      (append (tree->list-1 (left-branch tree))
              (cons (entry tree)
                    (tree->list-1 (right-branch tree))))))

(define (tree->list-2 tree)
  (define (copy-to-list tree result-list)
    (if (null? tree)
        result-list
        (copy-to-list (left-branch tree)
                      (cons (entry tree)
                            (copy-to-list (right-branch tree)
                                          result-list)))))
  (copy-to-list tree '()))

(define tree1
  (make-tree 7
          (make-tree 3 '(1 () ()) '(5 () ()))
          (make-tree 9 '() '(11 () ()))))

(define tree2
  (make-tree 3
             '(1 () ())
             (make-tree 7
                        '(5 () ())
                        (make-tree 9 '() '(11 () ())))))



;;;;;;;;;;;;;;;;test
;;;;;;;;;;;;;;产生相同的结果
;;;;;;;;;;;;;;
(tree->list-1 tree1)
(tree->list-2 tree1)
(tree->list-1 tree2)
(tree->list-2 tree2)

;;;;;;;;;;;;;;;2.64
(define (list-tree elements)
  (car (partial-tree elements (length elements))))

(define (partial-tree elts n)
  (if (= n 0)
      (cons '() elts)
      (let ((left-size (quotient (- n 1) 2)))
        (let ((left-result (partial-tree elts left-size)))
          (let ((left-tree (car left-result))
                (non-left-elts (cdr left-result))
                (right-size (- n (+ left-size 1))))
            (let ((this-entry (car non-left-elts))
                  (right-result (partial-tree (cdr non-left-elts)
                                              right-size)))
              (let ((right-tree (car right-result))
                    (remaining-elts (cdr right-result)))
                (cons (make-tree this-entry left-tree right-tree)
                      remaining-elts))))))))

;;;;;;;;;;;;test(a)
;;;;;;;;;;;;先算出左子树的size再构造左子树，以及剩下的非左子树
;;;;;;;;;;;;的序列，以及右子树的size再根据这些构造完整的树
;;;;;;;;;;;;实际上就是中序构造一颗平衡树
(list-tree '(1 3 5 7 9))

;;;;;;;;;;;;(b)
;;;;;;;;;;;;O(log(n))

;;;;;;;;;;;;;2.65
(define (new-union-set set1 set2)
  (list-tree (union-set (tree->list-2 set1) (tree->list-2 set2))))

(define (union-set set1 set2)
  (cond ((null? set1) set2)
        ((null? set2) set1)
        ((< (car set1) (car set2))
         (cons (car set1) (union-set (cdr set1) set2)))
        ((< (car set2) (car set1))
         (cons (car set2) (union-set set1 (cdr set2))))
        ((= (car set1) (car set2))
         (cons (car set1) (union-set (cdr set1) (cdr set2))))))

(define (new-intersection-set set1 set2)
  (list-tree (intersection-set (tree->list-2 set1)
                               (tree->list-2 set2))))

(define (intersection-set set1 set2)
  (if (or (null? set1) (null? set2))
      '()
      (let ((x1 (car set1)) (x2 (car set2)))
        (cond ((= x1 x2)
               (cons x1
                     (intersection-set (cdr set1)
                                      (cdr set2))))
              ((< x1 x2)
               (intersection-set (cdr set1) set2))
              ((< x2 x1)
               (intersection-set set1 (cdr set2)))))))

;;;;;;;;;;;;;;;;test
;;;;;;;;;;;;;;;;因为union-set和intersection-set
;;;;;;;;;;;;;;;;都是O(n)而list-tree 和 tree->list-2
;;;;;;;;;;;;;;;;都是O(log(n))所以总的步数为O(n)
(new-intersection-set (list-tree '(1 2 3 4 5))
                      (list-tree '(3 4 5 6 7)))

(new-union-set (list-tree '(1 2 3 4 5))
               (list-tree '(3 4 5 6 7)))

对于2.63 对步数还是没有好的理解

参考1 参考2

从参考一中可以看出tree->list-1 append数是正比于n的，但是步数应该为O（n*log（n））

因为append并不是每次都会append 个数为n的list

tree->list-2 只有cons操作，步数正比于n，O（n）

参考二中有一句话：

We can see from the results above and from inspecting the two procedures
that each node of the tree is visited one time by each algorithm. What 
happens at each of those n steps is subtly different though. The second 
procedure simply calls cons at each step, which we'll assume is a 
constant-time operation

可以仔细想一下