תרגול 13 עצים

1. תרגול 13עצים

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

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

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

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

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

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

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

9. דוגמא

10. מימוש: עץ

11. BinaryTree publicclassBinaryTree { protectedBinaryNoderoot; public BinaryTree() { root = null; } publicboolean isEmpty() { returnroot == null; } publicvoid insert(Object toAdd) { if (isEmpty()) root = newBinaryNode(toAdd); else root.insert(toAdd); } public String inOrder() { if (isEmpty()) return""; else returnroot.inOrder(); } public String preOrder() { if (isEmpty()) return""; elsereturnroot.preOrder(); } public String postOrder() { if (isEmpty()) return""; else returnroot.postOrder(); } }

12. BinaryNode publicclass BinaryNode { protected Object data; protected BinaryNode left; protected BinaryNode right; public BinaryNode(Object data) { this.data = data; left = null; right = null; } … } publicvoid 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); } }

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

14. דוגמה לשיטות של עצים: חישוב גובה בעץ בינארי כללי In BinaryTree publicint height() { if (isEmpty()) return -1; else returnroot.height(); } In BinaryNode publicint 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; }

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

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

17. Step 1 Step 2 Step 3 Step 4 Step 5 Step 6 Step 7 import java.util.Comparator; publicclass Main { publicstaticvoid 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()); } } 50 60 40 30 20 45 65

18. IntegerComparator publicclass IntegerComparator implements Comparator { publicint compare(Object o1, Object o2) { Integer i1 = (Integer) o1; Integer i2 = (Integer) o2; if (i1.intValue() > i2.intValue()) return 1; elseif (i1.intValue() == i2.intValue()) return 0; else return -1; } }

19. CharacterComparator publicclass CharacterComparator implements Comparator { publicint compare(Object o1, Object o2) { Character c1 = (Character) o1; Character c2 = (Character) o2; if (c1.charValue() > c2.charValue()) return 1; elseif (c1.charValue() == c2.charValue()) return 0; else return -1; } }

20. F B H A D K BST Insert: Example Example: Insert C C

21. הכנסת איבר חדש לעץ • In BST • publicvoid insert(Object toAdd){ • if (isEmpty()) { • root = new BSN(toAdd, this.comp); • } • else { • root.insert(toAdd); • } • } In BSN publicvoid 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); } }

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

23. שאלות ממבחנים

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

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

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

27. עץ בינארי מושלם בדיקה האם עץ בינארי הוא "מושלם" במחלקה BinaryTree: publicboolean isPerfect() { returnroot.isPerfect(); } במחלקה BinaryNode: publicboolean isPerfect() { int h = height(); // class method if (h==0) returntrue; if (h==1) return left != null && right != null; return left != null && left.height() == h - 1 && left.isPerfect() && right != null && right.height() == h - 1 && right.isPerfect()); }

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

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

30. עץ בינארי שלם נבדוק כמה מקרי קצה, כי אם גובה העץ הוא 0 או 1 נקבל שדרוש לבדוק אם גובה תת העץ הוא 0 או 1- במחלקה BinaryTree: publicboolean isComplete() { return root.isComplete(); }

31. במחלקה BinaryNode: publicboolean isComplete() { int h = height(); //class method if (h==0) returntrue; if (h==1) return left != null; //the height is at least 2: 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 && left.isComplete() && rightH == h-2 && right.isPerfect(); case2 = leftH == h-1 && left.isPerfect () &&rightH == h-1 && right.isComplete(); } return case1 || case2; }

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

33. הוסיפו את השיטה getKeysInRange למחלקות Heap ו-HeapNode . השיטה מחזירה רשימה משורשרת המכילה את כל המפתחות בתחום הסגור [cFirst, cLast]. לדוגמה, הקריאה getKeysInRange(new Integer(3), new Integer(8)); על הערימה שלהלן תחזיר רשימה המכילה את המפתחות 7,6,8,3 (לא בהכרח בסדר זה). 8 3 7 1 2 6

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

35. 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. In HeapNode class: publicvoid getKeysInRange(Comparable cFirst, Comparable cLast, LinkedList lKeys ) { if (mKey.compareTo(cFirst) >= 0 ) { if (mKey.compareTo(cLast) <= 0) lKeys.add(mKey); if (mLeft != null) mLeft.getKeysInRange(cFirst, cLast, lKeys); if (mRight != null) mRight.getKeysInRange(cFirst, cLast, lKeys); } }

37. The End!