1. Tirgul 13: Trees 1

2. הגדרות עץ – מודל מופשט של מבנה היררכי. עץ מורכב מאוסף של צמתים (קודקודים) עם יחס אבא-בן. שורש בעץ – צומת ללא אבא. בכל עץ יש בדיוק שורש אחד. לכל הצמתים פרט לשורש יש בדיוק אב אחד. 2

3. הגדרות צומת X הינו אב קדמון של צומת Y, ו Y הנו צאצא של X אם המסלול מהשורש אל Y עובר דרך X. צומת X הנו האבא של W, ו W הנו בן של X אם X הנו אב קדמון של W ויש ביניהם צלע Y X W 3

4. הגדרות עלה – צומת אשר אין לו בנים. עומק של צומת בעץ = מרחק הצומת מהשורש. 4

5. הגדרות גובה של העץ – עומק מקסימאלי של צומת בעץ (וגובה של עץ ריק הוא -1). עץ בינארי - עץ אשר בו מספר הבנים של כל צומת אינו עולה על 2. 5

6. הגדרות עץ חיפוש בינארי עץ בינארי אשר בו עבור כל צומת, הערכים של כל האיברים בתת העץ השמאלי שלו קטנים (או שווים) ממנו, וכל האיברים בתת העץ הימני שלו גדולים ממנו. 6 7 7 7 7 1 1 3 3 10 4 4 6 6 14 13

7. שלוש שיטות לסריקת עץ pre-order, in-order,post-order. בביצוע הסריקות בעץ הנתון יתקבל סדר האיברים הבא: תחילי (pre-order) : תוכי (in-order): סופי (post-order) : 1 1 9 9 8 8 6 6 3 3 2 2 5 5 7 1,6,8,5,2,9,3 8,6,2,5,9,1,3 8,2,9,5,6,3,1 מה הייתה התוצאה אם העץ היה binary search tree?

8. הגדרות: עוקב וקודם העוקב לצומת x: הצומת בעל מפתח הקטן ביותר הגדול מערך של x הקודם לצומת x: הוא הצומת בעל מפתח הגדול ביותר הקטן מערך של x דוגמה: הקודם של W הוא העוקב של W הוא הקודם של C הוא העוקב של C הוא ב- BST, לפי סריקת inOrder: R 8 Y B E

9. דוגמא 9

10. מימוש: עץ 10

11. public class BinaryTree { protected BinaryNode root; public BinaryTree() { root = null; } // BinaryTree public boolean isEmpty() { return root == null; } // isEmpty public void insert(Object toAdd) { if (isEmpty()) root = new BinaryNode(toAdd); else root.insert(toAdd); } // insert public String inOrder() { if (isEmpty()) return ""; else return root.inOrder(); } // inOrder public String preOrder() { if (isEmpty()) return ""; else return root.preOrder(); } // preOrder public String postOrder() { if (isEmpty()) return ""; else return root.postOrder(); } // postOrder } BinaryTree 11

12. BinaryNode public class BinaryNode { protected Object data; protected BinaryNode left; protected BinaryNode right; public BinaryNode(Object data) { this.data = data; left = null; right = null; } // BinaryNode … } public void insert(Object toAdd) { double select = Math.random(); if (select > 0.5) { if (left == null) left = new BinaryNode(toAdd); else left.insert(toAdd); } else { if (right == null) right = new BinaryNode(toAdd); else right.insert(toAdd); } } // insert 12

13. BinaryNode public String inOrder() { String res = ""; if (left != null) res = res + left.inOrder(); if (data == null) res = res + " "; else res = res + " " + data.toString() + " "; if (right != null) res = res + right.inOrder(); return res; } // inOrder public String preOrder() { String res = ""; if (data == null) res = res + " "; else res = res + " " + data.toString() + " "; if (left != null) res = res + left.preOrder(); if (right != null) res = res + right.preOrder(); return res; } // preOrder 13

14. BinaryNode 14 public String postOrder() { String res = ""; if (left != null) res = res + left.postOrder(); if (right != null) res = res + right.postOrder(); if (data == null) res = res + " "; else res = res + " " + data.toString() + " "; return res; } // postOrder

15. דוגמה לשיטות של עצים: חישוב גובה בעץ בינארי כללי במחלקה BinaryTree: public int height() { if (isEmpty()) return -1; else return root.height(); } // height במחלקה BinaryNode: public int height() { int resLeft = -1; int resRight = -1; if (left != null) { resLeft = left.height(); } if (right != null) { resRight = right.height(); } return Math.max(resLeft, resRight) + 1; } // height 15

16. מימוש: עץ חיפוש בינארי -BST BST BinaryTree BSN BinaryNode הורשה 16

17. BST 17 import java.util.Comparator; public class BST extends BinaryTree { private Comparator comp; public BST(Comparator comp) { super(); this.comp = comp; } // BST … // (override insert only) } // class BST public class BSN extends BinaryNode { private Comparator comp; public BSN(Object data, Comparator comp) { super(data); this.comp = comp; } // BSN … // (override insert, remove, etc.) } // class BSN

18. import java.util.Comparator; public class Main { public static void main(String[] args) { Comparator comp = new IntegerComparator(); BST tree1 = new BST(comp); tree1.insert(new Integer(50)); // Step 1 tree1.insert(new Integer(60)); // Step 2 tree1.insert(new Integer(40)); // Step 3 tree1.insert(new Integer(30)); // Step 4 tree1.insert(new Integer(20)); // Step 5 tree1.insert(new Integer(45)); // Step 6 tree1.insert(new Integer(65)); // Step 7 System.out.println("InOrder: " + tree1.inOrder()); System.out.println("PreOrder: " + tree1.preOrder()); System.out.println("PostOrder: " + tree1.postOrder()); System.out.println("Find Minimum: " + tree1.findMin()); System.out.println("Height: " + tree1.height()); } 18 50604030204565 Step 1Step 2Step 3Step 4Step 5Step 6Step 7

19. public class IntegerComparator implements Comparator { public int compare(Object o1, Object o2) { if (((Integer)o1).intValue() > ((Integer)o2).intValue()) return 1; else if (((Integer)o1).intValue() == ((Integer)o2).intValue()) return 0; else return -1; } IntegerComparator 19

20. public class CharacterComparator implements Comparator { public int compare(Object o1, Object o2) { if (((Character)o1).charValue() > ((Character)o2).charValue()) return 1; else if (((Character)o1).charValue() == ((Character)o2).charValue()) return 0; else return -1; } CharacterComparator 20

21. BST Insert: Example Example: Insert C F BH KDA C 21

22. הכנסה איבר חדש לעץ במחלקה BST: public void insert(Object toAdd) { if (isEmpty()) { root = new BSN(toAdd, this.comp); } else { root.insert(toAdd); } } // insert במחלקה BSN: public void insert(Object toAdd) { if (comp.compare(toAdd, this.data) < 0) { if (left == null) left = new BSN(toAdd,this.comp); else left.insert(toAdd); } if (comp.compare(toAdd, this.data) > 0) { if (right == null) right = new BSN(toAdd,this.comp); else right.insert(toAdd); } } // insert 22

23. מציאת קודקוד בעל מפתח מינימאלי בעץ חיפוש בינארי. במחלקה BST: public Object findMin() { if (isEmpty()) { return null; // Exceptions are needed... } return ((BSN)root).findMin(); } // findMin במחלקה BSN: public Object findMin() { BinaryNode t=this; while( t.left != null ) t = t.left; return t.data; } // findMin 23 מה היינו צריכים לעשות אם העץ לא היה BST?

24. דוגמא ממבחן 24

25. ( FULL ) עץ בינארי מלא עץ בינארי אשר בו לכל צומת פנימי יש (בדיוק) שני בנים. עץ בינארי מלא 25

26. ( PERFECT ) עץ בינארי מושלם עץ בינארי מלא שבו לכל העלים יש אותו עומק. עץ בינארי מושלם 26

27. ( COMPLETE ) עץ בינארי שלם לכל הקדקודים שלו עד h-2 שכבה h-2 יש בדיוק 2 בנים כל הקדקודים h ברמה ה h מרוכזים לשמאל עץ בינארי שגובהו hומתקיים: עץ בינארי שלם 27

28. בדיקה האם עץ בינארי הוא עץ בינארי מושלם במחלקה BST: public boolean isPerfect() { return ((BSN)root).isPerfect(); } במחלקה BSN: public boolean isPerfect() { int h = height(); //class method if (h==0) return true; if (h==1) return (!(left==null) && !(right==null)); return (!(left==null) && (left.height() == h - 1) && ((BSN)left).isPerfect() && !(right==null) &&(right.height() == h - 1) && ((BSN)right).isPerfect()); } עץ בינארי מושלם 28

29. בדיקה האם עץ בינארי הוא "שלם" ראינו את ההגדרות הבאות:עץ בינארי שלם עץ מושלם (perfect) - עץ בינארי מלא שבו לכל העלים אותו עומק עץ בינארי שלם (complete)עץ בינארי שגובהו h ומתקיים לכל הקדקודים שלו עד שכבה h-2 יש בדיוק 2 בנים כל הקדקודים ברמה ה h מרוכזים לשמאל עץ בינארי שלם 29

30. בהגדרה רקורסיבית הוא ריק או הבן השמאלי שלו הוא שורש של עץ שלם בגובה h-1 והבן הימני שלו הוא שורש של עץ מושלם בגובה h-2 או הבן השמאלי שלו הוא שורש של עץ מושלם בגובה h-1 והבן הימני שלו הוא שורש של עץ שלם בגובה h-1 עץ בינארי בגובה h הוא שלם אם ורק אם: 30

31. אנחנו נבדוק כמה מקרי קצה כי אם גובה העץ הוא 0 או 1 נקבל שדרוש לבדוק אם גובה תת העץ הוא 0 או –1 במחלקה BST: public boolean isComplete() { return ((BSN)root).isComplete(); } במחלקה BSN: public boolean isComplete() { int h = height(); //class method if (h==0) return true; if (h==1) return (!(left==null)); //the height is 2 and up: boolean has2Sons = (!(left==null) && !(right==null)); boolean case1=false, case2=false; if (has2Sons) { int leftH = left.height(); int rightH = right.height(); case1 = (((leftH == h-1) && ((BSN)left).isComplete()) && (rightH == h-2) && ((BSN)right).isPerfect()); case2 = (((leftH == h-1) && ((BSN)left).isPerfect ()) && (rightH == h-1) && ((BSN)right).isComplete()); } return case1 || case2; } עץ בינארי שלם 31

32. The End! 32

33. מבחן 2006 סמסטר ב' מועד ב' שאלה 1 סעיף א ערימה (heap) הינה עץ בינארי ובו המפתח בכל קודקוד גדול (כפי שמוגדר על ידי הממשק Comparable) מהמפתחות בילדיו. דוגמא – העץ להלן מהווה ערימה חוקית אך אם נוסיף לקודקוד בעל המפתח 7 ילד שמאלי עם מפתח 9 נקבל עץ שאינו מהווה ערימה חוקית בכל הסעיפים בשאלה זו ניתן להניח כי אין בעץ מפתחות בעלי ערך null. המחלקות Heap ו- HeapNode זהות למחלקות BinaryTree ו-BinaryNode כפי שנלמדו בכיתה ומכילות בנאים (constructors) ושיטות גישה (accessors) בהן ניתן להשתמש מבלי לממשן. 8 73 621 33

34. הוסיפו את השיטה getKeysInRange למחלקות Heap ו- HeapNode השיטה מחזירה רשימה משורשרת המכילה את כל המפתחות בתחום הסגור [cFirst, cLast]. לדוגמא – הקריאה getKeysInRange( new Integer(3), new Integer(8) ) על הערימה למעלה תחזיר רשימה המכילה את המפתחות 8,3,,67 (לא בהכרח בסדר זה). 8 73 621 34

35. public class Heap{ private HeapNode mRoot; public LinkedList getKeysInRange(Comparable cFirst, Comparable cLast ){ // Complete here } public class HeapNode{ private Comparable mKey; private HeapNode mLeft, mRight; public void getKeysInRange( Comparable cFirst, Comparable cLast, LinkedList lKeys ){ // Complete here } 35

36. In Heap class: public LinkedList getKeysInRange( Comparable cFirst, Comparable cLast ) { LinkedList lKeys = new LinkedList(); if( mRoot != null ) mRoot.getKeysInRange(cFirst,cLast,lKeys); return lKeys; } 36

37. In HeapNode class: public void getKeysInRange( Comparable cFirst, Comparable cLast, LinkedList lKeys ) { if( mData.compareTo( cFirst ) >= 0 ){ if( mData.compareTo( cLast ) <= 0 && mData.compareTo( cFirst ) >= 0 ) lKeys.add(mData ); if( mLeft != null ) mLeft.getKeysInRange(cFirst,cLast, lKeys); if( mRight != null ) mRight.getKeysInRange(cFirst,cLast, lKeys); } 37