Data Structure Lecture#11: Binary Trees (Chapter 5) U Kang Seoul National University

Transcription

1 Data Structure Lecture#11: Binary Trees (Chapter 5) U Kang Seoul National University U Kang (2016) 1

2 In This Lecture Implementation and space overhead of binary tree Main idea and operations for BST (Binary Search Tree) Complexity and implementations for BST U Kang (2016) 2

3 Recursion Examples int count(binnode rt) { if (rt == null) return 0; return 1 + count(rt.left()) + count(rt.right()); U Kang (2016) 3

4 Binary Tree Implementation (1) Leaf implementation is identical to internal node implementation U Kang (2016) 4

5 Binary Tree Implementation (2) Distinct internal and leaf node implementations Between implementations (1) and (2), which is better? Why? U Kang (2016) 5

6 Inheritance (1) /** Base class */ public interface VarBinNode { public boolean isleaf(); /** Leaf node */ class VarLeafNode implements VarBinNode { private String operand; public VarLeafNode(String val) { operand = val; public boolean isleaf() { return true; public String value() { return operand; ; U Kang (2016) 6

7 Inheritance (2) /** Internal node */ class VarIntlNode implements VarBinNode { private VarBinNode left; private VarBinNode right; private Character operator; public VarIntlNode(Character op, VarBinNode l, VarBinNode r) { operator = op; left = l; right = r; public boolean isleaf() { return false; public VarBinNode leftchild() { return left; public VarBinNode rightchild(){ return right; public Character value() { return operator; U Kang (2016) 7

8 Inheritance (3) /** Preorder traversal */ public static void traverse(varbinnode rt) { if (rt == null) return; if (rt.isleaf()) VisitLeafNode(((VarLeafNode)rt).value()); else { VisitInternalNode(((VarIntlNode)rt).value()); traverse(((varintlnode)rt).leftchild()); traverse(((varintlnode)rt).rightchild()); U Kang (2016) 8

9 Space Overhead (1) Space overhead = (non data space) / (total space) From the Full Binary Tree Theorem: Half of the pointers are null. If only leaves store data, then overhead depends on whether the tree is full. Ex: Full tree, all nodes the same, with two pointers to children and one to element: Total space required is (3p + d)n Overhead: 3pn If p = d, this means 3p/(3p + d) = 3/4 overhead. p: space for a pointer d: space for a data item U Kang (2016) 9

10 Space Overhead (2) How to decrease space overhead? Idea: eliminate child pointers from the leaf nodes Then, space overhead = nn 2 nn 2 (2pp)+nnnn 2pp = 2pp +nnnn+nnnn 2pp+dd If p = d, then the space overhead = 2/3 U Kang (2016) 10

11 Binary Search Trees BST Property: All elements stored in the left subtree of a node with value K have values < K. All elements stored in the right subtree of a node with value K have values >= K. U Kang (2016) 11

12 BSTNode (1) class BSTNode<K,E> implements BinNode<E> { private K key; private E element; private BSTNode<K,E> left; private BSTNode<K,E> right; public BSTNode() {left = right = null; public BSTNode(K k, E val) { left = right = null; key = k; element = val; public BSTNode(K k, E val, BSTNode<K,E> l, BSTNode<K,E> r) { left = l; right = r; key = k; element = val; public K key() { return key; public K setkey(k k) { return key = k; public E element() { return element; public E setelement(e v) { return element = v; U Kang (2016) 12

13 BSTNode (2) public BSTNode<K,E> left() { return left; public BSTNode<K,E> setleft(bstnode<k,e> p) { return left = p; public BSTNode<K,E> right() { return right; public BSTNode<K,E> setright(bstnode<k,e> p) { return right = p; public boolean isleaf() { return (left == null) && (right == null); U Kang (2016) 13

14 BST (1) /** BST implementation for Dictionary ADT */ class BST<K extends Comparable<? super K>, E> implements Dictionary<K, E> { private BSTNode<K,E> root; // Root of BST private int nodecount; // Size of BST /** Constructor */ BST() { root = null; nodecount = 0; /** Reinitialize tree */ public void clear() { root = null; nodecount = 0; /** Insert a record into the k Key value of the e The record to insert. */ public void insert(k k, E e) { root = inserthelp(root, k, e); nodecount++; U Kang (2016) 14

15 BST (2) /** Remove a record from the k Key value of record to Record removed, or null if there is none. */ public E remove(k k) { E temp = findhelp(root, k); // find it if (temp!= null) { root = removehelp(root, k); // remove it nodecount--; return temp; U Kang (2016) 15

16 BST (3) /** Remove/return root node from The record removed, null if empty. */ public E removeany() { if (root!= null) { E temp = root.element(); root = removehelp(root, root.key()); nodecount--; return temp; else return null; Record with key k, null if k The key value to find. */ public E find(k k) { return findhelp(root, k); Number of records in dictionary. */ public int size() { return nodecount; U Kang (2016) 16

17 Recursion Example boolean checkbst(bstnode<integer> rt, Integer low, Integer high) { if (rt == null) return true; Integer rootkey = rt.key(); if ((rootkey < low) (rootkey > high)) return false; // Out of range if (!checkbst(rt.left(), low, rootkey-1)) return false; // Left side failed return checkbst(rt.right(), rootkey, high); U Kang (2016) 17

18 BST Search private E findhelp(bstnode<k,e> rt, K k) { if (rt == null) return null; if (rt.key().compareto(k) > 0) return findhelp(rt.left(), k); else if (rt.key().compareto(k) == 0) return rt.element(); else return findhelp(rt.right(), k); U Kang (2016) 18

19 BST Insert (1) U Kang (2016) 19

20 BST Insert (2) private BSTNode<K,E> inserthelp(bstnode<k,e> rt, K k, E e) { if (rt == null) return new BSTNode<K,E>(k, e); if (rt.key().compareto(k) > 0) rt.setleft(inserthelp(rt.left(), k, e)); else rt.setright(inserthelp(rt.right(), k, e)); return rt; U Kang (2016) 20

21 Get/Remove Minimum Value private BSTNode<K,E> getmin(bstnode<k,e> rt) { if (rt.left() == null) return rt; else return getmin(rt.left()); private BSTNode<K,E> deletemin(bstnode<k,e> rt) { if (rt.left() == null) return rt.right(); else { rt.setleft(deletemin(rt.left())); return rt; U Kang (2016) 21

22 BST Remove (1) Main Idea (when the item to remove has 2 children) Find the minimum element from the right subtree of the item to remove Swap the minimum element with the item to remove U Kang (2016) 22

23 BST Remove (2) /** Remove a node with key value The tree with the node removed */ private BSTNode<K,E> removehelp(bstnode<k,e> rt, K k) { if (rt == null) return null; if (rt.key().compareto(k) > 0) rt.setleft(removehelp(rt.left(), k)); else if (rt.key().compareto(k) < 0) rt.setright(removehelp(rt.right(), k)); U Kang (2016) 23

24 BST Remove (3) else { // Found it, remove it if (rt.left() == null) return rt.right(); else if (rt.right() == null) return rt.left(); else { // Two children BSTNode<K,E> temp = getmin(rt.right()); rt.setelement(temp.element()); rt.setkey(temp.key()); rt.setright(deletemin(rt.right())); return rt; U Kang (2016) 24

25 Time Complexity of BST Operations Find: O(d) Insert: O(d) Delete: O(d) d = depth of the tree d is O(log n) if tree is balanced. What is the worst case? U Kang (2016) 25

26 Array Implementation (1) For complete binary tree Position Parent Left Child Right Child Left Sibling Right Sibling U Kang (2016) 26

27 Array Implementation (2) Parent (r) = Leftchild(r) = Rightchild(r) = Leftsibling(r) = Rightsibling(r) = U Kang (2016) 27

28 Array Implementation (3) Parent (r) = floor ((r-1)/2) if r!= 0 Leftchild(r) = 2r+1 if 2r+1 < n Rightchild(r) = 2r+2 if 2r+2 < n Leftsibling(r) = r 1 if r is even Rightsibling(r) = r + 1 if r is odd and r+1 < n U Kang (2016) 28

29 BST and Traversal What do we get from an inorder traversal from BST? U Kang (2016) 29

30 BST and Traversal What do we get from an inorder traversal from BST? Sorted values (in increasing order)! U Kang (2016) 30

31 What you need to know Implementations and space overhead of binary tree How to implement link-based BST operations Insert, remove, deletemin, find Get familiar with recursions in the operations Time complexity of BST operations Array-based implementations for complete binary tree U Kang (2016) 31

32 Questions? U Kang (2016) 32