1. מבוא למדעי המחשב
סיבוכיות

2. סיבוכיות - מוטיבציה סידרת פיבונאצ'י: long fibonacci (int n) {
if (n == 1 || n == 2)
return 1;
return (fibonacci(n-1) + fibonacci(n-2)); }
long fibonacci (int n) {
long tmp[LEN] = {1,1}, i;
for (i=2 ; i<n ; i++)
tmp[i] = tmp[i-1] + tmp[i-2];
return tmp[n-1]; }

3. חיפוש Search נתון מערך של שלמים ומספר שלם.
יש לקבוע האם המספר נמצא במערך:
יש להגדיר פונקציה המקבלת מערך של שלמים ואת אורכו וכן מספר שלם x, ומחזירה את האינדקס של התא במערך שבו נמצא x או-1 אם x לא נמצא במערך.
int search (int arr[ ] , int size, int x) {
int i;
for ( i=0 ; i < size ; i++ ) {
if ( x == arr[i] ) {
return i; }
return -1;
כמה זמן ?
כמה מקום ?

4. סיבוכיות Complexity נתון אלגוריתם הפועל על קלט.
נביט על סדרה של קלטים ההולכים וגדלים (למשל, באלגוריתם החיפוש – גודל המערך הולך וגדל).
נרצה לתאר כיצד יתנהג האלגוריתם (זמן ריצה+מקום) כאשר הקלט הולך וגדל (כאשר n ← ).
סיבוכיות זמן: מספר הפעולות שמבצע האלגוריתם ביחס ל- n.
סיבוכיות מקום: גודל המקום בו משתמש האלגוריתם ביחס ל- n.
אנו מודדים סיבוכיות של אלגוריתמים במקרה הגרוע:
Worst-case complexity

5. סיבוכיות Complexity אנו רוצים לדעת מהו סדר הגודל של סיבוכיות התכנית.
לכן – הסיבוכיות נמדדת בהשוואה לפונקציות תוך הזנחת קבועים.
הגדרה:
הפונקציה g(n) היא בעלת סיבוכיות f(n) אם קיימים קבועים c ו- n0 כך שלכל n>n0 g(n)≤c·f(n) .
אם הפונקציה g(n) היא בעלת סיבוכיות f(n), נסמן g(n)=O(f(n)).

6. סיבוכיות Complexity דוגמא לסדרי גודל: 3 1000 3000 1,000,000 4 10,000
40,000 5
100,000
500,000 6
6,000,000 10

7. חיפוש Search int search (int arr[ ] , int size, int x) { int i;
for ( i=0 ; i < size ; i++ ) {
if ( x == arr[i] ) {
return i; }
return -1;
סיבוכיות זמן: O(n)
אפשר יותר טוב ?

8. חיפוש בינארי נתון מערך ממוין של שלמים ומספר שלם.
יש לקבוע האם המספר נמצא במערך:
יש להגדיר פונקציה המקבלת מערך ממוין של שלמים ואת אורכו וכן מספר שלם x, ומחזירה את האינדקס של התא במערך שבו נמצא x או-1 אם x לא נמצא במערך.

9. חיפוש בינארי נתון מערך ממוין של שלמים ומספר שלם.
יש לקבוע האם המספר x נמצא במערך.
הרעיון:
לנצל את העובדה שהמערך ממוין.
לבדוק את היחס בין ערך האיבר האמצעי במערך לבין x:
אם x שווה לו ← סיימנו!
אם x קטן ממנו ← נחפש בחלק השמאלי.
אם x גדול ממנו ← נחפש בחלק הימני.

10. חיפוש בינארי מימוש: משתני עזר: low – נקודת התחלת החיפוש במערך
high – נקודת סיום החיפוש במערך.
נבנה פונקציה הבודקת האם
עבור low=0 ו- high=arr_len-1 נקבל את הפתרון.

11. חיפוש בינארי סיבוכיות זמן: O(logn)
/* binsearch: find x in arr[low] <= arr[low+1] <= ... <= arr[high-1] */
int binsearch(int arr[], int low, int high, int x) {
int mid;
if (low > high) { /* arr is exhausted, n not found */
return -1; }
mid = (low+high) / 2; /* middle of the relevant part of arr */
if (x < arr[mid]) /* search in the lower part */
return (binsearch(arr, low, mid-1, x));
else if (x > arr [mid]) /* search in the upper part */
return (binsearch(arr, mid+1, high, x));
else /* n found, return its index */
return mid;
סיבוכיות זמן: O(logn)

12. סיבוכיות - דוגמא
מערך בגודל n נקרא מושלם אם הוא מכיל אך ורק את המספרים 1,2,…,n כך שכל מספר מופיע בדיוק פעם אחת.
דוגמא:
מערך מושלם 3 2 4 1 5 2 4 1 5
מערך שאינו מושלם 3 2 4 1

13. סיבוכיות - דוגמא
מערך בגודל n נקרא מושלם אם הוא מכיל אך ורק את המספרים 1,2,…,n כך שכל מספר מופיע בדיוק פעם אחת.
הגדירו פונקציה המקבלת מערך ואת גודלו ומחזירה 1 אם המערך מושלם ו- 0 אחרת.

14. סיבוכיות - דוגמא int IsPerfect (int arr[], int len) { int i,j;
for (i=0; i<len; i++){
if (arr[i]<1 || arr[i]>len)
return FALSE;
for (j=i+1; j<len; j++){
if (arr[i]==arr[j]) }
return TRUE;
סיבוכיות זמן:
סיבוכיות מקום:

15. סיבוכיות - דוגמא
מערך בגודל n נקרא מושלם אם הוא מכיל אך ורק את המספרים 1,2,…,n כך שכל מספר מופיע בדיוק פעם אחת.
הגדירו פונקציה המקבלת מערך ואת גודלו ומחזירה 1 אם המערך מושלם ו- 0 אחרת.
דרישות סיבוכיות:
סיבוכיות זמן: O(n)
סיבוכיות מקום: O(n)

16. סיבוכיות - דוגמא int IsPerfect (int arr[], int len) {
int i, help[SIZE]={0};
for (i=0; i<len; i++){
if (arr[i]<1 || arr[i]>len)
return FALSE;
else
help[arr[i]]++; }
for (i=1; i<=len; i++){
if (help[i]!=1)
return TRUE;

17. מיזוג merge נתונים שני מערכים ממוינים של שלמים.
יש למזג את שני המערכים למערך ממוין אחד.
הרעיון:
עבור a,b – מערכי הקלט (ממוינים), c – מערך הפלט, נבצע:
כל עוד יש איברים בשני המערכים:
אם האיבר הנוכחי ב- a < האיבר הנוכחי ב-b
העתק לפלט את האיבר הנוכחי ב- a
קדם את מצביעי a ו- c
אחרת
העתק לפלט את האיבר הנוכחי ב- b
קדם את מצביעי b ו- c
העתק את שארית המערך a ל- c
העתק את שארית המערך b ל- c

18. מיזוג merge סיבוכיות זמן:
int merge (int list1[] , int size1 , int list2[] , int size2 , int list3[]) {
int i1, i2, i3;
if (size1+size2 > SIZE) {
return FALSE; }
i1 = 0; i2 = 0; i3 = 0;
while (i1 < size1 && i2 < size2) { /* while both lists are non-empty */
if (list1[i1] < list2[i2]) {
list3[i3++] = list1[i1++];
else {
list3[i3++] = list2[i2++];
while (i1 < size1) { /* copy remainder of list1 */
while (i2 < size2) { /* copy remainder of list2 */
return TRUE;
סיבוכיות זמן: