Random Binary Search Trees. EECS 214, Fall 2016

Transcription

1 Random Binary Search Trees EECS 214, Fall 2016

2 2 The necessity of balance

3 3 The necessity of balance n lg n , , , ,000, ,000, ,000, ,000,000,000 30

4 4 DSSL tree setup ; A RandNumTree is one of: ; - (node Number Natural RandNumTree RandNumTree) ; - '() (define-struct node (key size left right)) (define (new-node k) (node k 1 '() '())) (define (tree-size t) (if (node? t) (node-size t) 0)) (define (fix-size! t) (set-node-size! t (+ 1 (tree-size (node-left t)) (tree-size (node-right t)))))

5 5 Leaf insertion in DSSL The easy way to add elements to a tree at the leaves: (define (leaf-insert! t k) (cond [(empty? t) (new-node k)] [(< k (node-key t)) (set-node-left! t (leaf-insert! (node-left t) k)) (fix-size! t) t] [(> k (node-key t)) (set-node-right! t (leaf-insert! (node-right t) k)) (fix-size! t) t] [else t]))

6 6 Leaf insertion 7

7 6 Leaf insertion 7 3

8 6 Leaf insertion 7 3 1

9 6 Leaf insertion

10 6 Leaf insertion

11 6 Leaf insertion

12 6 Leaf insertion

13 6 Leaf insertion

14 6 Leaf insertion

15 6 Leaf insertion

16 6 Leaf insertion

17 6 Leaf insertion

18 6 Leaf insertion

19 6 Leaf insertion

20 7 The permutation distribution Can we characterize how sequences of insertions produce (un)balanced trees?

21 7 The permutation distribution Can we characterize how sequences of insertions produce (un)balanced trees? 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 severely unbalanced (degenerate)

22 7 The permutation distribution Can we characterize how sequences of insertions produce (un)balanced trees? 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 severely unbalanced (degenerate) 7, 3, 1, 0, 2, 5, 4, 6, 11, 9, 8, 10, 13, 12, 14 balanced

23 7 The permutation distribution Can we characterize how sequences of insertions produce (un)balanced trees? 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 severely unbalanced (degenerate) 7, 3, 1, 0, 2, 5, 4, 6, 11, 9, 8, 10, 13, 12, 14 balanced 7, 11, 3, 13, 9, 5, 1, 14, 12, 10, 8, 6, 4, 2, 0 balanced

24 7 The permutation distribution Can we characterize how sequences of insertions produce (un)balanced trees? 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 severely unbalanced (degenerate) 7, 3, 1, 0, 2, 5, 4, 6, 11, 9, 8, 10, 13, 12, 14 balanced 7, 11, 3, 13, 9, 5, 1, 14, 12, 10, 8, 6, 4, 2, 0 balanced In fact, the only sequence to produce the right-branching degenerate tree is 0,, 14 There are 21,964,800 sequences that produce the same perfectly balanced tree

25 8 A random BST tends to be balanced If you generate a tree by leaf-inserting a random permutation of its elements, it will probably be balanced In particular, the expected length of a search path is 2 ln n + O(1)

26 8 A random BST tends to be balanced If you generate a tree by leaf-inserting a random permutation of its elements, it will probably be balanced In particular, the expected length of a search path is 2 ln n + O(1) Unfortunately, we usually can t do that, but we can simulate it

27 9 A tool: tree rotations D B B D E A A C C E Note that order is preserved

28 9 A tool: tree rotations D B B D E A A C C E Note that order is preserved Exercise: implement tree rotations

29 10 In DSSL (define (rotate-right! d) (define b (node-left d)) (set-node-left! d (node-right b)) (set-node-right! b d) (fix-size! d) (fix-size! b) b) (define (rotate-left! b) (define d (node-right b)) (set-node-right! b (node-left d)) (set-node-left! d b) (fix-size! b) (fix-size! d) d)

30 11 Root insertion Using rotations, we can insert at the root: To insert into an empty tree, create a new node To insert into a non-empty tree, if the new key is greater than the root, then root-insert (recursively) into the right subtree, then rotate left By symmetry, if the key belongs to the left of the old root, root insert into the left subtree and then rotate right

31 12 Root insertion in DSSL (define (root-insert! t k) (cond [(empty? t) (new-node k)] [(< k (node-key t)) (set-node-left! t (root-insert! (node-left t) k)) (rotate-right! t)] [(> k (node-key t)) (set-node-right! t (root-insert! (node-right t) k)) (rotate-left! t)] [else t]))

32 13 Randomized insertion We can now build a randomized insertion function that maintains the random shape of the tree: Suppose we insert into a subtree of size k, so the result will have size k + 1 If the tree were random, the new element would be a the root with probability 1 k+1 So we root insert with that probability, and otherwise recursively insert into a subsubtree

33 14 Randomized insertion in DSSL (define (insert! t k) (cond [(empty? t) (new-node k)] [(zero? (random (add1 (tree-size t)))) (root-insert! t k)] [(< k (node-key t)) (set-node-left! t (insert! (node-left t) k)) (fix-size! t) t] [(> k (node-key t)) (set-node-right! t (insert! (node-right t) k)) (fix-size! t) t] [else t]))

34 15 Deletion idea To delete a node, we join its subtrees recursively, randomly selecting which contributes the root (based on size): B B + E A C A C + E

35 16 Join in DSSL (define (join! t1 t2) (cond [(empty? t1) t2] [(empty? t2) t1] [(< (random (+ (tree-size t1) (tree-size t2))) (tree-size t1)) (set-node-right! t1 (join! (node-right t1) t2)) (fix-size! t1) t1] [else (set-node-left! t2 (join! t1 (node-left t2))) (fix-size! t2) t2]))

36 17 Delete in DSSL (define (delete! t k) (cond [(empty? t) t] [(< k (node-key t)) (set-node-left! t (delete! (node-left t) k)) (fix-size! t) t] [(> k (node-key t)) (set-node-right! t (delete! (node-right t) k)) (fix-size! t) t] [else (join! (node-left t) (node-right t))]))

37 Next time: guaranteed balance