תכנות – שיעור 7. חזרה -מערכים נגדיר בעזרתו קבוצת משתנים כאשר יהיה לנו מספר רב של משתנים זהים נגדיר בעזרתו קבוצת משתנים כאשר יהיה לנו מספר רב של משתנים.

Slides:



Advertisements
Similar presentations
מבוא למדעי המחשב לתעשייה וניהול
Advertisements

מבוא למדעי המחשב לתעשייה וניהול דוגמאות ותרגול נוסף במערך חד ממדי הרצאה 12.
Pointers הרצאה קריטית. השאלות הפתוחות מה זה ה- & שמופיע ב scanf מדוע כשמעבירים מחרוזת ל scanf אין צורך ב & האם ניתן להכריז על מערך שגדלו אינו ידוע בתחילת.
רקורסיות נושאי השיעור פתרון משוואות רקורסיביות שיטת ההצבה
תכנות תרגול 7 שבוע : מערכים עד היום התוכניות שלנו לא ידעו לשמור כמות גדולה של מידע ללא הגדרת כמות גדולה של משתנים. עד היום התוכניות שלנו לא.
תכנות תרגול 9 שבוע : הקשר בין מערכים למצביעים נרצה לעמוד על הקשר בין מערך למצביע מאחר ומערכים הם הכללה של משתנים הרי שברור שלמערך ולכל אחד מאיבריו.
תכנות תרגול 6 שבוע : חישוב e זוהי הנוסחא לחישוב e נראה כיצד לתרגם אותה לפונקציה n n.
תרגול 5 רקורסיות. רקורסיה קריאה של פונקציה לעצמה –באופן ישיר או באופן עקיף היתרון : תכנות של דברים מסובכים נעשה ברור ונוח יותר, מכיוון שזו למעשה צורת.
מבוא כללי למדעי המחשב שיעור 4 מרצה: שי גוטנר. חזרה - משתנים מסוג char משתנים אלו מיצגים תווים. משתנים אלו מיצגים תווים. לכל תו יש קוד מספרי שמייצג אותו.
מבוא לשפת C חידות ונקודות חשובות נכתב על-ידי יורי פקלני. © כל הזכויות שמורות לטכניון – מכון טכנולוגי לישראל.
מבוא למדעי המחשב תרגול 8 - מחרוזות שעת קבלה : יום שני 11:00-12:00 דוא " ל :
מבוא כללי למדעי המחשב תרגול. הבית האדום כתובת : רחוב קוקוריקו 2 הבית הירוק כתובת : רחוב קוקוריקו 4 הבית הצהוב כתובת : רחוב קוקוריקו 1 הבית הורוד כתובת.
1 Formal Specifications for Complex Systems (236368) Tutorial #5 Refinement in Z: data refinement; operations refinement; their combinations.
תכנות תרגול 9 שבוע : מערכים int a; a=5; int a[10]; a[2] = 5; 5 a a[0] a[1] a[2] a[9]  5 משתנה בודד מערך גישה למשתנה השלישי במערך.
בהסתברות לפחות למצא בעיה במודל PAC עבור בהסתברות ε הפונקציה f טועה מודל ONLINE 1. אחרי כל טעות הפונקציה משתפרת 2. מספר הטעיות קטן.
מבוא למדעי המחשב © אריק פרידמן 1 מצביעים כמערכים דוגמה.
שיעור שישי: מערכים ופונקציות
תכנות תרגול 6 שבוע : תרגיל שורש של מספר מחושב לפי הסדרה הבאה : root 0 = 1 root n = root n-1 + a / root n-1 2 כאשר האיבר ה n של הסדרה הוא קירוב.
מבוא למדעי המחשב מחרוזות, מצביעים וכתובות
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
1 Formal Specifications for Complex Systems (236368) Tutorial #1 Course site : T.A. :Emilia Katz.
תכנות תרגול 6 שבוע : הגדרת פונקציות return-value-type function-name(parameter1, parameter2, …) הגדרת סוג הערכים שהפונקציה מחזירה שם הפונקציהרשימת.
מבוא כללי למדעי המחשב שיעור 5
תכנות תרגול 14 שבוע:
תכנות תרגול 10 שבוע : הקשר בין מערכים למצביעים נרצה לעמוד על הקשר בין מערך למצביע מאחר ומערכים הם הכללה של משתנים הרי שברור שלמערך ולכל אחד מאיבריו.
תכנות תרגול 14 שבוע : רשימות מקושרות ישנו מבנה נתונים אשר מאפשר ישנו מבנה נתונים אשר מאפשר לנו לבצע את הוספת האיברים בצורה נוחה יותר. מבנה זה.
קורס תכנות – סימסטר ב ' תשס " ח שיעור שישי: מערכים
מבוא למדעי המחשב תרגול 6 - מערכים שעת קבלה : יום שני 11:00-12:00 דוא " ל :
תכנות תרגול 7 שבוע : מערכים עד היום התוכניות שלנו לא ידעו לשמור כמות גדולה של מידע ללא הגדרת כמות גדולה של משתנים. עד היום התוכניות שלנו לא ידעו.
תכנות תרגול 5 שבוע : הגדרת פונקציות return-value-type function-name(parameter1, parameter2, …) הגדרת סוג הערכים שהפונקציה מחזירה שם הפונקציהרשימת.
מערכים עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר עד היום כדי לייצג 20 סטודנטים נאלצנו להגדיר int grade1, grade2, …, grade20; int grade1, grade2, …, grade20;
מודל הלמידה מדוגמאות Learning from Examples קלט: אוסף של דוגמאות פלט: קונסיסטנטי עם פונקציה f ב- C ז"א קונסיסטנטי עם S ז"א מודל הלמידה מדוגמאות Learning.
עקרון ההכלה וההדחה.
יחס סדר חלקי.
תכנות מונחה עצמים Object Oriented Programming (OOP) אתגר מחזור ב' Templates תבניות.
מבוא למדעי המחשב תרגול 3 שעת קבלה : יום שני 11:00-12:00 דוא " ל :
Markov Decision Processes (MDP) תומר באום Based on ch. 14 in “Probabilistic Robotics” By Thrun et al. ב"הב"ה.
מודל הלמידה מדוגמאות Learning from Examples קלט: אוסף של דוגמאות פלט: קונסיסטנטי עם פונקציה f ב- C ז"א קונסיסטנטי עם S ז"א.
1 מבוא למדעי המחשב סיבוכיות. 2 סיבוכיות - מוטיבציה סידרת פיבונאצ'י: long fibonacci (int n) { if (n == 1 || n == 2) return 1; else return (fibonacci(n-1)
מבוא למדעי המחשב תרגול 12 – הקצאת זיכרון דינאמית שעת קבלה : יום שני 11:00-12:00 דוא " ל :
11 Introduction to Programming in C - Fall 2010 – Erez Sharvit, Amir Menczel 1 Introduction to Programming in C תרגול
תכנות תרגול 8 שבוע : מערכים עד היום התוכניות שלנו לא ידעו לשמור כמות גדולה של מידע ללא הגדרת כמות גדולה של משתנים. עד היום התוכניות שלנו לא.
- אמיר רובינשטיין מיונים - Sorting משפט : חסם תחתון על מיון ( המבוסס על השוואות בלבד ) של n מפתחות הינו Ω(nlogn) במקרה הגרוע ובממוצע. ניתן לפעמים.
Structure. מה לומדים היום ? דרך לבנות מבנה נתונים בסיסי – Structure מייצר " טיפוס " חדש מתאים כאשר רוצים לאגד כמה משתנים יחד דוגמאות : עובד : שם, טלפון,
מבוא למדעי המחשב הרצאה 9: תכנות רקורסיבי 2 1. חישוב עצרת: רקורסיית זנב public static int fact (int n){ return factacc(n,1); } public static int factacc.
קורס תכנות שיעור עשירי: מיונים, חיפושים, וקצת סיבוכיות חישוב.
מבוא למדעי המחשב לתעשייה וניהול הרצאה 12. ספריות.
מבנים קרן כליף. ביחידה זו נלמד :  מהו מבנה (struct)  איתחול מבנה  השמת מבנים  השוואת מבנים  העברת מבנה לפונקציה  מבנה בתוך מבנה  מערך של מבנים.
1 מבוא למדעי המחשב הרצאה 5: פונקציות. 2 מבוא לפונקציות חלוקה של אלגוריתם לתת משימות: משימה - פונקציה: דוגמאות מציאת המקסימלי מבין שני איברים האינדקס של.
1 Formal Specifications for Complex Systems (236368) Tutorial #1 Course site:
עקרונות תכנות מונחה עצמים תרגול 11: OOP in C++. Outline  Where do the objects live ?  Inheritance  Slicing  Overriding vs Shadowing.
מספרים אקראיים ניתן לייצר מספרים אקראיים ע"י הפונקציה int rand(void);
Programming Arrays.
Formal Specifications for Complex Systems (236368) Tutorial #1
מבוא למדעי המחשב סיבוכיות.
הקצאות דינאמיות בשילוב מבנים
מערכים ומצביעים הקצאה דינאמית של מערכים דו-מימדיים
מיונים וחיפושים קרן כליף.
מבוא למדעי המחשב – סמסטר א' תשע"ב
שיעור חמישי: מערכים ומחרוזות
מצביעים קרן כליף.
מערכים קרן כליף.
תירגול 14: מבני נתונים דינאמיים
ממשקים - interfaces איך לאפשר "הורשה מרובה".
מצביעים קרן כליף.
מבוא כללי למדעי המחשב תרגול 6
מערכים של מצביעים הקצאה דינאמית
מבוא למדעי המחשב מצביעים.
תירגול 8:מצביעים והקצאה דינאמית
שיעור עשירי: מיונים, חיפושים, וקצת סיבוכיות חישוב
Presentation transcript:

תכנות – שיעור 7

חזרה -מערכים נגדיר בעזרתו קבוצת משתנים כאשר יהיה לנו מספר רב של משתנים זהים נגדיר בעזרתו קבוצת משתנים כאשר יהיה לנו מספר רב של משתנים זהים Type name[SIZE]; Type name[SIZE]; Char a[10]; int b[50]; Char a[10]; int b[50]; הגודל חייב להיות קבוע. הגודל חייב להיות קבוע. פנייה לאיברי המערך מתבצעת ע"י a[k] כאשר K בין 0 ל-SIZE-1 פנייה לאיברי המערך מתבצעת ע"י a[k] כאשר K בין 0 ל-SIZE-1 אתחול ע"י לולאה או רשימת אתחול אתחול ע"י לולאה או רשימת אתחול

החלפה בין משתנים נסתכל על התוכנית הבאה: נסתכל על התוכנית הבאה: int main() { int a,b,x,y,temp; int a,b,x,y,temp; temp = x; x = y; y = temp;  temp = a; a = b; b = temp; } החלפת הערכים

החלפה בין משתנים כפי שלמדנו במצב כזה הינו רוצים שתהיה פונקציה שתבצע את החלפה הזו בין המשתנים. כפי שלמדנו במצב כזה הינו רוצים שתהיה פונקציה שתבצע את החלפה הזו בין המשתנים.

החלפה בין משתנים נכתוב פונקציה כזו בשם swap נכתוב פונקציה כזו בשם swap void swap(int p, int q) { int tmp = p; p = q; q = tmp; }

החלפה בין משתנים int main() { int a=10,b=2,x=3,y=5,temp; int a=10,b=2,x=3,y=5,temp;swap(x,y);swap(a,b);}

החלפה בין משתנים  נעקוב אחרי הקריאה לפונקציה swap(x,y); 3p 6q void swap (int q,int p) { int temp = p; p = q; q = temp; }6p3q

מצביעים ראינו שכל משתנה שהגדרנו בתוכנית שלנו מוצקה עבורו תא באזור כלשהו בזיכרון. ראינו שכל משתנה שהגדרנו בתוכנית שלנו מוצקה עבורו תא באזור כלשהו בזיכרון. int main() { Int x,y; } לכל תא כזה יש כתובת בזיכרון של המחשב. לכל תא כזה יש כתובת בזיכרון של המחשב. כדי להגיע לכתובת של משתנה משתמשים באופרטור &. כדי להגיע לכתובת של משתנה משתמשים באופרטור &. x y

מצביעים מה יחזירו &x ו &y. מה יחזירו &x ו &y. x 5000 y 5004

מצביעים ניתן להגדיר משתנים שסוגם הוא מצביע. ניתן להגדיר משתנים שסוגם הוא מצביע. משתנים כאלה מחזיקים בתוכם את הכתובות. משתנים כאלה מחזיקים בתוכם את הכתובות. int main() { int x,y; int* p; p = &x; } 5000 x 5000 y 5004 p 9008

מצביעים כדי לסמן שמצביע לא מצביע לשום מקום נהוג להשים לו NULL כדי לסמן שמצביע לא מצביע לשום מקום נהוג להשים לו NULL p = NULL; p = NULL; אפשר לחשוב על משתנה מסוג מצביע כאל חץ: אפשר לחשוב על משתנה מסוג מצביע כאל חץ: x y p

מצביעים int main() { int x=7,*p = &x; printf(“Value %d Pointer %p\n”, x, p); } כדי להדפיס את ערך שאילו מצביע p. כדי להדפיס את ערך שאילו מצביע p. printf(“Value %d\n”,*p) פורמט הדפסה של משתנה מסוג מצביע

מצביעים יש לשים לב שאין הצבעה לביטויים ולקבועים יש לשים לב שאין הצבעה לביטויים ולקבועים&3&(k+99)

Call by value and call by reference בכל הפונקציות של c מנגנון העברת של הפונקציות הוא לפי ערך. בכל הפונקציות של c מנגנון העברת של הפונקציות הוא לפי ערך. נחזור לפונקצית ה swap. נחזור לפונקצית ה swap. הבעיה הייתה שהחלפת הערכים התבצעה בין הפרמטרים של הפונקציה ולא בין המשתנים עצמם. הבעיה הייתה שהחלפת הערכים התבצעה בין הפרמטרים של הפונקציה ולא בין המשתנים עצמם.

Call by reference int main() { int a=10,b=2,x=3,y=5; int a=10,b=2,x=3,y=5;swap(&x,&y);swap(&a,&b);} void swap (int* q,int* p) { int temp = *p; *p = *q; *q = *temp; }

Call by reference  בכדי לממש call by reference יש לבצע את הדברים הבאים: 1 להגדיר את הפרמטרים של הפונקציה כמצביעים void swap(int *p, int *q) 2 להשתמש בגוף הפונקציה בערכים שליהם שמצביעים מצביעים *p = *q; *p = *q; 3 בקריאה לפונקציה להעביר כתובות כארגומנטים swap(&x, &y);

Call by value and call by reference בכל הפונקציות של c מנגנון העברת של הפונקציות הוא לפי ערך. בכל הפונקציות של c מנגנון העברת של הפונקציות הוא לפי ערך. נחזור לפונקצית ה swap. נחזור לפונקצית ה swap. הבעיה הייתה שהחלפת הערכים התבצעה בין הפרמטרים של הפונקציה ולא בין המשתנים עצמם. הבעיה הייתה שהחלפת הערכים התבצעה בין הפרמטרים של הפונקציה ולא בין המשתנים עצמם.

Call by reference int main() { int a=10,b=2,x=3,y=5; int a=10,b=2,x=3,y=5;swap(&x,&y);swap(&a,&b);} void swap (int* q,int* p) { int temp = *p; *p = *q; *q = temp; }

Call by reference בכדי לממש call by reference יש לבצע את הדברים הבאים: בכדי לממש call by reference יש לבצע את הדברים הבאים: 1 להגדיר את הפרמטרים של הפונקציה כמצביעים void swap(int *p, int *q) 2 להשתמש בגוף הפונקציה בערכים שלהם שמצביעים מצביעים *p = *q; *p = *q; 3 בקריאה לפונקציה להעביר כתובות כארגומנטים swap(&x, &y);

הקשר בין מערכים ומצביעים כאשר אנחנו מגדירים מערך בגדול 20 של שלמים אזי יש לנו 20 משתנים מסוג int בזיכרון. מה הכתובת של משתנים אלו ? כאשר אנחנו מגדירים מערך בגדול 20 של שלמים אזי יש לנו 20 משתנים מסוג int בזיכרון. מה הכתובת של משתנים אלו ? int a[20]; int a[20]; a[19] a[0] כמו לכל משתנה גם לאיברי המערך ישנה כתובת. כיצד נגיע לכתובת זו?

הקשר בין מערכים ומצביעים ניתן להגיע לכתובות בדרך הרגילה ניתן להגיע לכתובות בדרך הרגילה int *p; int *p; p = &a[0]; p = &a[0]; נזכר שהמערך ממוקם בצורה רציפה בזיכרון לכן כתובות איברי המערך הן רציפות למשל: נזכר שהמערך ממוקם בצורה רציפה בזיכרון לכן כתובות איברי המערך הן רציפות למשל:

משמעות שם המערך פניה לשם המערך נותנת לנו את כתובת המערך שהיא למעשה מצביע לאיבר הראשון במערך. פניה לשם המערך נותנת לנו את כתובת המערך שהיא למעשה מצביע לאיבר הראשון במערך. בשם המערך ניתן להשתמש כדי לקבל את הכתובת הזו לא ניתן לשנות אותו (כלומר הוא מצביע קבוע) בשם המערך ניתן להשתמש כדי לקבל את הכתובת הזו לא ניתן לשנות אותו (כלומר הוא מצביע קבוע) int *p; int *p; p = a; p = a; p מצביע לראש המערך. (את p כמובן שניתן לשנות) p מצביע לראש המערך. (את p כמובן שניתן לשנות)

חשבון של מצביעים ניתן להשתמש בפעולות חיבור וחיסור על כתובות. זה שימושי בעיקר בשילוב עם מערכים. ניתן להשתמש בפעולות חיבור וחיסור על כתובות. זה שימושי בעיקר בשילוב עם מערכים. *(a+i) שקול a[i]; *(a+i) שקול a[i]; *(p+i) שקול p[i]; *(p+i) שקול p[i];

חשבון של מצביעים מספר דרכים לכתוב לולאה שרצה על מערך: מספר דרכים לכתוב לולאה שרצה על מערך: for (i=0; i<N; i++) sum + = a[i]; for (p = a, i=0; i<N; i++) sum + = *(p+i); for (p=a; p<=&a[N-1]; p++) sum + = *p;

חשבון של מצביעים כיצד ה++ יודע לקדם את המצביע לאיבר הבא ? כיצד ה++ יודע לקדם את המצביע לאיבר הבא ? הבעיה: המערך יכול להיות של תווים של שלמים או של כל דבר והמרחק בין התאים הוא שונה. הבעיה: המערך יכול להיות של תווים של שלמים או של כל דבר והמרחק בין התאים הוא שונה. מה המרחק עבור int ? מה המרחק עבור int ? מה המרחק עבור char ? מה המרחק עבור char ?

חשבון של מצביעים כיוון שהגדרנו את סוג האיבר שאילו המצביע מצביע ולכן יש לנו את הגודל שצריך לקפוץ בכל פעם. זו החשיבות והסיבה שמגדירים את סוג האיבר שאילו מצביעים. כיוון שהגדרנו את סוג האיבר שאילו המצביע מצביע ולכן יש לנו את הגודל שצריך לקפוץ בכל פעם. זו החשיבות והסיבה שמגדירים את סוג האיבר שאילו מצביעים. המקום השני שבו אנו משתמשים בסוג שאליו מצביעים הוא בשימוש ב-* המקום השני שבו אנו משתמשים בסוג שאליו מצביעים הוא בשימוש ב-*

העברת מערך לפונקציה כיצד נכתוב פונקציה שמקבל כערך מערך ומבצעת חישוב על איבריו? כיצד נכתוב פונקציה שמקבל כערך מערך ומבצעת חישוב על איבריו? נניח שנרצה לכתוב פונקציה שמקבלת מערך של מספרים ומחזירה את סכום איברי המערך. נניח שנרצה לכתוב פונקציה שמקבלת מערך של מספרים ומחזירה את סכום איברי המערך. העברת מערך לפונקציה מתבצעת למעשה ע"י העברת מצביע לראש המערך. העברת מערך לפונקציה מתבצעת למעשה ע"י העברת מצביע לראש המערך. int sum(int a[], int size); int sum(int a[], int size); prototype

העברת מערך לפונקציה a[ ] זהו פשוט מצביע למערך של int. a[ ] זהו פשוט מצביע למערך של int. הפרמטר השני הוא גודל המערך. הפרמטר השני הוא גודל המערך. מאחר ואנחנו עובדים עם מצביעים אין לנו מידע מהו גודל המערך ולכן נעביר את המידע הזה כפרמטר לפונקציה. מאחר ואנחנו עובדים עם מצביעים אין לנו מידע מהו גודל המערך ולכן נעביר את המידע הזה כפרמטר לפונקציה.

העברת מערך לפונקציה ההגדרות הבאות שקולות: ההגדרות הבאות שקולות: int f(float arr[]); int f(float arr[]); int f(float arr[5]); int f(float arr[5]); int f(float arr[100]); int f(float arr[100]); int f(float *arr); int f(float *arr);

העברת מערך לפונקציה int sum(int a[], int size) { int i, res = 0; for(i = 0; i < size; i++) res += a[i]; res += a[i]; return res; }

העברת מערך לפונקציה Int sum(int *p, int size) { int i, res = 0; for(i = 0; i < size; i++) res += p[i]; res += p[i]; return res; }

העברת מערך לפונקציה כאשר נרצה למנוע א אפשרות של שינוי איברי המערך בפונקציה נעביר את המערך כconst- כאשר נרצה למנוע א אפשרות של שינוי איברי המערך בפונקציה נעביר את המערך כconst- int sum(const int a[], int size) { int i, res = 0; for(i = 0; i < size; i++) res += a[i]; res += a[i]; return res; }

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

מיון מערכים מציאת אלגוריתם למיון מציאת אלגוריתם למיון פסאודו קוד פסאודו קוד קוד תיקני ב-C קוד תיקני ב-C

מיון מערכים-אלגוריתם האלגוריתם: האלגוריתם: נגדיר אלגוריתם בעל N שלבים כאשר בסוף השלב ה-K, K האיברים הקטנים ביותר יהיו ממוינים. נגדיר אלגוריתם בעל N שלבים כאשר בסוף השלב ה-K, K האיברים הקטנים ביותר יהיו ממוינים. אלגוריתם משני לשלב ה-K אלגוריתם משני לשלב ה-K נמצא את האיבר המינימל מבין N-K+1 האיברים הגדולים(אשר נמצאים במערך בין N-(K ונחליף בינו לבין האיבר K. נמצא את האיבר המינימל מבין N-K+1 האיברים הגדולים(אשר נמצאים במערך בין N-(K ונחליף בינו לבין האיבר K.

מיון מערכים – פסאודו קוד SORT(A) N = size(A) For k =1 to N min = A[k] min_index = k for j = k + 1 to N if (A[j] < min) min_index = j; min = A[j] min_index = j; min = A[j]endSwap(A,k,min_index);end מציאת האיבר המינימלי מ- k עד n min הערך המינימלי min_index האיבר בעל הערך המינמלי

מיון מערכים –קוד Void swap(int *, int *); Void Sort(int A[], int size) { int min, min_index, k, j; for(k = 0; k < size; k++) {min = A[k]; min_index = k; for(j = k + 1; j< size; j++) {…..} swap(A + k, A + min_index); }}

מיון מערכים –קוד for(j= k + 1; j < size; j++) { if (a[j] < min) { min = a[j]; min_index = j; }}

מיון מערכים מציאת איבר יכולה להיעשות מהר log 2 (N)) כאשר במערך לא ממוין ייקח למצוא איבר N צעדים מציאת איבר יכולה להיעשות מהר log 2 (N)) כאשר במערך לא ממוין ייקח למצוא איבר N צעדים

מציאת איבר במערך ממוין – חיפוש בינארי int BinarySearch(const int arr[], int size, int key) { int low, middle, high; low = 0; high = size - 1; while(low <= high) { middle = (low + high) / 2; if (key == arr[middle]) return middle; if (key > arr[middle]) low = middle + 1; else high = middle -1; } return -1; }

איך יראה פיתרון רקורסיבי לבעיה? איך יראה פיתרון רקורסיבי לבעיה?

מיון מערכים-יעילות הזמן שייקח לתוכנית זאת למיין הוא סדר גודל של n^2 הזמן שייקח לתוכנית זאת למיין הוא סדר גודל של n^2 האם ניתן לשפר זאת? האם ניתן לשפר זאת?

מיון בזמן ליניארי- אם הערכים בטווח קטן בכדי לבצע מיון זה נצטרך באופן כללי שני מערכי עזר אחד למערך הממוין ואחד למערך עזר (כאשר איברי המערך הם מספרים ניתן להסתפק רק במערך העזר) בכדי לבצע מיון זה נצטרך באופן כללי שני מערכי עזר אחד למערך הממוין ואחד למערך עזר (כאשר איברי המערך הם מספרים ניתן להסתפק רק במערך העזר) הרעיון יהיה לספור בעזרת מערך העזר כמה איברים קטנים מאיבר עם ערך k וכך ניתן יהי להכניסו למקום ללא בעיות הרעיון יהיה לספור בעזרת מערך העזר כמה איברים קטנים מאיבר עם ערך k וכך ניתן יהי להכניסו למקום ללא בעיות

מיון בזמן ליניארי- אם הערכים בטווח קטן Counting_Sort(A,B) Set C[N] to 0 For i=1 to SIZE C[A[i]] = C[A[i]] + 1; For i=2 to N C[i] = C[i-1] + C[i] For j=1 to SIZE B[C[A[j]]] = A[j] C[A[j]] = C[A[j]] - 1 כמה איברים מכל סוג כמה איברים קטנים מאיבר מסוג k הכנסה למערך הפלט

void CountSort(const int a[], int b[], int size) { int i; int c[RANGE] = {0}; for(i = 0; i < size; i++) c[a[i]]++; for(i=1; i < RANGE; i++) c[i] += c[i-1]; for(i=0; i < size; i++) { b[c[a[i]]] = a[i]; c[a[i]]--;}return;}

#include #include #define SIZE 10 #define RANGE 6 void CountSort(const int a[], int b[], int size); void Print(const int arr[], int size); int main() { int a[SIZE] = {5,3,2,5,5,4,1,1,0,0}, b[SIZE] ={0}; Print(a, SIZE); CountSort(a,b,SIZE); Print(b, SIZE); return 0; }

יעילות תוכנית זאת תרוץ בזמן ליניארי ב-גודל המערך ובגודל הטווח אך תשתמש במקום עזר תוכנית זאת תרוץ בזמן ליניארי ב-גודל המערך ובגודל הטווח אך תשתמש במקום עזר