Embed Size (px)
Citation preview
רשימת פונקציות שימושיות למבחן
2................................................................מחרוזות
4.................................................פונקציות גלובליות
5................................................................מערכים
9..............................................................רקורסיות
13................................................................יעילות
14.............................................................מצביעים
15..............................................................רשימות
17....................................................רשימה ממוינת
18..........סיבוכיות של זמני ריצה על רשימה מקושרת
18................................................רשימה דו-סטרית
20.....................................................עצים בינארים
21..........................................סריקת עצים בינארים
22.....................................................עצים ממוינים
1
מחרוזות . הפונקציהstrcpyבמחרוזת נעשית בעזרת הפונקציה פעולת השמה : העתקת מחרוזת
strcpyעושה העתק של הארגומנט השני שלה ומציבה אותו במשתנה שהוא הארגומנט הראשון.
>include <string.h#יש צורך להגדיר בראש התוכנית
strcpy (s, “what is your shoe size ?“) ;
נראית כך:פעולת הקלט
Cin >> s;
פעולות על מחרוזות
ישנן מספר פעולות )פונקציות( שונות שאפשר לבצע על מחרוזות בשפתc++.
תוצאה פונקציה
. )תו ראשון נמצאs במחרוזת іמחזירה את התו במיקום
(0במיקום
S [ і ]
.sמחזירה את אורכה של המחרוזת Strlen (s)
זהות, תו אחרי תו. אםt ו- s אם המחרוזות 0מחזירה
-.1 ואחרת יוחזר ,1 יוחזר t גדולה מהמחרוזת sהמחרוזת
Strcmp (s,t)
Strcpy (s,t) ומחזירה ערך זה.s לתוך המחרוזת tמעתיקה את המחרוזת
לתוךt התווים הראשונים של המחרוזת nמעתיקה את
ומחזירה ערך זה.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
פונקצית הפיכת אות קטנה לגדולה ולהפך
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
}
3
פונקציות גלובליות) החלפת סדר שני משתניםswap(
void swap )int &a, int &b({
int temp;temp = b;
a = b;b = temp;
}
מתוך ספרית חזקה( #include <math.h<).Y בחזקת Xמבצע
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 integerfloat num = atof )str( ; //ascii to float
4
מערכיםאיתחול מערך לאפס
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 “ ;
}
}
5
-קריאת נתונים מהUser(מטריצה) לתוך מערך דו ממיידי
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
במערך דו ממיידי (מטריצה)ספציפיתספירת שכנים לקורדינאטה
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;
{
7
מיפונקציה זו סופרת כמה מספרים עם אותו ערך יש במערך (טווח מספרים 0 – 9.(
את כמות המספרים מכל ערך .(Bלמערך חדש )הפונקציה מכניסה
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
רקורסיותחזקה בעזרת שימוש ברקורסיה
float apowerb )float a,int b( }
if )b == 0( //stop conditionreturn 1;
return )a * apowerb )a,b-1((; //recursive call{
(.11 = > 435)לדג: המספר אבריחיבור כל
int sum_f )int n)}
if )n<10)return )n);
elsereturn )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
) מחזירה את חיבור כל התאיםחיבור כל התאים במערך(
int sum_rec )int a [ ],int n)}
if )n==1) //stop conditionreturn a [0[;
elsereturn ) 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 conditoinreturn )a [ n-1 ]; // return a [ 0 ]
elseif )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 conditoinreturn )a [ n-1 ](; // a [ 0]
elseif ))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);{
10
וסכימת ערכיהם1 ממנו עד ל- הקטניםפירוק מספר למספרים 10 = 4+3+2+1 הפונקציה תחזיר: 4)לדג: קלט =
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
}
= 13 8 5 3 2 1 1הפונקציה מחשבת את סדרת פיבונאצ"י לדג : קלט 21...
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 - recursivelycout<<ch;
}
11
258 ( עמוד 532 , ידפיס 235) לדג: קלט = היפוך מספר
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];
elsereturn )sum_vec )vec,n-1( + vec[n-1](;
}
12
גודל IXEDNהמערך
יעילות
)לא לרשימות מקושרותלהל"ן הפונקציות לטיפול ביעילות (
318 – 316עמוד הפונקציות הם :
Void read_input )int a [ ](;נועד לקבלת נתונים לתוך מערך מהקלט
Void write_output )int a[ ] (;נועד להדפסת המערך הממויין.
Void merge_sort )int a[ ] ,int low, int high(;.)n log n( O)סיבוכיות = על מערך מיון מיזוגמבצע
.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
מצביעים
.341הפונקציות הנ"ל היא מתוך עמוד
הפונקציה מקבלתpointer למחרוזת str ומחליפה אות קטנה לאות גדולה
Char *string_upprcase )char *s(;
14
רשימות) קריאת רשימהlist) מהמשתמש עם מספר תאים קבוע (max(
(struct כמובן גם ב- numberבכדי לקרוא מספרים יש להחליף ל- )351עמוד //This function get a pointer address of a list, and read the list from the inputvoid 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;
}
(.354 – 350להל"ן רשימת פונקציות מתוך הספר עמודים ) Void read )element *&list(;
קוראת רשימה מהקלט.351עמוד :
Void write )element *list(;מדפיסה את הרשימה המקושרת.
351עמוד :
15
Int length )element *list(; ומחזירה את האורך שלה.listמקבלת 351עמוד :
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מכניסה את האיבר החדש ל-
.ele ופונקצית addפונקצית .354– 353עמוד :
Element *ele )element *list,int position(;(.position לאותו מיקום )pointerמקבלת רשימה ומיקום ומחזירה
.353עמוד :
Void add )int new_num, element *&list,element *this_el(; לאותוnew_numמקבלת מספר חדש, רשמיה, ומיקום / כתובת הכנסה , ומכניסה את ה-
מיקום.354עמוד :
Element *succ )element*list,element *this_el((.pointerמקבלת איבר ברשימה, ומחזירה מצביע לאיבר הבא )מחזירה
.355עמוד :
16
Element *pred )element*list,element *this_el((.pointerמקבלת איבר ברשימה ומחזירה מצביע לאיבר הקודם )מחזירה
.356עמוד :
Element *search )element*list,int num(;מקבלת רשימה ומספר ומחזירה מצביע לאיבר בו מאוחסן האיבר.
.356עמוד :
Int count ) element *list,int num(; ( ברשימהnumמקבלת רשימה ומספר , וסופרת כמה פעמים מופיע ערך מסוים )המספר
list.)10.6) 387עמוד :
Void delete_list )element *&list(; ומוחקת את כל איברה מהזיכרון )המצביע לראשה יהיה בסיוםlistמקבלת רשימה
, NULLהפונקציה בעל ערך (.10.7 )387עמוד :
Void append )element *&a , element *&b(; )ערכו שלa לסופה של הרשימה b , ומצרפת את הרשימה b ו- aמקבלת שתי רשימות
.NULL צריך להיות בסיום הפונקציה bהמצביע על ראש (10.8 )387עמוד :
רשימה ממוינת
Void merge_sort )element *&list( המקבלתsecond_front_back_split ) משתמשת בפונקציה של רשימה מקושרת מיון מיזוג
רשימה ומחזירה שתי רשימות ממוינות. rec_dorted_listכמו כן משתמשת הפונקציה ב-
.364עמוד :
17
Void seond_front_back_split )element *source,element *&front, element *&back(;מקבלת רשימה ומפצלת אותה לשניים.
.361עמוד
Element *rec_sorted_merge )element *a,element *b(;ממזגת בין שני רשימות ממוינות.
.363עמוד :
Void *read_sort )(; מקבלת רשימה ריקה ומכניסה את המספר כל פעם בצורה ממוינית. היא קוראת לפונקציה
search.בכדי להכניס כל איבר למקומו הנכון בכדי שהרשימה תישאר ממויינת .362עמוד :
Element *search )element *list , int num(; לרשימהpointerמקבלת רשימה ומספר ומחפשת את המקום המתאים להכניסו, ומחזירה
הממוינת..363 – 362עמוד :
Void remove_duplicates )element *&list(; מקבלת רשימה ממוינת ומוחקת את כל המופעים הכפולים של האיבר. יש לסרוק את
הרשימה פעם אחת בלבד.(.10.9 )388עמוד :
סיבוכיות של זמני ריצה על רשימה מקושרת.365 – 364עמוד :
רשימה דו-סטרית
Void add_to_double )int new_num, element *&list,element *this_el(;
18
לאחר האיברnew_num איבר חדש עם המספר listמכניסה לרשימה דו סיטרית this_elעל ידי המוצבע
367 – 366עמוד :
Void remove_from_double )element *&list , int position); і ומוחקת את האיבר במיקום ה- і )) position ומספר listמקבלת רשומה דו-סיטרית
.listמהרשימה .389 – 388עמוד :
Void print_in_reverse )element *list(
ומדפיסה את אבירה מהסוף להתחלה.listמקבלת רשימה דו-סיטרית .389עמוד :
19
עצים בינארים
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(;מחזיר את הערך המאוחסן בשורש.
20
.375עמוד :
Void modify_root )node *root , int new_num(;משנה את הערך המאוחסן בשורש
.376עמוד :
Int empty_tree )node *root(; אחרת.0 עם העץ ריק, ו 1מחזיר ערך
.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 , ובודקת האם קיימם שני צמתים בעץ y ו- x ושני מספרים Tמקבל מצביע לעץ
.x –של הוא צאצא y , כך ש- y ו- xהמכילים את /(10.18 )390עמוד :
Int min ) int a ,int b, int c(; ומחזירה את האיבר הקטן ביותר בעץ.Tמקבלת עץ
(10.19 )390עמוד:
Int max )) int a ,int b,(; ומחזירה את גובההו.Tמקבלת עץ
(.10.20 )391עמוד :
21
סריקת עצים בינארים
.הדפסת תכולת העץ בשלושה צורות
: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 ) ( ;בונה עץ בינארי ממויין מרשימת מספרים בקלט, הערך הראשון יאוחסן בשורש העץ.
add_to_sorted לאיתחול עץ ריק ולפונקציה ) init_empty ) tהיא משתמשת בפונקציה שתכניס את המספר למקומו בעץ הממויין.
.382עמוד :
Void add_to_sorted ) node *&root, int num(;תכניס את המספר למקומו בעץ הממויין .
.382עמוד :
22
Node *search_sorted )node *root, int x(;חיפוש ערך בעץ ממויין.
.381עמוד :
23
