Tirgul 13 trees
Download
1 / 37

Tirgul 13: Trees - PowerPoint PPT Presentation


  • 167 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Tirgul 13: Trees' - qamar


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

הגדרות

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

  • שורש בעץ – צומת ללא אבא. בכל עץ יש בדיוק שורש אחד. לכל הצמתים פרט לשורש יש בדיוק אב אחד.


הגדרות

X

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

  • צומת X הנו האבא של W, ו W הנו בן של X אם X הנו אב קדמון של W ויש ביניהם צלע

W

Y


הגדרות

  • עלה – צומת אשר אין לו בנים.

  • עומקשל צומת בעץ= מרחק הצומת מהשורש.


הגדרות

  • גובהשל העץ – עומק מקסימאלי של צומת בעץ (וגובה של עץ ריק הוא -1).

  • עץ בינארי - עץ אשר בו מספר הבנים של כל צומת אינו עולה על 2.


הגדרות

עץ חיפוש בינארי

עץ בינארי אשר בו עבור כל צומת, הערכים של כל האיברים בתת העץ השמאלי שלו קטנים (או שווים) ממנו, וכל האיברים בתת העץ הימני שלו גדולים ממנו.

7

3

10

6

1

14

4

7

13


1

6

3

5

8

2

9

שלוש שיטות לסריקת עץ

pre-order, in-order ,post-order.

בביצוע הסריקות בעץ הנתון יתקבל סדר האיברים הבא:

  • תחילי (pre-order):

  • תוכי (in-order):

  • סופי (post-order):

מה הייתה התוצאה אם העץ היה binary search tree?

1,6,8,5,2,9,3

8,6,2,5,9,1,3

8,2,9,5,6,3,1


הגדרות: עוקב וקודם

העוקב לצומת x:

הצומת בעל מפתח הקטן ביותר הגדול מערך שלx

הקודם לצומתx:

הוא הצומת בעל מפתח הגדול ביותר הקטן מערך שלx

דוגמה:

הקודם של W הוא

העוקב של W הוא

הקודם של C הוא

העוקב של C הוא

ב- BST, לפי סריקת inOrder:

R

Y

B

E




Binarytree
BinaryTree

publicclassBinaryTree {

protectedBinaryNoderoot;

publicBinaryTree() {

root = null;

} // BinaryTree

publicbooleanisEmpty() {

returnroot == null;

} // isEmpty

publicvoid insert(Object toAdd) {

if (isEmpty())

root = newBinaryNode(toAdd);

else

root.insert(toAdd);

} // insert

public String inOrder() {

if (isEmpty())

return"";

else

returnroot.inOrder();

} // inOrder

public String preOrder() {

if (isEmpty())

return"";

elsereturnroot.preOrder();

} // preOrder

public String postOrder() {

if (isEmpty())

return"";

else

returnroot.postOrder();

} // postOrder

}


Binarynode
BinaryNode

publicvoid insert(Object toAdd) {

double select = Math.random();

if (select > 0.5) {

if (left == null)

left = newBinaryNode(toAdd);

else

left.insert(toAdd);

}

else {

if (right == null)

right = newBinaryNode(toAdd);

else

right.insert(toAdd);

}

} // insert

publicclassBinaryNode {

protected Object data;

protectedBinaryNodeleft;

protectedBinaryNoderight;

publicBinaryNode(Object data) {

this.data = data;

left = null;

right = null;

} // BinaryNode

}


Binarynode1
BinaryNode

public String preOrder() {

String res = "";

if (data == null)

res = res + " <null> ";

else

res = res + " " + data.toString() + " ";

if (left != null)

res = res + left.preOrder();

if (right != null)

res = res + right.preOrder();

return res;

} // preOrder

public String inOrder() {

String res = "";

if (left != null)

res = res + left.inOrder();

if (data == null)

res = res + " <null> ";

else

res = res + " " + data.toString() + " ";

if (right != null)

res = res + right.inOrder();

return res;

} // inOrder


Binarynode2
BinaryNode

public String postOrder() {

String res = "";

if (left != null)

res = res + left.postOrder();

if (right != null)

res = res + right.postOrder();

if (data == null)

res = res + " <null> ";

else

res = res + " " + data.toString() + " ";

return res;

} // postOrder


דוגמה לשיטות של עצים: חישוב גובה בעץ בינארי כללי

במחלקה 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;

} // height

במחלקה BinaryTree:

publicint height() {

if (isEmpty())

return -1;

else

returnroot.height();

} // height


מימוש:עץחיפוש בינארי -BST

BinaryTree

BinaryNode

הורשה

BST

BSN


BST

import java.util.Comparator;

publicclass BST extends BinaryTree

{

private Comparator comp;

public BST(Comparator comp) {

super();

this.comp = comp;

} // BST

// (override insert only)

} // class BST

publicclass BSN extends BinaryNode

{

private Comparator comp;

public BSN(Object data, Comparator comp)

{

super(data);

this.comp = comp;

} // BSN

// (override insert, remove, etc.)

} // class BSN


Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

importjava.util.Comparator;

publicclass Main {

publicstaticvoid main(String[] args) {

Comparator comp = newIntegerComparator();

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


Integercomparator
IntegerComparator

publicclassIntegerComparatorimplements Comparator {

publicint compare(Object o1, Object o2) {

if (((Integer)o1).intValue() > ((Integer)o2).intValue())

return 1;

elseif (((Integer)o1).intValue() == ((Integer)o2).intValue())

return 0;

else

return -1;

}

}


Charactercomparator
CharacterComparator

publicclassCharacterComparatorimplements Comparator {

publicint compare(Object o1, Object o2) {

if (((Character)o1).charValue() > ((Character)o2).charValue())

return 1;

elseif (((Character)o1).charValue() == ((Character)o2).charValue())

return 0;

else

return -1;

}

}


Bst insert example

F

B

H

A

D

K

BST Insert: Example

  • Example: Insert C

C


הכנסה איבר חדש לעץ

  • במחלקה BST:

  • publicvoid insert(Object toAdd)

  • {

  • if (isEmpty()) {

    • root = new BSN(toAdd, this.comp);

  • }

  • else {

  • root.insert(toAdd);

  • }

  • } // insert

במחלקה 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);

}

} // insert


מציאת קודקוד בעל מפתח מינימאליבעץ חיפוש בינארי.

במחלקה BST:

public Object findMin() {

if (isEmpty()) {

returnnull; // 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

מה היינו צריכים לעשות אם העץ לא היה BST?



עץ בינארי מלא

( FULL )עץ בינארי מלא

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


Perfect

עץ בינארי מושלם

( PERFECT )עץ בינארי מושלם

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


Complete

לכל הקדקודים שלו עד

שכבה h-2

יש בדיוק 2 בנים

כל הקדקודים

ברמה ה h

מרוכזים לשמאל

עץ בינארי שגובהו hומתקיים:

עץ בינארי שלם

( COMPLETE )עץ בינארי שלם


עץ בינארי מושלם

בדיקה האם עץ בינארי הוא עץ בינארי מושלם

במחלקה BST:

publicboolean isPerfect() {

return ((BSN)root).isPerfect();

}

במחלקה BSN:

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) &&

((BSN)left).isPerfect() &&

!(right==null) &&(right.height() == h - 1) &&

((BSN)right).isPerfect());

}


ראינו את ההגדרות הבאות:עץ בינארי שלם

עץ מושלם (perfect)- עץ בינארי מלא שבו לכל העלים אותו עומק

עץ בינארי שלם (complete)עץ בינארי שגובהו h ומתקיים

לכל הקדקודים שלו עד שכבה h-2

יש בדיוק 2 בנים

כל הקדקודים ברמה ה h

מרוכזים לשמאל

בדיקה האם עץ בינארי הוא "שלם"

עץ בינארי שלם


הוא ריק

או

הבן השמאלי שלו הוא שורש של עץ שלם בגובה h-1

והבן הימני שלו הוא שורש של עץ מושלם בגובה h-2

או

הבן השמאלי שלו הוא שורש של עץ מושלם בגובה h-1

והבן הימני שלו הוא שורש של עץ שלם בגובה h-1

עץ בינארי בגובה h הוא שלם אם ורק אם:

בהגדרה רקורסיבית


0 1 0 1

עץ בינארי שלם

אנחנו נבדוק כמה מקרי קצה כי אם גובה העץ הוא 0 או 1 נקבל שדרוש לבדוק אם גובה תת העץ הוא 0 או –1

במחלקה BST:

publicboolean isComplete() {

return ((BSN)root).isComplete();

}

במחלקה BSN:

publicboolean isComplete() {

int h = height(); //class method

if (h==0) returntrue;

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;

}



2006 1

8

3

7

1

2

6

מבחן 2006 סמסטר ב' מועד ב' שאלה 1

  • סעיף א

    ערימה (heap) הינה עץ בינארי ובו המפתח בכל קודקוד גדול (כפי שמוגדר על ידי הממשק Comparable) מהמפתחות בילדיו.

    דוגמא – העץ להלן מהווה ערימה חוקית אך אם נוסיף לקודקוד בעל המפתח 7 ילד שמאלי עם מפתח 9 נקבל עץ שאינו מהווה ערימה חוקית

  • בכל הסעיפים בשאלה זו ניתן להניח כי אין בעץ מפתחות בעלי ערך null.

  • המחלקות Heap ו- HeapNode זהות למחלקות BinaryTree ו-BinaryNode כפי שנלמדו בכיתה ומכילות בנאים (constructors) ושיטות גישה (accessors) בהן ניתן להשתמש מבלי לממשן.


8

3

7

1

2

6

הוסיפו את השיטה getKeysInRange למחלקות Heap ו-HeapNode

השיטה מחזירה רשימה משורשרת המכילה את כל המפתחות בתחום הסגור [cFirst, cLast].

  • לדוגמא – הקריאה

    getKeysInRange( new Integer(3) , new Integer(8))

    על הערימה למעלה תחזיר רשימה המכילה את המפתחות 8,3,,67 (לא בהכרח בסדר זה).


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

}

}


In Heap class:

public LinkedList getKeysInRange( Comparable cFirst, Comparable cLast ) {

LinkedList lKeys = new LinkedList();

if( mRoot != null )

mRoot.getKeysInRange(cFirst,cLast,lKeys);

return lKeys;

}


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);

}

}


ad