>> 1 SPEAKER: בואו לתת לי פתרון זה לנסות.
אז בואו נסתכל על מה ששלנו צומת struct תיראה.
הנה, אנחנו רואים שאנחנו הולכים יש לי בול Word וכוכב צומת Struct
ילדים סוגרים האלפבית.
הדבר ראשון אז ייתכן שאתה תוהה, מדוע חשיש האלפבית מוגדר כ27?
ובכן, זוכר שאנחנו הולכים צריכים לטיפול בגרש, ולכן
זה הולך להיות קצת מיוחד מקרה בכל תכנית זו.
>> אוקיי, עכשיו, זוכר איך הגיבורים באמת עובד.
בואו נגיד שאנחנו אינדקס מילת החתולים, אז מן השורש של איירי שלנו,
אנחנו הולכים להסתכל על הילדים מערך, ואנחנו הולכים להסתכל על
מדד שמתאים למכתב ג אז זה יהיה מדד שניים.
אז בהתחשב בכך, שייתן לנו צומת חדשה, ולאחר מכן נצטרך
לעבוד מצומת.
>> כך שבהתחשב בצומת זה, אנחנו שוב הולך להסתכל על מערך הילדים,
ואנחנו הולכים להסתכל על מדד אפס למתאים בחתול.
אז אנחנו הולכים ללכת לצומת ש, וניתנו צומת זה, אנחנו הולכים
להסתכל על המדד שמתאים לט ועבר לצומת ש,
סוף סוף, יש לנו נראים לחלוטין באמצעות מילת החתול שלנו, ועכשיו בול
מילה אמורה לציין אם מילת נתונה זה היא למעשה מילה.
>> אז למה אנחנו צריכים את זה מקרה מיוחד?
ובכן, מה אם מילת קטסטרופה הוא במילון שלנו, אבל
מילת החתול לא?
אז במבט כדי לראות אם מילת החתול במילון שלנו, אנחנו הולכים
בהצלחה להסתכל דרך המדדים C-A-T ולהגיע לצומת, אבל זה
רק בגלל אסון שקרה לי ליצור צמתים בדרך מC-A-T כל
בדרך לסוף המילה.
אז בול מילה משמשת לציין אם מיקום מסוים זה בעצם
מצביע על מילה.
>> אז עכשיו שאנחנו יודעים את כל מה ש, נכון הגיבורים הולכים להיראות כמו, בואו נסתכל
בפונקצית העומס.
אז טען הולך לחזור בול לאם אנחנו בהצלחה או
מילון וטעון ללא הצלחה זה הולך להיות המילון
שאנחנו רוצים לטעון.
הדבר אז קודם כל אנחנו הולכים לעשות הוא לפתוח עד שהמילון לקריאה.
אנחנו צריכים לוודא שאנחנו לא נכשלנו, כך שאם המילון לא היה
נפתח בהצלחה, הוא יחזור לא, ובמקרה זה אנחנו הולכים
בתמורת שווא.
אבל בהנחה שזה בהצלחה פתחתי, אז אנחנו יכולים באמת לקרוא
באמצעות המילון.
>> דבר אז קודם כל אנחנו הולכים רוצה לעשות זה יש לנו את זה
שורש משתנה גלובלי.
עכשיו, שורש הוא הולך להיות כוכב צומת.
זה החלק העליון של איירי שאנחנו הולך להיות iterating דרך.
דבר אז קודם כל אנחנו הולכים לרוצים לעשות הוא להקצות זיכרון לשורש שלנו.
>> שים לב שאנחנו משתמשים Calloc פונקציה, שהוא בעצם אותו הדבר
כפונקציה malloc, למעט זה מובטח להחזיר משהו שהוא
מאופס בחוץ לגמרי.
אז אם אנחנו משמשים malloc, היינו צריך לעבור את כל המצביעים בנו
צומת ולוודא כי הם כולם ריקים.
אז Calloc יעשה את זה בשבילנו.
>> עכשיו, בדיוק כמו malloc, אנחנו צריכים לעשות בטוח שההקצאה בעצם
מוצלח.
אם זה חזר ריק, אז אנחנו צריך לסגור המילון שלנו
להגיש ולהחזיר שקר.
אז בהנחת שההקצאה היה מוצלח, אנחנו הולכים להשתמש בצומת
כוכב סמן כדי לחזר דרך איירי שלנו.
אז השורש שלנו אף פעם לא הולך להשתנות, אבל אנחנו הולכים להשתמש בסמן ל
בעצם ללכת מצומת לצומת.
>> בסדר, אז בזה ללולאה, אנחנו קריאה דרך קובץ המילון,
ואנחנו משתמשים בfgetc.
אז fgetc הולך לתפוס אחת דמות מהקובץ.
אנחנו הולכים להמשיך תופס דמויות בזמן שאנחנו לא מגיעים
בסופו של הקובץ, ולכן יש שני מקרים שאנחנו צריכים להתמודד איתו.
הראשון, אם הדמות לא הייתה קו חדש, כדי שנדע אם זה היה חדש
קו, אז אנחנו עומדים לעבור למילה חדשה.
אבל בהנחה שזה לא היה בשורה חדשה, ולאחר מכן כאן, אנחנו רוצים להבין את
מדד שאנחנו הולכים לאינדקס לתוך במערך שהילדים
הסתכלנו בעבר.
>> אז כמו שאמרתי קודם, שאנחנו צריכים מקרה מיוחד הגרש.
שים לב שאנחנו משתמשים במפעיל המשולש כאן, ולכן אנחנו הולכים לקריאה
זה כאילו הדמות שאנו קוראים בהייתה גרש, אז אנחנו הולכים
נקבע מדד שווה למינוס האלפבית 1, אשר יהיה המדד 26.
דבר אחר, אם זה לא היה גרש, אז אנחנו הולכים להגדיר את המדד
שווה למינוס ג.
אז זוכר בחזרה מסטי עמ 'קודמים, מינוס ג הוא הולך לתת לנו
עמדה אלפביתית של ג, כך שאם ג הוא האות, זה יהיה
לתת לנו מדד אפס.
לאות B, זה ייתן לי שלנו המדד 1, וכן הלאה.
>> אז זה נותן לנו המדד ל מערך ילדים שאנחנו רוצים.
עכשיו, אם מדד זה הוא ריק כרגע מערך הילדים, זה אומר ש
צומת אינה קיימת כיום מ נתיב זה, ולכן אנחנו צריכים להקצות
צומת לנתיב.
זה מה שאנחנו עושים פה.
אז אנחנו הולכים, שוב, השתמשו בCalloc פונקציה, כך שאין לנו
כדי לאפס את כל המצביעים, ואנחנו, שוב, צריך לבדוק שCalloc
לא נכשל.
אם Calloc לא להיכשל, אז אנחנו צריכים לפרוק הכל, לסוגרנו
מילון, ולחזור שקר.
>> אז בהנחה שזה לא נכשל, ולאחר מכן זה יהיה ליצור ילד חדש עבורנו,
ואז אנחנו נלך לילד הזה.
הסמן שלנו לחזר עד אותו ילד.
עכשיו, אם זה לא היה ריק מלכתחילה, לאחר מכן הסמן יכול רק לחזר
עד שהילד מבלי יש להקצות כל דבר.
זה המקרה שבו אנו קרו ראשון להקצות את מילת החתול, ו
זה אומר שכאשר אנחנו הולכים להקצות קטסטרופה, אנחנו לא צריכים ליצור
בלוטות לC-A-T שוב.
הם כבר קיימים.
>> אוקיי, אז מה הוא Else זה?
זה המצב שבו היה ג n הלוכסן ההפוך, שבו ג היה קו חדש.
משמעות דבר היא שיש לנו בהצלחה השלים מילה.
עכשיו, מה שאנחנו רוצים לעשות כשאנחנו הושלם בהצלחה מילה?
אנחנו הולכים להשתמש במילת תחום זה בתוך צומת Struct שלנו.
>> אנחנו רוצים להגדיר את זה נכון, כדי ש מצביע על כך שפסק זו מצביעה
מילה מוצלחת מילה בפועל.
כעת, קבע כי ל-True.
אנחנו רוצים לאפס את הסמן שלנו לנקודה לתחילת איירי שוב.
ולבסוף, להגדיל המילון שלנו גודל מאז שמצאנו מילה אחרת.
>> בסדר, אז אנחנו הולכים להמשיך לעשות כי, קריאה בתווים על ידי
אופי, בניית צמתים חדשים ב איירי ועבור כל מילה ב
מילון, עד שסוף סוף תגיעו לג שווה EOF, ובמקרה זה, אנחנו שוברים
מתוך הקובץ.
עכשיו, יש שני מקרים תחת שבו אנו יכולים להיות פגעו EOF.
הראשון הוא אם יש שגיאה קריאה מהקובץ, כך שאם לא היה
טעות, אנחנו צריכים לעשות טיפוסיים לפרוק הכל, לסגור את התיק,
בתמורת שווא.
בהנחה שלא הייתה טעות, כי רק אומר שאנחנו באמת פגעו בסופו של
את הקובץ, ובמקרה זה, אנחנו סוגרים להגיש ולהחזיר נכון מאז ש
העמיס את המילון בהצלחה לאיירי שלנו.
>> כל כך עכשיו בואו הנכון, הוצא.
כאשר מסתכלים על פונקצית עזיבה, אנו רואים בדוק כי הוא הולך לחזור בול.
זה מחזיר True אם המילה הזאת שזה שעבר הוא באיירי שלנו.
היא מחזירה שקר אחר.
>> אז איך אנחנו הולכים לקבוע אם מילה זו היא באיירי שלנו?
אנו רואים כאן, בדיוק כמו בעבר, אנחנו הולכים להשתמש בסמן ללחזר
דרך איירי שלנו.
עכשיו, הנה, אנחנו הולכים לחזר על כל המילה שלנו.
אז iterating מעל המילה אנחנו עברתי, אנחנו הולכים כדי לקבוע את
מדד לתוך מערך שהילדים מתאים לi סוגר מילה.
אז זה הולך להיראות בדיוק כמו עומס, שבו אם אני הוא מילת סוגר
גרש, אז אנחנו רוצים להשתמש במדד האלפבית מינוס 1 כי אנחנו נחושים
כי מקום שבו אנחנו הולכים כדי לאחסן את הגרשיים.
>> עוד אנחנו הולכים להשתמש tolower מילת סוגר i.
אז לזכור מילה שיכולה להיות שרירותי היוון, ולכן אנחנו
רוצה לוודא שאנחנו משתמשים גרסה קטנה של דברים.
וכך להפחית מאותיות קטנות כי ל, שוב, לתת לנו
עמדת אלפביתי אופי זה.
אז זה הולך להיות האינדקס שלנו לתוך המערך לילדים.
>> ועכשיו, אם מדד שלילדים המערך הוא ריק, זה אומר שאנחנו
כבר לא יכול להמשיך iterating למטה איירי שלנו.
אם זה המקרה, מילה זו לא יכולה אולי יהיה באיירי שלנו, שכן אם זה
היו, זה אומר שלא יהיה הדרך למטה למילה הזאת, ושהיית
אף פעם לא נתקל באפס.
אז נתקל null, אנחנו חוזרים שקר.
המילה אינה נמצאת במילון.
אם זה לא היה ריק, ואז אנחנו הולכים תמשיך חוזר ונשנית, ולכן אנחנו הולכים
לעדכן את הסמן שלנו כדי להצביע על כי צומת מסוימת במדד זה.
>> אז אנחנו ממשיכים לעשות את זה לאורך כל המילה כולה.
בהנחה שאנחנו אף פעם לא פגעו null, שאמצעי היינו יכול לעבור את כולו
עולם ולמצוא צומת באיירי שלנו, אבל אנחנו לא ממש נעשו עדיין.
אנחנו לא רוצים רק כדי לחזור נכון.
אנחנו רוצים לחזור מילת שגיאת סמן מאז, זכור שוב, אם חתול לא
במילון ואסוננו הוא, אז אנחנו תקבלו בהצלחה באמצעות
מילת החתול, אבל מילת סמן יהיה לא נכון ולא נכון.
אז אנחנו חוזרים מילת סמן כדי לציין אם פסק זו היא למעשה מילה,
וזה אותו לבדיקה.
>> אז בואו לבדוק את גודל.
אז גודל הולך להיות די קל מאז, זכרו בעומס, אנחנו
להגדיל כל גודל מילון כל מילה שאנו פוגשים.
אז גודל הוא רק הולך לחזור גודל מילון, וזהו זה.
>> בסדר, אז לבסוף, יש לנו לפרוק.
אז לפרוק, אנחנו הולכים להשתמש פונקציה רקורסיבית בעצם לעשות את כל
של העבודה בשבילנו, ולכן הפונקציה שלנו הוא הולך להיקרא פורק.
מה פורק הוא הולך לעשות?
אנו רואים כאן פורקים כי הוא הולך לחזר על כל הילדים ב
צומת המסוימת הזה, ואם הילד הצומת היא לא ריקה, אז אנחנו הולכים
לפרוק את צומת הילד.
>> אז זה הולך באופן רקורסיבי לפרוק את כל הילדים שלנו.
ברגע שאנחנו בטוחים שכל הילדים שלנו כבר פרק, אז אנחנו
יכול לשחרר את עצמנו, אז לפרוק את עצמנו.
אז זה באופן רקורסיבי יהיה לפרוק כל איירי, ואז ברגע זה
עשיתי, אנחנו יכולים רק לחזור נכון.
לפרוק לא יכול להיכשל, אנחנו רק לשחרר את הדברים.
אז ברגע שנסיים לשחרר הכל, החזר אמיתי.
וזהו זה.
השם שלי הוא רוב, וזה היה [לא ברור].