88621159 Data Structures and Algorithms 2/2561 Binary Search Tree 88621159 Data Structures and Algorithms 2/2561

Tree Tree เป็นโครงสร้างหลักอีกชนิดหนึ่งสามารถนำมาใช้ในการจัดการกับข้อมูล คล้ายกับการจัดเก็บด้วย Linked-List เพียงแต่มีเงื่อนไข และวิธีการในการจัดการที่ต่างกัน

Tree Path หมายถึงเส้นทางจาก node ใด node หนึ่งไปยัง node สุดท้ายที่อยู่ในเส้นทางนั้น Edge หมายถึงเส้นทางเชื่อมต่อระหว่าง node สอง node (บางครั้งเรียกว่า link) Root หมายถึง node ที่อยู่บนสุดใน tree นั้นๆ ซึ่งมีเพียง node เดียวเท่านั้น Parent คือ โหนดที่อยู่ในลำดับบนของอีกโหนดหนึ่ง Child คือ โหนดที่อยู่ในลำดับล่างของอีกโหนดหนึ่ง Sibling คือ โหนดที่อยู่ในระดับเดียวกัน Leaf คือ โหนดที่อยู่ในตำแหน่งล่างสุดของ tree Sub-tree คือ กลุ่มของ node ที่อยู่ใน tree โดยมี node ใด node หนึ่งเป็น root

Tree Root A เป็น Root A เป็น Parent ของ B Edge B เป็น Child ของ A Path B และ C เป็น Sibling D E F C เป็น Leaf B D E F เป็น Sub-tree ของ A Edge Path Leaf

Binary Tree Binary tree เป็น tree ที่ node แต่ละ node สามารถที่จะมีลูก (children) ได้สูงสุด 2 node อยู่ทางซ้ายหนึ่ง node อยู่ทางขวาหนึ่ง node

Binary Search Tree (BST) เป็น Binary tree ที่มีข้อกำหนดพิเศษเฉพาะตัวคือ ข้อมูลของ node ลูกที่อยู่ทางซ้ายของ node parent จะต้องมีค่าน้อย กว่าค่าของข้อมูลที่อยู่ใน node parent และ ค่าของข้อมูลที่อยู่ใน node ลูกที่อยู่ทางขวา ของ node parent จะมีค่ามากกว่าค่าของข้อมูลที่ อยู่ใน node parent click

Java Implementation To implement: use two links per Node. A Node is comprised of: A item. A reference to the left subtree. A reference to the right subtree. private class Node { private T item; private Node left; private Node right; private Node(T item) { this.item = item; left = null; right = null; }

BST: Skeleton BST. Allow generic item class BST<T extends Comparable<T>> { private Node root; private class Node { private T item; private Node left; private Node right; private Node(T item) { this.item = item; left = null; right = null; } BST() { root = null; } public void insert(T item) {...} private Node insert(T item, Node node) {...} public boolean search(T item) {...} private boolean search(T item, Node node) {...} requires T to provide compareTo() method;

Recursion on Trees เราสามารถเขียน Recursive methods เพื่อ ปฏิบัติการบน trees ได้ Base case empty tree leaf node Recursive case แก้ปัญหาต้นไม้ย่อยทางด้านซ้าย และ ด้านขวา นำคำตอบของปัญหาต้นไม้ย่อย ๆ มา รวมกันเพื่อให้ได้คำตอบของปัญหาต้นไม้ ที่ใหญ่กว่า

BST: insert public void insert(T item) { root = insert(item, root); } private Node insert(T item, Node node) { if(node == null) return new Node(item); int cmp = item.compareTo(node.item); if(cmp < 0) node.left = insert(item, node.left); else if(cmp > 0) node.right = insert(item, node.right); return node;

BST: search public boolean search(T item) { return search(item, root); } private boolean search(T item, Node node) { while(node != null) { int cmp = item.compareTo(node.item); if(cmp < 0) node = node.left; else if(cmp > 0) node = node.right; else return true; //found item return false; //no item found

Binary Tree Traversals Preorder traversal Postorder traversal Inorder traversal class BST<T extends Comparable<T>> { ... //print data of node in Pre-order public void preorder() {…} private void preorder(Node node) {…} //print data of node in Post-order public void postorder() {…} private void postorder(Node node) {…} //print data of node in in-order public void inorder() {…} private void inorder(Node node) {…} }

10 5 2 8 7 14 Preorder traversal click Visit node. Recursively visit left subtree. Recursively visit right subtree. 10 5 2 8 7 14 5 10 2 14 8 7 click

Preorder traversal public void preorder() { preorder(root); } private void preorder(Node node) { if (node == null) return; System.out.print(node.item + " "); preorder(node.left); preorder(node.right);

2 7 8 5 14 10 Postorder traversal click Recursively visit left subtree. Recursively visit right subtree. Visit node. 2 7 8 5 14 10 5 10 2 14 8 7 click

Postorder traversal //print data of node in Post-order fashion public void postorder() { postorder(root); } private void postorder(Node node) { if(node==null) return; postorder(node.left); postorder(node.right); System.out.print(node.item + " ");

Inorder traversal 2 5 7 8 10 14 click Recursively visit left subtree. Visit node. Recursively visit right subtree. 2 5 7 8 10 14 5 10 2 14 8 7 click

Inorder traversal //print data of node in in-order fashion public void inorder() { inorder(root); } private void inorder(Node node) { if (node == null) return; inorder(node.left); System.out.print(node.item + " "); inorder(node.right);

BST: Analysis Running time per put/get. There are many BSTs that correspond to same set of keys. Cost is proportional to depth of node. number of nodes on path from root to node depth = 1 hi be depth = 2 at no at no depth = 3 do if pi go pi depth = 4 be go me of we do if of we depth = 5 hi me

BST: Analysis Best case. If tree is perfectly balanced, depth is at most log N. average depth => inserting N keys at random takes 2 N ln N comparisons (just like quicksort) variance of height is O(1) so extremely unlikely that height is far away from mean

BST: Analysis Worst case. If tree is unbalanced, depth is N. average depth => inserting N keys at random takes 2 N ln N comparisons (just like quicksort) variance of height is O(1) so extremely unlikely that height is far away from mean

BST: Analysis Average case. If keys are inserted in random order, average depth is 2 log N. average depth => inserting N keys at random takes 2 N ln N comparisons (just like quicksort) variance of height is O(1) so extremely unlikely that height is far away from mean

Binary Search Tree Input: 7, 1, 0, 3, 2, 5, 4, 6, 9, 8, 10 Preorder: 7 1 0 3 2 5 4 6 9 8 10 Inorder: 0 1 2 3 4 5 6 7 8 9 10 Postorder: 0 2 4 6 5 3 1 8 10 9 7