1
00:00:00,000 --> 00:00:08,250

2
00:00:08,250 --> 00:00:12,680
>> ג'ייסון הירשהורן: ברוכים הבאים לכולם
לסעיף שבע.

3
00:00:12,680 --> 00:00:15,040
אנחנו בשבוע של הקורס שבעה.

4
00:00:15,040 --> 00:00:18,440
וביום חמישי הקרוב זה
ליל כל הקדושים הוא כל כך אני

5
00:00:18,440 --> 00:00:21,420
התלבש כמו דלעת.

6
00:00:21,420 --> 00:00:23,460
לא יכולתי להתכופף ולשים על
הנעליים שלי, אז בגלל זה אני

7
00:00:23,460 --> 00:00:25,660
רק לובש גרביים.

8
00:00:25,660 --> 00:00:29,220
אני גם לא לובש שום דבר מתחת
זה, ולכן אני לא יכול לקחת אותו אם זה

9
00:00:29,220 --> 00:00:29,950
מסיח את דעתך.

10
00:00:29,950 --> 00:00:31,860
אני מתנצל מראש על כך.

11
00:00:31,860 --> 00:00:33,170
אתה לא צריך לדמיין
מה קורה.

12
00:00:33,170 --> 00:00:34,240
אני לובש את תחתוני הבוקסר.

13
00:00:34,240 --> 00:00:36,170
אז זה הכול טוב.

14
00:00:36,170 --> 00:00:41,120
>> יש לי סיפור ארוך על למה אני
לבושים כדלעת, אבל אני הולך

15
00:00:41,120 --> 00:00:45,110
תשמור את זה למועד מאוחר יותר בסעיף זה
כי אני רוצה להתחיל.

16
00:00:45,110 --> 00:00:47,720
יש לנו הרבה דברים מרגשים
ללכת על זה שבוע.

17
00:00:47,720 --> 00:00:51,810
רובם מתייחסים באופן ישיר לכך
הסט של שבוע בעיה, שגיאות כתיב.

18
00:00:51,810 --> 00:00:54,680
אנחנו הולכים להיות הולכים על מקושרים
רשימות וטבלאות חשיש

19
00:00:54,680 --> 00:00:57,160
לכל הסעיף.

20
00:00:57,160 --> 00:01:02,490
אני שם את הרשימה הזאת מדי שבוע, רשימה של
משאבים כדי שתוכלו לעזור לך עם

21
00:01:02,490 --> 00:01:04,120
החומר בקורס הזה.

22
00:01:04,120 --> 00:01:07,600
אם בהפסד או אם מחפש קצת
מידע נוסף, לבדוק את אחד

23
00:01:07,600 --> 00:01:09,930
משאבים אלה.

24
00:01:09,930 --> 00:01:14,530
>> שוב, pset6 הוא שגיאות כתיב,
pset של השבוע.

25
00:01:14,530 --> 00:01:17,690
וזה גם מעודד אותך, ואני
ממליץ לך, להשתמש בחלק אחר

26
00:01:17,690 --> 00:01:20,320
משאבים במיוחד עבור pset זה.

27
00:01:20,320 --> 00:01:23,390
בפרט, יש לי שלוש
מופיע על המסך -

28
00:01:23,390 --> 00:01:27,160
gdb, שאנחנו כבר מכירים
וכבר שימוש במשך זמן מה עכשיו, הוא

29
00:01:27,160 --> 00:01:29,270
הולך להיות מאוד מועיל בשבוע זה.

30
00:01:29,270 --> 00:01:30,190
אז שמתי את זה כאן.

31
00:01:30,190 --> 00:01:32,910
אבל בכל פעם שאתה עובד עם C,
אתה צריך להיות תמיד באמצעות gdb כדי

32
00:01:32,910 --> 00:01:34,430
באגים בתוכניות שלך.

33
00:01:34,430 --> 00:01:36,660
השבוע גם valgrind.

34
00:01:36,660 --> 00:01:38,535
האם מישהו יודע מה valgrind עושה?

35
00:01:38,535 --> 00:01:42,184

36
00:01:42,184 --> 00:01:43,890
>> קהל: בודק זה לדליפות זיכרון?

37
00:01:43,890 --> 00:01:45,950
>> ג'ייסון הירשהורן: Valgrind
בדיקות לדליפות זיכרון.

38
00:01:45,950 --> 00:01:49,970
אז אם לך משהו malloc בך
תכנית, אתה שואל לזיכרון.

39
00:01:49,970 --> 00:01:52,920
בסוף התכנית שלך, יש לך
לכתוב חופשי על כל מה שיש לך

40
00:01:52,920 --> 00:01:54,800
malloced לתת הזיכרון בחזרה.

41
00:01:54,800 --> 00:01:58,420
אם אתה לא כותב חופשי בסוף ו
התכנית שלך מגיעה למסקנה,

42
00:01:58,420 --> 00:02:00,000
הכל באופן אוטומטי
להיות משוחרר.

43
00:02:00,000 --> 00:02:02,340
ולתוכניות קטנות, זה
לא כזה עניין גדול.

44
00:02:02,340 --> 00:02:05,250
אבל אם אתה כותב ריצה ארוכה יותר
תכנית שלא לפרוש,

45
00:02:05,250 --> 00:02:09,180
בהכרח, בכמה דקות או
כמה שניות, ואז דליפות זיכרון

46
00:02:09,180 --> 00:02:10,710
יכול להיות עסקה ענק.

47
00:02:10,710 --> 00:02:14,940
>> אז לpset6, הציפייה היא כי
יהיה לך אפס דליפות זיכרון עם

48
00:02:14,940 --> 00:02:15,910
התכנית שלך.

49
00:02:15,910 --> 00:02:18,690
valgrind כדי לבדוק דליפות זיכרון, לרוץ
וזה ייתן לכם כמה נחמד

50
00:02:18,690 --> 00:02:21,190
תפוקה ומאפשרות לך לדעת אם
או לא הכל היה בחינם.

51
00:02:21,190 --> 00:02:23,940
אנחנו להתאמן עם אותו מאוחר יותר
היום, בתקווה.

52
00:02:23,940 --> 00:02:25,790
>> לבסוף, פקודת הבדל.

53
00:02:25,790 --> 00:02:28,900
אתה השתמשת במשהו דומה לזה
בpset5 עם כלי הצצה.

54
00:02:28,900 --> 00:02:30,780
מותר לך להסתכל פנימה.

55
00:02:30,780 --> 00:02:33,400
אתה משמש גם הבדל, גם, לכל
הבעיה להגדיר מפרט.

56
00:02:33,400 --> 00:02:35,950
אבל באפשר לך
להשוות בין שני קבצים.

57
00:02:35,950 --> 00:02:39,180
אתה יכול להשוות את הקובץ והמפה הסיביות
כותרות מידע של פתרון וצוות

58
00:02:39,180 --> 00:02:42,200
הפתרון שלך בpset5 אם
בחרת להשתמש בו.

59
00:02:42,200 --> 00:02:44,030
הבדל יאפשר לך
כמו גם לעשות את זה,.

60
00:02:44,030 --> 00:02:48,620
אתה יכול להשוות את התשובה הנכונה עבור
הבעיה של השבוע שנקבעה לתשובה שלך

61
00:02:48,620 --> 00:02:52,210
ולראות אם הוא שורות או לראות
שבו הטעויות.

62
00:02:52,210 --> 00:02:55,870
>> אז אלה הם שלושה כלים טובים כי
אתה צריך להשתמש בזה בשבוע, ו

63
00:02:55,870 --> 00:02:58,130
בהחלט לבדוק את התכנית שלך
עם שלושת כלים אלה

64
00:02:58,130 --> 00:03:00,520
לפני הפעלתו פנימה

65
00:03:00,520 --> 00:03:04,650
שוב, כפי שכבר הזכרתי בכל שבוע,
אם יש לך משוב עליי - שני

66
00:03:04,650 --> 00:03:06,470
חיובי ובונה -

67
00:03:06,470 --> 00:03:09,930
תרגיש חופשי לראש לאתר
בחלק התחתון של שקופית זו

68
00:03:09,930 --> 00:03:11,270
וקלטתי אותו שם.

69
00:03:11,270 --> 00:03:13,440
אני באמת מעריך את כל
וכל המשוב.

70
00:03:13,440 --> 00:03:17,360
ואם אתה נותן לי דברים ספציפיים ש
אני יכול לעשות כדי לשפר או שאני

71
00:03:17,360 --> 00:03:21,350
עושה טוב שאתה רוצה אותי
תמשיך, אני לוקח את זה ללב ו

72
00:03:21,350 --> 00:03:24,040
באמת משתדל להקשיב
למשוב שלך.

73
00:03:24,040 --> 00:03:27,720
אני לא יכול להבטיח שאני הולך לעשות
הכל, אם כי, כמו ללבוש

74
00:03:27,720 --> 00:03:30,700
דלעת תחפושת בכל שבוע.

75
00:03:30,700 --> 00:03:34,020
>> אז אנחנו הולכים לבלות את עיקר
סעיף, כפי שציינתי, מדבר על

76
00:03:34,020 --> 00:03:37,240
רשימות מקושרות וטבלאות חשיש, אשר
יהיה ישים ישירות

77
00:03:37,240 --> 00:03:38,780
להגדיר את הבעיה הזו בשבוע.

78
00:03:38,780 --> 00:03:42,580
רשימות מקושרות נלך מעל יחסית
מהר כי אנחנו כבר בילינו קצת הוגנים

79
00:03:42,580 --> 00:03:44,930
זמן הולך על זה בסעיף.

80
00:03:44,930 --> 00:03:48,680
וכך תהיה לנו ישר לתוך
קידוד בעיות עבור רשימות מקושרות.

81
00:03:48,680 --> 00:03:52,740
ואז בסוף נדבר על
חשיש שולחנות וכיצד הם חלים על זה

82
00:03:52,740 --> 00:03:55,280
הבעיה של השבוע שנקבעה.

83
00:03:55,280 --> 00:03:57,560
>> ראית את הקוד הזה בעבר.

84
00:03:57,560 --> 00:04:02,730
זה הוא struct, והוא מגדיר
משהו שנקרא חדש צומת.

85
00:04:02,730 --> 00:04:10,660
ובתוך צומת יש מספר שלם
פה ושם הוא מצביע ל

86
00:04:10,660 --> 00:04:11,830
צומת אחר.

87
00:04:11,830 --> 00:04:12,790
ראינו את זה קודם.

88
00:04:12,790 --> 00:04:14,830
זה כבר מגיע ל
כמה שבועות עכשיו.

89
00:04:14,830 --> 00:04:18,680
הוא משלב מצביעים, שאנחנו כבר
עובד עם, וstructs, המאפשר

90
00:04:18,680 --> 00:04:22,079
לנו לשלב שתי שונה
דברים לסוג נתונים אחד.

91
00:04:22,079 --> 00:04:24,830

92
00:04:24,830 --> 00:04:26,490
>> יש הרבה קורה על המסך.

93
00:04:26,490 --> 00:04:30,220
אבל כל זה צריך להיות יחסית
מכיר אותך.

94
00:04:30,220 --> 00:04:33,810
בשורה הראשונה, אנחנו
להכריז על צומת חדשה.

95
00:04:33,810 --> 00:04:41,650
ואז בתוך שהצומת חדשה, אני קובע
השלם בצומת שלאחד.

96
00:04:41,650 --> 00:04:44,950
אנו רואים בשורה הבאה שאני עושה
printf הפקודה, אבל אני כבר באפור

97
00:04:44,950 --> 00:04:48,080
פקודת printf כי באמת
חלק חשוב הוא הקו הזה כאן -

98
00:04:48,080 --> 00:04:50,020
new_node.n.

99
00:04:50,020 --> 00:04:51,270
מה הנקודה זה אומרת?

100
00:04:51,270 --> 00:04:53,810

101
00:04:53,810 --> 00:04:57,240
>> קהל: לכו לצומת ו
להעריך את ערך n עבורו.

102
00:04:57,240 --> 00:04:58,370
>> ג'ייסון הירשהורן: זה
בדיוק נכון.

103
00:04:58,370 --> 00:05:03,300
דוט פירושו לגשת לחלק n
של צומת חדשה זה.

104
00:05:03,300 --> 00:05:05,690
קו זה לצד עושה מה?

105
00:05:05,690 --> 00:05:16,140

106
00:05:16,140 --> 00:05:17,050
מייקל.

107
00:05:17,050 --> 00:05:21,910
>> קהל: זה יוצר צומת אחר
שיצביע על הצומת החדשה.

108
00:05:21,910 --> 00:05:24,870
>> ג'ייסון הירשהורן: אז זה לא
ליצור צומת חדשה.

109
00:05:24,870 --> 00:05:26,120
זה יוצר את מה?

110
00:05:26,120 --> 00:05:28,300

111
00:05:28,300 --> 00:05:29,300
>> קהל: מצביע.

112
00:05:29,300 --> 00:05:33,460
>> ג'ייסון הירשהורן: מצביע לצומת,
כפי שצוין על ידי * פסק זו כאן.

113
00:05:33,460 --> 00:05:34,800
אז זה יוצר מצביע לצומת.

114
00:05:34,800 --> 00:05:37,490
ושצומת הוא זה מצביע
ל, מייקל?

115
00:05:37,490 --> 00:05:38,440
>> קהל: צומת חדשה?

116
00:05:38,440 --> 00:05:39,240
>> ג'ייסון הירשהורן: צומת חדשה.

117
00:05:39,240 --> 00:05:43,020
וזה מצביע שם, כי יש לנו
נתתי לו את הכתובת של צומת חדשה.

118
00:05:43,020 --> 00:05:45,820
ועכשיו בקו הזה שאנו רואים
שתי דרכים שונות

119
00:05:45,820 --> 00:05:46,910
להביע את אותו הדבר.

120
00:05:46,910 --> 00:05:49,650
ואני רוצה להצביע על כמה אלה
שני דברים זהים.

121
00:05:49,650 --> 00:05:54,740
בשורה הראשונה, אנחנו dereference
את המצביע.

122
00:05:54,740 --> 00:05:55,830
אז אנחנו הולכים לצומת.

123
00:05:55,830 --> 00:05:56,830
זה מה שכוכב זה אומר.

124
00:05:56,830 --> 00:05:57,930
ראינו את זה לפני עם מצביעים.

125
00:05:57,930 --> 00:05:59,280
עבור לצומת.

126
00:05:59,280 --> 00:06:00,370
זה בסוגריים.

127
00:06:00,370 --> 00:06:04,610
ולאחר מכן לגשת באמצעות מפעיל הנקודה
אלמנט n של הצומת.

128
00:06:04,610 --> 00:06:08,430
>> אז זה לוקח את התחביר
ראינו כאן ועכשיו

129
00:06:08,430 --> 00:06:09,670
משתמש בו עם מצביע.

130
00:06:09,670 --> 00:06:13,730
כמובן, זה נהיה סוג של עסוק אם
אתה כותב בסוגריים אלה -

131
00:06:13,730 --> 00:06:14,940
כי כוכב ונקודה.

132
00:06:14,940 --> 00:06:16,220
זה נהיה קצת עסוק.

133
00:06:16,220 --> 00:06:18,500
אז יש לנו קצת סוכר תחבירי.

134
00:06:18,500 --> 00:06:19,920
והקו הזה ממש כאן -

135
00:06:19,920 --> 00:06:21,170
ptr_node-> n.

136
00:06:21,170 --> 00:06:25,400

137
00:06:25,400 --> 00:06:28,000
שעושה את אותו דבר בדיוק.

138
00:06:28,000 --> 00:06:30,840
אז שני קווים אלו של קוד הם
שווה ערך ואעשה

139
00:06:30,840 --> 00:06:31,650
את אותו הדבר בדיוק.

140
00:06:31,650 --> 00:06:34,210
>> אבל אני רציתי להצביע עליהם לפני
שנמשיך כך אתה מבין

141
00:06:34,210 --> 00:06:39,000
זה באמת הדבר הזה כאן הוא
רק סוכר תחבירי לביטול הפניה למבנה

142
00:06:39,000 --> 00:06:44,200
המצביע ולאחר מכן הולך
חלק n של struct ש.

143
00:06:44,200 --> 00:06:45,525
כל שאלות על השקופית הזאת?

144
00:06:45,525 --> 00:06:53,020

145
00:06:53,020 --> 00:06:54,390
על אישור.

146
00:06:54,390 --> 00:06:58,510
>> אז אנחנו הולכים לעבור כמה
של פעולות שאתה יכול לעשות על

147
00:06:58,510 --> 00:06:59,730
רשימות מקושרות.

148
00:06:59,730 --> 00:07:05,770
רשימה מקושרת, כזכור, היא סדרה של
צמתים שמצביעים אחד לשני.

149
00:07:05,770 --> 00:07:12,470
ואנחנו בדרך כלל מתחילים עם מצביע
ראש הנקרא, בדרך כלל, המצביע על

150
00:07:12,470 --> 00:07:14,040
הדבר הראשון ברשימה.

151
00:07:14,040 --> 00:07:18,900
אז בשורה הראשונה כאן, אנחנו
יש לי L המקורי הראשון שלנו.

152
00:07:18,900 --> 00:07:21,370
אז דבר שאתה יכול לחשוב עליו - זה
טקסט כאן אתה יכול לחשוב כמו

153
00:07:21,370 --> 00:07:23,560
רק את המצביע עלינו מאוחסן
באיזשהו מקום שנקודות

154
00:07:23,560 --> 00:07:24,670
לאלמנט הראשון.

155
00:07:24,670 --> 00:07:27,500
וברשימה מקושרת זה
יש לנו ארבעה צמתים.

156
00:07:27,500 --> 00:07:29,530
כל צומת היא תיבה גדולה.

157
00:07:29,530 --> 00:07:33,430
התיבה הגדולה יותר בתוך גדול
תיבה היא החלק השלם.

158
00:07:33,430 --> 00:07:37,400
ואז יש לנו חלק מצביע.

159
00:07:37,400 --> 00:07:39,630
>> תיבות אלה אינן נמשכים אל
בקנה מידה בגלל כמה גדול הוא

160
00:07:39,630 --> 00:07:42,320
שלם בבתים?

161
00:07:42,320 --> 00:07:43,290
כמה גדול עכשיו?

162
00:07:43,290 --> 00:07:43,710
ארבעה.

163
00:07:43,710 --> 00:07:45,470
ועד כמה גדול זה מצביע?

164
00:07:45,470 --> 00:07:45,940
ארבעה.

165
00:07:45,940 --> 00:07:48,180
אז באמת, אם היינו לצייר
זה בקנה המידה בשתי התיבות

166
00:07:48,180 --> 00:07:49,690
יהיה באותו הגודל.

167
00:07:49,690 --> 00:07:52,870
במקרה זה, אנחנו רוצים להכניס
משהו לרשימה המקושרת.

168
00:07:52,870 --> 00:07:57,190
אז אתה יכול לראות כאן למטה אנחנו החדרה
החמישה לעבור דרך

169
00:07:57,190 --> 00:08:01,310
רשימה מקושרת, תמצא בו חמש
הולך, ולאחר מכן להכניס אותו.

170
00:08:01,310 --> 00:08:03,560
>> בואו לשבור את זה וללכת
קצת יותר לאט.

171
00:08:03,560 --> 00:08:05,510
אני הולך להצביע על הלוח.

172
00:08:05,510 --> 00:08:09,930
אז יש לנו צומתנו חמש כי
שיצרנו בmallocs.

173
00:08:09,930 --> 00:08:11,190
למה כולם צוחק?

174
00:08:11,190 --> 00:08:12,130
סתם, בצחוק.

175
00:08:12,130 --> 00:08:13,310
על אישור.

176
00:08:13,310 --> 00:08:14,820
אז יש לנו malloced חמש.

177
00:08:14,820 --> 00:08:16,310
יצרנו את הצומת הזה
במקום אחר.

178
00:08:16,310 --> 00:08:17,740
יש לנו את זה מוכן ללכת.

179
00:08:17,740 --> 00:08:20,130
אנחנו מתחילים בחלק הקדמי של
הרשימה שלנו עם שתי.

180
00:08:20,130 --> 00:08:22,380
ואנחנו רוצים להכניס
בצורה ממוינת.

181
00:08:22,380 --> 00:08:27,550
>> אז אם אנחנו רואים שני ואנחנו רוצים לשים את
בחמש, מה אנחנו עושים כאשר אנו רואים

182
00:08:27,550 --> 00:08:28,800
משהו פחות מאשר לנו?

183
00:08:28,800 --> 00:08:31,850

184
00:08:31,850 --> 00:08:33,520
מה?

185
00:08:33,520 --> 00:08:36,750
אנחנו רוצים להכניס חמש לתוך זה
רשימה מקושרת, להשאיר אותו מסודרת.

186
00:08:36,750 --> 00:08:37,520
אנחנו רואים את המספר שתיים.

187
00:08:37,520 --> 00:08:38,769
אז מה אנחנו עושים?

188
00:08:38,769 --> 00:08:39,179
מרקוס?

189
00:08:39,179 --> 00:08:40,679
>> קהל: התקשר למצביע
לצומת הבאה.

190
00:08:40,679 --> 00:08:42,530
>> ג'ייסון הירשהורן: ולמה לעשות
אנחנו הולכים לצד אחד?

191
00:08:42,530 --> 00:08:45,970
>> קהל: כי זה
הצומת הבאה ברשימה.

192
00:08:45,970 --> 00:08:48,310
ואנחנו רק יודעים שמיקום אחר.

193
00:08:48,310 --> 00:08:50,410
>> ג'ייסון הירשהורן: וחמש גדול
משני, בפרט.

194
00:08:50,410 --> 00:08:51,600
מכיוון שאנחנו רוצים לשמור עליו ממוינים.

195
00:08:51,600 --> 00:08:52,730
אז חמש גדול משניים.

196
00:08:52,730 --> 00:08:54,460
אז אנחנו עוברים לבאה.

197
00:08:54,460 --> 00:08:55,240
ועכשיו אנחנו מגיעים לארבעה.

198
00:08:55,240 --> 00:08:56,490
ומה קורה כאשר אנחנו מגיעים לארבעה?

199
00:08:56,490 --> 00:08:58,920

200
00:08:58,920 --> 00:09:00,310
>> חמש גדול מארבעה.

201
00:09:00,310 --> 00:09:01,460
אז אנחנו ממשיכים הלאה.

202
00:09:01,460 --> 00:09:03,110
ועכשיו אנחנו בשש.

203
00:09:03,110 --> 00:09:04,360
ומה אנחנו רואים בגיל שש?

204
00:09:04,360 --> 00:09:08,672

205
00:09:08,672 --> 00:09:09,608
כן, קרלוס?

206
00:09:09,608 --> 00:09:10,544
>> קהל: שש גדול מחמישה.

207
00:09:10,544 --> 00:09:11,480
>> ג'ייסון הירשהורן: שישה הוא
יותר מחמישה.

208
00:09:11,480 --> 00:09:13,660
אז זה שבו אנו רוצים
להכניס חמש.

209
00:09:13,660 --> 00:09:17,320
עם זאת, יש לזכור שאם אנחנו
יש רק מצביע אחד כאן -

210
00:09:17,320 --> 00:09:19,840
זה המצביע הנוסף שלנו זה
חוצה דרך הרשימה.

211
00:09:19,840 --> 00:09:21,860
ואנחנו מצביעים על שש.

212
00:09:21,860 --> 00:09:25,010
איבדנו את עקבותיו של מה
בא לפני שש.

213
00:09:25,010 --> 00:09:29,130
אז אם אנחנו רוצים להכניס משהו לתוך
רשימה זו שמירה על אותה מסודרים, אנחנו

214
00:09:29,130 --> 00:09:31,630
כנראה צריכים מצביעים כמה?

215
00:09:31,630 --> 00:09:32,280
>> קהל: שני.

216
00:09:32,280 --> 00:09:32,920
>> ג'ייסון הירשהורן: שתיים.

217
00:09:32,920 --> 00:09:35,720
אחד כדי לעקוב אחר הנוכחי
אחד ואחד כדי לעקוב אחר

218
00:09:35,720 --> 00:09:37,050
מקודמתה.

219
00:09:37,050 --> 00:09:38,450
זוהי רק רשימה מקושרת ביחידים.

220
00:09:38,450 --> 00:09:39,670
זה רק הולך לכיוון אחד.

221
00:09:39,670 --> 00:09:43,220
אם היו לנו רשימה מקושרת כפול, שבו
הכל מצביע על הדבר

222
00:09:43,220 --> 00:09:46,240
אחרי זה והדבר לפני זה, ואז
לא היינו צריך לעשות את זה.

223
00:09:46,240 --> 00:09:49,350
אבל במקרה הזה אנחנו לא רוצים להפסיד
אחר מה בא לפנינו במקרה

224
00:09:49,350 --> 00:09:53,350
אנחנו צריכים להכניס חמש איפשהו
באמצע.

225
00:09:53,350 --> 00:09:55,610
אומר שהיינו החדרת תשע.

226
00:09:55,610 --> 00:09:57,260
מה יקרה כאשר
הגענו לשמונה?

227
00:09:57,260 --> 00:10:01,860

228
00:10:01,860 --> 00:10:04,880
>> קהל: שיהיה לך ל
תקבל שנקודת האפס.

229
00:10:04,880 --> 00:10:07,820
במקום שיש נקודת אפס שתהיה לך
כדי להוסיף אלמנט ולאחר מכן יש לי

230
00:10:07,820 --> 00:10:09,216
זה מצביע על תשע.

231
00:10:09,216 --> 00:10:09,700
>> ג'ייסון הירשהורן: בדיוק.

232
00:10:09,700 --> 00:10:10,600
אז אנחנו מקבלים שמונה.

233
00:10:10,600 --> 00:10:13,140
אנחנו מגיעים לסוף הרשימה בגלל
זה מצביע על NULL.

234
00:10:13,140 --> 00:10:16,330
ועכשיו, במקום שיש בו להצביע על
null לנו את זה מצביע על הצומת החדשה שלנו.

235
00:10:16,330 --> 00:10:19,870
ואנו קובעים את המצביע ב
הצומת החדשה שלנו לריק.

236
00:10:19,870 --> 00:10:21,445
האם יש למישהו שאלות
אודות הכנסה?

237
00:10:21,445 --> 00:10:25,620

238
00:10:25,620 --> 00:10:28,100
מה אם לא אכפת לי
שמירה על הרשימה ממוינת?

239
00:10:28,100 --> 00:10:31,701

240
00:10:31,701 --> 00:10:34,350
>> קהל: זה מקל על
תחילת או הסוף.

241
00:10:34,350 --> 00:10:35,510
>> ג'ייסון הירשהורן: זה מקל על
תחילתו או בסופו של הדבר.

242
00:10:35,510 --> 00:10:37,276
איזה מהם כדאי לנו לעשות?

243
00:10:37,276 --> 00:10:38,770
בובי?

244
00:10:38,770 --> 00:10:41,020
למה בסוף?

245
00:10:41,020 --> 00:10:43,250
>> קהל: בגלל ההתחלה
הוא כבר מלא.

246
00:10:43,250 --> 00:10:43,575
>> ג'ייסון הירשהורן: אישור.

247
00:10:43,575 --> 00:10:44,360
תחילת כבר מלאה.

248
00:10:44,360 --> 00:10:46,090
מי שרוצה לטעון נגד בובי.

249
00:10:46,090 --> 00:10:47,290
מרקוס.

250
00:10:47,290 --> 00:10:48,910
>> קהל: ובכן אתה כנראה רוצה
לתקוע אותו בהתחלה כי

251
00:10:48,910 --> 00:10:50,140
אחרת, אם אתה שם אותו ב
הסוף הייתי שיש לך

252
00:10:50,140 --> 00:10:51,835
חוצה את הרשימה כולה.

253
00:10:51,835 --> 00:10:52,990
>> ג'ייסון הירשהורן: בדיוק.

254
00:10:52,990 --> 00:10:57,970
אז אם אנחנו חושבים על זמן ריצה,
זמן ריצה של הכנסה בסוף

255
00:10:57,970 --> 00:11:00,110
יהיה n, בגודל של זה.

256
00:11:00,110 --> 00:11:03,080
מה זמן הריצה O הגדול של החדרה
בהתחלה?

257
00:11:03,080 --> 00:11:04,170
זמן קבוע.

258
00:11:04,170 --> 00:11:07,075
אז אם לא אכפת לך על שמירה
משהו מסודר, הרבה יותר טוב פשוט

259
00:11:07,075 --> 00:11:08,420
הכנס בתחילת רשימה זו.

260
00:11:08,420 --> 00:11:10,320
ושאפשר לעשות בזמן קבוע.

261
00:11:10,320 --> 00:11:13,900

262
00:11:13,900 --> 00:11:14,690
>> על אישור.

263
00:11:14,690 --> 00:11:18,870
המבצע הבא הוא למצוא, אשר אחר -
אנחנו כבר ניסחנו את זה כחיפוש.

264
00:11:18,870 --> 00:11:22,470
אבל אנחנו הולכים להסתכל דרך
רשימה מקושרת לאובייקט כלשהו.

265
00:11:22,470 --> 00:11:26,000
אתם ראיתם את הקוד עבור
חיפוש בלפני הרצאה.

266
00:11:26,000 --> 00:11:29,490
אבל אנחנו סוג של פשוט עשינו את זה עם
להוסיף, או לפחות הכנסה

267
00:11:29,490 --> 00:11:30,580
משהו מסודר.

268
00:11:30,580 --> 00:11:36,350
אתה מסתכל דרך, הולך צומת בצומת,
עד שתמצא את המספר שאתה

269
00:11:36,350 --> 00:11:37,780
מחפש.

270
00:11:37,780 --> 00:11:39,670
מה קורה אם אתה מגיע
סוף הרשימה?

271
00:11:39,670 --> 00:11:43,020
אומר שאני מחפש תשע ואני
להגיע לסוף הרשימה.

272
00:11:43,020 --> 00:11:44,270
מה אנחנו עושים?

273
00:11:44,270 --> 00:11:47,147

274
00:11:47,147 --> 00:11:48,110
>> קהל: בתמורת שווא?

275
00:11:48,110 --> 00:11:48,690
>> ג'ייסון הירשהורן: בתמורת שווא.

276
00:11:48,690 --> 00:11:49,960
לא מצאו אותו.

277
00:11:49,960 --> 00:11:52,010
אם אתם מגיעים לסוף הרשימה ו
לא מצא את המספר שאתה

278
00:11:52,010 --> 00:11:54,170
מחפש, זה לא שם.

279
00:11:54,170 --> 00:11:55,420
כל שאלות על למצוא?

280
00:11:55,420 --> 00:11:59,530

281
00:11:59,530 --> 00:12:04,615
אם זה היה רשימה ממוינת, מה היית עושה
להיות שונה לחיפוש שלנו?

282
00:12:04,615 --> 00:12:07,370

283
00:12:07,370 --> 00:12:08,103
כן.

284
00:12:08,103 --> 00:12:10,600
>> קהל: זה יהיה למצוא את הערך הראשון
זה גדול יותר מזה

285
00:12:10,600 --> 00:12:12,390
שאתה מחפש ו
אז בתמורת שווא.

286
00:12:12,390 --> 00:12:13,190
>> ג'ייסון הירשהורן: בדיוק.

287
00:12:13,190 --> 00:12:17,310
אז אם זה רשימה ממוינת, אם אנחנו מקבלים
משהו שהוא גדול יותר ממה

288
00:12:17,310 --> 00:12:20,180
אנחנו מחפשים, אנחנו לא צריכים
להמשיך ללכת לסוף הרשימה.

289
00:12:20,180 --> 00:12:24,060
אנחנו יכולים בשלב זה לחזור שווא
כי אנחנו לא הולכים למצוא את זה.

290
00:12:24,060 --> 00:12:27,340
השאלה היא עכשיו, שדיברנו עליו
שמירה על רשימות מקושרות ממוינים,

291
00:12:27,340 --> 00:12:28,180
שמירה על אותם לא ממוין.

292
00:12:28,180 --> 00:12:30,050
זה הולך להיות משהו שאתה
כנראה הולך צריך לחשוב על

293
00:12:30,050 --> 00:12:34,240
כאשר בעיה קידוד להגדיר חמש אם
לבחור שולחן חשיש עם נפרד

294
00:12:34,240 --> 00:12:36,360
גישת שרשור, אשר
נדבר על המשך.

295
00:12:36,360 --> 00:12:41,400
>> אבל האם זה שווה את זה כדי לשמור את הרשימה
ממוין ואז תוכל אולי לקבל

296
00:12:41,400 --> 00:12:42,310
חיפושים מהירים יותר?

297
00:12:42,310 --> 00:12:47,220
או שעדיף להוסיף במהירות
משהו בריצה מתמדת אבל אז

298
00:12:47,220 --> 00:12:48,430
יש כבר מחפש?

299
00:12:48,430 --> 00:12:52,250
זה איזון נכון שיש, כי אתה
מקבל להחליט מה מתאים יותר

300
00:12:52,250 --> 00:12:53,590
לבעיה הספציפית שלך.

301
00:12:53,590 --> 00:12:56,680
ויש לא בהכרח אחד
תשובה נכונה לחלוטין.

302
00:12:56,680 --> 00:12:59,520
אבל זה בהחלט החלטה שאתה מקבל
לעשות, וכנראה טוב להגן על

303
00:12:59,520 --> 00:13:05,270
כי, למשל, תגובה או שתיים למה
בחרת אחד על פנים השני.

304
00:13:05,270 --> 00:13:06,490
>> לבסוף, מחיקה.

305
00:13:06,490 --> 00:13:08,100
ראינו מחיקה.

306
00:13:08,100 --> 00:13:09,180
זה דומה לחיפוש.

307
00:13:09,180 --> 00:13:11,020
אנחנו מחפשים את האלמנט.

308
00:13:11,020 --> 00:13:12,390
אומר שאנחנו מנסים למחוק שש.

309
00:13:12,390 --> 00:13:14,450
כך אנו מוצאים שש ממש כאן.

310
00:13:14,450 --> 00:13:18,860
הדבר שאנחנו צריכים לעשות אנחנו בטוחים
לעשות הוא שכל מה שהוא מצביע על

311
00:13:18,860 --> 00:13:21,220
שישה - כפי שאנו רואים בצעד
שניים לכאן -

312
00:13:21,220 --> 00:13:26,500
מה שמצביע על שישה הצרכים ל
לדלג על שישה עכשיו ולהיות שונה כדי

313
00:13:26,500 --> 00:13:28,160
כל מה ששש הוא מצביעים.

314
00:13:28,160 --> 00:13:31,410
אנחנו לא רוצים אי פעם ליתום שאר
הרשימה שלנו על ידי שוכח לקבוע כי

315
00:13:31,410 --> 00:13:32,960
מצביע קודם.

316
00:13:32,960 --> 00:13:35,960
ואז לפעמים, בהתאם
בתכנית, הם פשוט

317
00:13:35,960 --> 00:13:37,380
למחוק את הצומת הזה לחלוטין.

318
00:13:37,380 --> 00:13:40,135
לפעמים אתה רוצה לחזור
הערך זה בצומת זה.

319
00:13:40,135 --> 00:13:42,490
אז ככה מחיקת עבודות.

320
00:13:42,490 --> 00:13:44,610
כל שאלות על מחיקה?

321
00:13:44,610 --> 00:13:51,280

322
00:13:51,280 --> 00:13:53,850
>> קהל: אז אם אתה הולך למחוק
זה, היית פשוט להשתמש בחינם כי

323
00:13:53,850 --> 00:13:55,655
ככל הנראה זה היה malloced?

324
00:13:55,655 --> 00:13:57,976
>> ג'ייסון הירשהורן: אם ברצונך לפנות
משהו זה בדיוק נכון ואתה

325
00:13:57,976 --> 00:13:58,540
malloced זה.

326
00:13:58,540 --> 00:14:00,410
אומר שאנחנו רוצים לחזור על ערך זה.

327
00:14:00,410 --> 00:14:04,010
אנחנו יכולים להחזיר לה שש ולאחר מכן בחינם
פסק זו ושיחה חינם על זה.

328
00:14:04,010 --> 00:14:06,180
או שאנחנו כנראה היינו קוראים חופשיים ראשון
ולאחר מכן לחזור שש.

329
00:14:06,180 --> 00:14:11,210

330
00:14:11,210 --> 00:14:11,580
>> על אישור.

331
00:14:11,580 --> 00:14:14,010
אז בואו נעבור לתרגול קידוד.

332
00:14:14,010 --> 00:14:16,090
אנחנו הולכים לקוד שלוש פונקציות.

333
00:14:16,090 --> 00:14:18,260
הראשון נקרא insert_node.

334
00:14:18,260 --> 00:14:22,170
אז יש לך קוד שאני בדוא"ל לך, ו
אם אתה צופה בזה בשלב מאוחר יותר

335
00:14:22,170 --> 00:14:28,020
אתה יכול לגשת לקוד בlinked.c
באתר CS50.

336
00:14:28,020 --> 00:14:30,880
אבל בlinked.c, יש כמה
קוד שלד שכבר

337
00:14:30,880 --> 00:14:32,280
נכתב בשבילך.

338
00:14:32,280 --> 00:14:34,560
ואז יש כמה פונקציות
אתה צריך לכתוב.

339
00:14:34,560 --> 00:14:36,380
>> ראשית אנחנו הולכים
לכתוב insert_node.

340
00:14:36,380 --> 00:14:39,800
ומה עושה insert_node
כלומר מוסיף מספר שלם.

341
00:14:39,800 --> 00:14:42,440
ואתה נותן את המספר השלם
לרשימה מקושרת.

342
00:14:42,440 --> 00:14:45,470
ובפרט, שאתה צריך
כדי לשמור על הרשימה הממוינת

343
00:14:45,470 --> 00:14:47,650
מהקטן ביותר לגדול ביותר.

344
00:14:47,650 --> 00:14:51,360
כמו כן, אתה לא רוצה
להוסיף כל כפילויות.

345
00:14:51,360 --> 00:14:54,600
לבסוף, כפי שאתה יכול לראות insert_node
מחזיר bool.

346
00:14:54,600 --> 00:14:57,140
אז אתה אמור ליידע את המשתמש
או אם לא היה להכניס

347
00:14:57,140 --> 00:15:00,800
מוצלח על ידי החזרת אמת או שקר.

348
00:15:00,800 --> 00:15:02,580
בסופו של תכנית זו -

349
00:15:02,580 --> 00:15:05,750
ועבור שלב זה אתה לא צריך
לדאוג לשחרר שום דבר.

350
00:15:05,750 --> 00:15:11,790
אז כל מה שאתה עושה הוא לוקח מספר שלם
והכנסתו לרשימה.

351
00:15:11,790 --> 00:15:13,890
>> זה מה שאני מבקש ממך לעשות עכשיו.

352
00:15:13,890 --> 00:15:17,620
שוב, בlinked.c, שבו אתה
כל מה שיש, הוא קוד השלד.

353
00:15:17,620 --> 00:15:20,980
ואתה צריך לראות לכיוון החלק התחתון
מדגם ההצהרה על הפונקציה.

354
00:15:20,980 --> 00:15:27,390
עם זאת, לפני שנכנס לקידוד זה
ב-C, אני מאוד ממליץ לך ללכת

355
00:15:27,390 --> 00:15:29,330
לאורך השלבים שהיינו
מתאמן בכל שבוע.

356
00:15:29,330 --> 00:15:31,100
אנחנו כבר עברנו
תמונה של זה.

357
00:15:31,100 --> 00:15:33,380
אז צריך להיות לך קצת הבנה
של איך זה עובד.

358
00:15:33,380 --> 00:15:36,590
אבל אני הייתי ממליץ לך לכתוב
כמה pseudocode לפני הצלילה פנימה

359
00:15:36,590 --> 00:15:38,640
ואנחנו הולכים לעבור על
pseudocode כקבוצה.

360
00:15:38,640 --> 00:15:41,470
ואז ברגע שאתה כתבת
pseudocode, וברגע שכתבנו

361
00:15:41,470 --> 00:15:45,850
pseudocode כקבוצה, אתה יכול
להיכנס לקידוד זה בג

362
00:15:45,850 --> 00:15:49,980
>> כעד, פונקצית insert_node ראשים
הוא כנראה הקשה ביותר של

363
00:15:49,980 --> 00:15:53,550
שלושת שאנחנו הולכים לכתוב כי אני
הוסיף כמה אילוצים נוספים

364
00:15:53,550 --> 00:15:57,190
שלך תכנות, בפרט כי
אתה לא הולך להכניס כל

365
00:15:57,190 --> 00:15:59,880
כפילויות וכי הרשימה
צריך להישאר ממוין.

366
00:15:59,880 --> 00:16:02,660
אז זו תכנית שאינה של מה בכך
כי אתה צריך קוד.

367
00:16:02,660 --> 00:16:06,470
ולמה שלא תיקח 6:55
דקות רק כדי לקבל עובדות על

368
00:16:06,470 --> 00:16:07,640
pseudocode ואת הקוד.

369
00:16:07,640 --> 00:16:09,460
ואז תוכל להתחיל
הולך כקבוצה.

370
00:16:09,460 --> 00:16:11,680
שוב, אם יש לך שאלות פשוט
להרים את היד שלך ואני אבוא בסביבה.

371
00:16:11,680 --> 00:16:15,258

372
00:16:15,258 --> 00:16:16,508
.

373
00:16:16,508 --> 00:18:28,370

374
00:18:28,370 --> 00:18:30,120
>> אנחנו גם עושים בדרך כלל אלה -

375
00:18:30,120 --> 00:18:32,070
או שאני לא אומר במפורש שאתה
יכול לעבוד עם אנשים.

376
00:18:32,070 --> 00:18:36,500
אבל כמובן, אני מאוד ממליץ לך,
אם יש לך שאלות, לשאול

377
00:18:36,500 --> 00:18:39,840
השכן שיושב לידך
או אפילו לעבוד עם מישהו

378
00:18:39,840 --> 00:18:40,510
אחר אם אתה רוצה.

379
00:18:40,510 --> 00:18:42,600
זה לא חייב להיות בודד
פעילות שקטה.

380
00:18:42,600 --> 00:20:11,770

381
00:20:11,770 --> 00:20:16,330
>> בואו נתחיל עם כתיבה כמה
pseudocode על הלוח.

382
00:20:16,330 --> 00:20:19,395
מי יכול לתת לי את השורה הראשונה של
pseudocode לתכנית זו?

383
00:20:19,395 --> 00:20:22,240

384
00:20:22,240 --> 00:20:23,640
עבור פונקציה זו, ולא -
insert_node.

385
00:20:23,640 --> 00:20:29,960

386
00:20:29,960 --> 00:20:31,830
אלדן?

387
00:20:31,830 --> 00:20:36,560
>> קהל: אז הדבר הראשון שעשיתי היה
ליצור מצביע חדש לצומת ואני

388
00:20:36,560 --> 00:20:41,320
אותחל זה מצביע על אותו
דבר שהרשימה היא מצביעה.

389
00:20:41,320 --> 00:20:41,550
>> ג'ייסון הירשהורן: אישור.

390
00:20:41,550 --> 00:20:45,190
אז אתה יוצר מצביע חדש
לרשימה, שלא את הצומת.

391
00:20:45,190 --> 00:20:45,420
>> קהל: כן.

392
00:20:45,420 --> 00:20:46,150
כן.

393
00:20:46,150 --> 00:20:46,540
>> ג'ייסון הירשהורן: אישור.

394
00:20:46,540 --> 00:20:48,221
ואז מה אנחנו רוצים לעשות?

395
00:20:48,221 --> 00:20:49,163
מה של אחרי זה?

396
00:20:49,163 --> 00:20:50,105
מה בנוגע לצומת?

397
00:20:50,105 --> 00:20:51,050
אין לנו צומת.

398
00:20:51,050 --> 00:20:52,300
פשוט יש לנו ערך.

399
00:20:52,300 --> 00:20:55,918

400
00:20:55,918 --> 00:20:58,890
אם ברצונך להוסיף צומת, מה לעשות אנחנו
צריך לעשות קודם לפני שאנחנו אפילו יכולים

401
00:20:58,890 --> 00:20:59,980
חושב על הכנסתו?

402
00:20:59,980 --> 00:21:00,820
>> קהל: אה, סליחה.

403
00:21:00,820 --> 00:21:02,160
אנחנו צריכים malloc מרחב לצומת.

404
00:21:02,160 --> 00:21:02,455
>> ג'ייסון הירשהורן: מצוין.

405
00:21:02,455 --> 00:21:03,210
בואו לעשות -

406
00:21:03,210 --> 00:21:04,628
על אישור.

407
00:21:04,628 --> 00:21:06,065
לא יכול להגיע גבוה זה.

408
00:21:06,065 --> 00:21:08,939

409
00:21:08,939 --> 00:21:09,897
על אישור.

410
00:21:09,897 --> 00:21:13,236
אנחנו הולכים לרדת, ולאחר מכן
אנחנו משתמשים בשתי עמודות.

411
00:21:13,236 --> 00:21:13,732
אני לא יכול ללכת כי -

412
00:21:13,732 --> 00:21:14,982
על אישור.

413
00:21:14,982 --> 00:21:23,660

414
00:21:23,660 --> 00:21:25,130
צור קשר חדש.

415
00:21:25,130 --> 00:21:29,380
באפשרותך ליצור מצביע נוסף לרשימה
או שאתה יכול פשוט להשתמש ברשימה כפי שהיא קיימת.

416
00:21:29,380 --> 00:21:30,720
אתה לא באמת צריך לעשות את זה.

417
00:21:30,720 --> 00:21:31,750
>> אז אנחנו יוצרים צומת חדש.

418
00:21:31,750 --> 00:21:32,010
גדול.

419
00:21:32,010 --> 00:21:32,840
זה מה שאנחנו עושים ראשון.

420
00:21:32,840 --> 00:21:34,870
מה הלאה?

421
00:21:34,870 --> 00:21:35,080
>> קהל: חכה.

422
00:21:35,080 --> 00:21:38,330
האם עלינו ליצור צומת חדשה עכשיו או
האם עלינו לחכות על מנת לוודא כי

423
00:21:38,330 --> 00:21:42,260
אין כפילויות של הצומת
ברשימה לפני שאנחנו יוצרים אותו?

424
00:21:42,260 --> 00:21:43,100
>> ג'ייסון הירשהורן: שאלה טובה.

425
00:21:43,100 --> 00:21:47,770
בואו נחזיק את זה לאחר כך, כי
רוב הזמן נהיה יצירת

426
00:21:47,770 --> 00:21:48,220
צומת חדשה.

427
00:21:48,220 --> 00:21:49,110
אז אנחנו נשמור את זה כאן.

428
00:21:49,110 --> 00:21:51,006
אבל זו שאלה טובה.

429
00:21:51,006 --> 00:21:53,250
אם אנו יוצרים אותו ואנו מוצאים
כפול, מה שצריך

430
00:21:53,250 --> 00:21:54,490
אנחנו עושים לפני ההחזרה?

431
00:21:54,490 --> 00:21:55,190
>> קהל: לשחרר אותו.

432
00:21:55,190 --> 00:21:55,470
>> ג'ייסון הירשהורן: כן.

433
00:21:55,470 --> 00:21:56,500
כנראה לשחרר אותו.

434
00:21:56,500 --> 00:21:56,760
על אישור.

435
00:21:56,760 --> 00:21:59,850
מה עושה אחרי ש
ליצור צומת חדשה?

436
00:21:59,850 --> 00:22:02,260
אנני?

437
00:22:02,260 --> 00:22:04,780
>> קהל: אנחנו שמים את
מספר בצומת?

438
00:22:04,780 --> 00:22:05,140
>> ג'ייסון הירשהורן: בדיוק.

439
00:22:05,140 --> 00:22:07,190
אנחנו שמים את המספר - אנחנו malloc חלל.

440
00:22:07,190 --> 00:22:08,160
אני הולך להשאיר את זה
הכל כקו אחד.

441
00:22:08,160 --> 00:22:08,720
אבל אתה צודק.

442
00:22:08,720 --> 00:22:10,305
אנו malloc חלל, ולאחר מכן
אנחנו שמים את המספר פנימה

443
00:22:10,305 --> 00:22:12,585
אנחנו אפילו יכולים להגדיר את המצביע
חלק ממנה לריק.

444
00:22:12,585 --> 00:22:13,720
זה בדיוק נכון.

445
00:22:13,720 --> 00:22:17,400
ואז מה אחרי זה?

446
00:22:17,400 --> 00:22:18,490
ציירנו את התמונה הזאת על הלוח.

447
00:22:18,490 --> 00:22:21,190
אז מה אנחנו עושים?

448
00:22:21,190 --> 00:22:22,680
>> קהל: אנחנו נעבור על הרשימה.

449
00:22:22,680 --> 00:22:23,930
>> ג'ייסון הירשהורן: עבור דרך הרשימה.

450
00:22:23,930 --> 00:22:30,620

451
00:22:30,620 --> 00:22:31,100
על אישור.

452
00:22:31,100 --> 00:22:34,280
ומה שאנחנו עושים לבדוק בכל צומת.

453
00:22:34,280 --> 00:22:35,955
קורט, מה אנחנו בודקים
בכל צומת?

454
00:22:35,955 --> 00:22:41,640
>> קהל: בדוק אם ערך n של
הצומת שהיא גדולה מערך n

455
00:22:41,640 --> 00:22:43,070
של הצומת שלנו.

456
00:22:43,070 --> 00:22:43,340
>> ג'ייסון הירשהורן: אישור.

457
00:22:43,340 --> 00:22:44,280
אני הולך לעשות -

458
00:22:44,280 --> 00:22:45,855
כן, בסדר.

459
00:22:45,855 --> 00:22:48,160
אז זה n -

460
00:22:48,160 --> 00:22:59,040
אני הולך לומר אם הערך גדול
מצומת זה, אז מה אנחנו עושים?

461
00:22:59,040 --> 00:23:07,290
>> קהל: טוב, אז אנחנו מכניסים
את הדבר נכון לפני ש.

462
00:23:07,290 --> 00:23:07,970
>> ג'ייסון הירשהורן: אישור.

463
00:23:07,970 --> 00:23:09,410
אז אם זה גדול מזה,
אז אנחנו רוצים להוסיף.

464
00:23:09,410 --> 00:23:14,010
אבל אנחנו רוצים להכניס אותו ממש לפני
בגלל שאנחנו גם היו צריכים להיות

465
00:23:14,010 --> 00:23:16,070
שמירה על מסלול, ולאחר מכן,
של מה שהיה בעבר.

466
00:23:16,070 --> 00:23:22,690
אז הכנס בעבר.

467
00:23:22,690 --> 00:23:25,120
אז אנחנו כנראה פספסנו משהו
קודם לכן.

468
00:23:25,120 --> 00:23:27,770
אנחנו כנראה צריכים להיות שמירה
אחר מה שקורה.

469
00:23:27,770 --> 00:23:28,460
אבל אנחנו נחזור לשם.

470
00:23:28,460 --> 00:23:30,160
אז מה הערך הוא פחות מ?

471
00:23:30,160 --> 00:23:38,030

472
00:23:38,030 --> 00:23:39,710
קורט, מה עושים אם
הערך הוא פחות מ?

473
00:23:39,710 --> 00:23:43,000
>> קהל: ואז אתה פשוט להמשיך
אלא אם כן זה האחרון.

474
00:23:43,000 --> 00:23:43,550
>> ג'ייסון הירשהורן: אני אוהב את זה.

475
00:23:43,550 --> 00:23:44,800
אז ללכת לצומת הבאה.

476
00:23:44,800 --> 00:23:47,410

477
00:23:47,410 --> 00:23:48,930
אלא אם כן זה האחרון -

478
00:23:48,930 --> 00:23:51,100
אנחנו כנראה בודקים בשביל זה
במונחים של מצב.

479
00:23:51,100 --> 00:23:54,870
אבל כן, הצומת הבאה.

480
00:23:54,870 --> 00:23:58,680
וזה מתחיל להיות נמוך מדי,
כך יהיה לנו לעבור לכאן.

481
00:23:58,680 --> 00:24:02,030
אבל אם -

482
00:24:02,030 --> 00:24:03,280
יכול כולם לראות את זה?

483
00:24:03,280 --> 00:24:07,230

484
00:24:07,230 --> 00:24:11,610
אם אנחנו שווים את מה שאנחנו עושים?

485
00:24:11,610 --> 00:24:15,740
אם הערך שאנחנו מנסים להכניס
שווה הערך של הצומת הזה?

486
00:24:15,740 --> 00:24:16,320
כן?

487
00:24:16,320 --> 00:24:18,400
>> קהל: [לא ברור].

488
00:24:18,400 --> 00:24:18,850
>> ג'ייסון הירשהורן: כן.

489
00:24:18,850 --> 00:24:19,290
בהתחשב בזה -

490
00:24:19,290 --> 00:24:20,090
מרקוס הוא נכון.

491
00:24:20,090 --> 00:24:21,330
היינו יכולים אולי לעשות
משהו שונה.

492
00:24:21,330 --> 00:24:25,360
אבל בהתחשב בעובדה שיצרנו אותו, כאן
אנחנו צריכים לשחרר ואז לחזור.

493
00:24:25,360 --> 00:24:26,774
אוי ואבוי.

494
00:24:26,774 --> 00:24:30,080
האם זה טוב יותר?

495
00:24:30,080 --> 00:24:31,850
איך זה?

496
00:24:31,850 --> 00:24:33,100
על אישור.

497
00:24:33,100 --> 00:24:35,360

498
00:24:35,360 --> 00:24:37,640
חינם ואז מה תעשה לנו
לחזור, [לא ברור]?

499
00:24:37,640 --> 00:24:41,330

500
00:24:41,330 --> 00:24:44,110
על אישור.

501
00:24:44,110 --> 00:24:45,360
האם אנחנו חסרות משהו?

502
00:24:45,360 --> 00:24:53,500

503
00:24:53,500 --> 00:24:59,650
אז שבו אנו עוקבים אחר
של הצומת שלפני?

504
00:24:59,650 --> 00:25:02,370
>> קהל: אני חושב שזה הייתי הולך
לאחר יצירת צומת חדשה.

505
00:25:02,370 --> 00:25:02,600
>> ג'ייסון הירשהורן: אישור.

506
00:25:02,600 --> 00:25:03,940
אז בהתחלה אנחנו בטח -

507
00:25:03,940 --> 00:25:07,175
כן, אנחנו יכולים ליצור מצביע חדש
צומת, כמו מצביע צומת קודם ו

508
00:25:07,175 --> 00:25:09,600
מצביע צומת נוכחית.

509
00:25:09,600 --> 00:25:12,640
אז בואו נכניס את זה כאן.

510
00:25:12,640 --> 00:25:15,610

511
00:25:15,610 --> 00:25:26,900
יצירה נוכחית וקודמת
מצביעים לצומת.

512
00:25:26,900 --> 00:25:28,955
אבל כאשר אנחנו להתאים המצביעים האלה?

513
00:25:28,955 --> 00:25:30,205
איפה אנחנו עושים את זה בקוד?

514
00:25:30,205 --> 00:25:33,830

515
00:25:33,830 --> 00:25:34,160
ג'ף?

516
00:25:34,160 --> 00:25:35,170
>> קהל: - תנאי ערך?

517
00:25:35,170 --> 00:25:36,420
>> ג'ייסון הירשהורן: איזה
אחד במיוחד?

518
00:25:36,420 --> 00:25:39,862

519
00:25:39,862 --> 00:25:40,720
>> קהל: אני רק מבולבל.

520
00:25:40,720 --> 00:25:44,200
אם הערך גדול מהצומת הזו,
האם זה לא אומר שאתה רוצה ללכת

521
00:25:44,200 --> 00:25:45,320
לקשר הבא?

522
00:25:45,320 --> 00:25:49,515
>> ג'ייסון הירשהורן: אז אם הערך שלנו הוא
גדול מהערך של הצומת הזה.

523
00:25:49,515 --> 00:25:52,130
>> קהל: כן, אז היית רוצה
ללכת בהמשך הקו, נכון?

524
00:25:52,130 --> 00:25:52,590
>> ג'ייסון הירשהורן: נכון.

525
00:25:52,590 --> 00:25:53,840
אז אנחנו לא להכניס אותו לכאן.

526
00:25:53,840 --> 00:25:58,430

527
00:25:58,430 --> 00:26:03,240
אם הערך הוא פחות מ צומת זה, ולאחר מכן
אנחנו הולכים לצומת הבאה - או אז

528
00:26:03,240 --> 00:26:03,835
הכנס קודם.

529
00:26:03,835 --> 00:26:05,966
>> קהל: חכה, שהוא זה
צומת ובה היא ערך?

530
00:26:05,966 --> 00:26:08,510

531
00:26:08,510 --> 00:26:09,280
>> ג'ייסון הירשהורן: שאלה טובה.

532
00:26:09,280 --> 00:26:13,260
ערך להגדרת פונקציה זו
זה מה שאנחנו נתון.

533
00:26:13,260 --> 00:26:16,910
אז ערך הוא המספר שאנחנו נתון.

534
00:26:16,910 --> 00:26:21,120
אז אם הערך הוא פחות מזה
צומת, אנו זקוקים לזמן כדי להוסיף.

535
00:26:21,120 --> 00:26:24,575
אם הערך גדול מהצומת הזו,
אנחנו הולכים לצומת הבאה.

536
00:26:24,575 --> 00:26:26,790
ובחזרה לשאלה המקורית,
אם כי, שבו -

537
00:26:26,790 --> 00:26:29,060
>> קהל: אם הערך גדול
מצומת זה.

538
00:26:29,060 --> 00:26:30,310
>> ג'ייסון הירשהורן: וכך
מה אנחנו עושים כאן?

539
00:26:30,310 --> 00:26:36,790

540
00:26:36,790 --> 00:26:38,160
מתוק.

541
00:26:38,160 --> 00:26:38,860
זה נכון.

542
00:26:38,860 --> 00:26:41,370
אני רק הולך לכתוב
מצביעי עדכון.

543
00:26:41,370 --> 00:26:44,010
אבל כן, עם הזרם אחד
היית לעדכן אותו

544
00:26:44,010 --> 00:26:46,080
להצביע על הבא.

545
00:26:46,080 --> 00:26:47,330
כל דבר אחר שאנחנו חסרים?

546
00:26:47,330 --> 00:26:52,710

547
00:26:52,710 --> 00:26:54,940
אז אני הולך לסוג זה
קוד לתוך gedit.

548
00:26:54,940 --> 00:26:58,375
ובזמן שאני עושה את זה, אתה יכול לקבל
עוד כמה דקות לעבוד על קידוד

549
00:26:58,375 --> 00:28:19,240
זה בג

550
00:28:19,240 --> 00:28:20,940
>> אז יש לי קלט pseudocode.

551
00:28:20,940 --> 00:28:22,940
הערה מהירה לפני שנתחיל.

552
00:28:22,940 --> 00:28:25,560
אנחנו אולי לא מסוגלים לחלוטין
לסיים את זה בכל

553
00:28:25,560 --> 00:28:27,300
שלוש מהפונקציות הללו.

554
00:28:27,300 --> 00:28:30,630
יש פתרונות נכונים להם
שאני בדוא"ל לחבר 'ה

555
00:28:30,630 --> 00:28:33,730
אחרי סעיף, וזה יהיה
יפורסם בCS50.net.

556
00:28:33,730 --> 00:28:35,640
אז אני לא ממליץ לך
ללכת להסתכל על הסעיפים.

557
00:28:35,640 --> 00:28:40,550
אני ממליץ לך לנסות את אלה עליך
בבעלותך, ולאחר מכן להשתמש בפרקטיקה

558
00:28:40,550 --> 00:28:41,760
בעיות כדי לבדוק את התשובות שלך.

559
00:28:41,760 --> 00:28:47,070
אלה יש את כל תוכננו בשיתוף פעולה הדוק
להתייחס ולדבוק במה

560
00:28:47,070 --> 00:28:48,400
אתה צריך לעשות על סט הבעיה.

561
00:28:48,400 --> 00:28:53,820
אז אני ממליץ לך לתרגל את זה
בעצמך ולאחר מכן להשתמש בקוד כדי

562
00:28:53,820 --> 00:28:54,660
לבדוק את התשובות שלך.

563
00:28:54,660 --> 00:28:57,060
כי אני רוצה לעבור לחשיש
שולחנות בשלב כלשהו בסעיף.

564
00:28:57,060 --> 00:28:58,150
אז אנחנו לא יכולים לקבל את כל זה.

565
00:28:58,150 --> 00:28:59,960
אבל אנחנו נעשה ככל שביכולתנו עכשיו.

566
00:28:59,960 --> 00:29:00,370
>> על אישור.

567
00:29:00,370 --> 00:29:01,960
בואו נתחיל.

568
00:29:01,960 --> 00:29:04,770
אסם, איך אנו יוצרים צומת חדש?

569
00:29:04,770 --> 00:29:06,810
>> קהל: אתה struct *.

570
00:29:06,810 --> 00:29:09,640
>> ג'ייסון הירשהורן: אז אנחנו
יש שעד כאן.

571
00:29:09,640 --> 00:29:10,040
אה, סליחה.

572
00:29:10,040 --> 00:29:13,530
אתה אומר struct *.

573
00:29:13,530 --> 00:29:17,260
>> קהל: ואז [? סוג?]
צומת או צומת ג.

574
00:29:17,260 --> 00:29:17,780
>> ג'ייסון הירשהורן: אישור.

575
00:29:17,780 --> 00:29:19,740
אני הולך לקרוא לזה new_node
כדי שנוכל להישאר עקבי.

576
00:29:19,740 --> 00:29:22,646

577
00:29:22,646 --> 00:29:33,180
>> קהל: ואתה רוצה להגדיר את זה
לעמוד בראש, את הצומת הראשונה.

578
00:29:33,180 --> 00:29:33,580
>> ג'ייסון הירשהורן: אישור.

579
00:29:33,580 --> 00:29:37,290
אז עכשיו הצבעה זו כדי - כך זה
לא יצר צומת חדשה עדיין.

580
00:29:37,290 --> 00:29:41,380
זה רק מצביע על
הצומת ראשונה ברשימה.

581
00:29:41,380 --> 00:29:42,630
כיצד ניתן ליצור קשר חדש?

582
00:29:42,630 --> 00:29:45,490

583
00:29:45,490 --> 00:29:48,070
אם אני זקוק למרחב כדי ליצור קשר חדש.

584
00:29:48,070 --> 00:29:49,230
Malloc.

585
00:29:49,230 --> 00:29:51,710
ועד כמה גדול?

586
00:29:51,710 --> 00:30:00,390
>> קהל: הגודל של struct.

587
00:30:00,390 --> 00:30:01,150
>> ג'ייסון הירשהורן:
גודל של struct.

588
00:30:01,150 --> 00:30:02,400
ומה שנקרא struct?

589
00:30:02,400 --> 00:30:09,670

590
00:30:09,670 --> 00:30:09,840
>> קהל: צומת?

591
00:30:09,840 --> 00:30:11,640
>> ג'ייסון הירשהורן: צומת.

592
00:30:11,640 --> 00:30:17,640
אז malloc (sizeof (צומת));
נותן לנו מרחב.

593
00:30:17,640 --> 00:30:19,740
והאם הקו הזה -

594
00:30:19,740 --> 00:30:21,740
דבר אחד אינו נכון בקו הזה.

595
00:30:21,740 --> 00:30:24,430
האם new_node מצביע למבנה?

596
00:30:24,430 --> 00:30:25,650
זה שם גנרי.

597
00:30:25,650 --> 00:30:26,520
מה זה -

598
00:30:26,520 --> 00:30:27,450
צומת, בדיוק.

599
00:30:27,450 --> 00:30:29,340
זה צומת *.

600
00:30:29,340 --> 00:30:33,010
ומה עושים מייד אחרי
אנו malloc משהו, אסאן?

601
00:30:33,010 --> 00:30:34,476
מה הדבר הראשון שאנחנו עושים?

602
00:30:34,476 --> 00:30:38,850

603
00:30:38,850 --> 00:30:40,320
מה אם זה לא עובד?

604
00:30:40,320 --> 00:30:42,430
>> קהל: אה, לבדוק אם זה
מצביע לצומת?

605
00:30:42,430 --> 00:30:43,310
>> ג'ייסון הירשהורן: בדיוק.

606
00:30:43,310 --> 00:30:46,750
אז אם אתה new_node שווה שווה
null, מה אנחנו עושים?

607
00:30:46,750 --> 00:30:51,650

608
00:30:51,650 --> 00:30:54,820
זה מחזיר bool, בפונקציה זו.

609
00:30:54,820 --> 00:30:57,760
בדיוק.

610
00:30:57,760 --> 00:30:58,450
נראה טוב.

611
00:30:58,450 --> 00:30:59,680
משהו להוסיף שם?

612
00:30:59,680 --> 00:31:00,670
אנו נוסיף דברים בסופו של הדבר.

613
00:31:00,670 --> 00:31:03,160
אבל זה כל כך רחוק נראה טוב.

614
00:31:03,160 --> 00:31:06,170
צור מצביעים הנוכחיים וקודמים.

615
00:31:06,170 --> 00:31:08,650
מיכאל, איך אני עושה את זה?

616
00:31:08,650 --> 00:31:12,810
>> קהל: אתה היית צריך
לעשות צומת *.

617
00:31:12,810 --> 00:31:21,800

618
00:31:21,800 --> 00:31:25,502
היית צריך לעשות אחד לא
לnew_node אבל עבור

619
00:31:25,502 --> 00:31:26,905
צמתים כבר יש לנו.

620
00:31:26,905 --> 00:31:27,230
>> ג'ייסון הירשהורן: אישור.

621
00:31:27,230 --> 00:31:29,255
אז הצומת הנוכחית אנו נמצאים.

622
00:31:29,255 --> 00:31:30,505
אני אתקשר curr ש.

623
00:31:30,505 --> 00:31:39,650

624
00:31:39,650 --> 00:31:39,770
בסדר.

625
00:31:39,770 --> 00:31:41,620
החלטנו שאנחנו רוצים לשמור על
שני בגלל שאנחנו צריכים לדעת

626
00:31:41,620 --> 00:31:42,870
מה לפניו.

627
00:31:42,870 --> 00:31:45,770

628
00:31:45,770 --> 00:31:47,020
מה הם מקבלים מאותחלים ל?

629
00:31:47,020 --> 00:31:49,874

630
00:31:49,874 --> 00:31:54,180
>> קהל: הערך שלהם ברשימה שלנו.

631
00:31:54,180 --> 00:31:58,090
>> ג'ייסון הירשהורן: אז מה הוא
דבר ראשון ברשימה שלנו?

632
00:31:58,090 --> 00:32:04,050
או איך אנחנו יודעים איפה
התחלה של הרשימה שלנו היא?

633
00:32:04,050 --> 00:32:08,015
>> קהל: האם זה לא עבר
לפונקציה?

634
00:32:08,015 --> 00:32:08,466
>> ג'ייסון הירשהורן: נכון.

635
00:32:08,466 --> 00:32:09,716
זה נחקק בשנת ממש כאן.

636
00:32:09,716 --> 00:32:15,910

637
00:32:15,910 --> 00:32:18,980
אז אם זה עבר לפונקציה,
אתחיל ברשימה, מה על

638
00:32:18,980 --> 00:32:21,270
במערכה נוכחית שווה?

639
00:32:21,270 --> 00:32:22,110
>> קהל: רשימה.

640
00:32:22,110 --> 00:32:22,900
>> ג'ייסון הירשהורן: רשימה.

641
00:32:22,900 --> 00:32:24,090
זה בדיוק נכון.

642
00:32:24,090 --> 00:32:26,290
עכשיו יש לו את הכתובת של
תחילתה של הרשימה שלנו.

643
00:32:26,290 --> 00:32:28,450
ומה לגבי קודם?

644
00:32:28,450 --> 00:32:31,920
>> קהל: רשימה מינוס אחד?

645
00:32:31,920 --> 00:32:32,690
>> ג'ייסון הירשהורן: יש
שום דבר לפני זה.

646
00:32:32,690 --> 00:32:34,580
אז מה אנחנו יכולים לעשות כדי לסמן שום דבר?

647
00:32:34,580 --> 00:32:35,050
>> קהל: Null.

648
00:32:35,050 --> 00:32:35,450
>> ג'ייסון הירשהורן: כן.

649
00:32:35,450 --> 00:32:37,950
זה נשמע כמו רעיון טוב.

650
00:32:37,950 --> 00:32:38,360
מושלם.

651
00:32:38,360 --> 00:32:39,630
תודה.

652
00:32:39,630 --> 00:32:42,850
תעבור על הרשימה.

653
00:32:42,850 --> 00:32:45,490
קונסטנטין, כמה זמן אנחנו הולכים
כדי לעבור על הרשימה?

654
00:32:45,490 --> 00:32:49,010
>> קהל: עד שיגיעו ריק.

655
00:32:49,010 --> 00:32:49,390
>> ג'ייסון הירשהורן: אישור.

656
00:32:49,390 --> 00:32:50,430
אז אם, ואילו, ללולאה.

657
00:32:50,430 --> 00:32:52,200
מה אנחנו עושים?

658
00:32:52,200 --> 00:32:53,320
>> קהל: אולי ללולאה?

659
00:32:53,320 --> 00:32:53,910
>> ג'ייסון הירשהורן: בואו לעשות ללולאה.

660
00:32:53,910 --> 00:32:55,870
על אישור.

661
00:32:55,870 --> 00:33:02,465
>> קהל: ואנחנו אומרים ל--

662
00:33:02,465 --> 00:33:09,764

663
00:33:09,764 --> 00:33:13,390
עד שהמצביע הנוכחי
אינו שווה לריק.

664
00:33:13,390 --> 00:33:19,160
>> ג'ייסון הירשהורן: אז אם אנחנו יודעים
מצב, איך אנחנו יכולים לכתוב לולאה

665
00:33:19,160 --> 00:33:21,740
מבוסס את המצב הזה.

666
00:33:21,740 --> 00:33:24,380
איזה סוג של לולאה אנחנו צריכים להשתמש?

667
00:33:24,380 --> 00:33:25,260
>> קהל: בעוד.

668
00:33:25,260 --> 00:33:25,590
>> ג'ייסון הירשהורן: כן.

669
00:33:25,590 --> 00:33:27,130
זה הגיוני המבוסס יותר
את מה שאמרת.

670
00:33:27,130 --> 00:33:29,430
אם אנחנו רק רוצים להיכנס לזה היה לנו
פשוט יודע את הדבר הזה, זה יגרום

671
00:33:29,430 --> 00:33:31,680
תחושה לעשות לולאה בזמן.

672
00:33:31,680 --> 00:33:39,880
בעוד הנוכחי עושה null לא שווה,
אם הערך הוא פחות מ צומת זה.

673
00:33:39,880 --> 00:33:41,650
Akshar, תן לי את הקו הזה.

674
00:33:41,650 --> 00:33:48,810

675
00:33:48,810 --> 00:33:56,955
>> קהל: אם הנוכחי>-n
n פחות מהערך.

676
00:33:56,955 --> 00:34:00,170

677
00:34:00,170 --> 00:34:03,260
או להפוך את זה.

678
00:34:03,260 --> 00:34:06,140
לעבור סוגר זה.

679
00:34:06,140 --> 00:34:06,620
>> ג'ייסון הירשהורן: מצטער.

680
00:34:06,620 --> 00:34:08,760
>> קהל: שנה את הסוגר.

681
00:34:08,760 --> 00:34:10,914
>> ג'ייסון הירשהורן: אז אם זה
גדול יותר מהערך.

682
00:34:10,914 --> 00:34:18,719

683
00:34:18,719 --> 00:34:22,120
כי זה מבלבל עם
להגיב לעיל, אני הולך לעשות את זה.

684
00:34:22,120 --> 00:34:22,480
אבל כן.

685
00:34:22,480 --> 00:34:25,125
אם הערך שלנו הוא פחות מזה
צומת, מה אנחנו עושים?

686
00:34:25,125 --> 00:34:25,540
אה.

687
00:34:25,540 --> 00:34:26,710
יש לי אותו כאן.

688
00:34:26,710 --> 00:34:27,960
הכנס קודם.

689
00:34:27,960 --> 00:34:32,080

690
00:34:32,080 --> 00:34:32,370
על אישור.

691
00:34:32,370 --> 00:34:33,933
איך אנחנו עושים את זה?

692
00:34:33,933 --> 00:34:34,900
>> קהל: האם זה עדיין?

693
00:34:34,900 --> 00:34:36,150
>> ג'ייסון הירשהורן: כן.

694
00:34:36,150 --> 00:34:38,520

695
00:34:38,520 --> 00:34:39,770
>> קהל: אתה -

696
00:34:39,770 --> 00:34:42,909

697
00:34:42,909 --> 00:34:44,159
new_node-> הבא.

698
00:34:44,159 --> 00:34:46,770

699
00:34:46,770 --> 00:34:50,163
>> ג'ייסון הירשהורן: אז מה
שהולך להיות שווה?

700
00:34:50,163 --> 00:34:52,070
>> קהל: זה הולך הנוכחי שווה.

701
00:34:52,070 --> 00:34:53,889
>> ג'ייסון הירשהורן: בדיוק.

702
00:34:53,889 --> 00:34:55,730
וכל כך אחר -

703
00:34:55,730 --> 00:34:56,730
מה עוד אנחנו צריכים לעדכן?

704
00:34:56,730 --> 00:34:59,982
>> קהל: בדוק אם בעבר שווה אפס.

705
00:34:59,982 --> 00:35:01,870
>> ג'ייסון הירשהורן: אם קודם -

706
00:35:01,870 --> 00:35:03,730
כך שאם קודם שווה אפס.

707
00:35:03,730 --> 00:35:05,990
>> קהל: זה אומר שזה הולך
כדי להפוך את הראש.

708
00:35:05,990 --> 00:35:06,780
>> ג'ייסון הירשהורן: אמצעי זה
זה נהיה הראש.

709
00:35:06,780 --> 00:35:07,620
אז מה אנחנו עושים?

710
00:35:07,620 --> 00:35:12,510
>> קהל: אנו עושים בראש שווה new_node.

711
00:35:12,510 --> 00:35:16,690
>> ג'ייסון הירשהורן: ראש
שווה new_node.

712
00:35:16,690 --> 00:35:20,540
ולמה בראש כאן, לא יפרט?

713
00:35:20,540 --> 00:35:24,940
>> קהל: בגלל הראש הוא גלובלי
משתנה, המהווה את נקודת הזינוק.

714
00:35:24,940 --> 00:35:26,190
>> ג'ייסון הירשהורן: מתוק.

715
00:35:26,190 --> 00:35:33,750

716
00:35:33,750 --> 00:35:34,170
על אישור.

717
00:35:34,170 --> 00:35:36,150
ו--

718
00:35:36,150 --> 00:35:53,796
>> קהל: ואז אתה אחר prev->
הבא שווה new_node.

719
00:35:53,796 --> 00:35:55,080
ואז אתה חוזר נכון.

720
00:35:55,080 --> 00:35:59,560

721
00:35:59,560 --> 00:36:02,700
>> ג'ייסון הירשהורן: לאן
אנו קובעים סוף new_node?

722
00:36:02,700 --> 00:36:04,850
>> קהל: הייתי -

723
00:36:04,850 --> 00:36:06,180
אני מגדיר את זה בהתחלה.

724
00:36:06,180 --> 00:36:07,430
>> ג'ייסון הירשהורן: אז מה קו?

725
00:36:07,430 --> 00:36:10,000

726
00:36:10,000 --> 00:36:12,598
>> קהל: אחרי אם הצהרה
בודק אם זה ידוע.

727
00:36:12,598 --> 00:36:13,057
>> ג'ייסון הירשהורן: ממש כאן?

728
00:36:13,057 --> 00:36:18,335
>> קהל: הייתי עושה new_node-> n
שווה ערך.

729
00:36:18,335 --> 00:36:19,585
>> ג'ייסון הירשהורן: נשמע טוב.

730
00:36:19,585 --> 00:36:21,740

731
00:36:21,740 --> 00:36:25,090
כנראה שזה הגיוני - אנחנו לא
צריך לדעת מה אנחנו ברשימה

732
00:36:25,090 --> 00:36:26,280
כי אנחנו עוסקים רק
עם רשימה אחת.

733
00:36:26,280 --> 00:36:29,560
אז הצהרה על פונקציה טובה יותר עבור
זה רק כדי להיפטר מזה

734
00:36:29,560 --> 00:36:34,360
לגמרי ופשוט להכניס
ערך לתוך הראש.

735
00:36:34,360 --> 00:36:35,930
אנחנו אפילו לא צריכים לדעת
מה רשימה שאנו נמצאים בי

736
00:36:35,930 --> 00:36:39,140
אבל אני אשמור את זה לעת עתה ו
אז לשנות אותו על עדכון

737
00:36:39,140 --> 00:36:42,590
השקופיות וקוד.

738
00:36:42,590 --> 00:36:44,980
אז זה נראה טוב לעת עתה.

739
00:36:44,980 --> 00:36:46,560
אם ערך - שיכול לעשות את הקו הזה?

740
00:36:46,560 --> 00:36:47,810
אם -

741
00:36:47,810 --> 00:36:52,240

742
00:36:52,240 --> 00:36:53,840
מה אנחנו עושים כאן, נח.

743
00:36:53,840 --> 00:36:57,890

744
00:36:57,890 --> 00:37:07,100
>> קהל: אם הערך גדול
מ curr-> n -

745
00:37:07,100 --> 00:37:16,830

746
00:37:16,830 --> 00:37:18,240
>> ג'ייסון הירשהורן: איך לעשות
אנחנו הולכים לקשר הבא?

747
00:37:18,240 --> 00:37:27,760

748
00:37:27,760 --> 00:37:30,530
>> קהל: Curr-> n הוא
שווה new_node.

749
00:37:30,530 --> 00:37:37,630

750
00:37:37,630 --> 00:37:39,195
>> ג'ייסון הירשהורן: אז n הוא
מה חלק של struct?

751
00:37:39,195 --> 00:37:43,065

752
00:37:43,065 --> 00:37:46,020
המספר השלם.

753
00:37:46,020 --> 00:37:50,420
וnew_node הוא מצביע לצומת.

754
00:37:50,420 --> 00:37:51,880
אז מה חלק של curr אנחנו צריכים לעדכן?

755
00:37:51,880 --> 00:38:03,900

756
00:38:03,900 --> 00:38:05,400
אם לא n, אז מה החלק השני?

757
00:38:05,400 --> 00:38:21,680

758
00:38:21,680 --> 00:38:22,810
נח, מהו החלק האחר.

759
00:38:22,810 --> 00:38:23,570
>> קהל: אה, הבא.

760
00:38:23,570 --> 00:38:25,645
>> ג'ייסון הירשהורן: בשלב הבא, בדיוק.

761
00:38:25,645 --> 00:38:26,410
בדיוק.

762
00:38:26,410 --> 00:38:28,770
הבא הוא נכון.

763
00:38:28,770 --> 00:38:31,540
ומה עוד אנחנו צריכים
כדי לעדכן, נח?

764
00:38:31,540 --> 00:38:32,840
>> קהל: המצביעים.

765
00:38:32,840 --> 00:38:34,840
>> ג'ייסון הירשהורן: אז
אנו מעודכנים הנוכחיים.

766
00:38:34,840 --> 00:38:36,090
>> קהל: קודם-> הבא.

767
00:38:36,090 --> 00:38:48,160

768
00:38:48,160 --> 00:38:49,410
>> ג'ייסון הירשהורן: כן.

769
00:38:49,410 --> 00:38:57,465

770
00:38:57,465 --> 00:38:58,370
OK, נשהה.

771
00:38:58,370 --> 00:39:02,200
מי יכול לעזור לנו כאן?

772
00:39:02,200 --> 00:39:03,385
מנו, מה עלינו לעשות?

773
00:39:03,385 --> 00:39:05,615
>> קהל: אתה חייב להגדיר
זה שווה לcurr-> הבא.

774
00:39:05,615 --> 00:39:09,110

775
00:39:09,110 --> 00:39:11,630
אבל לעשות את זה לפני הקו הקודם.

776
00:39:11,630 --> 00:39:12,880
>> ג'ייסון הירשהורן: אישור.

777
00:39:12,880 --> 00:39:16,590

778
00:39:16,590 --> 00:39:18,260
כל דבר אחר?

779
00:39:18,260 --> 00:39:19,170
Akshar.

780
00:39:19,170 --> 00:39:22,680
>> קהל: אני לא חושב שאתה
נועד לשנות curr-> הבא.

781
00:39:22,680 --> 00:39:29,270
אני חושב שאתה אמור לעשות שווים curr
curr-> הבא ללכת לצומת הבאה.

782
00:39:29,270 --> 00:39:30,500
>> ג'ייסון הירשהורן: אז מצטער, שבו?

783
00:39:30,500 --> 00:39:32,680
על מה קו?

784
00:39:32,680 --> 00:39:33,420
קו זה?

785
00:39:33,420 --> 00:39:33,750
>> קהל: כן.

786
00:39:33,750 --> 00:39:35,745
הפוך curr שווה curr-> הבא.

787
00:39:35,745 --> 00:39:39,690

788
00:39:39,690 --> 00:39:43,360
>> ג'ייסון הירשהורן: אז זה נכון
בגלל הנוכחי הוא

789
00:39:43,360 --> 00:39:45,220
מצביע לצומת.

790
00:39:45,220 --> 00:39:48,550
ואנחנו רוצים שהוא יצביע למשנהו
צומת של מה שמקבל כיום

791
00:39:48,550 --> 00:39:49,930
הצבעתי.

792
00:39:49,930 --> 00:39:54,410
יש Curr עצמו הבא.

793
00:39:54,410 --> 00:39:58,620
אבל אם היינו לעדכן curr.next, אנחנו
יהיה עדכון הערה בפועל

794
00:39:58,620 --> 00:40:01,430
עצמו, לא איפה זה
המצביע הצביע.

795
00:40:01,430 --> 00:40:02,680
מה לגבי הקו הזה, אם כי.

796
00:40:02,680 --> 00:40:05,160

797
00:40:05,160 --> 00:40:07,330
אבי?

798
00:40:07,330 --> 00:40:09,590
>> קהל: קודם-> הבא שווה curr.

799
00:40:09,590 --> 00:40:12,500

800
00:40:12,500 --> 00:40:19,440
>> ג'ייסון הירשהורן: אז שוב, אם קודם הוא
מצביע לצומת, קודם-> הבא הוא

801
00:40:19,440 --> 00:40:23,020
מצביע בפועל בצומת.

802
00:40:23,020 --> 00:40:27,190
אז זה יהיה עדכון
מצביע בצומת לcurr.

803
00:40:27,190 --> 00:40:28,570
אנחנו לא רוצים לעדכן
מצביע בצומת.

804
00:40:28,570 --> 00:40:30,570
אנחנו רוצים לעדכן קודמים.

805
00:40:30,570 --> 00:40:31,850
אז איך אנחנו עושים את זה?

806
00:40:31,850 --> 00:40:34,250
>> קהל: זה יהיה רק ​​את קודם.

807
00:40:34,250 --> 00:40:34,565
>> ג'ייסון הירשהורן: נכון.

808
00:40:34,565 --> 00:40:35,560
קודם הוא מצביע לצומת.

809
00:40:35,560 --> 00:40:38,750
עכשיו אנחנו משנים אותו כדי
מצביע חדש לצומת.

810
00:40:38,750 --> 00:40:40,830
אישור תן לנו לרדת.

811
00:40:40,830 --> 00:40:41,940
לבסוף, התנאי אחרון זה.

812
00:40:41,940 --> 00:40:44,896
ג'ף, מה אנחנו עושים כאן?

813
00:40:44,896 --> 00:40:47,515
>> קהל: אם הערך הוא
שווה curr-> n.

814
00:40:47,515 --> 00:40:51,030

815
00:40:51,030 --> 00:40:51,300
>> ג'ייסון הירשהורן: מצטער.

816
00:40:51,300 --> 00:40:52,372
אלוהים אדירים.

817
00:40:52,372 --> 00:40:54,330
מה?

818
00:40:54,330 --> 00:40:55,580
ערך == curr-> n.

819
00:40:55,580 --> 00:41:01,050

820
00:41:01,050 --> 00:41:02,300
מה אנחנו עושים?

821
00:41:02,300 --> 00:41:04,760

822
00:41:04,760 --> 00:41:10,950
>> קהל: היית לשחרר new_node שלנו,
ואז היית בתמורת שווא.

823
00:41:10,950 --> 00:41:21,410

824
00:41:21,410 --> 00:41:23,460
>> ג'ייסון הירשהורן: זה מה
שכתבנו עד כה.

825
00:41:23,460 --> 00:41:25,710
האם יש למישהו משהו
להוסיף לפני שאנחנו עושים?

826
00:41:25,710 --> 00:41:35,460

827
00:41:35,460 --> 00:41:35,710
על אישור.

828
00:41:35,710 --> 00:41:36,960
בואו ננסה את זה.

829
00:41:36,960 --> 00:41:44,180

830
00:41:44,180 --> 00:41:46,110
שליטה יכולה להגיע לסוף
של פונקציה שאינה מבוטלת.

831
00:41:46,110 --> 00:41:48,310
אבי, מה קורה?

832
00:41:48,310 --> 00:41:51,380
>> קהל: האם אתה אמור לשים את התמורה
אמיתי מחוץ ללולאה בזמן?

833
00:41:51,380 --> 00:41:53,900

834
00:41:53,900 --> 00:41:54,400
>> ג'ייסון הירשהורן: אני לא יודע.

835
00:41:54,400 --> 00:41:54,780
האם אתה רוצה שאני?

836
00:41:54,780 --> 00:41:55,520
>> קהל: לא משנה.

837
00:41:55,520 --> 00:41:56,350
לא.

838
00:41:56,350 --> 00:41:57,180
>> ג'ייסון הירשהורן: Akshar?

839
00:41:57,180 --> 00:41:59,460
>> קהל: אני חושב שאתה אמור
לשים שווא לחזור בסוף

840
00:41:59,460 --> 00:42:02,230
מתוך הלולאה.

841
00:42:02,230 --> 00:42:03,270
>> ג'ייסון הירשהורן: אז איפה
אתה רוצה שזה ילך?

842
00:42:03,270 --> 00:42:05,270
>> קהל: כמו שמחוץ ללולאה בזמן.

843
00:42:05,270 --> 00:42:08,800
אז אם אתה יוצא ואילו לולאה שאמצעים
כי אתה כבר הגעת לסוף ו

844
00:42:08,800 --> 00:42:09,980
שום דבר לא קרה.

845
00:42:09,980 --> 00:42:10,410
>> ג'ייסון הירשהורן: אישור.

846
00:42:10,410 --> 00:42:12,340
אז מה אנחנו עושים כאן?

847
00:42:12,340 --> 00:42:13,702
>> קהל: אתה בתמורת שווא
גם שם.

848
00:42:13,702 --> 00:42:15,040
>> ג'ייסון הירשהורן: אה, אנחנו
לעשות את זה בשני המקומות?

849
00:42:15,040 --> 00:42:15,650
>> קהל: כן.

850
00:42:15,650 --> 00:42:16,900
>> ג'ייסון הירשהורן: אישור.

851
00:42:16,900 --> 00:42:24,840

852
00:42:24,840 --> 00:42:26,160
האם עלינו ללכת?

853
00:42:26,160 --> 00:42:26,980
אלוהים אדירים.

854
00:42:26,980 --> 00:42:27,290
אני מצטער.

855
00:42:27,290 --> 00:42:28,480
אני מתנצל על המסך.

856
00:42:28,480 --> 00:42:30,530
זה סוג של מתחרפן עלינו.

857
00:42:30,530 --> 00:42:31,520
אז לבחור אפשרות.

858
00:42:31,520 --> 00:42:35,260
אפס, לקוד, נסגר התכנית.

859
00:42:35,260 --> 00:42:36,700
אחד מוסיף משהו.

860
00:42:36,700 --> 00:42:37,990
בואו להכניס שלוש.

861
00:42:37,990 --> 00:42:42,900

862
00:42:42,900 --> 00:42:45,380
הכנס לא היה מוצלח.

863
00:42:45,380 --> 00:42:46,500
אני הולך להדפיס.

864
00:42:46,500 --> 00:42:48,050
אין לי שום דבר.

865
00:42:48,050 --> 00:42:48,450
על אישור.

866
00:42:48,450 --> 00:42:50,250
אולי זה היה סתם מזל.

867
00:42:50,250 --> 00:42:52,810
הכנס אחד.

868
00:42:52,810 --> 00:42:55,770
לא מוצלח.

869
00:42:55,770 --> 00:42:57,470
על אישור.

870
00:42:57,470 --> 00:43:02,400
בואו לרוץ דרך GDB ממש מהר
כדי לבדוק מה קורה.

871
00:43:02,400 --> 00:43:06,055
>> זכור gdb. / את השם שלך
תכנית מביאה אותנו לתוך GDB.

872
00:43:06,055 --> 00:43:07,610
האם זה הרבה להתמודד?

873
00:43:07,610 --> 00:43:08,560
מהבהב?

874
00:43:08,560 --> 00:43:10,400
כנראה שכן.

875
00:43:10,400 --> 00:43:12,760
עצום את עיניך ולקחת כמה עמוק
נשימות אם נמאס לך

876
00:43:12,760 --> 00:43:13,580
להסתכל על זה.

877
00:43:13,580 --> 00:43:14,200
אני בGDB.

878
00:43:14,200 --> 00:43:15,830
מה הדבר הראשון שאני עושה בGDB?

879
00:43:15,830 --> 00:43:17,050
אנחנו חייבים להבין
מה קורה כאן.

880
00:43:17,050 --> 00:43:17,310
בואו נראה.

881
00:43:17,310 --> 00:43:21,650
יש לנו שש דקות לדמות
מה קורה הלאה.

882
00:43:21,650 --> 00:43:22,900
לשבור ראשי.

883
00:43:22,900 --> 00:43:25,950

884
00:43:25,950 --> 00:43:28,130
ואז מה עליי לעשות?

885
00:43:28,130 --> 00:43:29,180
קרלוס?

886
00:43:29,180 --> 00:43:31,060
לרוץ.

887
00:43:31,060 --> 00:43:32,250
על אישור.

888
00:43:32,250 --> 00:43:34,160
בואו לבחור אפשרות.

889
00:43:34,160 --> 00:43:36,330
ומה N עושה?

890
00:43:36,330 --> 00:43:38,480
הבא.

891
00:43:38,480 --> 00:43:38,950
כן.

892
00:43:38,950 --> 00:43:39,740
>> קהל: לא הזכיר -

893
00:43:39,740 --> 00:43:45,230
אתה לא אומר את זה בראש, זה היה
אותחל לאפס בהתחלה.

894
00:43:45,230 --> 00:43:47,140
אבל חשבתי שאמרת שזה היה בסדר.

895
00:43:47,140 --> 00:43:50,040

896
00:43:50,040 --> 00:43:52,640
>> ג'ייסון הירשהורן: בואו נלך - בואו נסתכל
בGDB, ואז נלך אחורה.

897
00:43:52,640 --> 00:43:54,910
אבל זה נשמע כאילו יש לך כבר
כמה רעיונות על מה שקורה.

898
00:43:54,910 --> 00:43:58,340
אז אנחנו רוצים להכניס משהו.

899
00:43:58,340 --> 00:43:59,390
על אישור.

900
00:43:59,390 --> 00:44:00,150
יש לנו להוסיף.

901
00:44:00,150 --> 00:44:00,770
נא להזין את int.

902
00:44:00,770 --> 00:44:01,990
אנחנו נכניס שלוש.

903
00:44:01,990 --> 00:44:03,000
ואז אני על הקו הזה.

904
00:44:03,000 --> 00:44:07,030
איך אני הולך להתחיל באגים
הכנס ידוע פונקציה?

905
00:44:07,030 --> 00:44:08,280
אלוהים אדירים.

906
00:44:08,280 --> 00:44:10,990

907
00:44:10,990 --> 00:44:12,240
זה המון.

908
00:44:12,240 --> 00:44:14,372

909
00:44:14,372 --> 00:44:16,445
האם שמתחרפן הרבה?

910
00:44:16,445 --> 00:44:19,696

911
00:44:19,696 --> 00:44:21,680
>> קהל: אה, הוא מת.

912
00:44:21,680 --> 00:44:22,930
>> ג'ייסון הירשהורן: אני רק
משך אותו החוצה.

913
00:44:22,930 --> 00:44:27,364

914
00:44:27,364 --> 00:44:28,310
על אישור.

915
00:44:28,310 --> 00:44:29,560
>> קהל: אולי זה
קצה שני של החוט.

916
00:44:29,560 --> 00:44:37,000

917
00:44:37,000 --> 00:44:39,470
>> ג'ייסון הירשהורן: וואו.

918
00:44:39,470 --> 00:44:42,330
אז השורה התחתונה -

919
00:44:42,330 --> 00:44:43,470
מה אמר?

920
00:44:43,470 --> 00:44:46,040
>> קהל: אני אמרתי את האירוניה של טכני
קשיים בכיתה זו.

921
00:44:46,040 --> 00:44:46,410
>> ג'ייסון הירשהורן: אני יודע.

922
00:44:46,410 --> 00:44:48,660
אם רק היה לי שליטה על החלק הזה.

923
00:44:48,660 --> 00:44:49,910
[לא ברור]

924
00:44:49,910 --> 00:44:54,430

925
00:44:54,430 --> 00:44:55,400
זה נשמע נהדר.

926
00:44:55,400 --> 00:44:58,680
למה אתם לא מתחילים לחשוב על
מה שאנחנו יכולים לעשות את הלא נכונים,

927
00:44:58,680 --> 00:45:01,140
ואנחנו נחזור ב90 שניות.

928
00:45:01,140 --> 00:46:18,160

929
00:46:18,160 --> 00:46:23,010
>> Avica, אני הולך לשאול אותך איך ללכת
insert_node בתוך לאתר באגים אותה.

930
00:46:23,010 --> 00:46:28,940

931
00:46:28,940 --> 00:46:31,460
אז זה מקום שבו הפסקנו אחרון.

932
00:46:31,460 --> 00:46:35,110
כיצד אני יכול להיכנס פנימה insert_node, Avica,
לבדוק מה קורה?

933
00:46:35,110 --> 00:46:36,360
מה GDB הפקודה?

934
00:46:36,360 --> 00:46:41,050

935
00:46:41,050 --> 00:46:42,390
הפסקה לא הייתה לוקחת אותי פנימה.

936
00:46:42,390 --> 00:46:46,200

937
00:46:46,200 --> 00:46:47,130
האם יודעת המרקיזה?

938
00:46:47,130 --> 00:46:48,240
>> קהל: מה?

939
00:46:48,240 --> 00:46:51,780
>> ג'ייסון הירשהורן: פקודת GDB מה
אני משתמש כדי להיכנס פנימה בפונקציה זו?

940
00:46:51,780 --> 00:46:52,070
>> קהל: שלב?

941
00:46:52,070 --> 00:46:55,140
>> ג'ייסון הירשהורן: שלב באמצעות
ס 'זה לוקח אותי פנימה.

942
00:46:55,140 --> 00:46:55,476
על אישור.

943
00:46:55,476 --> 00:46:58,040
New_node mallocing קצת מרחב.

944
00:46:58,040 --> 00:46:59,120
כי הכל נראה כמו שלה הולך.

945
00:46:59,120 --> 00:47:00,370
הבה נבחן new_node.

946
00:47:00,370 --> 00:47:03,270

947
00:47:03,270 --> 00:47:05,410
זה יש לי כמה כתובת זיכרון.

948
00:47:05,410 --> 00:47:07,440
בואו לבדוק -

949
00:47:07,440 --> 00:47:08,500
זה כל מה נכון.

950
00:47:08,500 --> 00:47:12,220
אז הכל כאן נראה
לעבוד בצורה נכונה.

951
00:47:12,220 --> 00:47:14,530
>> קהל: מה ההבדל
בין P ותצוגה?

952
00:47:14,530 --> 00:47:16,160
>> ג'ייסון הירשהורן: P עומד על הדפסה.

953
00:47:16,160 --> 00:47:19,310
ואז אתה שואל מה
הבדל בין זה וזה?

954
00:47:19,310 --> 00:47:22,330
במקרה זה, שום דבר.

955
00:47:22,330 --> 00:47:26,960
אבל בדרך כלל יש
כמה הבדלים.

956
00:47:26,960 --> 00:47:28,220
ואתה צריך להסתכל במדריך GDB.

957
00:47:28,220 --> 00:47:29,560
אבל במקרה הזה, שום דבר.

958
00:47:29,560 --> 00:47:31,460
למרות שאנו נוטים להשתמש בהדפסה,, כי
אנחנו לא צריכים לעשות הרבה יותר מאשר

959
00:47:31,460 --> 00:47:33,960
להדפיס ערך יחיד.

960
00:47:33,960 --> 00:47:34,640
>> על אישור.

961
00:47:34,640 --> 00:47:40,300
אז אנחנו נמצאים על קו 80 של הקוד שלנו,
הגדרת הצומת * curr שווה לרשימה.

962
00:47:40,300 --> 00:47:42,500
תן לנו להדפיס את curr.

963
00:47:42,500 --> 00:47:45,260

964
00:47:45,260 --> 00:47:46,840
זה שווה רשימה.

965
00:47:46,840 --> 00:47:48,850
מתוק.

966
00:47:48,850 --> 00:47:49,340
חכה.

967
00:47:49,340 --> 00:47:50,590
זה שווה משהו.

968
00:47:50,590 --> 00:47:53,680

969
00:47:53,680 --> 00:47:56,190
זה לא נראה נכון.

970
00:47:56,190 --> 00:47:56,840
הנה.

971
00:47:56,840 --> 00:47:59,470
זה בגלל בGDB, נכון, אם
זה הקו שאתה על זה

972
00:47:59,470 --> 00:48:00,330
לא ביצע עדיין.

973
00:48:00,330 --> 00:48:03,100
אז אתה צריך להקליד למעשה
בסמוך לביצוע הקו

974
00:48:03,100 --> 00:48:05,230
לפני שראיתי את תוצאותיה.

975
00:48:05,230 --> 00:48:06,680
אז הנה אנחנו.

976
00:48:06,680 --> 00:48:09,490
אנחנו רק ביצענו את הקו הזה,
קודם שווה אפס.

977
00:48:09,490 --> 00:48:13,590
אז שוב, אם אנחנו להדפיס קודמים
אנו לא רואים שום דבר מוזר.

978
00:48:13,590 --> 00:48:18,680
אבל אם אנחנו באמת לבצע כי
קו, ואז תוכל לראות

979
00:48:18,680 --> 00:48:20,380
כי קו זה עבד.

980
00:48:20,380 --> 00:48:21,060
>> אז יש לנו curr.

981
00:48:21,060 --> 00:48:23,180
אלה הם גם טובים.

982
00:48:23,180 --> 00:48:24,010
נכון?

983
00:48:24,010 --> 00:48:28,130
עכשיו אנחנו בקו זה ממש כאן.

984
00:48:28,130 --> 00:48:29,310
בעוד curr לא null שווה.

985
00:48:29,310 --> 00:48:31,110
ובכן, מה עושה curr שווה?

986
00:48:31,110 --> 00:48:32,450
אנחנו רק ראינו את זה שווה אפס.

987
00:48:32,450 --> 00:48:33,210
הדפסנו אותו החוצה.

988
00:48:33,210 --> 00:48:35,110
אני להדפיס את זה שוב.

989
00:48:35,110 --> 00:48:36,720
אז הוא שבעוד לולאה
הולך לבצע?

990
00:48:36,720 --> 00:48:37,270
>> קהל: לא.

991
00:48:37,270 --> 00:48:39,790
>> ג'ייסון הירשהורן: לכן, כאשר הקלדתי כי
קו, אתה רואה שאנחנו קפצנו כל הדרך

992
00:48:39,790 --> 00:48:41,390
עד לתחתית, בתמורת שווא.

993
00:48:41,390 --> 00:48:44,520
ואז אנחנו הולכים לחזור שווא
ואחזור לתכנית שלנו ו

994
00:48:44,520 --> 00:48:48,020
סופו של דבר להדפיס, כמו שראינו,
הכנס לא היה מוצלח.

995
00:48:48,020 --> 00:48:51,010
אז, למישהו יש רעיונות על מה
אנחנו צריכים לעשות כדי לתקן את זה?

996
00:48:51,010 --> 00:48:54,200

997
00:48:54,200 --> 00:48:57,570
אני הולך לחכות עד שאני רואה
כמה ידיים לעלות.

998
00:48:57,570 --> 00:48:58,830
אנחנו לא בצענו את זה.

999
00:48:58,830 --> 00:49:01,660
זכרו, זה היה ראשון
דבר שאנחנו עושים.

1000
00:49:01,660 --> 00:49:02,430
אני לא הולך לעשות את בני זוג.

1001
00:49:02,430 --> 00:49:03,670
אני הולך לעשות כמה.

1002
00:49:03,670 --> 00:49:04,830
מכיוון שבני זוג אומר שני.

1003
00:49:04,830 --> 00:49:07,620
אני אחכה ליותר משני.

1004
00:49:07,620 --> 00:49:10,690
>> ההכנסה הראשונה, curr,
כברירת מחדל שווה אפס.

1005
00:49:10,690 --> 00:49:14,050
ולולאה זו מבצעת רק
אם curr הוא לא ריק.

1006
00:49:14,050 --> 00:49:18,740
אז איך אני יכול לעקוף את זה?

1007
00:49:18,740 --> 00:49:19,990
אני רואה שלוש ידיים.

1008
00:49:19,990 --> 00:49:28,490

1009
00:49:28,490 --> 00:49:29,780
אני אחכה ליותר משלושה.

1010
00:49:29,780 --> 00:49:33,460

1011
00:49:33,460 --> 00:49:35,940
מרקוס, מה אתה חושב?

1012
00:49:35,940 --> 00:49:37,730
>> קהל: ובכן, אם אתה צריך את זה כדי
לבצע יותר מפעם אחת, אתה פשוט

1013
00:49:37,730 --> 00:49:39,948
לשנות אותו ללולאה עשה בזמן.

1014
00:49:39,948 --> 00:49:41,250
>> ג'ייסון הירשהורן: אישור.

1015
00:49:41,250 --> 00:49:44,240
האם זה יפתור את הבעיה שלנו, אם כי?

1016
00:49:44,240 --> 00:49:47,750
>> קהל: במקרה זה לא בגלל
העובדה שהרשימה ריקה.

1017
00:49:47,750 --> 00:49:52,150
אז אתה כנראה רק צריך להוסיף
הצהרה שאם יציאות הלולאה

1018
00:49:52,150 --> 00:49:55,312
אז אתה צריך להיות בסוף
הרשימה, ובנקודה שאתה

1019
00:49:55,312 --> 00:49:56,562
יכול פשוט להכניס אותו.

1020
00:49:56,562 --> 00:49:58,920

1021
00:49:58,920 --> 00:49:59,680
>> ג'ייסון הירשהורן: אני אוהב את זה.

1022
00:49:59,680 --> 00:50:00,500
זה הגיוני.

1023
00:50:00,500 --> 00:50:03,390
אם הלולאה יוצאת -

1024
00:50:03,390 --> 00:50:04,800
כי זה יחזור שווא כאן.

1025
00:50:04,800 --> 00:50:08,220
אז אם יוצא הלולאה, ואז אנחנו ב
סוף הרשימה, או אולי

1026
00:50:08,220 --> 00:50:10,690
תתחיל מרשימה, אם אין שום דבר ב
זה, וזה אותו הדבר כמו הסוף.

1027
00:50:10,690 --> 00:50:12,770
אז עכשיו אנחנו רוצים להכניס
משהו כאן.

1028
00:50:12,770 --> 00:50:17,380
אז איך קוד שנראה, מרקוס?

1029
00:50:17,380 --> 00:50:21,600
>> קהל: אם אתה כבר קיבלת את הצומת
malloced, אתה יכול פשוט להגיד

1030
00:50:21,600 --> 00:50:25,400
new_node-> הבא שווה null משום
זה חייב להיות בסוף.

1031
00:50:25,400 --> 00:50:27,510
או new_node-> הבא שווה אפס.

1032
00:50:27,510 --> 00:50:27,765
>> ג'ייסון הירשהורן: אישור.

1033
00:50:27,765 --> 00:50:28,190
סליחה.

1034
00:50:28,190 --> 00:50:35,760
New_node-> הבא שווה null
בגלל שאנחנו בסוף.

1035
00:50:35,760 --> 00:50:36,460
זה לא לשים אותו פנימה

1036
00:50:36,460 --> 00:50:37,710
איך אפשר לשים אותו ברשימה?

1037
00:50:37,710 --> 00:50:46,130

1038
00:50:46,130 --> 00:50:46,460
נכון.

1039
00:50:46,460 --> 00:50:47,750
זה רק הצבתו כ.

1040
00:50:47,750 --> 00:50:50,940
לא איך אנחנו באמת
לשים אותו ברשימה?

1041
00:50:50,940 --> 00:50:54,170
מה מצביע על
סוף הרשימה?

1042
00:50:54,170 --> 00:50:56,090
>> קהל: ראש.

1043
00:50:56,090 --> 00:50:57,566
>> ג'ייסון הירשהורן: סליחה?

1044
00:50:57,566 --> 00:50:59,440
>> קהל: הראש מצביע
לסוף הרשימה.

1045
00:50:59,440 --> 00:51:01,480
>> ג'ייסון הירשהורן: אם אין שום דבר ב
הרשימה, הראש מצביע על

1046
00:51:01,480 --> 00:51:04,170
סוף הרשימה.

1047
00:51:04,170 --> 00:51:06,920
כך שיעבוד עבור
ההכנסה ראשונה.

1048
00:51:06,920 --> 00:51:09,810
מה קורה אם יש כמה
דברים ברשימה?

1049
00:51:09,810 --> 00:51:12,470
ממה שאנו לא רוצים להגדיר
ראש שווה לnew_node.

1050
00:51:12,470 --> 00:51:13,790
מה אנחנו רוצים לעשות שם?

1051
00:51:13,790 --> 00:51:15,610
כן?

1052
00:51:15,610 --> 00:51:16,860
כנראה קודם.

1053
00:51:16,860 --> 00:51:23,560

1054
00:51:23,560 --> 00:51:24,810
האם זה עובד?

1055
00:51:24,810 --> 00:51:28,950

1056
00:51:28,950 --> 00:51:33,050
נזכיר כי קודם הוא רק
מצביע לצומת.

1057
00:51:33,050 --> 00:51:34,770
והקודם הוא משתנה מקומי.

1058
00:51:34,770 --> 00:51:38,080
אז הקו הזה יהיה להגדיר משתנה מקומי,
קודם, שווה או

1059
00:51:38,080 --> 00:51:39,380
מצביע לצומת חדשה זה.

1060
00:51:39,380 --> 00:51:41,500
זה לא יהיה ממש לשים אותו
ברשימה שלנו, אם כי.

1061
00:51:41,500 --> 00:51:44,330
איך אפשר לשים אותו ברשימה שלנו?

1062
00:51:44,330 --> 00:51:45,620
Akchar?

1063
00:51:45,620 --> 00:51:46,870
>> קהל: אני חושב שאתה
לעשות הנוכחי> הבא.

1064
00:51:46,870 --> 00:51:50,186

1065
00:51:50,186 --> 00:51:52,550
>> ג'ייסון הירשהורן: אישור.

1066
00:51:52,550 --> 00:51:54,010
curr-> הבא.

1067
00:51:54,010 --> 00:51:58,768
אז שוב, הסיבה היחידה שאנחנו למטה
כאן הוא, מה עושה נוכחית שווה?

1068
00:51:58,768 --> 00:51:59,760
>> קהל: שווה אפס.

1069
00:51:59,760 --> 00:52:01,790
>> ג'ייסון הירשהורן: אז מה
קורה אם אנחנו עושים null-> הבא?

1070
00:52:01,790 --> 00:52:02,810
מה אנחנו הולכים לקבל?

1071
00:52:02,810 --> 00:52:04,060
אנחנו נוציא את אשמת פילוח.

1072
00:52:04,060 --> 00:52:06,600

1073
00:52:06,600 --> 00:52:08,880
>> קהל: curr האם שווה אפס.

1074
00:52:08,880 --> 00:52:10,760
>> ג'ייסון הירשהורן: זה אותו הדבר
כמו קודם, אם כי, כי יש

1075
00:52:10,760 --> 00:52:12,820
משתנה מקומי אנחנו הגדרה
שווה לצומת חדשה זה.

1076
00:52:12,820 --> 00:52:16,680

1077
00:52:16,680 --> 00:52:20,920
בואו נחזור לתמונה שלנו
החדרה של משהו.

1078
00:52:20,920 --> 00:52:25,500
אומר שאנחנו מכניסים בסוף
הרשימה, כך ממש כאן.

1079
00:52:25,500 --> 00:52:30,010
יש לנו מצביע הנוכחי זה
מצביע על null ונקודה קודמת

1080
00:52:30,010 --> 00:52:32,800
זה מצביע על 8.

1081
00:52:32,800 --> 00:52:35,330
אז מה אנחנו צריכים לעשות כדי לעדכן, אבי?

1082
00:52:35,330 --> 00:52:36,680
>> קהל: הקודם-> הבא?

1083
00:52:36,680 --> 00:52:41,980
>> ג'ייסון הירשהורן: הקודם-> הבא הוא מה
אנחנו רוצים לעדכן כי

1084
00:52:41,980 --> 00:52:44,960
יהיה למעשה להכניס אותו ב
סוף הרשימה.

1085
00:52:44,960 --> 00:52:47,220
עדיין יש לנו באג אחד, לעומת זאת,
שאנחנו הולכים להיתקל.

1086
00:52:47,220 --> 00:52:50,090
מה הבאג הזה?

1087
00:52:50,090 --> 00:52:50,790
כן?

1088
00:52:50,790 --> 00:52:53,860
>> קהל: זה הולך לחזור
שקר במקרה זה?

1089
00:52:53,860 --> 00:52:56,380
>> ג'ייסון הירשהורן: הו, הוא
הולך בתמורת שווא.

1090
00:52:56,380 --> 00:52:57,430
אבל יש באג אחר.

1091
00:52:57,430 --> 00:52:58,930
אז אנחנו נצטרך לשים בתמורה אמיתית.

1092
00:52:58,930 --> 00:53:01,370
>> קהל: האם קודם עדיין שווה
null בחלק העליון של הרשימה?

1093
00:53:01,370 --> 00:53:03,645
>> ג'ייסון הירשהורן: עדיין אז קודם
שווה אפס בהתחלה.

1094
00:53:03,645 --> 00:53:07,480

1095
00:53:07,480 --> 00:53:10,440
אז איך אנחנו יכולים להתגבר על זה?

1096
00:53:10,440 --> 00:53:10,950
כן?

1097
00:53:10,950 --> 00:53:15,280
>> קהל: אני חושב שאתה יכול לעשות בדיקה
לפני ואילו לולאה כדי לראות אם זה

1098
00:53:15,280 --> 00:53:16,610
רשימה ריקה.

1099
00:53:16,610 --> 00:53:17,000
>> ג'ייסון הירשהורן: אישור.

1100
00:53:17,000 --> 00:53:17,710
אז בואו נלך כאן.

1101
00:53:17,710 --> 00:53:18,530
לעשות בדיקה.

1102
00:53:18,530 --> 00:53:19,380
אם -

1103
00:53:19,380 --> 00:53:20,770
>> קהל: אז אם את הראש
שווה שווה אפס.

1104
00:53:20,770 --> 00:53:24,300

1105
00:53:24,300 --> 00:53:26,320
>> ג'ייסון הירשהורן: אם ראש
שווה שווה null -

1106
00:53:26,320 --> 00:53:27,790
שיגיד לנו אם זה רשימה ריקה.

1107
00:53:27,790 --> 00:53:31,090
>> קהל: ואז אתה
לעשות ראש שווה חדש.

1108
00:53:31,090 --> 00:53:34,740
>> ג'ייסון הירשהורן: ראש
שווה new_node?

1109
00:53:34,740 --> 00:53:35,730
ומה עוד אנחנו צריכים לעשות?

1110
00:53:35,730 --> 00:53:37,020
>> קהל: ואז אתה חוזר נכון.

1111
00:53:37,020 --> 00:53:37,535
>> ג'ייסון הירשהורן: לא ממש.

1112
00:53:37,535 --> 00:53:38,785
חסרים לנו עוד צעד אחד.

1113
00:53:38,785 --> 00:53:41,590

1114
00:53:41,590 --> 00:53:43,710
>> קהל: New_node הבא
יש להצביע על NULL.

1115
00:53:43,710 --> 00:53:44,570
>> ג'ייסון הירשהורן: בדיוק, אלדן.

1116
00:53:44,570 --> 00:53:46,600
ואז אנחנו יכולים לחזור נכון.

1117
00:53:46,600 --> 00:53:47,560
על אישור.

1118
00:53:47,560 --> 00:53:51,630
אבל זה עדיין רעיון טוב לעשות דברים
בסוף הרשימה, נכון?

1119
00:53:51,630 --> 00:53:51,950
בסדר.

1120
00:53:51,950 --> 00:53:54,450
אנחנו עדיין באמת עשויים לקבל
לסוף הרשימה.

1121
00:53:54,450 --> 00:53:57,870
אז זה בסדר קוד זה אם אנחנו ב
בסופו של הרשימה ויש כמה

1122
00:53:57,870 --> 00:53:59,120
דברים ברשימה?

1123
00:53:59,120 --> 00:54:01,830

1124
00:54:01,830 --> 00:54:02,040
נכון?

1125
00:54:02,040 --> 00:54:03,540
מכיוון שעדיין יש לנו הרעיון של מרקוס.

1126
00:54:03,540 --> 00:54:06,870
אנחנו יכולים לצאת מהמעגל הזה, כי
אנחנו בסוף הרשימה.

1127
00:54:06,870 --> 00:54:09,308
אז אנחנו עדיין רוצים את זה
קוד כאן למטה?

1128
00:54:09,308 --> 00:54:10,520
>> קהל: כן.

1129
00:54:10,520 --> 00:54:11,000
>> ג'ייסון הירשהורן: כן.

1130
00:54:11,000 --> 00:54:14,190
ומה אנחנו צריכים לעשות כדי לשנות את זה ל?

1131
00:54:14,190 --> 00:54:15,440
נכון.

1132
00:54:15,440 --> 00:54:19,580

1133
00:54:19,580 --> 00:54:21,640
האם זה נשמע טוב
לכולם עד כה?

1134
00:54:21,640 --> 00:54:22,420
למישהו יש -

1135
00:54:22,420 --> 00:54:23,480
אבי, יש לך משהו להוסיף?

1136
00:54:23,480 --> 00:54:23,920
>> קהל: לא.

1137
00:54:23,920 --> 00:54:25,276
>> ג'ייסון הירשהורן: אישור.

1138
00:54:25,276 --> 00:54:27,010
אז אנחנו כבר עשינו כמה שינויים.

1139
00:54:27,010 --> 00:54:29,540
ביצענו בדיקה זו לפני שאנו
נכנס לרשימה ריקה.

1140
00:54:29,540 --> 00:54:31,790
אז יש לנו לטפל בן רשימה ריקה.

1141
00:54:31,790 --> 00:54:35,500
והנה אנחנו טיפלנו בהחדרה
משהו בסוף הרשימה.

1142
00:54:35,500 --> 00:54:38,930
אז זה נראה כמו לקיחה תוך לולאה זו
טיפול בדברים שביניהם,

1143
00:54:38,930 --> 00:54:41,920
אי שם ברשימה אם יש
דברים ברשימה.

1144
00:54:41,920 --> 00:54:42,280
>> על אישור.

1145
00:54:42,280 --> 00:54:44,310
תן לנו להפעיל את התכנית שוב.

1146
00:54:44,310 --> 00:54:50,170

1147
00:54:50,170 --> 00:54:50,755
לא מוצלח.

1148
00:54:50,755 --> 00:54:52,190
>> קהל: אתה לא עושה את זה.

1149
00:54:52,190 --> 00:54:53,940
>> ג'ייסון הירשהורן: אה,
אני לא עשיתי את זה.

1150
00:54:53,940 --> 00:54:56,250
נקודה טובה, מיכאל.

1151
00:54:56,250 --> 00:54:57,500
בואו נוסיף איפור המקושר.

1152
00:54:57,500 --> 00:55:01,590

1153
00:55:01,590 --> 00:55:04,830
קו 87 יש שגיאה.

1154
00:55:04,830 --> 00:55:05,420
קו 87.

1155
00:55:05,420 --> 00:55:06,600
אלדן, זה היה הקו שנתת לי.

1156
00:55:06,600 --> 00:55:08,962
מה לא בסדר?

1157
00:55:08,962 --> 00:55:10,710
>> קהל: זה חייב להיות לריק.

1158
00:55:10,710 --> 00:55:11,000
>> ג'ייסון הירשהורן: מצוין.

1159
00:55:11,000 --> 00:55:11,630
בדיוק נכון.

1160
00:55:11,630 --> 00:55:13,290
זה צריך להיות אפס.

1161
00:55:13,290 --> 00:55:15,210
בואו נעשה שוב.

1162
00:55:15,210 --> 00:55:17,220
לקמפל.

1163
00:55:17,220 --> 00:55:17,890
על אישור.

1164
00:55:17,890 --> 00:55:19,400
בואו להכניס שלוש.

1165
00:55:19,400 --> 00:55:20,570
הכנס היה מוצלח.

1166
00:55:20,570 --> 00:55:21,660
בואו להדפיס אותו.

1167
00:55:21,660 --> 00:55:23,590
הו, אם רק היינו יכול לבדוק.

1168
00:55:23,590 --> 00:55:25,500
אבל אנחנו לא עשינו
להדפיס פונקציה עדיין.

1169
00:55:25,500 --> 00:55:27,840
בואו להיכנס למשהו אחר.

1170
00:55:27,840 --> 00:55:29,090
מה שאנחנו צריכים להיכנס?

1171
00:55:29,090 --> 00:55:31,120

1172
00:55:31,120 --> 00:55:31,940
>> קהל: שבע.

1173
00:55:31,940 --> 00:55:33,340
>> ג'ייסון הירשהורן: שבע?

1174
00:55:33,340 --> 00:55:34,590
>> קהל: כן.

1175
00:55:34,590 --> 00:55:38,680

1176
00:55:38,680 --> 00:55:39,780
>> ג'ייסון הירשהורן: יש לנו אשמת צינוק.

1177
00:55:39,780 --> 00:55:43,760
אז יש לנו אחד, אבל ברור לנו
לא יכול לקבל שתיים.

1178
00:55:43,760 --> 00:55:45,690
זה 05:07.

1179
00:55:45,690 --> 00:55:48,370
כדי שנוכל לאתר באגים זה
במשך שלוש דקות.

1180
00:55:48,370 --> 00:55:51,240
אבל אני הולך לעזוב אותנו כאן
ותעבור לחשיש שולחנות.

1181
00:55:51,240 --> 00:55:54,290
אבל שוב, את התשובות לקוד זה
אני בדוא"ל לך אותו במעט.

1182
00:55:54,290 --> 00:55:55,440
אנחנו קרובים מאוד אליו.

1183
00:55:55,440 --> 00:55:58,300
אני מאוד ממליץ לך להבין
מה קורה כאן ולתקן את זה.

1184
00:55:58,300 --> 00:56:02,400
אז אני אגיד לך דוא"ל את הקוד הזה כמו
גם בתוספת הפתרון -

1185
00:56:02,400 --> 00:56:03,670
כנראה הפתרון בהמשך.

1186
00:56:03,670 --> 00:56:05,110
ראשית את הקוד הזה.

1187
00:56:05,110 --> 00:56:08,290
>> הדבר השני שאני רוצה לעשות לפני שאנחנו
סיום הוא שאנחנו לא שחררתי שום דבר.

1188
00:56:08,290 --> 00:56:10,370
אז אני רוצה להראות לכם מה
valgrind נראה.

1189
00:56:10,370 --> 00:56:14,310
אם נריץ גבולות valgrind
בתכנית שלנו,. / מקושר.

1190
00:56:14,310 --> 00:56:22,540
שוב, על פי השקופית הזו, אנחנו
צריך לרוץ valgrind עם סוג כלשהו של

1191
00:56:22,540 --> 00:56:26,410
אפשרות, במקרה זה
- דליפה צ'ק = מלא.

1192
00:56:26,410 --> 00:56:27,660
אז בואו לכתוב valgrind
- דליפה צ'ק = מלא.

1193
00:56:27,660 --> 00:56:31,910

1194
00:56:31,910 --> 00:56:35,080
אז זה יפעל valgrind
בתכנית שלנו.

1195
00:56:35,080 --> 00:56:37,000
ועכשיו התכנית פועלת למעשה.

1196
00:56:37,000 --> 00:56:40,190
אז אנחנו הולכים להפעיל אותו בדיוק כמו
לפני כן, לשים משהו פנימה

1197
00:56:40,190 --> 00:56:40,830
אני הולך לשים בשלוש.

1198
00:56:40,830 --> 00:56:41,790
זה עובד.

1199
00:56:41,790 --> 00:56:43,202
אני לא הולך לנסות לשים משהו
אחר, כי אנחנו הולכים

1200
00:56:43,202 --> 00:56:44,710
לקבל שווא צינוק במקרה זה.

1201
00:56:44,710 --> 00:56:46,700
אז רק אני הולך להפסיק.

1202
00:56:46,700 --> 00:56:50,160
>> ועכשיו שאתה רואה כאן למטה
לדלוף וסיכום ערימה.

1203
00:56:50,160 --> 00:56:52,310
אלה הם דברים טובים ש
אתה רוצה לבדוק.

1204
00:56:52,310 --> 00:56:56,780
אז סיכום הערימה - זה אומר, בשימוש
ביציאה - שמונה בתים בבלוק אחד.

1205
00:56:56,780 --> 00:56:58,370
זה בלוק אחד הוא
צומת אנחנו malloced.

1206
00:56:58,370 --> 00:57:02,230
מיכאל, שאמרת לפני צומת היא שמונה
עקיצות כי יש לו את המספר השלם

1207
00:57:02,230 --> 00:57:02,680
והמצביע.

1208
00:57:02,680 --> 00:57:04,550
אז זה הצומת שלנו.

1209
00:57:04,550 --> 00:57:08,170
ואז זה אומר שאנחנו משמשים malloc
שבע פעמים ואנחנו משוחררים

1210
00:57:08,170 --> 00:57:08,940
משהו שש פעמים.

1211
00:57:08,940 --> 00:57:13,680
אבל אנחנו אף פעם לא קראנו בחינם, אז אין לי
מושג על מה זה מדבר.

1212
00:57:13,680 --> 00:57:18,490
>> אבל די אם נאמרתי שכאשר
ריצות תכנית, malloc הוא להיקרא

1213
00:57:18,490 --> 00:57:20,330
בחלק מהמקומות אחרים שאנחנו
לא צריך לדאוג.

1214
00:57:20,330 --> 00:57:22,460
אז malloc כנראה נקרא
במקומות מסוימים.

1215
00:57:22,460 --> 00:57:24,480
אנחנו לא צריכים לדאוג איפה.

1216
00:57:24,480 --> 00:57:26,240
אבל זה באמת.

1217
00:57:26,240 --> 00:57:27,380
שורה הראשונה זה לנו.

1218
00:57:27,380 --> 00:57:28,320
עזבנו את הבלוק זה.

1219
00:57:28,320 --> 00:57:30,330
ואתה יכול לראות את זה כאן
בסיכום הדליפה.

1220
00:57:30,330 --> 00:57:31,950
ובכל זאת נגישה -

1221
00:57:31,950 --> 00:57:32,930
שמונה בתים בבלוק אחד.

1222
00:57:32,930 --> 00:57:34,100
כלומר, זיכרון ש--

1223
00:57:34,100 --> 00:57:35,730
יש לנו זיכרון שדלף.

1224
00:57:35,730 --> 00:57:37,570
איבד בהחלט -

1225
00:57:37,570 --> 00:57:38,770
משהו הולך לאיבוד לטוב.

1226
00:57:38,770 --> 00:57:40,590
באופן כללי, אתה לא
רואה שם שום דבר.

1227
00:57:40,590 --> 00:57:44,780
עדיין ניתן להגיע בדרך כלל שבו
אתה רואה את דברים, שבו אתה רוצה

1228
00:57:44,780 --> 00:57:48,900
להסתכל כדי לראות מה קוד צריך אותך
שחרר אבל שכחת לשחרר.

1229
00:57:48,900 --> 00:57:53,170
>> ולאחר מכן, אם זה לא היה המקרה,
אם עשינו הכל בחינם,

1230
00:57:53,170 --> 00:57:54,360
אנחנו יכולים לבדוק את זה.

1231
00:57:54,360 --> 00:57:57,330
בואו רק להפעיל את התכנית
לא לשים בשום דבר.

1232
00:57:57,330 --> 00:57:59,800
אתה תראה כאן למטה בשימוש ביציאה -

1233
00:57:59,800 --> 00:58:01,310
אפס בתים באפס בלוקים.

1234
00:58:01,310 --> 00:58:06,310
זה אומר שהיה לנו לא נותר
כאשר תכנית זו יצאה.

1235
00:58:06,310 --> 00:58:12,090
אז לפני שפונה בpset6, לרוץ valgrind
ולוודא שאין לך

1236
00:58:12,090 --> 00:58:15,310
כל דליפות זיכרון בתכנית שלך.

1237
00:58:15,310 --> 00:58:17,910
אם יש לך שאלות כלשהן עם valgrind,
מוזמן להגיע.

1238
00:58:17,910 --> 00:58:18,700
אבל זה איך אתה משתמש בו.

1239
00:58:18,700 --> 00:58:20,890
פשוט מאוד - לראות אם אתה
יש בשימוש ביציאה -

1240
00:58:20,890 --> 00:58:22,270
בתים כל בכל בלוקים.

1241
00:58:22,270 --> 00:58:27,890

1242
00:58:27,890 --> 00:58:29,580
>> אז אנחנו עובדים על צומת להוסיף.

1243
00:58:29,580 --> 00:58:33,840
היה לי שתי פונקציות אחרות כאן -
להדפיס צמתים וצומת בחינם.

1244
00:58:33,840 --> 00:58:37,780
שוב, אלה הם פונקציות שהן
הולך להיות טוב בשבילך להתאמן

1245
00:58:37,780 --> 00:58:40,990
משום שהם יעזרו לך לא רק עם
תרגילים אלא גם לדוגמא אלה

1246
00:58:40,990 --> 00:58:42,180
על הבעיה להגדיר.

1247
00:58:42,180 --> 00:58:44,230
הם המפה על די הדוקה לדברים
אתה הולך צריך לעשות ב

1248
00:58:44,230 --> 00:58:45,010
בעיה מוגדרת.

1249
00:58:45,010 --> 00:58:47,640
אבל אני רוצה לוודא
אנחנו נוגעים בכל דבר.

1250
00:58:47,640 --> 00:58:50,400
ושולחנות חשיש הם גם חיוניים כדי
מה שאנחנו עושים בסעיף זה

1251
00:58:50,400 --> 00:58:51,980
בשבוע - או בסט הבעיה.

1252
00:58:51,980 --> 00:58:55,200
>> אז אנחנו הולכים לסיים את הסעיף
מדבר על שולחנות חשיש.

1253
00:58:55,200 --> 00:58:58,140
אם אתה שם לב שעשיתי
שולחן חשיש קטן.

1254
00:58:58,140 --> 00:59:00,020
זה לא מה שאנחנו מדברים
כ, עם זאת.

1255
00:59:00,020 --> 00:59:03,540
על שונה אנחנו מדברים
סוג של שולחנות חשיש.

1256
00:59:03,540 --> 00:59:07,300
ובליבה, שולחן החשיש
הוא לא יותר מאשר

1257
00:59:07,300 --> 00:59:08,860
מערך בתוספת פונקצית חשיש.

1258
00:59:08,860 --> 00:59:11,150
אנחנו הולכים לדבר קצת, רק כדי
לוודא שכולם מבין מה

1259
00:59:11,150 --> 00:59:12,110
פונקציית hash היא.

1260
00:59:12,110 --> 00:59:15,420
ואני אומר לך עכשיו שזה
שום דבר לא יותר משני דברים -

1261
00:59:15,420 --> 00:59:18,590
מערך ופונקציה חשיש.

1262
00:59:18,590 --> 00:59:20,716
והנה הצעדים דרך
שזה פועל.

1263
00:59:20,716 --> 00:59:31,560

1264
00:59:31,560 --> 00:59:32,810
>> יש המערך שלנו.

1265
00:59:32,810 --> 00:59:38,460

1266
00:59:38,460 --> 00:59:39,460
יש הפונקציה שלנו.

1267
00:59:39,460 --> 00:59:43,180
בפרט, פונקציות חשיש צריכה
לעשות כמה דברים עם זה.

1268
00:59:43,180 --> 00:59:45,040
אני הולך לדבר באופן ספציפי
על בעיה זו שנקבעה.

1269
00:59:45,040 --> 00:59:46,450
זה כנראה הולך
לקחת במחרוזת.

1270
00:59:46,450 --> 00:59:50,570

1271
00:59:50,570 --> 00:59:51,770
ומה שזה הולך לחזור?

1272
00:59:51,770 --> 00:59:52,640
מה סוג הנתונים?

1273
00:59:52,640 --> 00:59:54,260
אלדן?

1274
00:59:54,260 --> 00:59:55,760
פונקציית hash לחזור?

1275
00:59:55,760 --> 00:59:58,760
מספר שלם.

1276
00:59:58,760 --> 01:00:01,700
אז זה מה שהחשיש
טבלה מורכבת מ--

1277
01:00:01,700 --> 01:00:05,430
שולחן בצורה של מערך
ופונקציה חשיש.

1278
01:00:05,430 --> 01:00:06,010
איך זה עובד?

1279
01:00:06,010 --> 01:00:07,300
זה עובד בשלושה שלבים.

1280
01:00:07,300 --> 01:00:08,740
אנחנו נותנים לו מפתח.

1281
01:00:08,740 --> 01:00:11,470
במקרה זה, ניתן לה מחרוזת.

1282
01:00:11,470 --> 01:00:18,140
אנו קוראים לפונקציית hash לצעד אחד
על המפתח ואנחנו מקבלים ערך.

1283
01:00:18,140 --> 01:00:20,310
>> באופן ספציפי, אנחנו אומרים
אנחנו מקבלים מספר שלם.

1284
01:00:20,310 --> 01:00:25,630
מספר שלם ש, יש ספציפיים מאוד
גבול למה שיכול להיות מספר שלם.

1285
01:00:25,630 --> 01:00:28,880
בדוגמא זו, המערך שלנו
הוא בגודל שלוש.

1286
01:00:28,880 --> 01:00:32,330
אז מה מספרים מספרים שלמים שיכולים להיות.

1287
01:00:32,330 --> 01:00:35,970
מהו טווח ערכים חוקיים עבור
מספר שלם ש, סוג ההחזרה של זה

1288
01:00:35,970 --> 01:00:37,220
חשיש פונקציה?

1289
01:00:37,220 --> 01:00:40,440

1290
01:00:40,440 --> 01:00:42,110
אפס, אחת ושתיים.

1291
01:00:42,110 --> 01:00:46,060
נקודת פונקצית החשיש היא
להבין את המקום במערך

1292
01:00:46,060 --> 01:00:47,790
שבו המפתח שלנו הולך.

1293
01:00:47,790 --> 01:00:51,290
יש רק שלוש אפשרי
מקומות כאן -

1294
01:00:51,290 --> 01:00:52,130
אפס, אחת, או שתיים.

1295
01:00:52,130 --> 01:00:55,360
אז פונקציה זו טובה יותר לחזור
אפס, אחת, או שתיים.

1296
01:00:55,360 --> 01:00:58,740
חלק indice תקף במערך זה.

1297
01:00:58,740 --> 01:01:02,770
>> ואז תלוי איפה הוא חוזר,
אתה יכול לראות את מערך יש פתוח

1298
01:01:02,770 --> 01:01:03,730
סוגר את הערך.

1299
01:01:03,730 --> 01:01:05,800
זה שבו אנחנו שמים את המפתח.

1300
01:01:05,800 --> 01:01:11,280
אז אנחנו זורקים בדלעת,
אנחנו יוצאים אפס.

1301
01:01:11,280 --> 01:01:15,540
בסוגר מערך 0, אנחנו שמים את הדלעת.

1302
01:01:15,540 --> 01:01:21,070
אנחנו זורקים בחתולים, אנחנו מקבלים את אחד.

1303
01:01:21,070 --> 01:01:24,110
אנחנו שמים את החתול בשעה אחת.

1304
01:01:24,110 --> 01:01:25,480
אנחנו מכניסים לעכביש.

1305
01:01:25,480 --> 01:01:26,710
אנחנו יוצאים שתיים.

1306
01:01:26,710 --> 01:01:30,200
אנחנו שמים את העכביש בסוגר מערך דו.

1307
01:01:30,200 --> 01:01:32,300
זה יהיה כל כך נחמד אם
זה עבד ככה.

1308
01:01:32,300 --> 01:01:35,570
אך למרבה הצער, כפי שאנו רואים,
זה קצת יותר מסובך.

1309
01:01:35,570 --> 01:01:37,570
>> לפני שאנחנו מגיעים לשם, כל שאלות
על זה בסיסי

1310
01:01:37,570 --> 01:01:38,820
ההגדרה של שולחן חשיש?

1311
01:01:38,820 --> 01:01:49,050

1312
01:01:49,050 --> 01:01:51,940
זוהי תמונה של בדיוק
מה שאנחנו ציירנו על הלוח.

1313
01:01:51,940 --> 01:01:55,420
אבל מאז שציירנו אותו על הלוח, אני
אני לא הולך להיכנס לזה עוד יותר.

1314
01:01:55,420 --> 01:02:00,430
בעיקרו של דבר מפתחות, הקופסה השחורה קסם -
או במקרה זה, תיבה צהבהב - של

1315
01:02:00,430 --> 01:02:02,410
פונקציית hash מעמידה אותם בדליים.

1316
01:02:02,410 --> 01:02:04,690
ובדוגמה זו אנחנו
לא לשים את השם.

1317
01:02:04,690 --> 01:02:07,880
אנחנו שמים את הטלפון המשויך
מספר שם בים.

1318
01:02:07,880 --> 01:02:10,430
אבל אתה יכול מאוד פשוט
לשים את השם בדלי.

1319
01:02:10,430 --> 01:02:12,950
>> זוהי רק תמונה של מה
אנחנו ציירנו על הלוח.

1320
01:02:12,950 --> 01:02:14,460
יש לנו בעיות פוטנציאליות, אם כי.

1321
01:02:14,460 --> 01:02:17,470
ויש שני בפרט
שקופיות שאני רוצה ללכת על.

1322
01:02:17,470 --> 01:02:20,230
הראשון הוא על
פונקציית hash.

1323
01:02:20,230 --> 01:02:22,620
אז שאלתי את השאלה, מה
עושה פונקצית חשיש טובה?

1324
01:02:22,620 --> 01:02:24,220
אני נותן שתי תשובות.

1325
01:02:24,220 --> 01:02:26,630
הראשון הוא שזה דטרמיניסטי.

1326
01:02:26,630 --> 01:02:29,660
בהקשר של פונקציות חשיש,
מה זה אומר?

1327
01:02:29,660 --> 01:02:37,840

1328
01:02:37,840 --> 01:02:39,282
כן?

1329
01:02:39,282 --> 01:02:42,850
>> קהל: זה יכול למצוא את
מדד בזמן קבוע?

1330
01:02:42,850 --> 01:02:43,810
>> ג'ייסון הירשהורן: זה
זה לא מה שזה אומר.

1331
01:02:43,810 --> 01:02:44,725
אבל זה ניחוש טוב.

1332
01:02:44,725 --> 01:02:46,100
יש עוד מישהו ניחוש
מה זה אומר?

1333
01:02:46,100 --> 01:02:47,780
שפונקציית hash טובה
הוא דטרמיניסטי?

1334
01:02:47,780 --> 01:02:48,280
אנני?

1335
01:02:48,280 --> 01:02:51,680
>> קהל: זה יכול להיות ממופה רק מפתח
למקום אחד בטבלת הגיבוב.

1336
01:02:51,680 --> 01:02:53,070
>> ג'ייסון הירשהורן: זה
בדיוק נכון.

1337
01:02:53,070 --> 01:02:57,430
בכל פעם שאתה מכניס דלעת,
זה תמיד מחזיר אפס.

1338
01:02:57,430 --> 01:03:01,660
אם אתה שם את בדלעת והחשיש
פונקציה מחזירה אפס, אבל יש

1339
01:03:01,660 --> 01:03:06,060
הסתברות לחזור משהו
אחר גדול מאפס -

1340
01:03:06,060 --> 01:03:09,280
אז אולי זה יכול לחזור אחד לפעמים
או שתי פעמים אחרות -

1341
01:03:09,280 --> 01:03:11,100
זה לא פונקצית חשיש טובה.

1342
01:03:11,100 --> 01:03:11,800
אתה צודק.

1343
01:03:11,800 --> 01:03:15,680
פונקציית hash שלך צריכה להחזיר את
אותו מספר שלם מדויק, במקרה זה, עבור

1344
01:03:15,680 --> 01:03:17,780
אותה המחרוזת מדויקת.

1345
01:03:17,780 --> 01:03:22,210
>> אולי זה מחזיר את אותו מספר שלם מדויק
עבור אותה מחרוזת מדויקת

1346
01:03:22,210 --> 01:03:24,430
ללא קשר להיוון.

1347
01:03:24,430 --> 01:03:27,980
אבל במקרה שזה עדיין
דטרמיניסטי, כי דברים רבים

1348
01:03:27,980 --> 01:03:29,350
ממופים אל אותו הערך.

1349
01:03:29,350 --> 01:03:30,170
זה בסדר.

1350
01:03:30,170 --> 01:03:32,615
כל עוד יש רק אחד
פלט עבור קלט נתון.

1351
01:03:32,615 --> 01:03:35,630

1352
01:03:35,630 --> 01:03:36,350
>> על אישור.

1353
01:03:36,350 --> 01:03:38,340
הדבר השני הוא שזה
חוזר מדדים תקפים.

1354
01:03:38,340 --> 01:03:40,220
אנחנו הבאנו את זה קודם לכן.

1355
01:03:40,220 --> 01:03:41,860
פונקציית hash זה -

1356
01:03:41,860 --> 01:03:43,710
אוי ואבוי -

1357
01:03:43,710 --> 01:03:46,840
צריכה פונקצית חשיש
לחזור מדדים תקפים.

1358
01:03:46,840 --> 01:03:47,740
אז אומר -

1359
01:03:47,740 --> 01:03:48,990
בואו נחזור לדוגמא זו.

1360
01:03:48,990 --> 01:03:52,580

1361
01:03:52,580 --> 01:03:57,540
פונקציית hash שלי סופרת את
האותיות במילה.

1362
01:03:57,540 --> 01:03:58,380
זה פונקצית החשיש.

1363
01:03:58,380 --> 01:03:59,740
ומחזיר מספר שלם ש.

1364
01:03:59,740 --> 01:04:04,280
אז אם יש לי את המילה, זה
הולך להחזיר אחד.

1365
01:04:04,280 --> 01:04:06,900
וזה הולך לשים כאן.

1366
01:04:06,900 --> 01:04:09,430
מה אם אני מכניס את מילת העטלף?

1367
01:04:09,430 --> 01:04:11,310
זה הולך לחזור שלוש.

1368
01:04:11,310 --> 01:04:12,560
איפה הבת ללכת?

1369
01:04:12,560 --> 01:04:18,730

1370
01:04:18,730 --> 01:04:19,750
>> זה לא מתאים.

1371
01:04:19,750 --> 01:04:21,000
אבל זה צריך ללכת לאנשהו.

1372
01:04:21,000 --> 01:04:23,340
זהו שולחן החשיש שלי אחרי הכל, ו
הכל צריך ללכת לאנשהו.

1373
01:04:23,340 --> 01:04:24,590
אז איפה צריך ללכת עטלף?

1374
01:04:24,590 --> 01:04:28,020

1375
01:04:28,020 --> 01:04:28,710
כל מחשבות?

1376
01:04:28,710 --> 01:04:29,450
ניחושים?

1377
01:04:29,450 --> 01:04:30,280
ניחושים טובים?

1378
01:04:30,280 --> 01:04:31,220
>> קהל: אפס.

1379
01:04:31,220 --> 01:04:32,120
>> ג'ייסון הירשהורן: למה אפס?

1380
01:04:32,120 --> 01:04:35,990
>> קהל: בגלל שלוש
מודולו שלוש הוא אפס?

1381
01:04:35,990 --> 01:04:38,620
>> ג'ייסון הירשהורן: שלוש
מודולו שלוש הוא אפס.

1382
01:04:38,620 --> 01:04:40,810
זה ניחוש גדול,
וזה נכון.

1383
01:04:40,810 --> 01:04:43,870
אז במקרה הזה שהוא צריך
כנראה ללכת על אפס.

1384
01:04:43,870 --> 01:04:51,080
אז דרך טובה להבטיח שחשיש זה
פונקציה מחזירה רק מדדים תקפים

1385
01:04:51,080 --> 01:04:54,580
למודולו זה על ידי הגודל של השולחן.

1386
01:04:54,580 --> 01:04:57,360
אם אתה מודולו מה זה חוזר על ידי
שלוש, אתה תמיד הולך לקבל

1387
01:04:57,360 --> 01:05:00,930
משהו בין אפס, אחת, ושתיים.

1388
01:05:00,930 --> 01:05:05,160
ואם זה תמיד חוזר שבעה, ו
אתה מודולו תמיד על ידי שלוש, אתה

1389
01:05:05,160 --> 01:05:06,030
תמיד הולך לקבל את אותו הדבר.

1390
01:05:06,030 --> 01:05:09,270
>> אז זה עדיין דטרמיניסטי
אם מודולו.

1391
01:05:09,270 --> 01:05:11,420
אבל זה יבטיח לך
אף פעם לא מקבל משהו -

1392
01:05:11,420 --> 01:05:12,940
תעשייה לא חוקית.

1393
01:05:12,940 --> 01:05:16,840
באופן כללי, מודולו שצריך לקרות
בתוך פונקציית hash שלך.

1394
01:05:16,840 --> 01:05:18,240
אז אתה לא צריך לדאוג בקשר לזה.

1395
01:05:18,240 --> 01:05:20,555
אתה רק יכול להבטיח כי
זה indice תקף.

1396
01:05:20,555 --> 01:05:23,700

1397
01:05:23,700 --> 01:05:26,700
כל שאלות על זה
מכשול פוטנציאלי?

1398
01:05:26,700 --> 01:05:36,590

1399
01:05:36,590 --> 01:05:39,060
>> על אישור.

1400
01:05:39,060 --> 01:05:40,290
ויש לנו ללכת.

1401
01:05:40,290 --> 01:05:42,890
המכשול פוטנציאלי בשלב הבא, ו
זה הוא אחד הגדול.

1402
01:05:42,890 --> 01:05:46,880
מה אם מפת שני מפתחות
לאותו הערך?

1403
01:05:46,880 --> 01:05:49,350
אז יש שתי דרכים להתמודד עם זה.

1404
01:05:49,350 --> 01:05:53,140

1405
01:05:53,140 --> 01:05:56,020
הראשון נקרא ליניארי
חיטוט, שאני

1406
01:05:56,020 --> 01:05:57,300
לא הולך לעבור על.

1407
01:05:57,300 --> 01:06:01,120
אבל אתה צריך להיות מוכר עם כמה
זה עובד ומה זה.

1408
01:06:01,120 --> 01:06:05,610
>> השנייה אחת אני הולך לעבור על
כי זה אחד, כי רבים

1409
01:06:05,610 --> 01:06:08,290
אנשים כנראה יהיו בסופו של דבר להחליט
להשתמש בסט הבעיה שלהם.

1410
01:06:08,290 --> 01:06:09,820
כמובן, אין לך.

1411
01:06:09,820 --> 01:06:15,280
אבל לקבוצת הבעיה, אנשים רבים
נוטה לבחור כדי ליצור שולחן חשיש

1412
01:06:15,280 --> 01:06:17,950
עם שרשור נפרד ליישום
המילון שלהם.

1413
01:06:17,950 --> 01:06:21,390
אז אנחנו הולכים לעבור על מה זה אומר
כדי ליצור טבלה עם חשיש

1414
01:06:21,390 --> 01:06:23,890
שרשור נפרד.

1415
01:06:23,890 --> 01:06:26,260
>> אז שמתי בדלעת.

1416
01:06:26,260 --> 01:06:29,560
היא מחזירה אפס.

1417
01:06:29,560 --> 01:06:31,410
ואני שם את הדלעת כאן.

1418
01:06:31,410 --> 01:06:35,880

1419
01:06:35,880 --> 01:06:37,930
אז שמתי ב--

1420
01:06:37,930 --> 01:06:39,922
מה עוד דבר נושא ליל כל הקדושים?

1421
01:06:39,922 --> 01:06:42,200
>> קהל: סוכריות.

1422
01:06:42,200 --> 01:06:42,770
>> ג'ייסון הירשהורן: סוכריות!

1423
01:06:42,770 --> 01:06:43,910
זה אחד גדול.

1424
01:06:43,910 --> 01:06:47,760
אני שם בממתקים וסוכריות
גם נותן לי אפס.

1425
01:06:47,760 --> 01:06:49,350
מה עליי לעשות?

1426
01:06:49,350 --> 01:06:51,940
יש לך רעיונות?

1427
01:06:51,940 --> 01:06:53,940
בגלל שאתה כל סוג של יודע
מה נפרד שרשור הוא.

1428
01:06:53,940 --> 01:06:55,190
אז כל רעיונות מה לעשות?

1429
01:06:55,190 --> 01:06:58,170

1430
01:06:58,170 --> 01:06:59,110
כן.

1431
01:06:59,110 --> 01:07:03,810
>> קהל: לשים את המחרוזת
למעשה בשולחן החשיש.

1432
01:07:03,810 --> 01:07:08,910
>> ג'ייסון הירשהורן: אז אנחנו הולכים
לצייר את הרעיון הטוב כאן.

1433
01:07:08,910 --> 01:07:09,340
על אישור.

1434
01:07:09,340 --> 01:07:12,290
>> קהל: יש לי hashtable
[לא ברור]

1435
01:07:12,290 --> 01:07:16,640
המצביע שמצביע על
תחילתה של רשימה.

1436
01:07:16,640 --> 01:07:20,930
ולאחר מכן יש לי דלעת להיות הערך הראשון
שברשימה וממתקים הצמודים יהיה

1437
01:07:20,930 --> 01:07:22,800
הערך השני שברשימה המקושרת.

1438
01:07:22,800 --> 01:07:23,420
>> ג'ייסון הירשהורן: אישור.

1439
01:07:23,420 --> 01:07:24,670
מרקוס, שהיה יוצא מן הכלל.

1440
01:07:24,670 --> 01:07:26,160
אני הולך לשבור את זה.

1441
01:07:26,160 --> 01:07:28,890
מרקוס אומר לא
להחליף דלעת.

1442
01:07:28,890 --> 01:07:30,660
זה יהיה רע.

1443
01:07:30,660 --> 01:07:33,640
אין לשים את הממתקים במקום אחר.

1444
01:07:33,640 --> 01:07:35,390
אנחנו הולכים לשים את שניהם על אפס.

1445
01:07:35,390 --> 01:07:37,770
אבל אנחנו הולכים להתמודד עם
לשים אותם באפס על ידי

1446
01:07:37,770 --> 01:07:39,395
יצירת רשימה על אפס.

1447
01:07:39,395 --> 01:07:42,430
ואנחנו הולכים ליצור רשימה של
כל מה שממופה לאפס.

1448
01:07:42,430 --> 01:07:47,960
והדרך הטובה ביותר שלמדנו כדי ליצור
רשימה שיכול לגדול ולהתכווץ

1449
01:07:47,960 --> 01:07:49,840
הוא דינמי לא בתוך
מערך אחר.

1450
01:07:49,840 --> 01:07:51,510
אז לא מערך רב ממדים.

1451
01:07:51,510 --> 01:07:54,080
אבל רק כדי ליצור רשימה מקושרת.

1452
01:07:54,080 --> 01:07:55,330
>> אז מה שהוא הציע -

1453
01:07:55,330 --> 01:07:57,950

1454
01:07:57,950 --> 01:07:59,200
אני הולך לקבל חדש -

1455
01:07:59,200 --> 01:08:15,380

1456
01:08:15,380 --> 01:08:19,689
הוא ליצור מערך עם מצביעים,
מערך של מצביעים.

1457
01:08:19,689 --> 01:08:20,580
על אישור.

1458
01:08:20,580 --> 01:08:24,180
כל רעיון או רמז מה הסוג
זה מצביעים צריכים להיות?

1459
01:08:24,180 --> 01:08:26,290
מרקוס?

1460
01:08:26,290 --> 01:08:27,250
>> קהל: מצביעים ל--

1461
01:08:27,250 --> 01:08:28,609
>> ג'ייסון הירשהורן: מכיוון שאתה
אמרה רשימה מקושרת, ולכן -

1462
01:08:28,609 --> 01:08:29,520
>> קהל: מצביעי צומת?

1463
01:08:29,520 --> 01:08:30,670
>> ג'ייסון הירשהורן: מצביעי צומת.

1464
01:08:30,670 --> 01:08:32,830
אם הדברים בצמודים לשלנו
רשימה הם צמתים ואז הם

1465
01:08:32,830 --> 01:08:34,370
צריך להיות מצביעי צומת.

1466
01:08:34,370 --> 01:08:35,939
ומה שהם שווים בהתחלה?

1467
01:08:35,939 --> 01:08:36,990
>> קהל: Null.

1468
01:08:36,990 --> 01:08:38,240
>> ג'ייסון הירשהורן: Null.

1469
01:08:38,240 --> 01:08:44,540

1470
01:08:44,540 --> 01:08:46,080
אז יש הדבר הריק שלנו.

1471
01:08:46,080 --> 01:08:47,170
חוזר דלעת אפס.

1472
01:08:47,170 --> 01:08:48,569
מה אנחנו עושים?

1473
01:08:48,569 --> 01:08:49,609
לווה אותי דרכו?

1474
01:08:49,609 --> 01:08:50,810
למעשה, מרקוס כבר נתן לי.

1475
01:08:50,810 --> 01:08:52,439
מישהו אחר ילווה אותי דרכו.

1476
01:08:52,439 --> 01:08:54,760
מה שאנחנו עושים כאשר אנחנו -

1477
01:08:54,760 --> 01:08:56,609
זה נראה דומה מאוד
מה בדיוק אנחנו עושים.

1478
01:08:56,609 --> 01:08:57,396
אבי.

1479
01:08:57,396 --> 01:08:59,090
>> קהל: אני הולך לקחת ניחוש.

1480
01:08:59,090 --> 01:09:01,250
לכן, כאשר אתה מקבל ממתקים.

1481
01:09:01,250 --> 01:09:01,640
>> ג'ייסון הירשהורן: כן.

1482
01:09:01,640 --> 01:09:03,120
ובכן, יש לנו דלעת.

1483
01:09:03,120 --> 01:09:03,870
בואו לקבל את הראשון שלנו.

1484
01:09:03,870 --> 01:09:04,324
יש לנו את הדלעת.

1485
01:09:04,324 --> 01:09:04,779
>> קהל: אישור.

1486
01:09:04,779 --> 01:09:05,880
חוזר דלעת אפס.

1487
01:09:05,880 --> 01:09:08,770
אז אתה שם אותו בזה.

1488
01:09:08,770 --> 01:09:10,810
או בעצם, אתה שם אותו
ברשימה המקושרת.

1489
01:09:10,810 --> 01:09:13,550
>> ג'ייסון הירשהורן: איך אנחנו
לשים אותו ברשימה המקושרת?

1490
01:09:13,550 --> 01:09:15,479
>> קהל: אה, את התחביר בפועל?

1491
01:09:15,479 --> 01:09:16,240
>> ג'ייסון הירשהורן: פשוט ללכת -

1492
01:09:16,240 --> 01:09:16,740
לומר יותר.

1493
01:09:16,740 --> 01:09:19,310
מה אנחנו עושים?

1494
01:09:19,310 --> 01:09:22,100
>> קהל: אתה פשוט להכניס
אותה כצומת הראשונה.

1495
01:09:22,100 --> 01:09:22,675
>> ג'ייסון הירשהורן: אישור.

1496
01:09:22,675 --> 01:09:29,069
אז יש לנו הצומת, הדלעת שלנו.

1497
01:09:29,069 --> 01:09:31,560
ועכשיו איך אני מכניס את זה?

1498
01:09:31,560 --> 01:09:34,590

1499
01:09:34,590 --> 01:09:37,090
>> קהל: אתה להקצות
אותו למצביע.

1500
01:09:37,090 --> 01:09:37,970
>> ג'ייסון הירשהורן: איזה מצביע?

1501
01:09:37,970 --> 01:09:39,620
>> קהל: המצביע על אפס.

1502
01:09:39,620 --> 01:09:41,420
>> ג'ייסון הירשהורן: אז איפה
עושה את הנקודה הזו?

1503
01:09:41,420 --> 01:09:42,810
>> קהל: כדי null עכשיו.

1504
01:09:42,810 --> 01:09:43,529
>> ג'ייסון הירשהורן: ובכן,
זה מצביע על NULL.

1505
01:09:43,529 --> 01:09:44,499
אבל אני שם את בדלעת.

1506
01:09:44,499 --> 01:09:46,053
אז איפה זה אמור להצביע?

1507
01:09:46,053 --> 01:09:46,880
>> קהל: לדלעת.

1508
01:09:46,880 --> 01:09:47,399
>> ג'ייסון הירשהורן: לדלעת.

1509
01:09:47,399 --> 01:09:48,760
בדיוק.

1510
01:09:48,760 --> 01:09:50,010
אז זה מצביע על דלעת.

1511
01:09:50,010 --> 01:09:52,500

1512
01:09:52,500 --> 01:09:54,250
ואיפה עושה את המצביע זה
בנקודת דלעת?

1513
01:09:54,250 --> 01:09:57,986

1514
01:09:57,986 --> 01:09:58,340
אל

1515
01:09:58,340 --> 01:09:58,590
>> קהל: Null.

1516
01:09:58,590 --> 01:09:59,210
>> ג'ייסון הירשהורן: NULL.

1517
01:09:59,210 --> 01:10:00,460
בדיוק.

1518
01:10:00,460 --> 01:10:03,570

1519
01:10:03,570 --> 01:10:05,140
אז אנחנו פשוט הכנסנו משהו
לרשימה המקושרת.

1520
01:10:05,140 --> 01:10:07,210
אנחנו פשוט כתבנו את הקוד הזה לעשות את זה.

1521
01:10:07,210 --> 01:10:09,520
כמעט כמעט קיבלנו אותו
נסדק לחלוטין.

1522
01:10:09,520 --> 01:10:10,790
עכשיו אנחנו להכניס ממתקים.

1523
01:10:10,790 --> 01:10:13,480
הממתקים שלנו גם הולך לאפס.

1524
01:10:13,480 --> 01:10:16,100
אז מה אנחנו עושים עם ממתקים?

1525
01:10:16,100 --> 01:10:18,790
>> קהל: זה תלוי אם
לא שאנחנו מנסים למיין את זה.

1526
01:10:18,790 --> 01:10:19,640
>> ג'ייסון הירשהורן: זה
בדיוק נכון.

1527
01:10:19,640 --> 01:10:21,070
זה תלוי אם או לא
אנחנו מנסים למיין את זה.

1528
01:10:21,070 --> 01:10:22,660
בואו נניח שאנחנו לא
הולך לסדר את זה.

1529
01:10:22,660 --> 01:10:24,880
>> קהל: ובכן, כפי שדנו
לפני, זה הפשוטה ביותר רק כדי לשים אותו

1530
01:10:24,880 --> 01:10:28,590
ממש בהתחלה כך שהמצביע
מאפס נקודות לממתקים.

1531
01:10:28,590 --> 01:10:29,020
>> ג'ייסון הירשהורן: אישור.

1532
01:10:29,020 --> 01:10:29,380
להחזיק מעמד.

1533
01:10:29,380 --> 01:10:30,630
תן לי ליצור ממתקים ממש כאן.

1534
01:10:30,630 --> 01:10:34,030

1535
01:10:34,030 --> 01:10:35,150
אז מצביע זה -

1536
01:10:35,150 --> 01:10:37,590
>> קהל: כן, עכשיו צריך
תצביע לממתקים.

1537
01:10:37,590 --> 01:10:40,580
ואז יש לי המצביע מ
נקודת ממתקים לדלעת.

1538
01:10:40,580 --> 01:10:43,140

1539
01:10:43,140 --> 01:10:44,560
>> ג'ייסון הירשהורן: כמו זה?

1540
01:10:44,560 --> 01:10:47,380
ואומר שיש לנו עוד
דבר למפה לאפס?

1541
01:10:47,380 --> 01:10:48,660
>> קהל: ובכן, אתה פשוט
לעשות את אותו הדבר?

1542
01:10:48,660 --> 01:10:50,290
>> ג'ייסון הירשהורן: לעשות את אותו הדבר.

1543
01:10:50,290 --> 01:10:53,700
אז במקרה הזה, אם אנחנו לא
רוצה לשמור את זה מסודרים על זה

1544
01:10:53,700 --> 01:10:55,270
נשמע פשוט למדי.

1545
01:10:55,270 --> 01:10:59,920
אנחנו לוקחים את המצביע בindice
שניתן על ידי פונקציית hash שלנו.

1546
01:10:59,920 --> 01:11:03,830
יש לנו נקודה שלצומת החדשה שלנו.

1547
01:11:03,830 --> 01:11:07,830
ואז מה שזה לא היה מכוון
בעבר -

1548
01:11:07,830 --> 01:11:10,620
במקרה null זה, ב
מקרה דלעת שנייה -

1549
01:11:10,620 --> 01:11:15,310
זה, מה שזה מצביע על
בעבר, אנו מוסיפים לתוך הבאים של

1550
01:11:15,310 --> 01:11:17,810
הצומת החדשה שלנו.

1551
01:11:17,810 --> 01:11:19,650
אנחנו מכניסים משהו
בהתחלה.

1552
01:11:19,650 --> 01:11:22,900
למעשה זה הרבה יותר פשוט ממה
מנסה לשמור על הרשימה הממוינת.

1553
01:11:22,900 --> 01:11:25,340
אבל שוב, חיפוש יהיה
נוסף על מסובך כאן.

1554
01:11:25,340 --> 01:11:28,300
אנחנו תמיד נצטרך ללכת עד הסוף.

1555
01:11:28,300 --> 01:11:29,650
>> על אישור.

1556
01:11:29,650 --> 01:11:32,750
כל שאלות על שרשור נפרד?

1557
01:11:32,750 --> 01:11:34,690
איך זה עובד?

1558
01:11:34,690 --> 01:11:35,820
אנא שאל אותם עכשיו.

1559
01:11:35,820 --> 01:11:39,260
אני באמת רוצה לעשות כל מה שאתה בטוח
להבין את זה לפני שאנחנו יוצאים.

1560
01:11:39,260 --> 01:11:48,410

1561
01:11:48,410 --> 01:11:52,060
>> קהל: למה אתה שם את הדלעת
וממתקים לאותו

1562
01:11:52,060 --> 01:11:54,108
חלק משולחן החשיש?

1563
01:11:54,108 --> 01:11:55,860
>> ג'ייסון הירשהורן: שאלה טובה.

1564
01:11:55,860 --> 01:11:59,140
למה אנחנו שמים אותם באותה
חלק משולחן החשיש?

1565
01:11:59,140 --> 01:12:03,200
ובכן, במקרה זה פונקצית החשיש
תשואת אפס עבור שניהם.

1566
01:12:03,200 --> 01:12:05,310
אז הם צריכים ללכת על אפס indice
כי שם אנחנו הולכים

1567
01:12:05,310 --> 01:12:07,420
לחפש אותם אם אי פעם
רוצה לחפש אותם.

1568
01:12:07,420 --> 01:12:11,750
שוב, עם גישה ליניארי חיטוט
לא היינו לשים את שניהם על אפס.

1569
01:12:11,750 --> 01:12:13,900
אבל בגישת השרשרת נפרדת,
אנחנו הולכים לשים את שניהם על אפס

1570
01:12:13,900 --> 01:12:16,620
ולאחר מכן ליצור רשימה משל אפס.

1571
01:12:16,620 --> 01:12:20,140
>> ואנחנו לא רוצים להחליף את הדלעת
פשוט בשביל זה כי אז יהיה

1572
01:12:20,140 --> 01:12:21,860
תניח שדלעת הייתה
מעולם לא הוכנס.

1573
01:12:21,860 --> 01:12:25,230
אם אנחנו רק לשמור על דבר אחד
מיקום שיהיה רע.

1574
01:12:25,230 --> 01:12:28,590
ואז לא יהיה שום
סיכוי שלנו אי פעם -

1575
01:12:28,590 --> 01:12:31,660
אם אי פעם היו לנו כפול, אז אנחנו
הייתי מוחק הערך הראשוני שלנו פשוט.

1576
01:12:31,660 --> 01:12:34,090
אז בגלל זה אנחנו עושים בגישה זו.

1577
01:12:34,090 --> 01:12:36,580
או שזו הסיבה שבחרנו - אבל שוב, אנחנו
בחר בגישת השרשור נפרדת,

1578
01:12:36,580 --> 01:12:39,670
שיש הרבה גישות אחרות
אחד יכול לבחור.

1579
01:12:39,670 --> 01:12:41,185
האם זה עונה על השאלה שלך?

1580
01:12:41,185 --> 01:12:41,660
>> על אישור.

1581
01:12:41,660 --> 01:12:42,910
קרלוס.

1582
01:12:42,910 --> 01:12:46,130

1583
01:12:46,130 --> 01:12:47,720
ליניארי חיטוט יהיה כרוך -

1584
01:12:47,720 --> 01:12:51,913
אם אנחנו נמצאים בהתנגשות אפס, אנחנו
היה נראה בנקודה הבאה כדי לראות אם

1585
01:12:51,913 --> 01:12:54,310
זה היה פתוח והכניס אותו לשם.

1586
01:12:54,310 --> 01:12:57,320
ואז אנחנו מסתכלים בספורט הבא ו
לראות אם זה היה פתוח והכניס אותו לשם.

1587
01:12:57,320 --> 01:12:59,780
כך אנו מוצאים זמינים הבאים
מקום פתוח והכנסתי אותו לשם.

1588
01:12:59,780 --> 01:13:02,580

1589
01:13:02,580 --> 01:13:03,890
יש עוד שאלות?

1590
01:13:03,890 --> 01:13:05,370
כן, אבי.

1591
01:13:05,370 --> 01:13:07,490
>> קהל: כהמשך לכך,
מה שאתה מתכוון בנקודה הבאה?

1592
01:13:07,490 --> 01:13:10,250
בשולחן החשיש או ברשימה מקושרת.

1593
01:13:10,250 --> 01:13:12,100
>> ג'ייסון הירשהורן: ליניארי
תכנות, אין רשימות מקושרות.

1594
01:13:12,100 --> 01:13:13,400
המקום הבא בטבלת הגיבוב.

1595
01:13:13,400 --> 01:13:13,820
>> קהל: אישור.

1596
01:13:13,820 --> 01:13:17,570
אז שולחן החשיש יהיה
אותחל לגודל -

1597
01:13:17,570 --> 01:13:19,560
כמו מספר המחרוזות
שאתה מכניס?

1598
01:13:19,560 --> 01:13:22,170
>> ג'ייסון הירשהורן: אתה היית עושה
רוצה שזה יהיה ממש גדול.

1599
01:13:22,170 --> 01:13:23,910
כן.

1600
01:13:23,910 --> 01:13:27,900
הנה תמונה של מה שאנו
פשוט צייר על הלוח.

1601
01:13:27,900 --> 01:13:29,470
שוב, יש לנו התנגשות ממש כאן.

1602
01:13:29,470 --> 01:13:30,710
ב152.

1603
01:13:30,710 --> 01:13:33,570
ואתם תראו שיצרנו
רשימה מקושרת ממנו.

1604
01:13:33,570 --> 01:13:38,200

1605
01:13:38,200 --> 01:13:41,850
שוב, השרשור הנפרד שולחן החשיש
גישה היא לא אחד שאתה

1606
01:13:41,850 --> 01:13:45,590
צריך לקחת לבעיות מוגדרות
שש אבל הוא אחד שהרבה

1607
01:13:45,590 --> 01:13:47,100
סטודנטים נוטים לקחת.

1608
01:13:47,100 --> 01:13:51,140
אז בנימה זאת, תן לנו לדבר בקצרה
לפני שאנחנו יוצאים על בעיה שש,

1609
01:13:51,140 --> 01:13:52,160
ולאחר מכן אני מתכוון לשתף אתכם בסיפור.

1610
01:13:52,160 --> 01:13:55,120
יש לנו שלוש דקות.

1611
01:13:55,120 --> 01:13:55,750
>> בעיה להגדיר שש.

1612
01:13:55,750 --> 01:13:57,790
יש לך ארבע פונקציות -

1613
01:13:57,790 --> 01:14:02,430
עומס, לבדוק, הגודל, ולפרוק.

1614
01:14:02,430 --> 01:14:03,380
עומס -

1615
01:14:03,380 --> 01:14:07,120
כן, אנחנו כבר הולכים
על עומס רק עכשיו.

1616
01:14:07,120 --> 01:14:09,330
ציירנו עומס על הלוח.

1617
01:14:09,330 --> 01:14:13,230
ואנחנו אפילו התחלנו קידוד הרבה
החדרה לתוך רשימה מקושרת.

1618
01:14:13,230 --> 01:14:18,020
אז העומס הוא לא הרבה יותר מאשר
מה שרק עושים.

1619
01:14:18,020 --> 01:14:21,070
>> עזיבה היא ברגע שיש לך
משהו טעון.

1620
01:14:21,070 --> 01:14:22,580
זה אותו התהליך כמו זה.

1621
01:14:22,580 --> 01:14:26,845
אותם שני החלקים הראשונים שבו אתה זורק
משהו לתוך פונקצית החשיש

1622
01:14:26,845 --> 01:14:29,190
ולקבל את הערך שלו.

1623
01:14:29,190 --> 01:14:30,700
אבל עכשיו אנחנו לא מכניסים את זה.

1624
01:14:30,700 --> 01:14:33,350
עכשיו אנחנו מחפשים אותו.

1625
01:14:33,350 --> 01:14:37,130
יש לי קוד לדוגמא שנכתב עבור מציאת
משהו ברשימה מקושרת.

1626
01:14:37,130 --> 01:14:38,250
אני ממליץ לך לתרגל את זה.

1627
01:14:38,250 --> 01:14:43,000
אבל באופן אינטואיטיבי למצוא משהו
די דומה להחדרת משהו.

1628
01:14:43,000 --> 01:14:46,540
ואכן, אנו ציירנו תמונה של מציאת
משהו ברשימה מקושרת, נע

1629
01:14:46,540 --> 01:14:48,910
דרך עד שהגעת לסוף.

1630
01:14:48,910 --> 01:14:52,430
ואם יש לך עד הסוף ולא יכל
מוצא את זה, אז זה לא שם.

1631
01:14:52,430 --> 01:14:55,400
אז זה סימון, במהות.

1632
01:14:55,400 --> 01:14:57,030
>> הבא הוא גודל.

1633
01:14:57,030 --> 01:14:57,910
בואו נדלג גודל.

1634
01:14:57,910 --> 01:15:00,040
לבסוף יש לך לפרוק.

1635
01:15:00,040 --> 01:15:02,890
ביטול טעינה היא אחד אנחנו לא נמשכים
על הלוח או מקודד עדיין.

1636
01:15:02,890 --> 01:15:05,990
אבל אני ממליץ לך לנסות אותו הקידוד
במדגם דוגמא הרשימה המקושרת שלנו.

1637
01:15:05,990 --> 01:15:11,440
אבל לפרוק באופן אינטואיטיבי
דומה לתשלום -

1638
01:15:11,440 --> 01:15:14,010
או שאני מתכוון זה דומה כדי לבדוק.

1639
01:15:14,010 --> 01:15:17,350
פרט לעכשיו בכל פעם שאתה הולך
דרך, אתה לא פשוט בודק כדי

1640
01:15:17,350 --> 01:15:19,090
לראות אם יש לך את הערך שלך שם.

1641
01:15:19,090 --> 01:15:22,490
אבל אתה לוקח את צומת וש
לשחרר אותו, בעצם.

1642
01:15:22,490 --> 01:15:23,610
זה מה לפרוק מבקש ממך לעשות.

1643
01:15:23,610 --> 01:15:24,670
כל מה שחינם שmalloced.

1644
01:15:24,670 --> 01:15:27,480
אז אתה עובר על הרשימה כולה
שוב, עובר את כל החשיש

1645
01:15:27,480 --> 01:15:27,760
שולחן שוב.

1646
01:15:27,760 --> 01:15:29,240
הפעם לא לבדוק
כדי לראות מה יש שם.

1647
01:15:29,240 --> 01:15:31,080
רק לשחרר את מה שיש.

1648
01:15:31,080 --> 01:15:33,260
>> ולבסוף גודל.

1649
01:15:33,260 --> 01:15:34,350
גודל צריך להיות מיושם.

1650
01:15:34,350 --> 01:15:35,590
אם אתה לא מיישם את הגודל -

1651
01:15:35,590 --> 01:15:36,250
אני אגיד את זה ככה.

1652
01:15:36,250 --> 01:15:39,740
אם אתה לא מיישם את הגודל בדיוק
שורת קוד אחד כולל

1653
01:15:39,740 --> 01:15:43,760
לחזור הצהרה, אתה
עושה גודל באופן שגוי.

1654
01:15:43,760 --> 01:15:47,170
אז להפוך את הגודל בטוח, לעיצוב מלא
נקודות, אתה עושה את זה בדיוק אחד

1655
01:15:47,170 --> 01:15:49,970
שורת קוד, כולל
שמירה על התמורה.

1656
01:15:49,970 --> 01:15:52,450
>> ולא לארוז את עדיין, Akchar.

1657
01:15:52,450 --> 01:15:53,700
שפן החרמן.

1658
01:15:53,700 --> 01:15:55,820

1659
01:15:55,820 --> 01:16:01,300
אני רוצה להגיד לך תודה חבר 'ה
באת לסעיף.

1660
01:16:01,300 --> 01:16:02,550
יש ליל כל הקדושים שמחים.

1661
01:16:02,550 --> 01:16:05,300

1662
01:16:05,300 --> 01:16:05,960
זו התחפושת שלי.

1663
01:16:05,960 --> 01:16:08,850
אני אלבש את זה ביום חמישי
אם אני רואה אותך בשעתי עבודה.

1664
01:16:08,850 --> 01:16:14,640
ואם אתה סקרן לגבי עוד קצת
רקע כלתחפושת זו, מרגיש

1665
01:16:14,640 --> 01:16:19,135
מוזמן לבדוק את 2011 סעיף
לסיפור על למה אני

1666
01:16:19,135 --> 01:16:20,900
לובש את תחפושת הדלעת.

1667
01:16:20,900 --> 01:16:23,680
וזה סיפור עצוב.

1668
01:16:23,680 --> 01:16:27,050
אז ודא שיש לך
כמה רקמות סמוכות.

1669
01:16:27,050 --> 01:16:28,680
אבל על זה, אם יש לך
שאלות שאני אשאר בסביבה

1670
01:16:28,680 --> 01:16:29,960
בחוץ אחרי הסעיף.

1671
01:16:29,960 --> 01:16:31,510
מזל טוב על בעיה להגדיר שש.

1672
01:16:31,510 --> 01:16:33,540
וכמו תמיד, אם יש לך
שאלות, תודיע לי.

1673
01:16:33,540 --> 01:16:35,584