רקורסיה - Recursion (הסבר נוסף)
print nums מקבלת מספר ומדפיסה את המספרים מ-1 עד אותו מספר. בכל הפעלה היא בודקת אם המספר גדול מ-0, מדפיסה אותו, וקוראת לעצמה עם המספר פחות אחד.a ב-b, כל מופע מחזיר a ומוסיף אותו לתוצאה של המופע שקרא לו. המופע עם b שווה 1 מחזיר את a עצמו.פרקי ההרצאה: רקורסיה - Recursion (הסבר נוסף)
תמלול ההרצאה: רקורסיה - Recursion (הסבר נוסף)
הטקסט המלא של הדקות הראשונות בהרצאה «רקורסיה - Recursion (הסבר נוסף)» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
טוב חברים בואו נלמד מה זה ריקורסיה, נעשה קונסול אפליקיישן חדש שנקרא ריקורסיה, מה זה ריקורסיה? ריקורסיה זה מתודה שקורית לעצמה.
מתודה שקורית לעצמה, לדוגמה אני אעשה עכשיו static נניח int, פונקציה שמחזירה int, אנחנו רוצים לעשות הדפסה על מסך, אתם יודעים מה, היא לא צריכה להחזיר שום דבר, היא צריכה להדפיס על המסך מספרים 1-9, כן?
תכף אתם תראו, להסביר את זה זה הרבה יותר קשה מאשר להראות את זה. מספרים 1-9, וזה נקרא, נקרא לה print nums. print nums, היא מקבלת איזשהו מספר והיא מדפיסה מספרים 1-9, אוקיי?
לאו דווקא 1-9, 1 עד המספר הזה, אוקיי? יפה מאוד. אז אנחנו רוצים להדפיס מספרים, אז אנחנו נקרא לפונקציה הזאת, נתחיל במספר 9, אני יודע מה, זה לא משנה.
יופי, אנחנו רוצים לקרוא לה. עכשיו כמובן שאפשר לעשות כל ריקורסיה בלולאה ואני רוצה להראות לכם משהו אחר. כמובן שאפשר לעשות לולאה שמדפיסה מספרים, כן?
שזה לא בעיה, כל ריקורסיה אפשר לעשות בלולאה ואני רוצה להראות לכם ריקורסיה. מה עושה ריקורסיה ומה הפואנטה שלה? if num גדול מ-0, אוקיי?
אם num גדול מ-0, תעשה דברים 40 בבקשה. תעשה קונסול רייטליין של num, תדפיס לי את ה-num ושימו לב, תקרא לעצמך, כאילו אתה פונקציה אחרת לגמרי, אבל כאילו תקרא לפונקציה אחרת שבמקרה זה הקופי שלך, אמנם פחות 1. תחשבו שזה כאילו, כאילו קראתי למתודה אחרת, כן?
אז נוצר לי בזיכרון מקום נפרד, כן? תסתכלו, זה קצת קשה להסביר. הנה, אתם רואים, הוא הדפיס לי מספרים מ-9 עד 1, התחיל ב-9, התחיל ב-9, הדפיס לי 9, קרא לעצמו עם 8. נכנס עוד פעם לפה עם 8, אבל זה מופע אחר.
בדק שזה גם גדול מאפס, הדפיס שמונה, קרא לעצמו עם שבע. שש, חמש, ארבע, שלוש, שתיים, אחד, הגיע לאפס, יצא החוצה והתחיל לצאת החוצה.
אולי זה קצת לא ברור, כי זה באמת בהתחלה לאנשים קצת לא ברור מה זה רקורסיה, אז אני אצייר לכם ככה. תחשבו שזה היה תוכנה ביצעה, סליחה, תוכנה ביצעה איזושהי שורת קוד, שורת קוד, שורת קוד, ואז יש לה איזושהי פונקציה עם השם של עצמה.
כן, היא קוראת לעצמה, נניח קוראים לה f, היא קוראת לעצמה עם num פחות אחת, איזושהי פונקציה שלנו, איך היא נקראת, print משהו, לא חשוב, נקרא לה f, וברגע שהיא קוראת לעצמה שוב, ויש לה קוד גם אחרי זה.
מה שקורה זה שברגע שהיא קוראת לעצמה, אבל עם מספר יותר קטן, התחלנו ב-9, כן? הפעלה ראשונה, num שווה ל-9. עכשיו היא קוראת לעצמה שוב, אבל הפעם, תסתכלו פה, הפעם, ה-num הוא כבר לא 9.
היא קוראת לעצמה שוב עם נם שווה שמונה ואז היא מגיעה לזה והיא קוראת לעצמה שוב ופה היא מדפיסה תשע פה היא מדפיסה שמונה כן יש פה הדפסה בגלל זה ראינו במסך קונסול רייטליין עכשיו תסתכלו מה יקרה הלאה עכשיו הקוד של הפונקציה הזה זה כאילו כאילו פונקציה קוראת לפונקציה אחרת אבל במקרה זה הקופי שלה עכשיו הפעם היא תקרא לעצמה שוב עם נם פחות אחד אז היא תקרא לעצמה שוב זה נקרא רקורסיה כשאתה
קורא לעצמך שוב ומייצר מופעים הרבה מובאים של עצמך בזיכרון. נם שווה 7. ו... הבנתם? קוראת לעצמה, קוראת לעצמה, קוראת לעצמה.
מה יקרה כשהיא תגיע לאפס? יום אחד היא תגיע לאפס. זה נקרא תנאי עצירה, אנחנו עוצרים. ברגע שאנחנו נגיע לאפס, אנחנו תכף נסתכל בקוד מה קורה, כדי לא להתבלבל.
אבל קוד, כשנם שווה לאפס, מה קורה? נם שווה לאפס, תסתכלו מה יקרה עכשיו. בקוד if נם שווה לאפס, הוא לא נכנס לפה, פשוט יוצא החוצה כן הוא פשוט יוצא החוצה ברגע שהוא יוצא החוצה הוא כאילו לא הוא לא קורא לעצמו את שוב הוא כבר לא עושה את זה הוא פשוט יוצא מפה ישירות החוצה וברגע שהוא יצא החוצה לאן הוא חוזר חוזר לזה שקרה לו לשורה הבאה
נכון לזה שקרה לו לשורה הבאה להמשיך לעשות אותה ומסיים ומה זה מסיים במקרה הזה אחרי שקראו לי וחזרתי לשורה הבאה זה שורת סיום אז הוא מתחיל פשוט לצאת כי אין פה שורה הבאה אז הוא יוצא הוא יוצא הוא יוצא ובסוף מסתיימת התוכנית פשוט פה אין לי את השורות האלה השורות האלו פה ריקות
אחרי קריאה לפונקציה השורות אצלי ריקות מוכנים לראות פה אחרי קריאה לפונקציה השורות אצלי ריקות מה היה קורה אם הייתי עושה ככה אז הוא היה עושה 987 מגיע לאפס וכשהוא היה יוצא הוא היה מתחיל להדפיס ביציאה מה זה ביציאה הוא היה מדפיס לי 1 2 3 זאת אומרת למעשה הוא היה מדפיס לי 1 עד 9 קלטתם?
כשהוא נכנס, 1 עד 9. כשהוא נכנס, הוא נכנס 9 עד 1, כי הוא כל פעם מוריד 1, אבל כשהוא יוצא, הוא יוצא בדיוק ברוורס מה שנקרא.
הוא יוצא ברוורס, ואז אני מדפיס אותו ביציאה. אם אני מדפיס פה מספרים ביציאה, אולי נוכל לשלב לכם את כל התמונות האלו ביחד על אותו מסך. הנה, יפה.
ברגע שאני מדפיס ביציאה, אני מדפיס לא כאן למעלה, 9, 8, 7, 6. אני אחרי שהוא מגיע לאפס ומתחיל לחזור חזרה אני מדפיס פה 1. פה כשהוא סיים את ה-1 והוא חזר ל-2 אני מדפיס פה 2, 3. כל פעם שאתה יוצא אני מזנב בך להדפיס ואז יוצא שאתה בעצם כל הכניסה שלך לא הדפסת כלום נכנסת נכנסת נכנסת
פה השורות האלו ריקות כשהגעת לאפס התחלת לצאת אמרתי לך להדפיס אתם רואים אחרי שהוא יוצא הוא מדפיס תקלוט טוב טוב זה תנאי היצירה שלי שיהיה כאן אוקיי, שזה יעצור לי מתישהו.
הוא נכנס, נכנס, נכנס, נכנס. שנייה, אני אראה לכם הכל ביחד. הוא נכנס, נכנס, נכנס, נכנס לעצמו. אתם יודעים מה? אני אפילו אראה לכם את זה פה ב-Locals.
בואו נעשה F11. הוא מתחיל Add Watch, יופי. אתם רואים? הוא מתחיל, איפה ה-Watch שלי? הוא מתחיל את הפונקציה עם תשע. עכשיו הוא קורא לעצמו עם שמונה.
זה קופי אחר בזיכרון. שלא תחשבו שזה אוטו קופי, זה קופי אחר בזיכרון, אוקיי? יופי, יופי, מה יש לך? הוא מתחיל בתשע, אה, זה הפלט שלנו, זה הפלט שלנו, סליחה, הפלט שלנו, הבנתי עכשיו איפה הבעיה, יופי, זה ככה, חבל שמתחתי את זה טיפה,
צריך לקצר את זה קצת, נעלה על זה קצת, כן, אתם תבינו את העיקרון, יופי, אז התחלנו מזה שהמספר הוא תשע, ועכשיו אנחנו מייצרים מופע חדש עם שמונה, עכשיו מייצרים מופע חדש עם שבע, ואז מייצרים שש, חמש, ארבע, שלוש, שתיים, אחד.
ירופים מייצרים מופע חדש עם אחד. מה קורה פה עכשיו אם הגענו כבר לאפס? באפס הוא לא עושה כלום, יוצא החוצה. ואז כשהוא יוצא החוצה הוא חוזר למי שקרא לו, אבל מי קרא לו?
מי קרא לאפס? אז זה של אחד קרא לאפס. אז הוא חזר לזה של אחד, אתם רואים? נ"ם שווה אחד. ומדפיס אותו במעמד היציאה.
הוא פה בשורות האלו, הלמטה, במעמד היציאה מדפיס ומי קרא לאחד? השניים. ועוד פעם הוא במעמד היציאה מדפיס.
ואז תסתכלו פה, תסתכלו פה במסך למעלה. אתם רואים? הוא כל פעם מדפיס, אתם רואים? ביציאה את ה-4, 5, 6.
אז הבנו דבר כזה שאם אנחנו מדפיסים בכניסה אנחנו נכנסים עם מספרים מגדול אל הקטן, מגיעים לתנאי עצירה שלנו, מתחילים לצאת. מתחילים לצאת.
תסתכלו עכשיו, אתם רואים? הוא נכנס עם 2321 הוא נכנס נכנס נכנס ואז יוצא יוצא יוצא אוקיי אלס בוא נעשה פה איזשהו אלס זה אומר שכאילו נאם לא גדול מאפס קונסול רייטליין זירו איזה יופי יצא לנו הנה אתם רואים הוא נכנס נכנס נכנס הוא נכנס נכנס נכנס הדפיס לנו מספרים בכניסה כל אלו
הודפסו בכניסה כל פעם קרה לעצמו עם הכניסה cm הגיע לזירו נכנס לתנאי היצירה שלנו הדפיס 0 יצא החוצה התחיל לצאת התחיל להדפיס את כל אלו בסדר הפוך זה נקרא רקורסיה זה ככה שתבינו את החלק הקל בואו נעשה עכשיו עם רקורסיה נעשה עם רקורסיה מכפלה אתם יודעים מה נעשה מכפלה נעשה עכשיו ברקורסיה מכפלה אז זה נקרא נקרא לזה רקורסיה אחד בואו נעשה רקורסיה נוספת נסגור את
זה נסגור את זה ונפתח visual studio חדש ונעשה פרויקט חדש של, נעשה פה פרויקט חדש ונקרא לו רקורסייה רקורסיב מולטיפלייר מולטי מולטי מולטי מולטיפלייר, לא יודע. טוב, מכפלה אנחנו רוצים לעשות פונקציה של מכפלה כאשר מותר לנו להשתמש רק בחיבור עכשיו כל עוד פעם אני חוזר כל רקורסייה אפשר להחליף בלולאה לפעמים
זה פשוט הרבה יותר מסובך הלוגיקה של רקורסייה היא יותר מורכבת אבל אבל הפתרון של רקורסי יכול להיות יותר פשוט מאשר פתרון בלולה.
אבל כל רקורסי אפשר להחליף בלולה. יפה, אז אנחנו רוצים לעשות בעצם מולטי מולטי מולטיפלי מכפלה שמקבלת איזשהו שני מספרים a וind b שני מספרים ומחזירה לנו מכפלה תוצאה עד עכשיו שימו לב היא בתוך השם שלה תחזיר לנו בעצם תוצאת המכפלה.
אנחנו נעשה console right line איזה שהם מספרים בואו נעשה איזה שהם מספרים int x שווה לא יודע מה 4 int y שווה 3 console right line x כפול x כפול y שווה x כפול y שווה לmultiply למכפלה לפונקציה אנחנו נקרא לפונקציה עם x פסיק y כאן בסדר?