1
00:00:00,000 --> 00:00:00,530

2
00:00:00,530 --> 00:00:03,070
>> 1 SPEAKER: בואו לתת לי
פתרון זה לנסות.

3
00:00:03,070 --> 00:00:07,130
אז בואו נסתכל על מה ששלנו
צומת struct תיראה.

4
00:00:07,130 --> 00:00:11,040
הנה, אנחנו רואים שאנחנו הולכים יש לי
בול Word וכוכב צומת Struct

5
00:00:11,040 --> 00:00:12,990
ילדים סוגרים האלפבית.

6
00:00:12,990 --> 00:00:18,720
הדבר ראשון אז ייתכן שאתה תוהה,
מדוע חשיש האלפבית מוגדר כ27?

7
00:00:18,720 --> 00:00:22,540
ובכן, זוכר שאנחנו הולכים צריכים
לטיפול בגרש, ולכן

8
00:00:22,540 --> 00:00:25,610
זה הולך להיות קצת מיוחד
מקרה בכל תכנית זו.

9
00:00:25,610 --> 00:00:28,780
>> אוקיי, עכשיו, זוכר איך
הגיבורים באמת עובד.

10
00:00:28,780 --> 00:00:33,420
בואו נגיד שאנחנו אינדקס מילת החתולים,
אז מן השורש של איירי שלנו,

11
00:00:33,420 --> 00:00:36,670
אנחנו הולכים להסתכל על הילדים
מערך, ואנחנו הולכים להסתכל על

12
00:00:36,670 --> 00:00:42,250
מדד שמתאים למכתב
ג אז זה יהיה מדד שניים.

13
00:00:42,250 --> 00:00:46,400
אז בהתחשב בכך, שייתן לנו
צומת חדשה, ולאחר מכן נצטרך

14
00:00:46,400 --> 00:00:47,880
לעבוד מצומת.

15
00:00:47,880 --> 00:00:51,830
>> כך שבהתחשב בצומת זה, אנחנו שוב
הולך להסתכל על מערך הילדים,

16
00:00:51,830 --> 00:00:56,170
ואנחנו הולכים להסתכל על מדד אפס
למתאים בחתול.

17
00:00:56,170 --> 00:01:01,240
אז אנחנו הולכים ללכת לצומת ש,
וניתנו צומת זה, אנחנו הולכים

18
00:01:01,240 --> 00:01:05,170
להסתכל על המדד שמתאים
לט ועבר לצומת ש,

19
00:01:05,170 --> 00:01:09,590
סוף סוף, יש לנו נראים לחלוטין
באמצעות מילת החתול שלנו, ועכשיו בול

20
00:01:09,590 --> 00:01:15,020
מילה אמורה לציין אם
מילת נתונה זה היא למעשה מילה.

21
00:01:15,020 --> 00:01:17,530
>> אז למה אנחנו צריכים את זה מקרה מיוחד?

22
00:01:17,530 --> 00:01:21,680
ובכן, מה אם מילת קטסטרופה
הוא במילון שלנו, אבל

23
00:01:21,680 --> 00:01:24,120
מילת החתול לא?

24
00:01:24,120 --> 00:01:29,030
אז במבט כדי לראות אם מילת החתול
במילון שלנו, אנחנו הולכים

25
00:01:29,030 --> 00:01:34,880
בהצלחה להסתכל דרך המדדים
C-A-T ולהגיע לצומת, אבל זה

26
00:01:34,880 --> 00:01:39,760
רק בגלל אסון שקרה לי
ליצור צמתים בדרך מC-A-T כל

27
00:01:39,760 --> 00:01:41,250
בדרך לסוף המילה.

28
00:01:41,250 --> 00:01:46,520
אז בול מילה משמשת לציין אם
מיקום מסוים זה בעצם

29
00:01:46,520 --> 00:01:48,370
מצביע על מילה.

30
00:01:48,370 --> 00:01:52,920
>> אז עכשיו שאנחנו יודעים את כל מה ש, נכון
הגיבורים הולכים להיראות כמו, בואו נסתכל

31
00:01:52,920 --> 00:01:54,800
בפונקצית העומס.

32
00:01:54,800 --> 00:01:58,670
אז טען הולך לחזור בול
לאם אנחנו בהצלחה או

33
00:01:58,670 --> 00:02:03,020
מילון וטעון ללא הצלחה
זה הולך להיות המילון

34
00:02:03,020 --> 00:02:04,520
שאנחנו רוצים לטעון.

35
00:02:04,520 --> 00:02:08,310
הדבר אז קודם כל אנחנו הולכים לעשות הוא לפתוח
עד שהמילון לקריאה.

36
00:02:08,310 --> 00:02:12,060
אנחנו צריכים לוודא שאנחנו לא נכשלנו,
כך שאם המילון לא היה

37
00:02:12,060 --> 00:02:15,280
נפתח בהצלחה, הוא יחזור
לא, ובמקרה זה אנחנו הולכים

38
00:02:15,280 --> 00:02:16,340
בתמורת שווא.

39
00:02:16,340 --> 00:02:21,290
אבל בהנחה שזה בהצלחה
פתחתי, אז אנחנו יכולים באמת לקרוא

40
00:02:21,290 --> 00:02:22,310
באמצעות המילון.

41
00:02:22,310 --> 00:02:24,940
>> דבר אז קודם כל אנחנו הולכים
רוצה לעשות זה יש לנו את זה

42
00:02:24,940 --> 00:02:26,560
שורש משתנה גלובלי.

43
00:02:26,560 --> 00:02:30,250
עכשיו, שורש הוא הולך להיות כוכב צומת.

44
00:02:30,250 --> 00:02:33,830
זה החלק העליון של איירי שאנחנו
הולך להיות iterating דרך.

45
00:02:33,830 --> 00:02:38,200
דבר אז קודם כל אנחנו הולכים לרוצים
לעשות הוא להקצות זיכרון לשורש שלנו.

46
00:02:38,200 --> 00:02:42,040
>> שים לב שאנחנו משתמשים Calloc
פונקציה, שהוא בעצם אותו הדבר

47
00:02:42,040 --> 00:02:45,560
כפונקציה malloc, למעט זה
מובטח להחזיר משהו שהוא

48
00:02:45,560 --> 00:02:47,240
מאופס בחוץ לגמרי.

49
00:02:47,240 --> 00:02:51,350
אז אם אנחנו משמשים malloc, היינו צריך
לעבור את כל המצביעים בנו

50
00:02:51,350 --> 00:02:54,220
צומת ולוודא כי
הם כולם ריקים.

51
00:02:54,220 --> 00:02:56,780
אז Calloc יעשה את זה בשבילנו.

52
00:02:56,780 --> 00:03:00,390
>> עכשיו, בדיוק כמו malloc, אנחנו צריכים לעשות
בטוח שההקצאה בעצם

53
00:03:00,390 --> 00:03:01,580
מוצלח.

54
00:03:01,580 --> 00:03:04,060
אם זה חזר ריק, אז אנחנו
צריך לסגור המילון שלנו

55
00:03:04,060 --> 00:03:06,170
להגיש ולהחזיר שקר.

56
00:03:06,170 --> 00:03:11,040
אז בהנחת שההקצאה היה
מוצלח, אנחנו הולכים להשתמש בצומת

57
00:03:11,040 --> 00:03:14,340
כוכב סמן כדי לחזר
דרך איירי שלנו.

58
00:03:14,340 --> 00:03:17,950
אז השורש שלנו אף פעם לא הולך להשתנות,
אבל אנחנו הולכים להשתמש בסמן ל

59
00:03:17,950 --> 00:03:20,770
בעצם ללכת מצומת לצומת.

60
00:03:20,770 --> 00:03:25,000
>> בסדר, אז בזה ללולאה, אנחנו
קריאה דרך קובץ המילון,

61
00:03:25,000 --> 00:03:26,965
ואנחנו משתמשים בfgetc.

62
00:03:26,965 --> 00:03:30,360
אז fgetc הולך לתפוס אחת
דמות מהקובץ.

63
00:03:30,360 --> 00:03:33,430
אנחנו הולכים להמשיך תופס
דמויות בזמן שאנחנו לא מגיעים

64
00:03:33,430 --> 00:03:37,540
בסופו של הקובץ, ולכן יש
שני מקרים שאנחנו צריכים להתמודד איתו.

65
00:03:37,540 --> 00:03:41,640
הראשון, אם הדמות לא הייתה
קו חדש, כדי שנדע אם זה היה חדש

66
00:03:41,640 --> 00:03:44,480
קו, אז אנחנו עומדים
לעבור למילה חדשה.

67
00:03:44,480 --> 00:03:49,300
אבל בהנחה שזה לא היה בשורה חדשה, ולאחר מכן
כאן, אנחנו רוצים להבין את

68
00:03:49,300 --> 00:03:52,440
מדד שאנחנו הולכים לאינדקס לתוך
במערך שהילדים

69
00:03:52,440 --> 00:03:53,890
הסתכלנו בעבר.

70
00:03:53,890 --> 00:03:57,950
>> אז כמו שאמרתי קודם, שאנחנו צריכים
מקרה מיוחד הגרש.

71
00:03:57,950 --> 00:04:01,040
שים לב שאנחנו משתמשים במפעיל המשולש
כאן, ולכן אנחנו הולכים לקריאה

72
00:04:01,040 --> 00:04:05,500
זה כאילו הדמות שאנו קוראים בהייתה
גרש, אז אנחנו הולכים

73
00:04:05,500 --> 00:04:11,740
נקבע מדד שווה למינוס האלפבית
1, אשר יהיה המדד 26.

74
00:04:11,740 --> 00:04:15,190
דבר אחר, אם זה לא היה גרש,
אז אנחנו הולכים להגדיר את המדד

75
00:04:15,190 --> 00:04:17,820
שווה למינוס ג.

76
00:04:17,820 --> 00:04:23,090
אז זוכר בחזרה מסטי עמ 'קודמים,
מינוס ג הוא הולך לתת לנו

77
00:04:23,090 --> 00:04:27,470
עמדה אלפביתית של ג, כך שאם
ג הוא האות, זה יהיה

78
00:04:27,470 --> 00:04:28,770
לתת לנו מדד אפס.

79
00:04:28,770 --> 00:04:32,180
לאות B, זה ייתן לי
שלנו המדד 1, וכן הלאה.

80
00:04:32,180 --> 00:04:37,070
>> אז זה נותן לנו המדד ל
מערך ילדים שאנחנו רוצים.

81
00:04:37,070 --> 00:04:42,540
עכשיו, אם מדד זה הוא ריק כרגע
מערך הילדים, זה אומר ש

82
00:04:42,540 --> 00:04:47,470
צומת אינה קיימת כיום מ
נתיב זה, ולכן אנחנו צריכים להקצות

83
00:04:47,470 --> 00:04:49,220
צומת לנתיב.

84
00:04:49,220 --> 00:04:50,610
זה מה שאנחנו עושים פה.

85
00:04:50,610 --> 00:04:54,650
אז אנחנו הולכים, שוב, השתמשו בCalloc
פונקציה, כך שאין לנו

86
00:04:54,650 --> 00:05:00,130
כדי לאפס את כל המצביעים, ואנחנו,
שוב, צריך לבדוק שCalloc

87
00:05:00,130 --> 00:05:01,300
לא נכשל.

88
00:05:01,300 --> 00:05:04,760
אם Calloc לא להיכשל, אז אנחנו צריכים
לפרוק הכל, לסוגרנו

89
00:05:04,760 --> 00:05:06,880
מילון, ולחזור שקר.

90
00:05:06,880 --> 00:05:14,110
>> אז בהנחה שזה לא נכשל, ולאחר מכן
זה יהיה ליצור ילד חדש עבורנו,

91
00:05:14,110 --> 00:05:16,000
ואז אנחנו נלך לילד הזה.

92
00:05:16,000 --> 00:05:19,030
הסמן שלנו לחזר
עד אותו ילד.

93
00:05:19,030 --> 00:05:23,390
עכשיו, אם זה לא היה ריק מלכתחילה,
לאחר מכן הסמן יכול רק לחזר

94
00:05:23,390 --> 00:05:26,650
עד שהילד מבלי
יש להקצות כל דבר.

95
00:05:26,650 --> 00:05:30,790
זה המקרה שבו אנו קרו ראשון
להקצות את מילת החתול, ו

96
00:05:30,790 --> 00:05:34,390
זה אומר שכאשר אנחנו הולכים להקצות
קטסטרופה, אנחנו לא צריכים ליצור

97
00:05:34,390 --> 00:05:35,720
בלוטות לC-A-T שוב.

98
00:05:35,720 --> 00:05:37,620
הם כבר קיימים.

99
00:05:37,620 --> 00:05:40,140
>> אוקיי, אז מה הוא Else זה?

100
00:05:40,140 --> 00:05:44,600
זה המצב שבו היה ג
n הלוכסן ההפוך, שבו ג היה קו חדש.

101
00:05:44,600 --> 00:05:47,780
משמעות דבר היא שיש לנו בהצלחה
השלים מילה.

102
00:05:47,780 --> 00:05:51,020
עכשיו, מה שאנחנו רוצים לעשות כשאנחנו
הושלם בהצלחה מילה?

103
00:05:51,020 --> 00:05:55,250
אנחנו הולכים להשתמש במילת תחום זה
בתוך צומת Struct שלנו.

104
00:05:55,250 --> 00:06:00,570
>> אנחנו רוצים להגדיר את זה נכון, כדי ש
מצביע על כך שפסק זו מצביעה

105
00:06:00,570 --> 00:06:03,320
מילה מוצלחת מילה בפועל.

106
00:06:03,320 --> 00:06:05,050
כעת, קבע כי ל-True.

107
00:06:05,050 --> 00:06:09,210
אנחנו רוצים לאפס את הסמן שלנו לנקודה
לתחילת איירי שוב.

108
00:06:09,210 --> 00:06:13,510
ולבסוף, להגדיל המילון שלנו
גודל מאז שמצאנו מילה אחרת.

109
00:06:13,510 --> 00:06:16,450
>> בסדר, אז אנחנו הולכים להמשיך לעשות
כי, קריאה בתווים על ידי

110
00:06:16,450 --> 00:06:21,960
אופי, בניית צמתים חדשים ב
איירי ועבור כל מילה ב

111
00:06:21,960 --> 00:06:26,810
מילון, עד שסוף סוף תגיעו לג
שווה EOF, ובמקרה זה, אנחנו שוברים

112
00:06:26,810 --> 00:06:28,100
מתוך הקובץ.

113
00:06:28,100 --> 00:06:31,110
עכשיו, יש שני מקרים תחת
שבו אנו יכולים להיות פגעו EOF.

114
00:06:31,110 --> 00:06:35,680
הראשון הוא אם יש שגיאה
קריאה מהקובץ, כך שאם לא היה

115
00:06:35,680 --> 00:06:39,280
טעות, אנחנו צריכים לעשות טיפוסיים
לפרוק הכל, לסגור את התיק,

116
00:06:39,280 --> 00:06:40,520
בתמורת שווא.

117
00:06:40,520 --> 00:06:43,870
בהנחה שלא הייתה טעות, כי
רק אומר שאנחנו באמת פגעו בסופו של

118
00:06:43,870 --> 00:06:47,820
את הקובץ, ובמקרה זה, אנחנו סוגרים
להגיש ולהחזיר נכון מאז ש

119
00:06:47,820 --> 00:06:51,010
העמיס את המילון בהצלחה
לאיירי שלנו.

120
00:06:51,010 --> 00:06:54,240
>> כל כך עכשיו בואו הנכון,
הוצא.

121
00:06:54,240 --> 00:06:58,780
כאשר מסתכלים על פונקצית עזיבה, אנו רואים
בדוק כי הוא הולך לחזור בול.

122
00:06:58,780 --> 00:07:03,740
זה מחזיר True אם המילה הזאת שזה
שעבר הוא באיירי שלנו.

123
00:07:03,740 --> 00:07:06,170
היא מחזירה שקר אחר.

124
00:07:06,170 --> 00:07:10,110
>> אז איך אנחנו הולכים לקבוע אם
מילה זו היא באיירי שלנו?

125
00:07:10,110 --> 00:07:14,270
אנו רואים כאן, בדיוק כמו בעבר,
אנחנו הולכים להשתמש בסמן ללחזר

126
00:07:14,270 --> 00:07:16,010
דרך איירי שלנו.

127
00:07:16,010 --> 00:07:20,650
עכשיו, הנה, אנחנו הולכים לחזר
על כל המילה שלנו.

128
00:07:20,650 --> 00:07:24,680
אז iterating מעל המילה אנחנו
עברתי, אנחנו הולכים כדי לקבוע את

129
00:07:24,680 --> 00:07:29,280
מדד לתוך מערך שהילדים
מתאים לi סוגר מילה.

130
00:07:29,280 --> 00:07:34,150
אז זה הולך להיראות בדיוק כמו
עומס, שבו אם אני הוא מילת סוגר

131
00:07:34,150 --> 00:07:38,110
גרש, אז אנחנו רוצים להשתמש במדד
האלפבית מינוס 1 כי אנחנו נחושים

132
00:07:38,110 --> 00:07:41,160
כי מקום שבו אנחנו הולכים
כדי לאחסן את הגרשיים.

133
00:07:41,160 --> 00:07:44,440
>> עוד אנחנו הולכים להשתמש tolower
מילת סוגר i.

134
00:07:44,440 --> 00:07:48,270
אז לזכור מילה שיכולה להיות שרירותי
היוון, ולכן אנחנו

135
00:07:48,270 --> 00:07:51,590
רוצה לוודא שאנחנו משתמשים
גרסה קטנה של דברים.

136
00:07:51,590 --> 00:07:55,300
וכך להפחית מאותיות קטנות כי
ל, שוב, לתת לנו

137
00:07:55,300 --> 00:07:57,940
עמדת אלפביתי
אופי זה.

138
00:07:57,940 --> 00:08:01,740
אז זה הולך להיות האינדקס שלנו
לתוך המערך לילדים.

139
00:08:01,740 --> 00:08:06,480
>> ועכשיו, אם מדד שלילדים
המערך הוא ריק, זה אומר שאנחנו

140
00:08:06,480 --> 00:08:09,050
כבר לא יכול להמשיך iterating
למטה איירי שלנו.

141
00:08:09,050 --> 00:08:13,320
אם זה המקרה, מילה זו לא יכולה
אולי יהיה באיירי שלנו, שכן אם זה

142
00:08:13,320 --> 00:08:18,000
היו, זה אומר שלא יהיה
הדרך למטה למילה הזאת, ושהיית

143
00:08:18,000 --> 00:08:19,350
אף פעם לא נתקל באפס.

144
00:08:19,350 --> 00:08:21,910
אז נתקל null, אנחנו חוזרים שקר.

145
00:08:21,910 --> 00:08:23,810
המילה אינה נמצאת במילון.

146
00:08:23,810 --> 00:08:28,200
אם זה לא היה ריק, ואז אנחנו הולכים
תמשיך חוזר ונשנית, ולכן אנחנו הולכים

147
00:08:28,200 --> 00:08:33,150
לעדכן את הסמן שלנו כדי להצביע על כי
צומת מסוימת במדד זה.

148
00:08:33,150 --> 00:08:36,659
>> אז אנחנו ממשיכים לעשות את זה לאורך כל
המילה כולה.

149
00:08:36,659 --> 00:08:40,630
בהנחה שאנחנו אף פעם לא פגעו null, שאמצעי
היינו יכול לעבור את כולו

150
00:08:40,630 --> 00:08:44,840
עולם ולמצוא צומת באיירי שלנו,
אבל אנחנו לא ממש נעשו עדיין.

151
00:08:44,840 --> 00:08:46,350
אנחנו לא רוצים רק כדי לחזור נכון.

152
00:08:46,350 --> 00:08:51,400
אנחנו רוצים לחזור מילת שגיאת סמן
מאז, זכור שוב, אם חתול לא

153
00:08:51,400 --> 00:08:55,140
במילון ואסוננו הוא,
אז אנחנו תקבלו בהצלחה באמצעות

154
00:08:55,140 --> 00:08:59,810
מילת החתול, אבל מילת סמן
יהיה לא נכון ולא נכון.

155
00:08:59,810 --> 00:09:04,990
אז אנחנו חוזרים מילת סמן כדי לציין
אם פסק זו היא למעשה מילה,

156
00:09:04,990 --> 00:09:06,530
וזה אותו לבדיקה.

157
00:09:06,530 --> 00:09:08,310
>> אז בואו לבדוק את גודל.

158
00:09:08,310 --> 00:09:11,410
אז גודל הולך להיות די קל
מאז, זכרו בעומס, אנחנו

159
00:09:11,410 --> 00:09:15,480
להגדיל כל גודל מילון
כל מילה שאנו פוגשים.

160
00:09:15,480 --> 00:09:20,820
אז גודל הוא רק הולך לחזור
גודל מילון, וזהו זה.

161
00:09:20,820 --> 00:09:24,650
>> בסדר, אז לבסוף, יש לנו לפרוק.

162
00:09:24,650 --> 00:09:29,050
אז לפרוק, אנחנו הולכים להשתמש
פונקציה רקורסיבית בעצם לעשות את כל

163
00:09:29,050 --> 00:09:33,390
של העבודה בשבילנו, ולכן הפונקציה שלנו
הוא הולך להיקרא פורק.

164
00:09:33,390 --> 00:09:35,830
מה פורק הוא הולך לעשות?

165
00:09:35,830 --> 00:09:40,640
אנו רואים כאן פורקים כי הוא הולך
לחזר על כל הילדים ב

166
00:09:40,640 --> 00:09:45,810
צומת המסוימת הזה, ואם הילד
הצומת היא לא ריקה, אז אנחנו הולכים

167
00:09:45,810 --> 00:09:47,760
לפרוק את צומת הילד.

168
00:09:47,760 --> 00:09:52,070
>> אז זה הולך באופן רקורסיבי
לפרוק את כל הילדים שלנו.

169
00:09:52,070 --> 00:09:55,140
ברגע שאנחנו בטוחים שכל הילדים שלנו
כבר פרק, אז אנחנו

170
00:09:55,140 --> 00:09:58,830
יכול לשחרר את עצמנו, אז לפרוק את עצמנו.

171
00:09:58,830 --> 00:10:04,550
אז זה באופן רקורסיבי יהיה לפרוק
כל איירי, ואז ברגע זה

172
00:10:04,550 --> 00:10:06,910
עשיתי, אנחנו יכולים רק לחזור נכון.

173
00:10:06,910 --> 00:10:09,770
לפרוק לא יכול להיכשל, אנחנו
רק לשחרר את הדברים.

174
00:10:09,770 --> 00:10:12,985
אז ברגע שנסיים לשחרר
הכל, החזר אמיתי.

175
00:10:12,985 --> 00:10:14,380
וזהו זה.

176
00:10:14,380 --> 00:10:16,792
השם שלי הוא רוב, וזה
היה [לא ברור].

177
00:10:16,792 --> 00:10:21,888