1. ‫למבחן‬ ‫שימושיות‬ ‫פונקציות‬ ‫רשימת‬
‫מחרוזות‬.................................................................................................................................1
‫גלובליות‬ ‫פונקציות‬.....................................................................................................................3
‫מערכים‬...................................................................................................................................4
‫רקורסיות‬.................................................................................................................................8
...........................................................................................................................................11
...........................................................................................................................................11
‫יעילות‬...................................................................................................................................13
‫מצביעים‬................................................................................................................................14
‫רשימות‬.................................................................................................................................15
‫ממוינת‬ ‫רשימה‬........................................................................................................................17
‫מקושרת‬ ‫רשימה‬ ‫על‬ ‫ריצה‬ ‫זמני‬ ‫של‬ ‫סיבוכיות‬.................................................................................18
‫דו-סטרית‬ ‫רשימה‬....................................................................................................................18
‫בינארים‬ ‫עצים‬........................................................................................................................20
‫בינארים‬ ‫עצים‬ ‫סריקת‬...............................................................................................................21
‫ממוינים‬ ‫עצים‬.........................................................................................................................22
‫מחרוזות‬
‫העתקת‬‫מחרוזת‬:‫פעולת‬‫השמה‬‫במחרוזת‬‫נעשית‬‫בעזרת‬‫הפונקציה‬strcpy‫הפונקציה‬ .
strcpy‫עושה‬‫העתק‬‫של‬‫הארגומנט‬‫השני‬‫שלה‬‫ומציבה‬‫אותו‬‫במשתנה‬‫שהוא‬‫הארגומנט‬
.‫הראשון‬
‫יש‬‫צורך‬‫להגדיר‬‫בראש‬‫התוכנית‬#include <string.h<
strcpy (s, “what is your shoe size ?“) ;
•‫פעולת‬‫הקלט‬‫נראית‬:‫כך‬
Cin >> s;
‫פעולות‬‫על‬‫מחרוזות‬
1

2. •‫ישנן‬‫מספר‬‫פעולות‬‫שונות‬ (‫)פונקציות‬‫שאפשר‬‫לבצע‬‫על‬‫מחרוזות‬‫בשפת‬c.++
‫תוצאה‬ ‫פונקציה‬
‫מחזירה‬‫את‬‫התו‬‫במיקום‬і‫במחרוזת‬s‫)תו‬ .‫ראשון‬‫נמצא‬‫במיקום‬0( S [ і[
‫מחזירה‬‫את‬‫אורכה‬‫של‬‫המחרוזת‬s. Strlen (s(
‫מחזירה‬0‫אם‬‫המחרוזות‬s-‫ו‬t‫תו‬ ,‫זהות‬‫אחרי‬‫אם‬ .‫תו‬‫המחרוזת‬s
‫גדולה‬‫מהמחרוזת‬t‫יוחזר‬1‫ואחרת‬ ,‫יוחזר‬1.-
Strcmp (s,t(
‫מעתיקה‬‫את‬‫המחרוזת‬t‫לתוך‬‫המחרוזת‬s‫ומחזירה‬‫ערך‬.‫זה‬ Strcpy (s,t(
‫מעתיקה‬‫את‬n‫התווים‬‫הראשונים‬‫של‬‫המחרוזת‬t‫לתוך‬‫המחרוזת‬s
‫ומחזירה‬‫ערך‬.‫זה‬
Strncpy (s,t,n(
•‫בדיקת‬‫האם‬‫התוו‬‫במחרוזת‬‫הוא‬‫אות‬
for (int і = 0 ; і<max ; і++)
{
( isalpha (str[i]) ) // function from cytpe that check if the char is a letter
}
‫הערה‬‫יש‬ :‫צורך‬‫להגדיר‬‫בתחילת‬‫התוכנית‬‫את‬‫הספרייה‬:#include <cytpe.h<
•‫פונקצית‬‫הפיכת‬‫אות‬‫קטנה‬‫לגדולה‬‫ולהפך‬
2

3. void OpositeLetter (char str [ ] )
{
for ( int i=0; str[i] != NULL; і++ ) //until the NULLl character
{
if ( isalpha (str[i]) ) //function from cytpe that check if the char is a letter
}
if ( (str[i]>='a') && (str[i]<=’z’) )
}
str[i]=(str[i]-32)
continue;
{
if ((str[i]>='A') && (str[i]<=’Z’) )
{
str[i]=(str[i]+32)
continue;
}
}
}
}
•‫ניקוי‬‫מחרוזת‬‫מתווים‬‫שאינם‬‫אותיות‬
void cleaning_str (char str [n])
{
int ok_chars = 0 ;
for (int i=0; str[i] != ‘0’ ; і++)
{
if (isalpha(str[i])) //check if the character is an alphabetic
str [ ok_chars++ ] = str [ і ]
}
Str [ ok_chars++ ] = '0 '; // terminate the string
}
‫גלובליות‬ ‫פונקציות‬
•‫החלפת‬‫סדר‬‫שני‬‫משתנים‬)swap(
3

4. void swap (int &a, int &b)
{
int temp;
temp = b;
a = b;
b = temp;
}
•‫חזקה‬‫)מתוך‬‫ספרית‬#include <math.h<(
‫מבצע‬X‫בחזקת‬Y.
pow(x,y);
•‫שורש‬‫)מתוך‬‫ספרית‬#include <math.h<(
sqrt(y);
•‫בדיקה‬‫האם‬‫המספר‬‫זוגי‬‫או‬‫לא‬
int even (int num)
}
return (num % 2 == 0 ? 1 : 0); //if Condition true return 1 else return 0
{
•‫הפיכת‬‫מחרוזת‬-‫ל‬integer‫)ערך‬‫מספרי‬‫שעליו‬‫ניתן‬‫לבצע‬‫פעולות‬(‫מתמטיות‬
‫מצריך‬‫שימוש‬‫בספרית‬#>include <stdlib.h
int num = atoi (str) ; //ascii to integer
float num = atof (str) ; //ascii to float
‫מערכים‬
•‫איתחול‬‫מערך‬‫לאפס‬
4

5. Void init (int A [ ],const int n)
{
for (int і=0; і<n; і++)
{
str[ і ] = 0;
}
}
•‫קריאת‬‫נתונים‬-‫מה‬User‫לתוך‬‫מערך‬
void read (int A [n], const int n )
{
for (int і=0 ; і<n ; і++)
{
cin>> A [ і ];
}
}
•‫הדפסת‬‫מערך‬
void write (int A [n], const int n )
{
for (int і=0 ; і<n ; і++)
{
cout<< A[і]<<“t “ ;
}
}
•‫קריאת‬‫נתונים‬-‫מה‬User‫לתוך‬‫מערך‬‫דו‬‫ממיידי‬(‫)מטריצה‬
5

6. void read (int A [n] [n], const int n )
{
for (int і=0 ; і<n ; і++)
{
for (int j=0; j<n; j++)
{
cin>> A [ і ] [ j ];
}
}
•‫הדפסת‬‫מערך‬‫דו‬‫ממיידי‬(‫מטריצה‬ )
void write (int A [n] [n], const int n )
{
for (int і=0 ; і<n ; і++)
{
for (int j=0; j<n; j++)
{
cout<<”t “<< A [ і ] [ j ];
}
cout<<endl;
}
•‫ספירת‬‫שכנים‬‫לקורדינאטה‬‫ספציפית‬‫במערך‬‫דו‬‫ממיידי‬(‫)מטריצה‬
6

7. Int CountNeighbours (int Matrix[N][N], const int N, int i, int j(
{
int count = 0;
int x,y;
for(int row = 0; row<3;++row(
{
)for (int column = 0; column <3; ++column
{
if (row == 1 && column == 1(
continue;
x = i+row-1;
y = j+column-1;
//Legal cell (if (x>=0 && x<N && y>=0 && y<N
];count += Matrix[x][y
{
{
return count ;
}
•‫פונקצית‬‫חיפוש‬‫במערך‬‫דו‬‫ממיידי‬)‫לא‬‫ממוין‬(
int if_exists (int a[n][m], int num)
}
for (int i=0; i<n; і++)
}
for (int j=0; j<m;j++)
{
if (a[i] [j] == num;
return 1;
{
{
return 0;
{
•‫פונקציה‬‫זו‬‫סופרת‬‫כמה‬‫מספרים‬‫עם‬‫אותו‬‫ערך‬‫יש‬‫במערך‬‫)טווח‬‫מספרים‬‫מי‬0–9.(
‫הפונקציה‬‫מכניסה‬‫למערך‬‫חדש‬)B(‫את‬‫כמות‬‫המספרים‬‫מכל‬‫ערך‬.
7

8. void check_M_into_N (int A[ ],int B[ ] ,const int n ,const int m)
}
int var = 0;
for(int x = 0; x<n; x++)
{
if (A[x]<n(
{
var =A[x[;
if (var<=m(
{
B [var] ++ ;
{
{
{
{
‫רקורסיות‬
8

9. •‫חזקה‬‫בעזרת‬‫שימוש‬‫ברקורסיה‬
float apowerb (float a,int b)
}
if (b == 0) //stop condition
return 1;
return (a * apowerb (a,b-1)); //recursive call
{
•‫חיבור‬‫כל‬‫אברי‬‫המספר‬:‫)לדג‬435< =11.(
int sum_f (int n(
}
if (n<10(
return (n(;
else
return (n%10) + sum_f (n/10(; //recursive call
{
•‫מציאת‬‫המחלק‬‫המשותף‬‫המקסימלי‬‫בין‬‫שני‬‫מספרים‬)gcd(
Int gcd (int n, int m)
{
if ( (n<0) || (m<0) )
return 1;
if (n == m)
return n;
if (n < m)
return (gcd (n, m-n));
return (gcd (m, n-m));
}
•‫חיבור‬‫כל‬‫התאים‬‫במערך‬)‫מחזירה‬‫את‬‫חיבור‬‫כל‬‫התאים‬(
9

10. int sum_rec (int a [ ],int n(
}
if (n==1( //stop condition
return a [0[;
else
return ( sum_rec (a,n-1) + a[n-1 [ ) ; //recursive call
{
•‫מציאת‬‫האיבר‬‫הכי‬‫גדול‬‫במערך‬)FMC = Find Max Cell(
іnt find_max_cell (int a [ ] , int n)
{
if n==1) //stop conditoin
return (a [ n-1 ]; // return a [ 0 ]
else
if (a [ n-1 ] > find_max_cell (a, n-1) //search for the biggest cell
return (a [ n-1 ] ;
else
return find_max_cell (a, n-1);
}
•‫מציאת‬‫זוג‬‫התאים‬‫הצמודים‬‫אשר‬‫נותנים‬‫לנו‬‫את‬‫הסכום‬‫הכי‬‫גדול‬‫על‬‫ידי‬‫חיבורם‬
int sum_max_couple (int a[ ],int n(
}
if (n==1) //stop conditoin
return (a [ n-1 ]); // a [ 0]
else
if ((a [ n-1 ]+ a [n-2]) > sum_max_couple (a, n-1((
return (a [ n-1 ] + a [n-2] ) ;
else
return sum_max_couple (a, n-1(;
{
•‫פירוק‬‫מספר‬‫למספרים‬‫הקטנים‬‫ממנו‬‫עד‬-‫ל‬1‫וסכימת‬‫ערכיהם‬
‫קלט‬ :‫)לדג‬=4‫הפונקציה‬:‫תחזיר‬4+3+2+1=10
10

11. Int sum (int limit)
{
if (limit == 1)
return 1;
return (limit + sum (limit – 1); //recursive call
•‫הפונקציה‬‫מחשבת‬‫את‬‫המספר‬‫המתקבל‬‫ממכפלת‬‫כל‬‫הספרות‬‫של‬num
int son_calc (int num)
{
if (num<10) //stop condition
return (num(;
else
return (num%10) * son_calc (num/10); // recursion call
}
•‫הפונקציה‬‫מחשבת‬‫את‬‫סדרת‬‫פיבונאצ"י‬‫לדג‬‫קלט‬ :=1123581321...
‫עמוד‬:253
Int fib (int n)
{
if (n < 3 ) //stop condition
return 1;
else
return ( fib (n-2) + fib ( n-1) ); //recursive call
•‫הדפסת‬‫משפט‬‫מהסוף‬‫להתחלה‬‫)עמ‬256.(
Void reverse ( )
{
char ch;
cin>>ch;
if ( !cin.eof() )
reverse (); //read another character - recursively
cout<<ch;
}
‫היפוך‬‫מספר‬‫קלט‬ :‫לדג‬ )=235‫ידפיס‬ ,532‫עמוד‬ (258
11

12. Void rev_num (int n(
}
cout<<n % 10;
if ( (n / 10 ) > 0(
rev_num (n/10;(
{
•‫הפונקציה‬‫מקבלת‬‫מערך‬‫ומחזירה‬1‫עם‬‫ערך‬‫כל‬‫אחד‬‫מאיברי‬‫המערך‬‫גדול‬‫מסכום‬
‫קודמיו‬‫)משתמשת‬‫בשני‬‫פונקציות‬(‫רקורסיביות‬
Int is_order_vec (int vec[ ] ,int n)
{
if (n == 1 )
return 1;
else
if (vec[ n-1] > sum_vec(vec, n-1) )
return is_order_vec (vec, n-1);
else
return 0;
}
Int sum_vec (int vev[ ] , int n)
{
if ( n == 1)
return vec[0];
else
return (sum_vec (vec,n-1) + vec[n-1]);
}
12
‫המערך‬ ‫גודל‬
IXEDN

13. ‫יעילות‬
‫להל"ן‬‫הפונקציות‬‫לטיפול‬‫ביעילות‬)‫לא‬‫לרשימות‬‫מקושרות‬(
‫עמוד‬316–318
‫הפונקציות‬‫הם‬:
Void read_input (int a [ ]);
‫נועד‬‫לקבלת‬‫נתונים‬‫לתוך‬‫מערך‬‫מהקלט‬
Void write_output (int a[ ] );
‫נועד‬‫להדפסת‬‫המערך‬.‫הממויין‬
Void merge_sort (int a[ ] ,int low, int high);
‫מבצע‬‫מיון‬‫מיזוג‬‫על‬‫מערך‬‫)סיבוכיות‬=O (n log n.(
‫משתמש‬‫בפונקציות‬:merge.
‫עמוד‬317.
Void merge (int a, int left,int mid, int right);
‫ממזג‬‫שני‬‫מערכים‬‫ממוינים‬‫לאחד‬‫)נקרא‬‫על‬‫ידי‬merge_sort.(
Void copy_arr (int from[ ] ,int to [ ] , int ind, int length,int c_ind);
‫פונקציה‬‫להעתקת‬‫ערכים‬‫מי‬‫מערך‬‫אחד‬‫לשני‬‫והיא‬‫נקראת‬‫על‬‫ידי‬‫פונקצית‬merge
)318.(
13

14. ‫מצביעים‬
‫הפונקציות‬‫הנ"ל‬‫היא‬‫מתוך‬‫עמוד‬341.
•‫הפונקציה‬‫מקבלת‬pointer‫למחרוזת‬str‫ומחליפה‬‫אות‬‫קטנה‬‫לאות‬‫גדולה‬
Char *string_upprcase (char *s);
14

15. ‫רשימות‬
•‫קריאת‬‫רשימה‬)list‫מהמשתמש‬ (‫עם‬‫מספר‬‫תאים‬‫קבוע‬)max(
‫עמוד‬351)‫בכדי‬‫לקרוא‬‫מספרים‬‫יש‬‫להחליף‬-‫ל‬number‫כמובן‬‫גם‬-‫ב‬struct(
//This function get a pointer address of a list, and read the list from the input
void read ( element *&list, const int max(
}
element *p,*last;
list=new element;
p=list;
cout<<"Enter a letter : “ ;
cin>>p->letter;
for (int cnt=0; cnt<max; cnt++)
}
p->next =new element;
last= p;
p=p->next;
cout<<"Enter a letter : “ ;
cin>> p-> letter;
{
delete (p(;
last -> next = NULL;
}
‫להל"ן‬‫רשימת‬‫פונקציות‬‫מתוך‬‫הספר‬‫עמודים‬)350–354.(
Void read (element *&list);
‫קוראת‬‫רשימה‬.‫מהקלט‬
‫עמוד‬:351
Void write (element *list);
‫מדפיסה‬‫את‬‫הרשימה‬.‫המקושרת‬
‫עמוד‬:351
Int length (element *list);
‫מקבלת‬list‫ומחזירה‬‫את‬‫האורך‬.‫שלה‬
‫עמוד‬:351
15

16. Int position (element *list, int num);
‫מקבלת‬‫רשימה‬‫ומספר‬‫ומחזירה‬‫את‬‫מיקומו‬
‫עמוד‬:352
Void remove (element *&list,int position );
‫מקבלת‬‫רשימה‬‫מיקום‬ +‫ומוחקת‬‫את‬‫המספר‬‫באותו‬.‫מקום‬
‫עמוד‬:352.
Void del (element *&list, int num);
‫מקבלת‬‫רשימה‬+‫מספר‬‫מבצעת‬ ,‫את‬‫החיפוש‬‫אחרי‬‫האיבר‬‫ומוחקת‬ ,‫אותו‬.‫מהרשימה‬
‫עמוד‬:358
Void insert (element *&list,int new_num,int position);
‫מכניסה‬‫את‬‫האיבר‬‫החדש‬-‫ל‬position‫הפונקציה‬ ,‫שקיבלנו‬‫נעזרת‬‫לביצוע‬‫זאת‬‫על‬‫ידי‬‫פונקצית‬
add‫ופונקצית‬ele.
‫עמוד‬:353–354.
Element *ele (element *list,int position);
‫מקבלת‬‫רשימה‬‫ומיקום‬‫ומחזירה‬pointer‫לאותו‬‫מיקום‬)position.(
‫עמוד‬:353.
Void add (int new_num, element *&list,element *this_el);
‫מקבלת‬‫מספר‬‫ומיקום‬ ,‫רשמיה‬ ,‫חדש‬‫כתובת‬ /‫הכנסה‬‫ומכניסה‬ ,‫את‬-‫ה‬new_num‫לאותו‬‫מיקום‬
‫עמוד‬:354.
Element *succ (element*list,element *this_el)
‫מקבלת‬‫איבר‬‫ומחזירה‬ ,‫ברשימה‬‫מצביע‬‫לאיבר‬‫הבא‬‫)מחזירה‬pointer.(
‫עמוד‬:355.
Element *pred (element*list,element *this_el)
‫מקבלת‬‫איבר‬‫ברשימה‬‫ומחזירה‬‫מצביע‬‫לאיבר‬‫הקודם‬‫)מחזירה‬pointer.(
‫עמוד‬:356.
16

17. Element *search (element*list,int num);
‫מקבלת‬‫רשימה‬‫ומספר‬‫ומחזירה‬‫מצביע‬‫לאיבר‬‫בו‬‫מאוחסן‬.‫האיבר‬
‫עמוד‬:356.
Int count ( element *list,int num);
‫מקבלת‬‫רשימה‬‫ומספר‬‫וסופרת‬ ,‫כמה‬‫פעמים‬‫מופיע‬‫ערך‬‫מסוים‬‫)המספר‬num‫ברשימה‬ (list.
‫עמוד‬:387)10.6)
Void delete_list (element *&list);
‫מקבלת‬‫רשימה‬list‫ומוחקת‬‫את‬‫כל‬‫איברה‬‫מהזיכרון‬‫)המצביע‬‫לראשה‬‫יהיה‬‫בסיום‬‫הפונקציה‬‫בעל‬
‫ערך‬NULL,
‫עמוד‬:387)10.7.(
Void append (element *&a , element *&b);
‫מקבלת‬‫שתי‬‫רשימות‬a-‫ו‬b‫ומצרפת‬ ,‫את‬‫הרשימה‬b‫לסופה‬‫של‬‫הרשימה‬a‫)ערכו‬‫של‬‫המצביע‬
‫על‬‫ראש‬b‫צריך‬‫להיות‬‫בסיום‬‫הפונקציה‬NULL.
‫עמוד‬:387)10.8(
‫ממוינת‬ ‫רשימה‬
Void merge_sort (element *&list)
‫מיון‬‫מיזוג‬‫של‬‫רשימה‬‫מקושרת‬‫משתמשת‬ )‫בפונקציה‬second_front_back_split‫המקבלת‬
‫רשימה‬‫ומחזירה‬‫שתי‬‫רשימות‬.‫ממוינות‬
‫כמו‬‫כן‬‫משתמשת‬‫הפונקציה‬-‫ב‬rec_dorted_list
‫עמוד‬:364.
Void seond_front_back_split (element *source,element *&front, element *&back;(
‫מקבלת‬‫רשימה‬‫ומפצלת‬‫אותה‬.‫לשניים‬
‫עמוד‬361.
17

18. Element *rec_sorted_merge (element *a,element *b);
‫ממזגת‬‫בין‬‫שני‬‫רשימות‬.‫ממוינות‬
‫עמוד‬:363.
Void *read_sort ();
‫מקבלת‬‫רשימה‬‫ריקה‬‫ומכניסה‬‫את‬‫המספר‬‫כל‬‫פעם‬‫בצורה‬‫היא‬ .‫ממוינית‬‫קוראת‬‫לפונקציה‬
search‫בכדי‬‫להכניס‬‫כל‬‫איבר‬‫למקומו‬‫הנכון‬‫בכדי‬‫שהרשימה‬‫תישאר‬.‫ממויינת‬
‫עמוד‬:362.
Element *search (element *list , int num);
‫מקבלת‬‫רשימה‬‫ומספר‬‫ומחפשת‬‫את‬‫המקום‬‫המתאים‬‫ומחזירה‬ ,‫להכניסו‬pointer‫לרשימה‬
.‫הממוינת‬
‫עמוד‬:362–363.
Void remove_duplicates (element *&list);
‫מקבלת‬‫רשימה‬‫ממוינת‬‫ומוחקת‬‫את‬‫כל‬‫המופעים‬‫הכפולים‬‫של‬‫יש‬ .‫האיבר‬‫לסרוק‬‫את‬‫הרשימה‬
‫פעם‬‫אחת‬.‫בלבד‬
‫עמוד‬:388)10.9.(
‫מקושרת‬ ‫רשימה‬ ‫על‬ ‫ריצה‬ ‫זמני‬ ‫של‬ ‫סיבוכיות‬
‫עמוד‬:364–365.
‫דו-סטרית‬ ‫רשימה‬
Void add_to_double (int new_num, element *&list,element *this_el);
‫מכניסה‬‫לרשימה‬‫דו‬‫סיטרית‬list‫איבר‬‫חדש‬‫עם‬‫המספר‬new_num‫לאחר‬‫האיבר‬‫המוצבע‬‫על‬
‫ידי‬this_el
‫עמוד‬:366–367
Void remove_from_double (element *&list , int position);
‫מקבלת‬‫רשומה‬‫דו-סיטרית‬list‫ומספר‬і (( position‫ומוחקת‬‫את‬‫האיבר‬‫במיקום‬-‫ה‬і
‫מהרשימה‬list.
‫עמוד‬:388–389.
18

19. Void print_in_reverse (element *list)
‫מקבלת‬‫רשימה‬‫דו-סיטרית‬list‫ומדפיסה‬‫את‬‫אבירה‬‫מהסוף‬.‫להתחלה‬
‫עמוד‬:389.
19

20. ‫בינארים‬ ‫עצים‬
Void init_empty (node *&root);
‫מאתחלת‬‫עץ‬.‫ריק‬
‫עמוד‬:374.
Void init_node (node *&root,int num);
‫מאתחלת‬‫עץ‬‫עם‬‫צומת‬.‫אחד‬
‫עמוד‬374.
Void build (node *&root, node *left, node *right, int num);
‫מקבלת‬‫תת‬‫עץ‬‫תת‬ ,‫שמאלי‬‫עץ‬‫ימני‬‫ומספר‬‫ובונה‬‫מהם‬‫עץ‬‫בינארי‬‫שבשורשו‬.‫המספר‬
‫עמוד‬:374.
Node *left (node *root);
‫מחזירה‬‫מצביע‬‫לתת‬‫עץ‬.‫השמאלי‬
‫עמוד‬:374.
Node *right (node *root);
‫מחזירה‬‫מצביע‬‫לתת‬‫עץ‬.‫ימני‬
‫עמוד‬:374.
Void add_lson (node *root,node *new_tree);
‫מוסיף‬‫את‬‫המצביע‬‫כבן‬‫שמאלי‬‫)עמוד‬ .‫לשורש‬375.(
Void add_rson (node *root,node *new_tree);
‫מוסיף‬‫את‬‫המצביע‬‫כבן‬‫ימני‬‫)עמוד‬ .‫לשורש‬375.(
Void delete_lson (node *root);
‫מוחק‬‫את‬‫הבן‬‫השמאלי‬‫של‬‫הצומת‬
‫עמוד‬:375.
Void delete_rson (node *root);
‫מוחק‬‫את‬‫הבן‬‫ימני‬‫של‬‫הצומת‬
‫עמוד‬:375.
Int retrieve_root ( node *root);
‫מחזיר‬‫את‬‫הערך‬‫המאוחסן‬.‫בשורש‬
‫עמוד‬:375.
Void modify_root (node *root , int new_num);
‫משנה‬‫את‬‫הערך‬‫המאוחסן‬‫בשורש‬
‫עמוד‬:376.
20

21. Int empty_tree (node *root);
‫מחזיר‬‫ערך‬1‫עם‬‫העץ‬‫ו‬ ,‫ריק‬0.‫אחרת‬
‫עמוד‬:376.
Int no_of_nodes (node *root);
‫מונה‬‫את‬‫מספר‬‫הצמתים‬.‫בעץ‬
‫עמוד‬:376.
Int no_of_leaves (node *root);
‫מונה‬‫את‬‫מספר‬‫העלים‬.‫בעץ‬
‫עמוד‬:376.
Int is_leaf (node *T);
‫מקבל‬‫צומת‬‫ומחזיר‬‫תשובה‬‫אם‬‫הוא‬‫עלה‬
‫עמוד‬:377.
Int is_in_tree (node *T,int a);
‫מקבל‬‫מספר‬‫ועץ‬‫)לא‬‫ומחזיר‬ (‫ממויין‬‫תשובה‬‫אם‬‫המספר‬‫נמצא‬.‫בעץ‬
‫עמוד‬:377.
Int descendant (node *T,int x, int y);
‫מקבל‬‫מצביע‬‫לעץ‬T‫ושני‬‫מספרים‬x-‫ו‬y‫ובודקת‬ ,‫האם‬‫קיימם‬‫שני‬‫צמתים‬‫בעץ‬T‫המכילים‬
‫את‬x-‫ו‬y‫כך‬ ,-‫ש‬y‫הוא‬‫צאצא‬‫של‬–x.
‫עמוד‬:390)10.18/(
Int min ( int a ,int b, int c);
‫מקבלת‬‫עץ‬T‫ומחזירה‬‫את‬‫האיבר‬‫הקטן‬‫ביותר‬.‫בעץ‬
:‫עמוד‬390)10.19(
Int max (( int a ,int b,);
‫מקבלת‬‫עץ‬T‫ומחזירה‬‫את‬.‫גובההו‬
‫עמוד‬:391)10.20.(
‫בינארים‬ ‫עצים‬ ‫סריקת‬
‫הדפסת‬‫תכולת‬‫העץ‬‫בשלושה‬‫צורות‬.
21

22. ‫סריקת‬pre order:
void print_pre (node *root);
‫עמוד‬:379.
‫סריקת‬in order:
void print_in (node *root);
‫עמוד‬:380.
‫סריקת‬post order:
void print_post (node *root);
‫עמוד‬:380.
‫ממוינים‬ ‫עצים‬
Node *build_sorted_tree ( ) ;
‫בונה‬‫עץ‬‫בינארי‬‫ממויין‬‫מרשימת‬‫מספרים‬‫הערך‬ ,‫בקלט‬‫הראשון‬‫יאוחסן‬‫בשורש‬.‫העץ‬
‫היא‬‫משתמשת‬‫בפונקציה‬init_empty ( t‫לאיתחול‬ (‫עץ‬‫ריק‬‫ולפונקציה‬add_to_sorted
‫שתכניס‬‫את‬‫המספר‬‫למקומו‬‫בעץ‬.‫הממויין‬
‫עמוד‬:382.
Void add_to_sorted ( node *&root, int num);
‫תכניס‬‫את‬‫המספר‬‫למקומו‬‫בעץ‬‫הממויין‬.
‫עמוד‬:382.
Node *search_sorted (node *root, int x);
‫חיפוש‬‫ערך‬‫בעץ‬.‫ממויין‬
‫עמוד‬:381.
22