表转化成平衡二叉树
其中有一种分治的思想。
(define (list->tree 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))))))))
(car (partial-tree elements (length elements))))
(display (list->tree '(3 1 2 4 1 2)))
二叉查找树实现集合
#lang planet neil/sicp
(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 (element-of-tree? x tree)
(cond ((null? tree) #f)
((= x (entry tree)) #t)
((< x (entry tree)) (element-of-tree? x (left-branch tree)))
((> x (entry tree)) (element-of-tree? x (right-branch tree)))))
(define (adjoin-tree x tree)
(cond ((null? tree) (make-tree x '() '()))
((= x (entry tree)) tree)
((< x (entry tree))
(make-tree (entry tree) (adjoin-tree x (left-branch tree)) (right-branch tree)))
((> x (entry tree))
(make-tree (entry tree) (left-branch tree) (adjoin-tree x (right-branch tree))))))
(define (delete-tree x tree)
(define (find-max tree)
(if (and (null? (left-branch tree)) (null? (right-branch tree)))
(entry tree)
(find-max (right-branch tree))))
(define (dlt x tree)
(if (null? tree)
'()
(if (= (entry tree) x)
(let ((left (left-branch tree)) (right (right-branch tree)))
(cond ((and (null? left) (null? right)) '())
((null? left) right)
((null? right) left)
(else
(let ((mx (find-max left)))
(make-tree mx (dlt mx left) right)))))
(make-tree (entry tree) (dlt x (left-branch tree)) (dlt x (right-branch tree))))))
(if (element-of-tree? x tree)
(dlt x tree)
tree))
(define (tree->list 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 (list->tree 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))))))))
(car (partial-tree elements (length elements))))
(define (union-tree tree1 tree2)
(define (union-list list1 list2)
(cond ((null? list1) list2)
((null? list2) list1)
((< (car list1) (car list2))
(cons (car list1) (union-list (cdr list1) list2)))
((< (car list2) (car list1))
(cons (car list2) (union-list (cdr list2) list1)))
((= (car list1) (car list2))
(cons (car list1) (union-list (cdr list1) (cdr list2))))))
(list->tree (union-list (tree->list tree1) (tree->list tree2))))
(define (intersection-tree tree1 tree2)
(define (intersection-list list1 list2)
(cond ((or (null? list1) (null? list2)) '())
((< (car list1) (car list2))
(intersection-list (cdr list1) list2))
((< (car list2) (car list1))
(intersection-list (cdr list2) list1))
((= (car list1) (car list2))
(cons (car list1) (intersection-list (cdr list1) (cdr list2))))))
(list->tree (intersection-list (tree->list tree1) (tree->list tree2))))
(define (getlist n MAX)
(if (= n 0)
'()
(cons (random MAX) (getlist (- n 1) MAX))))
(define (list->BST lst)
(if (null? lst)
'()
(adjoin-tree (car lst) (list->BST (cdr lst)))))
注：
list->tree和tree->list行为恰好相反。- 树转化成表是从右往左放数。
- 最大的值一定是树最右边的结点，而这个结点正好在转化成表的时候处于表的最右端，保证了转化成的表的有序性（当然前提树是二叉查找树）。
- 要想通过
list->tree得到一棵二叉查找树，必须保证是有序表。
添加、删除操作
(define tree '())
(set! tree (adjoin-tree 3 tree))
(set! tree (adjoin-tree 1 tree))
(set! tree (adjoin-tree 5 tree))
(set! tree (adjoin-tree 8 tree))
(set! tree (adjoin-tree 9 tree))
(set! tree (adjoin-tree 7 tree))
(set! tree (adjoin-tree 2 tree))
(set! tree (adjoin-tree 4 tree))
(set! tree (adjoin-tree 11 tree))
(display tree) (newline)
; (3 (1 () (2 () ())) (5 (4 () ()) (8 (7 () ()) (9 () (11 () ())))))
(set! tree (delete-tree 3 tree))
(display tree) (newline)
; (2 (1 () ()) (5 (4 () ()) (8 (7 () ()) (9 () (11 () ())))))
(display (delete-tree 8 tree)) (newline)
; (2 (1 () ()) (5 (4 () ()) (7 () (9 () (11 () ())))))
(display (delete-tree 9 tree)) (newline)
; (2 (1 () ()) (5 (4 () ()) (8 (7 () ()) (11 () ()))))
(display (delete-tree 5 tree)) (newline)
; (2 (1 () ()) (4 () (8 (7 () ()) (9 () (11 () ())))))
(set! tree (delete-tree 2 tree))
(display tree) (newline)
; (1 () (5 (4 () ()) (8 (7 () ()) (9 () (11 () ())))))
(display (delete-tree 1 tree)) (newline)
; (5 (4 () ()) (8 (7 () ()) (9 () (11 () ()))))
(set! tree (delete-tree 5 tree))
(set! tree (delete-tree 4 tree))
(set! tree (delete-tree 8 tree))
(set! tree (delete-tree 7 tree))
(set! tree (delete-tree 9 tree))
(set! tree (delete-tree 11 tree))
(display tree) (newline)
; (1 () ())
(set! tree (delete-tree 1 tree))
(display tree)
; ()
对两棵二叉查找树取 交、并 操作。
(define list1 (list 1 2 3 9))
(define list2 (list 3 4 7 9))
(define tree1 (list->tree list1))
(define tree2 (list->tree list2))
(display tree1)(newline)
; (2 (1 () ()) (3 () (9 () ())))
(display tree2)(newline)
; (4 (3 () ()) (7 () (9 () ())))
(display (union-tree tree1 tree2))(newline)
; (3 (1 () (2 () ())) (7 (4 () ()) (9 () ())))
(display (intersection-tree tree1 tree2))
; (3 () (9 () ()))
利用上面的函数也可以实现(O(n+nlogn))的排序操作。
(define list1 (getlist 10 10)) ; 生成随机表
(define bst1 (list->BST list1)) ; 转化成二叉查找树
(display list1)(newline)
(display bst1)(newline)
(display (tree->list bst1)) ; 有序表
总结
用 Scheme 实现二叉查找树真的很有意思，首先是代码结构非常紧凑，加上有意义的变量名、函数名会显得更加直观，但是要想一次写好，必须对整个过程进行设计，不然很容易写到后面发现前面有缺漏从而影响全局的代码。
其中一些代码来自于 SICP，自己按照 BST 删除的原理实现了删除的过程。
关于递归的理解更深了一点。首先要明确这个过程到底要做什么？会返回什么值？是什么类型的值？