1
00:00:00,000 --> 00:00:09,700

2
00:00:09,700 --> 00:00:12,140
>> ZAMYLA צ'אן: בואו נעשה את
בודק איות.

3
00:00:12,140 --> 00:00:16,900
אם אתה פותח speller.c, אז אתה תראה
כי רוב פונקציונלי עבור

4
00:00:16,900 --> 00:00:20,810
בדיקת קובץ טקסט נגד
מילון הוא כבר עשה בשבילך.

5
00:00:20,810 --> 00:00:26,330
. / איות, עוברת בטקסט מילון
להגיש ואז עוד קובץ טקסט,

6
00:00:26,330 --> 00:00:28,960
יבדוק שקובץ הטקסט
כנגד המילון.

7
00:00:28,960 --> 00:00:34,160
>> עכשיו, קבצי טקסט מילון יכילו
מילות תקפות, אחד בכל שורה.

8
00:00:34,160 --> 00:00:37,910
אז speller.c יקרא טען
בקובץ טקסט המילון.

9
00:00:37,910 --> 00:00:43,650
זה יהיה לקרוא לפונקציה שנקראת בדוק על
כל מילה בקובץ הטקסט שהוזן,

10
00:00:43,650 --> 00:00:46,460
הדפסה כל המילים באיות שגוי.

11
00:00:46,460 --> 00:00:50,030
>> Speller.c גם יקרא לגודל
לקבוע את מספר המילים ב

12
00:00:50,030 --> 00:00:53,500
ביטול טעינת מילון ולקרוא
כדי לפנות מקום בזיכרון.

13
00:00:53,500 --> 00:00:57,600
speller.c גם לעקוב אחר כמה
הרבה זמן הוא משמש כדי לנהל מאלה

14
00:00:57,600 --> 00:01:00,560
תהליכים, אבל אנחנו
תגיע לזה מאוחר יותר.

15
00:01:00,560 --> 00:01:02,440
>> אז מה אנחנו צריכים לעשות?

16
00:01:02,440 --> 00:01:05,110
אנחנו צריכים למלא בdictionary.c.

17
00:01:05,110 --> 00:01:09,940
בdictionary.c, יש לנו את העוזר
טען פונקציה, שטוען את

18
00:01:09,940 --> 00:01:10,855
מילון.

19
00:01:10,855 --> 00:01:15,490
עזיבה הפונקציה, שבודקת אם
מילת נתונה היא במילון.

20
00:01:15,490 --> 00:01:19,150
גודל הפונקציה מחזיר את המספר
של מילות במילון.

21
00:01:19,150 --> 00:01:24,870
ולבסוף, יש לנו לפרוק, אשר
משחרר את המילון מזיכרון.

22
00:01:24,870 --> 00:01:27,070
>> אז קודם כל, בואו להתמודד עם עומס.

23
00:01:27,070 --> 00:01:32,110
לכל מילה בטקסט המילון
קובץ, עומס יהיה לאחסן את המילים האלה ב

24
00:01:32,110 --> 00:01:34,860
מבנה נתוני מילון
על פי הבחירה, גם שלך

25
00:01:34,860 --> 00:01:36,750
חשיש שולחן או הגיבורים.

26
00:01:36,750 --> 00:01:39,440
אני אלך על שניהם ב
זה ללכת דרך.

27
00:01:39,440 --> 00:01:43,150
>> ראשית בואו נדבר על שולחנות חשיש.

28
00:01:43,150 --> 00:01:47,050
אומר שהיה לך 10 כדורי ביליארד ו
אתה רוצה לאחסן אותם.

29
00:01:47,050 --> 00:01:50,420
אתה יכול לשים את כולם בדלי,
וכאשר אתה צורך ספציפי

30
00:01:50,420 --> 00:01:54,010
ממוספר כדור, הייתי לך לקחת את אחד
מתוך הדלי בכל פעם

31
00:01:54,010 --> 00:01:55,880
מחפש את הכדור.

32
00:01:55,880 --> 00:01:59,370
ועם רק 10 כדורים, אתה צריך להיות
תוכל למצוא את הכדור בסביר

33
00:01:59,370 --> 00:02:01,160
כמות של זמן.

34
00:02:01,160 --> 00:02:03,180
>> אבל מה אם היה לך 20 כדורים?

35
00:02:03,180 --> 00:02:05,480
זה עלול לקחת קצת יותר זמן עכשיו.

36
00:02:05,480 --> 00:02:06,180
מה לגבי 100?

37
00:02:06,180 --> 00:02:07,880
1,000?

38
00:02:07,880 --> 00:02:11,590
עכשיו, זה יהיה הרבה יותר קל אם
היו לך דליים מרובים.

39
00:02:11,590 --> 00:02:15,890
אולי דלי אחד לכדורים ממוספרים אפס
עד תשע, עוד דלי ל

40
00:02:15,890 --> 00:02:18,800
כדורים ממוספרים 10 דרך
19, וכן הלאה.

41
00:02:18,800 --> 00:02:22,330
>> עכשיו כשאתה צריך לחפש ספציפי
כדור, אתה עלול באופן אוטומטי

42
00:02:22,330 --> 00:02:26,320
ללכת לדלי אחד ספציפי ו
חיפוש באמצעות דלי ש.

43
00:02:26,320 --> 00:02:29,840
ואם כל אחד מהסלים יש כ 10
כדורים, אז אתה יכול לחפש בקלות

44
00:02:29,840 --> 00:02:31,790
דרכו.

45
00:02:31,790 --> 00:02:34,960
>> עכשיו, עם שכן יש לנו עסק
מילונים, דלי אחד ל

46
00:02:34,960 --> 00:02:41,970
את כל המילים במילון יהיה
כנראה יהיה הרבה פחות מדי דליים.

47
00:02:41,970 --> 00:02:44,370
אז בואו נסתכל על שולחנות חשיש.

48
00:02:44,370 --> 00:02:46,940
>> תחשוב על זה כמו מערך של דליים.

49
00:02:46,940 --> 00:02:50,370
ובמקרה הזה, הדליים
הן הרשימות המקושרות שלנו.

50
00:02:50,370 --> 00:02:54,770
ואנחנו אחלק את כל המילים שלנו
בין הרשימות המקושרות אלה מרובים ב

51
00:02:54,770 --> 00:02:58,940
דרך מאורגנת באמצעות פונקצית חשיש,
שיגיד לנו ש

52
00:02:58,940 --> 00:03:03,720
דלי מפתח נתון, נתון
מילה, שייכת.

53
00:03:03,720 --> 00:03:05,960
>> בואו לייצג את זה באופן סכמטי.

54
00:03:05,960 --> 00:03:11,320
קופסות הכחולות כאן מכילות ערכים ו
תיבות אדומות מצביעות על ערך אחר

55
00:03:11,320 --> 00:03:12,280
זוג מצביע.

56
00:03:12,280 --> 00:03:14,800
אנחנו קוראים לצומת זוגות אלה.

57
00:03:14,800 --> 00:03:18,260
עכשיו, כל אחד מהסלים, כפי שאמרתי
קודם לכן, היא רשימה מקושרת.

58
00:03:18,260 --> 00:03:21,820
ברשימות מקושרות, יש כל צומת ערך,
כמו גם מצביע ל

59
00:03:21,820 --> 00:03:23,170
הערך הבא.

60
00:03:23,170 --> 00:03:26,150
>> עכשיו, העוסק ברשימות מקושרות,
זה מאוד חשוב כי אתה

61
00:03:26,150 --> 00:03:28,120
לא לאבד את כל קישורים.

62
00:03:28,120 --> 00:03:32,250
ועובדה נוספת שיש לזכור היא ש
צומת שעברה, אם זה לא מצביע על

63
00:03:32,250 --> 00:03:35,120
צומת אחר, מצביע על null.

64
00:03:35,120 --> 00:03:37,970
>> אז איך אנחנו מייצגים את זה ב-C?

65
00:03:37,970 --> 00:03:40,540
אנו מגדירים struct שלנו כאן.

66
00:03:40,540 --> 00:03:44,850
והערך במקרה זה הוא
מערך תווים של אורך.

67
00:03:44,850 --> 00:03:48,880
אורך בתוספת 1, שבו אורך הוא
אורך מרבי של כל מילה, בתוספת 1 ל

68
00:03:48,880 --> 00:03:50,380
השליחות קטלנית null.

69
00:03:50,380 --> 00:03:54,210
ואז יש לנו מצביע
צומת אחר שנקרא על הבא.

70
00:03:54,210 --> 00:03:56,730
>> אז בואו נעשה רשימה מקושרת קטנה.

71
00:03:56,730 --> 00:04:00,390
ראשית, אתה רוצה malloc הצומת שלך,
אשר יוצר מקום בזיכרון

72
00:04:00,390 --> 00:04:04,010
גודלו של סוג הצומת שלך.

73
00:04:04,010 --> 00:04:06,100
ולהפוך את צומת אחר,
mallocing שוב.

74
00:04:06,100 --> 00:04:09,370

75
00:04:09,370 --> 00:04:14,340
>> עכשיו, אם אתה רוצה להקצות ערך ל
מילה, אז אפשר לומר חץ node1

76
00:04:14,340 --> 00:04:18,820
מילה שווה "הלו". מפעיל חץ זה
dereferences המצביע ו

77
00:04:18,820 --> 00:04:20,620
כניסות המשתנים של struct.

78
00:04:20,620 --> 00:04:24,330
בדרך זו, אנו לא צריכים להשתמש בשתי
הנקודה ומפעיל הכוכב.

79
00:04:24,330 --> 00:04:30,100
>> אז יש לי מילת החץ node2 שווה
"עולם". ושם, הערכים

80
00:04:30,100 --> 00:04:33,110
מאוכלס בבלוטות שלי.

81
00:04:33,110 --> 00:04:38,780
כדי להפוך את הקישורים, אני אעבור בnode1
חץ הבא, גישה שלכוכב צומת,

82
00:04:38,780 --> 00:04:44,160
שמצביע הצומת, שווה node2,
מצביע node1 לnode2 שתיים.

83
00:04:44,160 --> 00:04:46,360
ויש לנו רשימה מקושרת.

84
00:04:46,360 --> 00:04:51,480
>> אז זה היה רק ​​רשימה מקושרת אחד, אבל
שולחן חשיש הוא מערך של כל

85
00:04:51,480 --> 00:04:52,520
רשימות מקושרות.

86
00:04:52,520 --> 00:04:55,920
ובכן, תהיה לנו את אותו צומת
מבנה כמו קודם.

87
00:04:55,920 --> 00:05:00,140
אבל אם אנחנו רוצים שולחן חשיש בפועל,
אז אנחנו יכולים רק לעשות את מצביע צומת

88
00:05:00,140 --> 00:05:01,330
מערך כאן.

89
00:05:01,330 --> 00:05:04,940
לדוגמא, גודל 500.

90
00:05:04,940 --> 00:05:08,910
>> עכשיו שימו לב, יש הולך להיות מסחרי
off בין הגודל שלך

91
00:05:08,910 --> 00:05:11,280
שולחן חשיש והגודל
של הרשימות המקושרות שלך.

92
00:05:11,280 --> 00:05:15,640
אם יש לך מספר ממש גבוה של
דליים, לדמיין צורך לרוץ חזרה

93
00:05:15,640 --> 00:05:18,230
ושוב בקו ל
למצוא הדלי שלך.

94
00:05:18,230 --> 00:05:21,530
אבל אתה גם לא רוצה מספר קטן
דליים, כי אז אנחנו חוזרים ל

95
00:05:21,530 --> 00:05:26,850
הבעיה המקורית של איך שיש
כדורים רבים מדי בדלי שלנו.

96
00:05:26,850 --> 00:05:30,480
>> בסדר, אבל איפה הכדור שלנו הולך?

97
00:05:30,480 --> 00:05:33,150
ובכן, ראשית עלינו
יש כדור, נכון?

98
00:05:33,150 --> 00:05:39,130
אז בואו malloc צומת לכל
מילה חדשה שיש לנו.

99
00:05:39,130 --> 00:05:42,900
צומת * שווים new_node
malloc (sizeof (צומת)).

100
00:05:42,900 --> 00:05:46,760
>> עכשיו שיש לנו את המבנה הזה, אנחנו
ניתן לסרוק ב, באמצעות הפונקציה

101
00:05:46,760 --> 00:05:51,850
fscanf, מחרוזת מהקובץ שלנו, אם
זה קובץ מילון, לתוך

102
00:05:51,850 --> 00:05:55,780
מילת חץ new_node, שם new_node
מילת חץ היא שלנו

103
00:05:55,780 --> 00:05:58,110
יעד של המילה.

104
00:05:58,110 --> 00:06:01,900
>> בשלב הבא, אנחנו רוצים חשיש ש
מילה באמצעות פונקצית חשיש.

105
00:06:01,900 --> 00:06:05,860
פונקציית hash לוקחת מחרוזת
ומחזיר את אינדקס.

106
00:06:05,860 --> 00:06:09,760
במקרה זה, המדד צריך
להיות פחות ממספר

107
00:06:09,760 --> 00:06:11,440
דליים שיש לך.

108
00:06:11,440 --> 00:06:14,600
>> עכשיו, פונקציות חשיש, כאשר אתה מנסה
למצוא אחד וליצור אחד

109
00:06:14,600 --> 00:06:17,890
משלך, יש לזכור כי הם
צריך להיות דטרמיניסטי.

110
00:06:17,890 --> 00:06:22,420
זה אומר שאותו הערך צריך
המפה לאותו דלי בכל פעם

111
00:06:22,420 --> 00:06:23,800
שהחשיש זה.

112
00:06:23,800 --> 00:06:25,300
>> זה כמו סוג של ספרייה.

113
00:06:25,300 --> 00:06:28,560
כשאתה לוקח ספר, המבוסס על
מחבר, אתה יודע איזה מדף הוא צריך

114
00:06:28,560 --> 00:06:31,890
להמשיך, בין אם זה מספר מדף
אחד, שתיים, או שלוש.

115
00:06:31,890 --> 00:06:36,280
וספר שתמיד יהיה שייך על
אף אחד מן המדף, שתיים, או שלוש.

116
00:06:36,280 --> 00:06:39,460

117
00:06:39,460 --> 00:06:43,810
>> לכן, אם מילת חץ new_node יש
מילה מהמילון שלך, אז

118
00:06:43,810 --> 00:06:47,770
מילת חץ new_node ליבון תהיה
נותן המדד שלנו

119
00:06:47,770 --> 00:06:49,370
דלי של שולחן החשיש.

120
00:06:49,370 --> 00:06:54,040
ואז אנחנו נכניס את זה לתוך זה
רשימה ספציפית קשורה שצוינה על ידי

121
00:06:54,040 --> 00:06:56,060
להחזיר ערך של פונקציית hash שלנו.

122
00:06:56,060 --> 00:06:59,070
>> בואו נסתכל על דוגמא של
החדרת צומת אל

123
00:06:59,070 --> 00:07:01,750
התחלה של רשימה מקושרת.

124
00:07:01,750 --> 00:07:06,930
אם הראש הוא מצביע צומת שמצביעה על
תחילת מקושרת

125
00:07:06,930 --> 00:07:12,420
הרשימה, וnew_node מציין החדש
צומת שאתה רוצה להיכנס ב, רק

126
00:07:12,420 --> 00:07:17,340
הקצאה ועד ראש new_node תאבד
הקישור לשאר הרשימה.

127
00:07:17,340 --> 00:07:19,330
אז אנחנו לא רוצים לעשות את זה.

128
00:07:19,330 --> 00:07:22,160
>> במקום זאת, אנו רוצים לוודא
שאנחנו נאחזים בכל

129
00:07:22,160 --> 00:07:23,550
צומת יחידה בתכנית שלנו.

130
00:07:23,550 --> 00:07:29,560
שווים הבאים חץ new_node אז פועל
ראש ולאחר מכן את הראש שווה new_node

131
00:07:29,560 --> 00:07:34,470
ישמור את כל
קישורים ולא לאבד את כל.

132
00:07:34,470 --> 00:07:39,330
>> אבל מה אם אתה רוצה את הרשימה שלך להיות
מיון, משום שמסודר מקושר

133
00:07:39,330 --> 00:07:42,910
רשימה עשויה להיות קלה יותר עבור
מחפש אותו בשלב מאוחר יותר?

134
00:07:42,910 --> 00:07:46,020
ובכן, בשביל זה, אתה צריך לדעת
איך לעבור רשימות מקושרות.

135
00:07:46,020 --> 00:07:51,210
>> לחצות רשימה מקושרת, בואו
מצביע צומת, * צומת, לפעול כ

136
00:07:51,210 --> 00:07:54,120
הסמן שלך, המציין איזה
צומת שאתה ב, החל

137
00:07:54,120 --> 00:07:55,460
במרכיב הראשון.

138
00:07:55,460 --> 00:08:01,070
הלולאה עד הסמן היא ריקה, אנחנו יכולים
לנהל תהליכים מסוימים ולאחר מכן

139
00:08:01,070 --> 00:08:04,330
לקדם את הסמן כאשר אנחנו צריכים
באמצעות ערך של חץ סמן.

140
00:08:04,330 --> 00:08:08,820
>> זכרו, זה אותו הדבר כמו
אומר סמן כוכב, ביטול הפניה למבנה

141
00:08:08,820 --> 00:08:13,480
סמן, ולאחר מכן באמצעות
ערך מפעיל נקודה.

142
00:08:13,480 --> 00:08:19,000
אז לעדכן את הסמן על ידי הקצאה
את הסמן לחץ הסמן הבא.

143
00:08:19,000 --> 00:08:24,960
>> אומר לך לקבוע שD הופך ב
בין C ו-E כדי להכניס את הצומת,

144
00:08:24,960 --> 00:08:30,030
יש נקודת D new_node ל
E צומת, שהוא הסמן הבא.

145
00:08:30,030 --> 00:08:36,409
ואז C, הסמן, יכול לאחר מכן הצבע
לד בדרך זו, לשמור על רשימה.

146
00:08:36,409 --> 00:08:41,080
היזהר לא לאבד את הקישורים שלך על ידי
הזזת סמן החץ לצד D

147
00:08:41,080 --> 00:08:43,929
מייד.

148
00:08:43,929 --> 00:08:44,620
>> בסדר.

149
00:08:44,620 --> 00:08:48,920
אז ככה אתה יכול להכניס את צמתים,
לטעון אותם ב, מילות עומס לאלה

150
00:08:48,920 --> 00:08:51,600
צמתים, ולהכניס אותם
לשולחן החשיש שלך.

151
00:08:51,600 --> 00:08:53,580
אז עכשיו בואו נסתכל על ניסיונות.

152
00:08:53,580 --> 00:08:58,540
>> בגיבורים, בכל צומת תכיל
מערך של מצביעים לצומת, אחד לכל

153
00:08:58,540 --> 00:09:02,260
מכתב באלפבית
בתוספת גרש.

154
00:09:02,260 --> 00:09:06,150
וכל אלמנט במערך
יצביע לצומת אחרת.

155
00:09:06,150 --> 00:09:10,130
אם הצומת היא null אז שהמכתב,
הוא לא הולך להיות המכתב הבא של

156
00:09:10,130 --> 00:09:15,690
כל מילה ברצף, משום שכל
מילה מציינת אם זה אחרון

157
00:09:15,690 --> 00:09:18,160
אופייה של מילה או לא.

158
00:09:18,160 --> 00:09:19,750
>> בואו נסתכל על תרשים.

159
00:09:19,750 --> 00:09:22,260
אני מקווה שדברים יהיו
להיות קצת יותר ברור.

160
00:09:22,260 --> 00:09:27,210
בתרשים זה, אנו רואים כי רק
אותיות מסוימות ומחרוזות מסוימות

161
00:09:27,210 --> 00:09:28,190
נמצאים ברשימה החוצה.

162
00:09:28,190 --> 00:09:32,500
אז אתה יכול לעקוב אחר נתיבים מסוימים, ו
כל השבילים האלה יובילו אותך

163
00:09:32,500 --> 00:09:34,020
מילות שונות.

164
00:09:34,020 --> 00:09:37,630
>> אז איך אנחנו מייצגים את זה ב-C?

165
00:09:37,630 --> 00:09:41,910
ובכן, בכל צומת עכשיו הוא הולכת להיות
ערך בוליאני המציין אם

166
00:09:41,910 --> 00:09:46,580
צומת שהיא בסופו של
מילה מסוימת או לא.

167
00:09:46,580 --> 00:09:50,690
ואז זה יהיה גם מערך של
מצביעי צומת נקראים ילדים, ו

168
00:09:50,690 --> 00:09:53,440
יש הולכים להיות 27 שלהם.

169
00:09:53,440 --> 00:09:56,510
ותזכור, גם אתה תרצה
לעקוב אחר הקשר הראשון שלך.

170
00:09:56,510 --> 00:09:59,830
אנחנו הולכים לקרוא לשורש הזה.

171
00:09:59,830 --> 00:10:01,690
>> אז זה המבנה של הגיבורים.

172
00:10:01,690 --> 00:10:05,630
איך אנחנו מייצגים את זה
כמילון?

173
00:10:05,630 --> 00:10:09,890
ובכן, כדי לטעון במילים, לכל
מילה במילון, אתה הולך רוצה

174
00:10:09,890 --> 00:10:11,960
כדי לחזר דרך הגיבורים.

175
00:10:11,960 --> 00:10:16,170
וכל אלמנט בילדים
מתאים לאות אחרת.

176
00:10:16,170 --> 00:10:21,660
>> אז בודק את הערך בילדים
i אינדקס, שבו אני מייצג את

177
00:10:21,660 --> 00:10:24,840
מדד ספציפי של המכתב ש
אתה מנסה להוסיף.

178
00:10:24,840 --> 00:10:28,980
ובכן, אם זה ריק, אז אתה רוצה
malloc צומת חדשה ויש לי ילדים

179
00:10:28,980 --> 00:10:31,110
אני מצביע לצומת.

180
00:10:31,110 --> 00:10:35,630
>> אם זה לא ריק, אז זה אומר ש
שענף נתון, שניתן

181
00:10:35,630 --> 00:10:37,350
מחרוזת, כבר קיימת.

182
00:10:37,350 --> 00:10:40,160
אז אתה פשוט לעבור לכי
צומת חדשה ולהמשיך.

183
00:10:40,160 --> 00:10:43,220
אם אתה בסוף המילה ש
אתה מנסה לטעון ב

184
00:10:43,220 --> 00:10:48,120
מילון, אז אתה יכול להגדיר ש
צומת נוכחית שאתה על לנכון.

185
00:10:48,120 --> 00:10:51,550
>> אז בואו נסתכל על דוגמא של החדרה
המילה "שועל" לשלנו

186
00:10:51,550 --> 00:10:53,070
מילון.

187
00:10:53,070 --> 00:10:56,110
להעמיד פנים שאנחנו מתחילים עם
מילון ריק.

188
00:10:56,110 --> 00:11:01,610
המכתב הראשון, F, יהיה ממוקם
במדד חמישה ילדים של השורשים

189
00:11:01,610 --> 00:11:03,700
מערך ילדים.

190
00:11:03,700 --> 00:11:05,430
אז אנחנו הכניסו שבו

191
00:11:05,430 --> 00:11:14,610
>> לאחר מכן האות O יהיה בילדים
מדד 15, לאחר שפ ואז X

192
00:11:14,610 --> 00:11:20,180
יהיה אפילו מתחת לזה, הסתעפות
את הילדים של O.

193
00:11:20,180 --> 00:11:24,120
ולאחר מכן, כי X הוא האות האחרונה
במילה "השועל", ואז אני הולך

194
00:11:24,120 --> 00:11:27,210
צבע ירוק שכדי לציין כי
זה הסוף של המילה.

195
00:11:27,210 --> 00:11:32,880
ב-C, שיהיה קביעת האם
מילה בוליאנית לערך האמיתי.

196
00:11:32,880 --> 00:11:36,780
>> עכשיו מה אם המילה הבאה שאתה
טעינה בהיא המילה "foo"?

197
00:11:36,780 --> 00:11:41,490
ובכן, אתה לא צריך malloc יותר
מקום לF או לO, כי

198
00:11:41,490 --> 00:11:42,990
אלו שכבר קיימים.

199
00:11:42,990 --> 00:11:45,910
אבל O האחרון בfoo?

200
00:11:45,910 --> 00:11:47,320
אחד שיהיה לך לmalloc.

201
00:11:47,320 --> 00:11:52,390
הפוך צומת חדשה בשביל זה, הגדרה
הוא המילה בוליאנית לנכון.

202
00:11:52,390 --> 00:11:57,340
>> אז עכשיו בואו הכניסו "כלב". כלב
תתחיל עם מדד של שלושה השורשים

203
00:11:57,340 --> 00:12:00,520
ילדים, כי D יש לא
נוצר עדיין.

204
00:12:00,520 --> 00:12:04,990
ואנו עוקבים אחר תהליך דומה כמו
לפני, יצירת כלב המחרוזת,

205
00:12:04,990 --> 00:12:10,400
איפה G הוא בצבע ירוק, כי
זה הסוף של מילה.

206
00:12:10,400 --> 00:12:13,160
>> עכשיו, מה אם אנחנו רוצים להכניס "לעשות"?

207
00:12:13,160 --> 00:12:17,150
ובכן, זה הוא מחרוזת של כלב, ולכן
אנחנו לא צריכים לmalloc יותר.

208
00:12:17,150 --> 00:12:20,800
אבל אנחנו צריכים לעשות כדי לציין היכן יש לנו
הגיע לסוף של המילה.

209
00:12:20,800 --> 00:12:24,020
אז O יהיה בצבע ירוק.

210
00:12:24,020 --> 00:12:27,810
בהמשך תהליך שעל כל אחת
מילה במילון שלך, יש לך

211
00:12:27,810 --> 00:12:32,120
העמיס אותם באל או משלך
חשיש שולחן או הגיבורים שלך.

212
00:12:32,120 --> 00:12:37,530
>> speller.c יעבור במחרוזות עבור
dictionary.c כדי לבדוק אותם.

213
00:12:37,530 --> 00:12:41,140
עכשיו, פונקצית עזיבה יש לפעול
תחת מקרה חוסר רגישות.

214
00:12:41,140 --> 00:12:45,980
זה אומר שאותיות גדולות ו
אותיות קטנות ושילוב של שניהם

215
00:12:45,980 --> 00:12:50,670
צריך כל שווה ל אמיתי אם בכלל
שילוב של שהוא ב

216
00:12:50,670 --> 00:12:51,880
מילון.

217
00:12:51,880 --> 00:12:55,580
ניתן גם להניח שמחרוזות
רק הולך להכיל אלפביתי

218
00:12:55,580 --> 00:12:58,200
תווים או גרשיים.

219
00:12:58,200 --> 00:13:02,490
>> אז בואו נסתכל איך אתה יכול לבדוק
עם מבנה שולחן חשיש.

220
00:13:02,490 --> 00:13:07,330
ובכן, אם המילה קיימת, אז זה
ניתן למצוא בטבלת הגיבוב.

221
00:13:07,330 --> 00:13:12,240
אז אתה יכול לנסות למצוא את זה
מילה בדלי הרלוונטי.

222
00:13:12,240 --> 00:13:14,480
>> אז איזה דלי הייתי מילה שתהיה ב?

223
00:13:14,480 --> 00:13:20,060
ובכן, היית מקבל את המספר, מדד ה
הדלי, על ידי ליבון מילה ש

224
00:13:20,060 --> 00:13:23,690
ולאחר מכן בחיפוש שברשימה מקושרת,
חוצה דרך כל

225
00:13:23,690 --> 00:13:28,060
רשימה מקושרת, תוך שימוש במחרוזת
שקלו את הפונקציה.

226
00:13:28,060 --> 00:13:31,940
>> אם בסוף הרשימה המקושרת הוא
הגיע, כלומר את הסמן

227
00:13:31,940 --> 00:13:36,030
מגיע ריק, ולאחר מכן את המילה אינה
ניתן למצוא במילון.

228
00:13:36,030 --> 00:13:39,090
זה לא יהיה בכל דלי אחר.

229
00:13:39,090 --> 00:13:43,020
אז הנה, אתה עשוי לראות כיצד יש אולי
להיות תחלופה בין שיש גם

230
00:13:43,020 --> 00:13:46,280
מסודרים על רשימות מקושרות או ממוינים אלה.

231
00:13:46,280 --> 00:13:51,180
כך או ייקחו יותר זמן במהלך
לטעון או יותר זמן במהלך בדיקה.

232
00:13:51,180 --> 00:13:53,560
>> איך אתה יכול לבדוק ב
מבנה הגיבורים?

233
00:13:53,560 --> 00:13:56,370
אנחנו הולכים לנסוע כלפי מטה
בגיבורים.

234
00:13:56,370 --> 00:14:00,390
לכל אות במילה שהוזן
שאנחנו בודקים, נלך לזה

235
00:14:00,390 --> 00:14:03,280
מתאים אלמנט בילדים.

236
00:14:03,280 --> 00:14:07,770
>> אם האלמנט שהוא ריק, אז זה אומר
כי אין מחרוזות

237
00:14:07,770 --> 00:14:11,110
המכיל מילת הקלט שלנו, ולכן
המילה באיות שגוי.

238
00:14:11,110 --> 00:14:15,140
אם זה לא ריק, אנחנו יכולים לעבור ל
האות הבאה של המילה שאנחנו

239
00:14:15,140 --> 00:14:18,850
בדיקה ולהמשיך את התהליך הזה
עד שאנחנו מגיעים לסוף

240
00:14:18,850 --> 00:14:20,350
של מילת הקלט.

241
00:14:20,350 --> 00:14:23,330
ואז אנחנו יכולים לבדוק
אם הוא המילה נכונה.

242
00:14:23,330 --> 00:14:24,610
אם כן, אז נהדר.

243
00:14:24,610 --> 00:14:25,590
המילה נכונה.

244
00:14:25,590 --> 00:14:30,890
אבל אם לא, אף על פי שמחרוזת
קיים בגיבורים, המילה היא

245
00:14:30,890 --> 00:14:32,250
באיות שגוי.

246
00:14:32,250 --> 00:14:36,590
>> כאשר גודל הפונקציה נקרא, גודל
צריך להחזיר את מספר המילים ש

247
00:14:36,590 --> 00:14:39,110
נמצא במילון שלך נתון
מבנה הנתונים.

248
00:14:39,110 --> 00:14:42,780
אז אם אתה משתמש בשולחן חשיש, אתה
יכול גם לעבור בכל אחת

249
00:14:42,780 --> 00:14:45,860
רשימה מקושרת בכל אחת
דלי לספור את המספר

250
00:14:45,860 --> 00:14:47,130
מילים נמצאים שם.

251
00:14:47,130 --> 00:14:49,940
אם אתה משתמש בגיבורים, אתה יכול
לעבור כל null שאינו

252
00:14:49,940 --> 00:14:52,030
נתיב בגיבורים שלך.

253
00:14:52,030 --> 00:14:56,420
או בזמן שאתה טוען את המילון
ב, אולי אתה יכול לעקוב אחר כמה

254
00:14:56,420 --> 00:14:58,760
מילות רבות שאתה מעמיס פנימה

255
00:14:58,760 --> 00:15:03,180
>> ברגע שיסיים את בדיקת speller.c
קובץ טקסט נגד המילון, ולאחר מכן

256
00:15:03,180 --> 00:15:08,010
עושה את זה ולכן הוא קורא לפרוק, שבו
התפקיד שלך הוא לשחרר את כל דבר

257
00:15:08,010 --> 00:15:09,500
כי אתה כבר malloced.

258
00:15:09,500 --> 00:15:14,420
אז אם אתה משתמש בשולחן חשיש, אז אתה
צריך להיות זהיר במיוחד, כדי למנוע

259
00:15:14,420 --> 00:15:18,830
דליפות זיכרון בכך שלא לשחרר שום דבר
בטרם עת ומחזיק בכל

260
00:15:18,830 --> 00:15:20,780
קישור אחד לפני שאתה חופשי.

261
00:15:20,780 --> 00:15:24,680

262
00:15:24,680 --> 00:15:30,100
>> אז לכל אלמנט בטבלת החשיש
ועבור כל צומת ברשימה המקושרת,

263
00:15:30,100 --> 00:15:32,370
אתה רוצה לשחרר את הצומת.

264
00:15:32,370 --> 00:15:34,970
איך אתה הולך על שחרור
רשימה מקושרת?

265
00:15:34,970 --> 00:15:38,570
הגדרת הסמן מצביע הצומת שלך
הראש, ועד לתחילת

266
00:15:38,570 --> 00:15:43,100
רשימה מקושרת, אז בזמן שהסמן
הוא לא ריק, אתה יכול להגדיר זמני

267
00:15:43,100 --> 00:15:45,610
מצביע צומת לסמן שלך.

268
00:15:45,610 --> 00:15:48,370
לאחר מכן לקדם את הסמן.

269
00:15:48,370 --> 00:15:52,950
ואז אתה יכול לשחרר את זה זמני
בזמן שערך עדיין מחזיק ב

270
00:15:52,950 --> 00:15:55,650
כל מה שלאחר מכן.

271
00:15:55,650 --> 00:15:57,800
>> מה אם אתה משתמש בגיבורים?

272
00:15:57,800 --> 00:16:00,410
אז הדרך הטובה ביותר לעשות זאת
הוא לפרוק ממאוד

273
00:16:00,410 --> 00:16:02,290
תחתון לעליון.

274
00:16:02,290 --> 00:16:06,920
על ידי נסיעה הנמוכה ביותר האפשרי
צומת, אתה יכול לשחרר את כל המצביעים ב

275
00:16:06,920 --> 00:16:11,430
כי ילדים ולאחר מכן לחזור על עקבות
כלפי מעלה, לשחרר את כל האלמנטים בכל

276
00:16:11,430 --> 00:16:15,610
של מערכי ילדים, עד
אתה מכה צומת השורש העליונה שלך.

277
00:16:15,610 --> 00:16:18,920
כאן המקום רקורסיה
יהיה שימושי.

278
00:16:18,920 --> 00:16:22,780
>> כדי לוודא שיש לך כנראה ישוחרר
כל מה שיש לך malloced,

279
00:16:22,780 --> 00:16:24,400
אתה יכול להשתמש Valgrind.

280
00:16:24,400 --> 00:16:28,640
פועל Valgrind יהיה להפעיל את התכנית שלך
לספור כמה בתים של זיכרון

281
00:16:28,640 --> 00:16:32,440
אתה משתמש ולוודא שיש לך
שחרר את כולם, אומר לך

282
00:16:32,440 --> 00:16:34,530
שבו אתה יכול להיות
שכחתי חופשי.

283
00:16:34,530 --> 00:16:38,390
אז להריץ את זה וברגע שאומר לך Valgrind
ונותן לך ללכת קדימה, ולאחר מכן

284
00:16:38,390 --> 00:16:41,160
שתסיים לפרוק.

285
00:16:41,160 --> 00:16:44,420
>> עכשיו, כמה טיפים לפני שאתה הולך
את ולהתחיל ביישום שלך

286
00:16:44,420 --> 00:16:46,260
מילון.

287
00:16:46,260 --> 00:16:49,650
הייתי ממליץ לעבור בקטן יותר
מילון כשאתה מנסה לבדוק

288
00:16:49,650 --> 00:16:52,620
דברים החוצה וניפוי שגיאות בתמ"ג.

289
00:16:52,620 --> 00:16:58,550
השימוש באיות הוא. / איות,
מילון אופציונלי ולאחר מכן טקסט.

290
00:16:58,550 --> 00:17:01,550
>> כברירת מחדל, הוא טוען ב
המילון הגדול.

291
00:17:01,550 --> 00:17:06,670
אז אולי כדאי לך לעבור בקטן
מילון, או אולי אפילו לגרום לך

292
00:17:06,670 --> 00:17:11,819
המילון שלו, ההתאמה האישית שלך
וקובץ הטקסט שלך.

293
00:17:11,819 --> 00:17:15,950
>> ולבסוף, הייתי גם ממליץ
לקחת עט ונייר ולצייר

294
00:17:15,950 --> 00:17:20,490
דברים לפני, במהלך, ואחרי
שכתבת את כל הקוד שלך.

295
00:17:20,490 --> 00:17:24,170
רק לוודא שיש לך
המצביעים האלה בדיוק.

296
00:17:24,170 --> 00:17:26,480
>> אני מאחל לך את הטוב ביותר של מזל.

297
00:17:26,480 --> 00:17:29,690
וברגע שתסיים, אם תרצה
לקרוא תיגר על הלוח וגדול

298
00:17:29,690 --> 00:17:34,390
לראות כמה מהר את התכנית שלך היא לעומת
'החברים לכיתה שלך, אז אני ממליץ

299
00:17:34,390 --> 00:17:35,960
לך לבדוק את זה.

300
00:17:35,960 --> 00:17:39,220
>> עם זה, שתסיים
PSet האיות.

301
00:17:39,220 --> 00:17:41,800
השם שלי הוא Zamyla, וזה CS50.

302
00:17:41,800 --> 00:17:49,504