1
00:00:00,000 --> 00:00:03,423
>> [השמעת מוסיקה]

2
00:00:03,423 --> 00:00:05,380

3
00:00:05,380 --> 00:00:08,210
>> ANDI פנג: ברוכים הבאים לשבוע של סעיף 6.

4
00:00:08,210 --> 00:00:11,620
אנחנו חרגו מהסטנדרט שלנו
זמן קטע של יום שלישי

5
00:00:11,620 --> 00:00:14,130
אחר הצהריים ליום ראשון בבוקר היפה הזה.

6
00:00:14,130 --> 00:00:17,330
תודה לכולם ש
הצטרף אליי היום, אבל ברצינות,

7
00:00:17,330 --> 00:00:18,170
מחיאות כפות.

8
00:00:18,170 --> 00:00:20,600
>> זה מאמץ גדול למדי.

9
00:00:20,600 --> 00:00:23,600
אני כמעט אפילו לא לעשות את זה
בזמן, אבל זה היה בסדר.

10
00:00:23,600 --> 00:00:27,520
אז אני יודע שכולכם
יש פשוט עשה את זה לחידון.

11
00:00:27,520 --> 00:00:30,370
קודם כל, בברכה ל
הצד השני של מטבע ש.

12
00:00:30,370 --> 00:00:32,917
>> שנית, נדבר על זה.

13
00:00:32,917 --> 00:00:34,000
נדבר על החידון.

14
00:00:34,000 --> 00:00:35,700
נדבר על איך
אתה עושה בכיתה.

15
00:00:35,700 --> 00:00:36,550
אתה תהיה בסדר.

16
00:00:36,550 --> 00:00:39,080
יש לי החידונים שלך ל
אתה בסופו של הדבר מכאן,

17
00:00:39,080 --> 00:00:42,120
כך שאם אתם רוצים לקחת
תסתכלו על זה, בסדר גמור.

18
00:00:42,120 --> 00:00:46,590
>> כל כך מהר לפני שנתחיל,
סדר יום להיום הוא כדלקמן.

19
00:00:46,590 --> 00:00:48,430
כפי שניתן לראות, אנחנו
ירי בעצם מהיר

20
00:00:48,430 --> 00:00:52,120
דרך חבורה של מבני נתונים שלמה
באמת, באמת, באמת במהירות.

21
00:00:52,120 --> 00:00:54,380
אז ככזה, זה לא יהיה
היום סופר אינטראקטיבי.

22
00:00:54,380 --> 00:00:59,620
זה יהיה רק ​​לי סוג של צעקות
דברים שאתה, ואם אני לבלבל אותך,

23
00:00:59,620 --> 00:01:02,680
אם אני הולך מהר מדי, תן ​​לי לדעת.

24
00:01:02,680 --> 00:01:05,200
הם נתונים רק שונים
מבנים, וכחלק

25
00:01:05,200 --> 00:01:07,070
של pset לזה
שבוע הקרוב, תמצאו

26
00:01:07,070 --> 00:01:10,340
תתבקש ליישם אחד מהם,
אולי שתיים מthem-- שתיים מהם

27
00:01:10,340 --> 00:01:12,319
בpset.

28
00:01:12,319 --> 00:01:14,610
אוקיי, אז אני רק הולך ל
תתחיל עם כמה הודעות.

29
00:01:14,610 --> 00:01:19,070
אנחנו נלך על ערימות ותורים יותר ב
עומק ממה שעשינו לפני החידון.

30
00:01:19,070 --> 00:01:20,990
אנחנו נלך על מקושרים
רשימה שוב, שוב,

31
00:01:20,990 --> 00:01:23,899
יותר לעומק ממה ש
היו לנו לפני החידון.

32
00:01:23,899 --> 00:01:26,440
ולאחר מכן נדבר על חשיש
שולחנות, עצים ומנסה, ש

33
00:01:26,440 --> 00:01:28,890
כולם די צורך לpset.

34
00:01:28,890 --> 00:01:32,925
ואז נלך על כמה
עצות מועילות לpset5.

35
00:01:32,925 --> 00:01:37,360
>> אוקיי, אז חידון 0.

36
00:01:37,360 --> 00:01:41,090
הממוצע היה 58%.

37
00:01:41,090 --> 00:01:45,370
זה היה מאוד נמוך, ולכן אתם כל
עשה מאוד, טוב מאוד בהתאם

38
00:01:45,370 --> 00:01:46,510
עם זה.

39
00:01:46,510 --> 00:01:49,970
>> די הרבה, כלל אצבע הוא שאם אתה
בתוך סטיית התקן של הממוצע

40
00:01:49,970 --> 00:01:52,990
במיוחד מאז אנחנו בפחות
סעיף נוח, אתה בסדר גמור.

41
00:01:52,990 --> 00:01:54,120
אתה על מסלול.

42
00:01:54,120 --> 00:01:55,190
החיים טובים.

43
00:01:55,190 --> 00:01:58,952
>> אני יודע שזה מפחיד לחשוב ש
יש לי כמו 40% על חידון זה.

44
00:01:58,952 --> 00:02:00,160
אני הולך להיכשל ברמה זו.

45
00:02:00,160 --> 00:02:02,243
אני מבטיח לך, אתה לא
הולך להיכשל בכיתה.

46
00:02:02,243 --> 00:02:03,680
אתה לגמרי בסדר.

47
00:02:03,680 --> 00:02:06,850
>> לאלו מכם שהתגברו על
הממוצע, מרשים, מרשים,

48
00:02:06,850 --> 00:02:08,780
כמו, נעשה ברצינות גם.

49
00:02:08,780 --> 00:02:09,689
יש לי אותם איתי.

50
00:02:09,689 --> 00:02:11,730
אתה מוזמן לבוא לקחת אותם
בסוף הקטע.

51
00:02:11,730 --> 00:02:14,520
תודיע לי אם יש לך
נושאים, שאלות עימם.

52
00:02:14,520 --> 00:02:17,204
אם נוסיף את הציון שלך
בסדר, תן לנו לדעת.

53
00:02:17,204 --> 00:02:21,240
>> אוקיי, אז pset5, זה באמת
שבוע לאוניברסיטת ייל במובן מוזר

54
00:02:21,240 --> 00:02:24,240
שpset נובע
יום רביעי בצהריים, כולל

55
00:02:24,240 --> 00:02:27,317
האיחור של היום, כך שזה בעצם
בשל תיאורטי יום שלישי בצהריים.

56
00:02:27,317 --> 00:02:29,150
כנראה שאף אחד לא סיים
ביום שלישי בצהריים.

57
00:02:29,150 --> 00:02:30,830
זה לגמרי בסדר.

58
00:02:30,830 --> 00:02:33,700
אנחנו הולכים להיות שעתי עבודה
הלילה, כמו גם יום שני בלילה.

59
00:02:33,700 --> 00:02:36,810
וכל סעיפי שבוע זה יהיה
למעשה הפך לסדנאות,

60
00:02:36,810 --> 00:02:38,800
לכן אל תהסס להיכנס ב
כל קטע שאתה רוצה,

61
00:02:38,800 --> 00:02:42,810
והם יהיו סוג של מיני-pset
סדנאות לעזרה על זה.

62
00:02:42,810 --> 00:02:45,620
אז בתור שכזה, זה הקטע היחיד
לאן אנחנו מלמדים את החומר.

63
00:02:45,620 --> 00:02:49,220
כל הסעיפים האחרים יהיו התמקדות
באופן בלעדי על עזרה לpset.

64
00:02:49,220 --> 00:02:50,146
כֵּן?

65
00:02:50,146 --> 00:02:52,000
>> קהל: איפה שעתי עבודה?

66
00:02:52,000 --> 00:02:56,120
>> ANDI פנג: שעתי עבודה
tonight-- הו, שאלה טובה.

67
00:02:56,120 --> 00:03:00,580
אני חושב ששעתי עבודה הלילה
נמצאים בטורקיז או בCommons.

68
00:03:00,580 --> 00:03:02,984
אם תקישו CS50 המקוון
ואתה הולך לשעתי עבודה,

69
00:03:02,984 --> 00:03:05,650
לא צריך להיות לוח זמנים ש
אומר לך שבו כולם.

70
00:03:05,650 --> 00:03:07,954
>> אני יודע גם הלילה
או מחר הוא צהבהב,

71
00:03:07,954 --> 00:03:10,120
ואני חושב שיש לנו
נחלת ללילה.

72
00:03:10,120 --> 00:03:11,020
אני לא בטוח.

73
00:03:11,020 --> 00:03:11,700
שאלה טובה.

74
00:03:11,700 --> 00:03:14,430
בדוק בCS50.

75
00:03:14,430 --> 00:03:18,780
>> שאלות מגניבים, כל עניין
לוח זמנים לבאים כמו שלושה ימים?

76
00:03:18,780 --> 00:03:21,690
אני מבטיח לך בחורים כמו דוד
אמר, זה החלק העליון של הגבעה.

77
00:03:21,690 --> 00:03:23,050
אתם כמעט שם.

78
00:03:23,050 --> 00:03:24,644
רק שלושה ימים נוספים.

79
00:03:24,644 --> 00:03:26,310
להגיע לשם, ואז כולנו לרדת.

80
00:03:26,310 --> 00:03:28,114
תהיה לנו הפסקה CS-חופשית נחמדה.

81
00:03:28,114 --> 00:03:28,780
ברוך השב.

82
00:03:28,780 --> 00:03:30,779
אנחנו לצלול לתוך האינטרנט
תכנות ופיתוח,

83
00:03:30,779 --> 00:03:35,150
דברים שהם מאוד כיף בהשוואה
לחלק מpsets האחר.

84
00:03:35,150 --> 00:03:37,974
וזה יהיה צינה, ו
תהיה לנו הרבה כיף.

85
00:03:37,974 --> 00:03:38,890
תהיה לנו יותר ממתק.

86
00:03:38,890 --> 00:03:39,730
סליחה על ממתקים.

87
00:03:39,730 --> 00:03:40,945
שכחתי ממתקים.

88
00:03:40,945 --> 00:03:43,310
זה היה מחוספס בבוקר.

89
00:03:43,310 --> 00:03:46,340
אז אתם כמעט שם,
ואני ממש גאה בך חבר '.

90
00:03:46,340 --> 00:03:49,570
>> אוקיי, אז ערימות.

91
00:03:49,570 --> 00:03:53,331
מי אהב את השאלה על ג'ק
ובגדיו בחידון?

92
00:03:53,331 --> 00:03:53,830
אף אחד?

93
00:03:53,830 --> 00:03:56,500
אוקי זה בסדר.

94
00:03:56,500 --> 00:04:00,200
>> אז בעצם אתה יכול
התמונה ג'ק, הבחור הזה כאן,

95
00:04:00,200 --> 00:04:03,350
אוהב לקחת את הבגדים
מתוך ראש הערימה,

96
00:04:03,350 --> 00:04:05,750
והוא מחזיר אותו על
הערימה לאחר שהוא עשה.

97
00:04:05,750 --> 00:04:07,600
אז בדרך זו, הוא אף פעם לא
נראה מקבל

98
00:04:07,600 --> 00:04:10,090
לתחתית
מחסנית בבגדיו.

99
00:04:10,090 --> 00:04:12,600
אז זה סוג של מתאר
מבנה נתונים הבסיסי

100
00:04:12,600 --> 00:04:16,610
איך מחסנית מיושמת.

101
00:04:16,610 --> 00:04:20,060
>> בעיקרו של דבר, לחשוב על
מחסנית כמו כל ערימה של אובייקטים

102
00:04:20,060 --> 00:04:24,900
איפה אתה שם את הדברים על הראש, ו
אז אתה מכניס אותם החוצה מהחלק העליון.

103
00:04:24,900 --> 00:04:28,600
אז LIFO הוא ראשי התיבות שאנחנו אוהבים
לuse-- אחרון נכנס, ראשון יוצא.

104
00:04:28,600 --> 00:04:32,480
וכך תימשך לראש
הערימה היא ראשון שיוצא.

105
00:04:32,480 --> 00:04:34,260
וכך שני תנאים
אנחנו אוהבים לשייך

106
00:04:34,260 --> 00:04:36,190
עם שנקראים דחיפה ופופ.

107
00:04:36,190 --> 00:04:39,790
כאשר אתה דוחף משהו על
מחסנית, ואתה פופ לגבות אותו.

108
00:04:39,790 --> 00:04:43,422
>> ואז אני מניח שזה סוג של
מושג מופשט לאלה מכם

109
00:04:43,422 --> 00:04:45,630
שרוצה לראות כמו
יישום בפועל של זה

110
00:04:45,630 --> 00:04:46,740
בעולם האמיתי.

111
00:04:46,740 --> 00:04:50,170
כמה מכם כתבו מאמר
אולי כמו שעה לפני שהיה אמורים,

112
00:04:50,170 --> 00:04:54,510
ומחקת בטעות ענקית
נתח שלו, כמו בטעות?

113
00:04:54,510 --> 00:04:58,560
ואז מה לעשות שליטה
אנו משתמשים כדי להחזיר אותו?

114
00:04:58,560 --> 00:05:00,030
הבקרה-Z, כן?

115
00:05:00,030 --> 00:05:03,640
בקרה-Z, כך כמות פעמים
כי הבקרה-Z הציל את חיי,

116
00:05:03,640 --> 00:05:08,820
הציל את התחת שלי, בכל פעם
זה מיושם באמצעות מחסנית.

117
00:05:08,820 --> 00:05:13,020
>> בעיקרו של דבר את כל המידע
זה במסמך Word שלך,

118
00:05:13,020 --> 00:05:15,080
זה נדחק וצץ כרצונו.

119
00:05:15,080 --> 00:05:19,460
וכך בעצם כל פעם שאתה
למחוק כל דבר, אתה פופ לגבות אותו.

120
00:05:19,460 --> 00:05:22,820
ואז אם אתה צריך את זה על גב, אתה
לדחוף אותו, וזה מה שעושה בקרה-C.

121
00:05:22,820 --> 00:05:26,770
ופונקצית עולם כל כך אמיתית
של מבנה נתונים כמה פשוט

122
00:05:26,770 --> 00:05:28,690
יכול לעזור עם חיי היומיום שלך.

123
00:05:28,690 --> 00:05:31,710

124
00:05:31,710 --> 00:05:40,150
>> אז struct היא הדרך ש
אנחנו בעצם ליצור ערימה.

125
00:05:40,150 --> 00:05:44,720
אנו מקלידים להגדיר struct, ולאחר מכן
אנחנו קוראים לזה מחסנית בתחתית.

126
00:05:44,720 --> 00:05:47,440
ובתוך הערימה,
יש לנו שני פרמטרים

127
00:05:47,440 --> 00:05:51,580
שבעצם אנחנו יכולים לתפעל,
אז יש לנו יכולת מחרוזות כוכב char.

128
00:05:51,580 --> 00:05:55,150
>> כל מה שהוא עושה
יוצר מערך

129
00:05:55,150 --> 00:05:58,835
שאנחנו יכולים לאחסן מה שאתה רוצה
שבו אנו יכולים לקבוע את הקיבולת שלה.

130
00:05:58,835 --> 00:06:01,990
קיבולת האם רק את הסכום המקסימלי של
פריטים שאנחנו יכולים להכניס לתוך מערך זה.

131
00:06:01,990 --> 00:06:05,660
גודל int הוא הדלפק שמחזיק
אחר פריטים כמה כרגע

132
00:06:05,660 --> 00:06:07,850
בערימה.

133
00:06:07,850 --> 00:06:11,860
אז אנחנו יכולים לעקוב אחר,,
שני כמה גדול הערימה בפועל היא,

134
00:06:11,860 --> 00:06:14,850
ו, B, כמה מערימה ש
מלאנו בגלל שאנחנו לא רוצים

135
00:06:14,850 --> 00:06:18,800
לגלוש על מה היא היכולת שלנו.

136
00:06:18,800 --> 00:06:24,340
>> כך למשל, זה יפה
השאלה הייתה על החידון שלך.

137
00:06:24,340 --> 00:06:28,160
בעיקרו של דבר איך אנחנו דוחפים
על החלק העליון של מחסנית.

138
00:06:28,160 --> 00:06:28,830
די פשוט.

139
00:06:28,830 --> 00:06:30,621
אם אתה מסתכל על זה,
אנו ללכת דרך זה.

140
00:06:30,621 --> 00:06:32,640
אם [לא ברור] size--
זוכר, בכל פעם ש

141
00:06:32,640 --> 00:06:35,300
רוצה לגשת לכל
פרמטר בתוך struct,

142
00:06:35,300 --> 00:06:40,320
אתה עושה שם struct.parameter.

143
00:06:40,320 --> 00:06:42,720
>> במקרה זה, שלו
שמו של הערימה שלנו.

144
00:06:42,720 --> 00:06:46,230
אנחנו רוצים לגשת לגודל
שלו, ולכן אנחנו עושים s.size.

145
00:06:46,230 --> 00:06:50,280
אז כל עוד הגודל הוא לא
שווה לקיבולת או עוד

146
00:06:50,280 --> 00:06:52,940
כמו שזה פחות מיכולת,
גם יעבוד כאן.

147
00:06:52,940 --> 00:06:57,180
>> אתה רוצה לגשת בתוך
של הערימה שלך, כך s.strings,

148
00:06:57,180 --> 00:07:00,790
ואתה הולך לשים את זה מספר חדש
שאתה רוצה להכניס לתוך שם.

149
00:07:00,790 --> 00:07:05,030
בואו נגיד שאנחנו רוצים
הכנס n int על הערימה,

150
00:07:05,030 --> 00:07:08,905
אנחנו יכולים לעשות s.strings,
סוגריים, s.size שווה n.

151
00:07:08,905 --> 00:07:11,030
בגלל הגודל שבו אנחנו
כיום נמצאים בערימה

152
00:07:11,030 --> 00:07:14,590
אם אנחנו הולכים לדחוף
זה ב, אנחנו פשוט לגשת

153
00:07:14,590 --> 00:07:17,370
בכל מקום שהגודל הוא,
מלאות הנוכחיות של הערימה,

154
00:07:17,370 --> 00:07:21,729
ואנחנו דוחפים n int על זה.

155
00:07:21,729 --> 00:07:24,770
ואז אנחנו רוצים לוודא ש
אנחנו גם הגדלה גודל של n,

156
00:07:24,770 --> 00:07:27,436
כדי שנוכל לעקוב אחר שיש לנו
הוסיף דבר נוסף כדי הערימה.

157
00:07:27,436 --> 00:07:29,660
עכשיו יש לנו גודל גדול יותר.

158
00:07:29,660 --> 00:07:33,196
האם זה הגיוני כאן
כולם, איך זה עובד באופן הגיוני?

159
00:07:33,196 --> 00:07:34,160
זה היה סוג של מהיר.

160
00:07:34,160 --> 00:07:39,535

161
00:07:39,535 --> 00:07:42,160
קהל: האם אתה יכול לעבור על
s.stringss.strings [s.size] שוב?

162
00:07:42,160 --> 00:07:45,808
ANDI פנג: בטח, אז מה עושה
s.size כרגע לתת לנו?

163
00:07:45,808 --> 00:07:47,440
קהל: זה הגודל הנוכחי.

164
00:07:47,440 --> 00:07:50,890
ANDI פנג: בדיוק, כך
מדד הנוכחי שהגודל שלנו הוא ב,

165
00:07:50,890 --> 00:07:57,780
ולכן אנחנו רוצים לשים את המספר השלם החדש
שאנחנו רוצים להכניס לתוך s.size.

166
00:07:57,780 --> 00:07:58,760
האם זה הגיוני?

167
00:07:58,760 --> 00:08:01,110
בגלל s.strings, כל ש
הוא הוא שמו של המערך.

168
00:08:01,110 --> 00:08:03,510
כל זה הוא בגישה ל
מערך בתוך struct שלנו,

169
00:08:03,510 --> 00:08:06,030
ולכן אם אנחנו רוצים
מקום n למדד ש,

170
00:08:06,030 --> 00:08:09,651
אנחנו רק יכולים לגשת אליו
סוגריים באמצעות s.size.

171
00:08:09,651 --> 00:08:10,150
לְהִתְקַרֵר.

172
00:08:10,150 --> 00:08:13,580

173
00:08:13,580 --> 00:08:18,916
>> בסדר, פופ, אני פסאודו קוד אותו
בשבילכם, אבל רעיון דומה.

174
00:08:18,916 --> 00:08:19,790
האם זה הגיוני?

175
00:08:19,790 --> 00:08:22,310
אם הגודל גדול
מאפס, אז אתה

176
00:08:22,310 --> 00:08:25,350
יודע שאתה רוצה לקחת משהו
החוצה, כי אם הגודל הוא לא

177
00:08:25,350 --> 00:08:27,620
גדול מאפס, אז אתה
אין לי מה בערימה.

178
00:08:27,620 --> 00:08:29,840
>> אז אתה רק רוצה לבצע
קוד זה, זה יכול רק

179
00:08:29,840 --> 00:08:32,320
פופ אם יש משהו פופ.

180
00:08:32,320 --> 00:08:35,830
אז אם הגודל הוא גדול יותר
מ 0, אנחנו מינוס הגודל.

181
00:08:35,830 --> 00:08:40,020
אנו הפחתת הגודל ולאחר מכן לחזור
כל מה שבתוכו, כי

182
00:08:40,020 --> 00:08:42,710
על ידי צץ, אנחנו רוצים
גישה מה מאוחסן

183
00:08:42,710 --> 00:08:45,694
במדד של ראש הערימה.

184
00:08:45,694 --> 00:08:46,610
הכל הגיוני?

185
00:08:46,610 --> 00:08:49,693
אם עשיתי לך בחורים לכתוב את זה,
היית בחורים שיוכלו לכתוב את זה?

186
00:08:49,693 --> 00:08:52,029

187
00:08:52,029 --> 00:08:53,570
אישור, אתם יכולים לשחק עם זה.

188
00:08:53,570 --> 00:08:55,252
אל דאגה, אם אתה לא מבין את זה.

189
00:08:55,252 --> 00:08:57,460
אין לנו זמן לקוד
את זה היום כי יש לנו

190
00:08:57,460 --> 00:08:59,959
יש הרבה מבנים אלה
לעבור, אבל במהות

191
00:08:59,959 --> 00:09:02,214
פסאודו קוד, מאוד, דומה מאוד לדחוף.

192
00:09:02,214 --> 00:09:03,380
פעלתי יחד ההיגיון.

193
00:09:03,380 --> 00:09:06,092
ודא שאתה ניגש כל
תכונות של struct בצורה נכונה.

194
00:09:06,092 --> 00:09:06,574
כֵּן?

195
00:09:06,574 --> 00:09:09,282
>> קהל: האם שקופיות אלה ו
כל הדבר הזה יהיה עד היום, איש?

196
00:09:09,282 --> 00:09:11,586
ANDI פנג: תמיד, כן.

197
00:09:11,586 --> 00:09:13,710
אני הולך לנסות לשים
זה כמו שעה אחרי.

198
00:09:13,710 --> 00:09:16,626
אני אשלח דוד, דוד ינסה
לשים את זה כמו שעה אחרי זה.

199
00:09:16,626 --> 00:09:20,040

200
00:09:20,040 --> 00:09:25,470
>> אוקיי, אז לאחר מכן אנחנו עוברים לזה אחר
מבנה נתונים יפה בשם תור.

201
00:09:25,470 --> 00:09:30,140
כאתם יכולים לראות כאן,
תור, לבריטים בקרבנו,

202
00:09:30,140 --> 00:09:32,010
כל זה הוא קו.

203
00:09:32,010 --> 00:09:34,680
אז בניגוד למה
אתה חושב ערימה היא,

204
00:09:34,680 --> 00:09:37,750
תור הוא בדיוק מה ש
מבחינה לוגית אתה חושב שזה.

205
00:09:37,750 --> 00:09:41,914
הוא נערך לפי הכללים של FIFO,
שהוא ראשון נכנס, ראשון מתוך.

206
00:09:41,914 --> 00:09:43,705
אם אתה הראשון
אחד בשורה, אתה

207
00:09:43,705 --> 00:09:46,230
הראשון ש
יוצא מהקו.

208
00:09:46,230 --> 00:09:49,680
>> אז מה שאנחנו אוהבים לקרוא את זה
הוא dequeueing וenqueueing.

209
00:09:49,680 --> 00:09:52,380
אם אנחנו רוצים להוסיף משהו
לתורנו, אנחנו Enqueue.

210
00:09:52,380 --> 00:09:55,690
אם אנחנו רוצים dequeue, או לקחת
משהו משם, אנחנו dequeue.

211
00:09:55,690 --> 00:10:03,350
>> אז אותו מובן שאנחנו סוג של
יצירת אלמנטים בגודל קבוע ש

212
00:10:03,350 --> 00:10:06,500
יכול לאחסן מסוים
דברים, אבל אנחנו גם יכולים

213
00:10:06,500 --> 00:10:10,100
לשנות לאן אנחנו הצבה
פרמטרים הפנימיים שלהם

214
00:10:10,100 --> 00:10:13,140
המבוסס על איזה סוג של
פונקציונלי שאנחנו רוצים.

215
00:10:13,140 --> 00:10:16,700
אז ערימות, שרצינו שעבר
אחד, N להיות מתוך אחד הראשון.

216
00:10:16,700 --> 00:10:19,800
התור הוא שאנחנו רוצים הדבר הראשון
בלהיות הדבר הראשון.

217
00:10:19,800 --> 00:10:22,510

218
00:10:22,510 --> 00:10:26,710
>> אז struct הסוג
להגדיר, כפי שאתה יכול לראות,

219
00:10:26,710 --> 00:10:29,470
זה קצת שונה
ממה שהייתה הערימה

220
00:10:29,470 --> 00:10:33,120
כי לא לעשות אנחנו צריכים לשמור רק
אחר שבו הגודל הוא כיום,

221
00:10:33,120 --> 00:10:37,420
אנחנו רוצים גם לעקוב אחר הראש
כמו גם שבו אנו נמצאים כעת.

222
00:10:37,420 --> 00:10:39,580
אז אני חושב שזה יותר קל
אם אני מצייר את זה.

223
00:10:39,580 --> 00:10:53,270
אז בואו נדמיין שיש לנו תור,
כך נניח את הראש הוא ממש כאן.

224
00:10:53,270 --> 00:10:55,811

225
00:10:55,811 --> 00:10:58,310
ראש התור, בוא
רק אומר שכרגע יש,

226
00:10:58,310 --> 00:11:01,809
ואנחנו רוצים להכניס
משהו לתוך התור.

227
00:11:01,809 --> 00:11:04,350
אני הולך לקרוא לגודל במהות
הוא אותו הדבר כמו זנב,

228
00:11:04,350 --> 00:11:06,314
סוף בכל מקום התור שלך הוא.

229
00:11:06,314 --> 00:11:07,730
בואו נגיד גודל הוא ממש כאן.

230
00:11:07,730 --> 00:11:14,380

231
00:11:14,380 --> 00:11:18,400
>> אז איך עושה יתכן אחד
הכנס משהו לתוך תור?

232
00:11:18,400 --> 00:11:21,000

233
00:11:21,000 --> 00:11:24,130
מה מדד אנחנו רוצים למקם
לאן שאנחנו רוצים להכניס לתוך.

234
00:11:24,130 --> 00:11:29,320
אם זה תחילתך
בתור וזה הסוף שלו

235
00:11:29,320 --> 00:11:31,860
או הגודל שלו, שבו אנחנו עושים
רוצה להוסיף את האובייקט הבא?

236
00:11:31,860 --> 00:11:32,920
>> קהל: [לא ברור]

237
00:11:32,920 --> 00:11:35,920
ANDI פנג: בדיוק, אתה רוצה להוסיף
זה תלוי ביש לך כתב את זה.

238
00:11:35,920 --> 00:11:37,840
או שזו ריקה או שהוא ריק.

239
00:11:37,840 --> 00:11:42,630
אז אתה רוצה להוסיף אותו כנראה
כאן, כי אם הגודל הוא--

240
00:11:42,630 --> 00:11:50,540
אם כל אלה הם מלאים, אתה רוצה
כדי להוסיף אותו ממש כאן, נכון?

241
00:11:50,540 --> 00:11:57,150
>> ואז זה, בעוד מאוד, מאוד
פשוט, לא די תמיד נכון

242
00:11:57,150 --> 00:12:00,690
כי ההבדל העיקרי
בין תור ומחסנית

243
00:12:00,690 --> 00:12:04,350
הוא שיכול התור
למעשה לטפל

244
00:12:04,350 --> 00:12:06,980
כך שהשינויים בראש
תלוי איפה אתה רוצה

245
00:12:06,980 --> 00:12:08,650
תחילת המקל שלך כדי להתחיל.

246
00:12:08,650 --> 00:12:11,900
כתוצאה מכך, הזנב שלך
גם הולך להשתנות.

247
00:12:11,900 --> 00:12:14,770
ואז תסתכל ב
הקוד הזה עכשיו.

248
00:12:14,770 --> 00:12:18,620
כאתם גם התבקשו ל
לכתוב על החידון, Enqueue.

249
00:12:18,620 --> 00:12:22,580
אולי נדבר במה
התשובה הייתה מה שהייתה.

250
00:12:22,580 --> 00:12:26,790
>> אני לא ממש הצלחתי להתאים את הקו הזה על אחד,
אבל בעצם פיסת קוד זה

251
00:12:26,790 --> 00:12:29,030
צריך להיות בשורה אחת.

252
00:12:29,030 --> 00:12:30,140
לבלות כמו 30 שניות.

253
00:12:30,140 --> 00:12:33,000
תסתכל, ולראות למה
זו הדרך שזה.

254
00:12:33,000 --> 00:12:50,030

255
00:12:50,030 --> 00:12:55,420
>> struct מאוד, דומה מאוד, מאוד, מאוד
מבנה דומה לקודם

256
00:12:55,420 --> 00:12:58,090
מחסנית למעט אולי
שורת קוד אחת.

257
00:12:58,090 --> 00:13:01,190
וששורה אחת של קוד
קובע את הפונקציונליות.

258
00:13:01,190 --> 00:13:03,900
וזה באמת מבדיל
תור מערימה.

259
00:13:03,900 --> 00:13:18,510

260
00:13:18,510 --> 00:13:22,010
>> כל אחד רוצה לקחת דקירה
במסביר מדוע יש לך

261
00:13:22,010 --> 00:13:24,980
יש דבר מסובך זה כאן?

262
00:13:24,980 --> 00:13:27,845
אנו רואים את החזרה שלנו
מודול חבר נפלא.

263
00:13:27,845 --> 00:13:31,020
כפי שאתם בחורים בקרוב יבואו
להכיר בתכנות,

264
00:13:31,020 --> 00:13:34,910
כמעט בכל עת שאתה צריך משהו
כדי לעטוף כל דבר,

265
00:13:34,910 --> 00:13:36,850
מודול הולך להיות הדרך לעשות את זה.

266
00:13:36,850 --> 00:13:40,510
אז ידיעה ש, האם מישהו רוצה
לנסות להסביר קו זה של קוד?

267
00:13:40,510 --> 00:13:44,060

268
00:13:44,060 --> 00:13:47,507
כן, כל התשובות
מקובל ומבורך.

269
00:13:47,507 --> 00:13:48,840
קהל: האם אתה מדבר אליי?

270
00:13:48,840 --> 00:13:49,506
ANDI פנג: כן.

271
00:13:49,506 --> 00:13:56,200
קהל: הו, לא מצטער.

272
00:13:56,200 --> 00:14:00,250
ANDI פנג: אוקיי, אז בואו
ללכת דרך קוד זה.

273
00:14:00,250 --> 00:14:03,642
לכן, כאשר אתה מנסה
להוסיף משהו על תור,

274
00:14:03,642 --> 00:14:08,510
במקרה היפה שהראש קורה
להיות כאן, זה קל מאוד עבורנו

275
00:14:08,510 --> 00:14:10,960
רק כדי ללכת עד הסוף
הכנס משהו, נכון?

276
00:14:10,960 --> 00:14:14,690
אבל כל העניין של תור
שהראש ממש יכול באופן דינמי

277
00:14:14,690 --> 00:14:17,280
לשנות תלוי איפה אנחנו
רוצה תחילת q שלנו להיות,

278
00:14:17,280 --> 00:14:19,880
וכמו, הזנב כזה
גם הולך להשתנות.

279
00:14:19,880 --> 00:14:31,100
>> וכך מתאר לעצמי שזה לא היה
בתור, אלא זה היה התור.

280
00:14:31,100 --> 00:14:37,900

281
00:14:37,900 --> 00:14:39,330
נניח שהראש הוא ממש כאן.

282
00:14:39,330 --> 00:14:54,900

283
00:14:54,900 --> 00:14:56,980
בואו נגיד שהתור שלנו נראה כמו זה.

284
00:14:56,980 --> 00:15:00,190
אם אנחנו רוצים להעביר בי
תחילת השורה היא,

285
00:15:00,190 --> 00:15:03,400
נניח שהעברנו ראש
בדרך זו ובגדלים כאן.

286
00:15:03,400 --> 00:15:07,100
>> עכשיו אנחנו רוצים להוסיף משהו ל
התור הזה, אבל כמו שאתם יכולים לראות,

287
00:15:07,100 --> 00:15:11,150
זה לא כל כך פשוט כמו שרק
להוסיף מה שאחרי הגודל

288
00:15:11,150 --> 00:15:13,630
כי אז נגמרו
גבולות של המערך האמיתי שלנו.

289
00:15:13,630 --> 00:15:16,190
איפה אנחנו רוצים באמת להוסיף כאן.

290
00:15:16,190 --> 00:15:18,610
זה היופי של תור
הוא שלנו, מבחינה ויזואלית זה

291
00:15:18,610 --> 00:15:22,380
נראה כמו הקו הולך ככה,
אבל כאשר הם מאוחסנים במבנה נתונים,

292
00:15:22,380 --> 00:15:29,370
הם נותנים לו כמו כמו מחזור.

293
00:15:29,370 --> 00:15:32,360
זה סוג של עוטף
לחזית באותה הדרך

294
00:15:32,360 --> 00:15:34,780
כי קו יכול גם לעטוף
סביב בהתאם לכל מקום שאתה

295
00:15:34,780 --> 00:15:36,279
רוצה תחילת השורה להיות.

296
00:15:36,279 --> 00:15:38,630
וכך אנו אם לקחת
להסתכל למטה כאן, בואו

297
00:15:38,630 --> 00:15:40,880
אומר שאנחנו רוצים ליצור
פונקציה שנקראת Enqueue.

298
00:15:40,880 --> 00:15:43,980
רצינו להוסיף n int לq ש.

299
00:15:43,980 --> 00:15:49,250
אם q.size q-- אנחנו נתקשר כי הנתונים שלנו
structure-- אם queue.size לא

300
00:15:49,250 --> 00:15:52,520
שווה לקיבולת או אם
זה פחות מיכולת,

301
00:15:52,520 --> 00:15:55,120
q.strings הוא המערך בתוך q שלנו.

302
00:15:55,120 --> 00:15:58,380
אנחנו הולכים להגדיר
ששווה לq.heads,

303
00:15:58,380 --> 00:16:02,730
שנמצא ממש כאן, בתוספת q.size
מודולוס על ידי היכולת, ש

304
00:16:02,730 --> 00:16:04,290
לעטוף בחזרה כאן.

305
00:16:04,290 --> 00:16:08,040
>> אז בדוגמא, מדד זה
ראש הוא 1, נכון?

306
00:16:08,040 --> 00:16:11,480
המדד של גודל הוא 0, 1, 2, 3, 4.

307
00:16:11,480 --> 00:16:19,500
אז אנחנו יכולים לעשות מודול 1 בתוספת 4
על ידי היכולת שלנו שהיא 5.

308
00:16:19,500 --> 00:16:20,920
מה זה נותן לנו?

309
00:16:20,920 --> 00:16:23,270
מהו המדד ש
יוצא מזה?

310
00:16:23,270 --> 00:16:24,080
>> קהל: 0.

311
00:16:24,080 --> 00:16:27,870
>> ANDI פנג: 0, ש
במקרה כאן,

312
00:16:27,870 --> 00:16:30,640
ולכן אנחנו רוצים להיות מסוגלים
להכניס לכאן.

313
00:16:30,640 --> 00:16:34,730
וכך משוואה זו כאן סוג
רק עובד עם כל מספרים

314
00:16:34,730 --> 00:16:36,750
תלוי איפה
ראש והגודל שלך הם.

315
00:16:36,750 --> 00:16:38,541
אם אתה יודע מה אלה
דברים, אתה יודע

316
00:16:38,541 --> 00:16:43,170
בדיוק שבו אתה רוצה להכניס
כל מה שאחרי התור שלך.

317
00:16:43,170 --> 00:16:44,640
האם זה הגיוני לכולם?

318
00:16:44,640 --> 00:16:48,560
>> אני יודע סוג של מוח
טיזר במיוחד מאז זה

319
00:16:48,560 --> 00:16:50,512
בא בעקבות החידון שלך.

320
00:16:50,512 --> 00:16:52,220
אבל אני מקווה שכולם
עכשיו אפשר להבין

321
00:16:52,220 --> 00:16:57,800
מדוע פתרון זה או זה
פונקציה היא אופן שבו הוא.

322
00:16:57,800 --> 00:16:59,840
כל אחד קצת לא ברור בזה?

323
00:16:59,840 --> 00:17:03,471

324
00:17:03,471 --> 00:17:03,970
אוקיי.

325
00:17:03,970 --> 00:17:07,109

326
00:17:07,109 --> 00:17:09,970
>> אז עכשיו, אם אתה
רציתי dequeue, זה

327
00:17:09,970 --> 00:17:15,240
המקום שבו הראש שלנו יהיה הסטה
כי אם היינו dequeue,

328
00:17:15,240 --> 00:17:17,030
אנו לא לוקחים את הקצה של q.

329
00:17:17,030 --> 00:17:19,130
אנחנו רוצים לקחת את הראש, נכון?

330
00:17:19,130 --> 00:17:24,260
אז כתוצאה מכך, הראש הולך להשתנות,
ולכן כאשר אתה Enqueue,

331
00:17:24,260 --> 00:17:26,800
יש לך לעקוב אחר
איפה הראש שלך והגודל שלך

332
00:17:26,800 --> 00:17:29,450
הם להיות מסוגל להכניס
למיקום הנכון.

333
00:17:29,450 --> 00:17:32,740
>> ולכן כאשר אתה dequeue,
אני גם פסאודו קוד אותו החוצה.

334
00:17:32,740 --> 00:17:35,480
אתה מוזמן אם אתה רוצה
לנסות קידוד את זה.

335
00:17:35,480 --> 00:17:36,980
אתה רוצה להזיז את הראש, נכון?

336
00:17:36,980 --> 00:17:39,320
אם אני רוצה dequeue, אני
היה להזיז את הראש מעל.

337
00:17:39,320 --> 00:17:40,800
זה יהיה הראש.

338
00:17:40,800 --> 00:17:45,617
>> והיית הגודל הנוכחי שלנו
לחסר, כי אנחנו כבר לא

339
00:17:45,617 --> 00:17:46,950
יש ארבעה אלמנטים במערך.

340
00:17:46,950 --> 00:17:51,370
יש לנו רק שלוש, ולאחר מכן אנחנו רוצים
לחזור כל מה שמאוחסן בתוך

341
00:17:51,370 --> 00:17:56,260
של הראש כי אנחנו רוצים לקחת את זה
ערך כל כך דומה מאוד לערימה.

342
00:17:56,260 --> 00:17:58,010
רק אתה לוקח
ממקום אחר,

343
00:17:58,010 --> 00:18:01,770
ואתה צריך להקצות מחדש את המצביע
למקום אחר כתוצאה מכך.

344
00:18:01,770 --> 00:18:03,890
מבחינה הגיונית, כולם לעקוב אחרי?

345
00:18:03,890 --> 00:18:05,690
גדול.

346
00:18:05,690 --> 00:18:10,156
>> אוקיי, אז אנחנו הולכים לדבר קצת
יותר לעומק על רשימות מקושרות

347
00:18:10,156 --> 00:18:13,280
כי הם נהיה מאוד, מאוד חשובים
בשבילך במהלך השבוע של

348
00:18:13,280 --> 00:18:14,964
psets.

349
00:18:14,964 --> 00:18:17,130
רשימות מקושרות, כמו שאתם
זוכר, את כולם

350
00:18:17,130 --> 00:18:22,570
הם צמתים שהם צמתים של מסוים
ערכים של שני ערך ומצביע

351
00:18:22,570 --> 00:18:26,290
המקושרים יחד
על ידי מצביעים אלה.

352
00:18:26,290 --> 00:18:29,880
וכך struct על איך
אנו יוצרים צומת כאן היא ש

353
00:18:29,880 --> 00:18:33,569
יש לי n int, שהוא כל מה ש
הערך בn חנות או מחרוזת

354
00:18:33,569 --> 00:18:35,610
או מה שאתה רוצה
קורא לזה, n כוכב char.

355
00:18:35,610 --> 00:18:41,482
כוכב צומת struct, המהווה את המצביע
כי אתה רוצה להיות בכל צומת,

356
00:18:41,482 --> 00:18:43,690
אתה הולך לי ש
נקודת מצביע לכיוון הבא.

357
00:18:43,690 --> 00:18:48,207

358
00:18:48,207 --> 00:18:50,040
יהיה לך את הראש
של רשימה מקושרת זה

359
00:18:50,040 --> 00:18:53,140
הולך להצביע לשאר
הערכים כן הלאה וכן הלאה

360
00:18:53,140 --> 00:18:55,290
עד שסופו של דבר להגיע לסוף.

361
00:18:55,290 --> 00:18:58,040
והצומת האחרונה זה רק
הולך לא צריך מצביע.

362
00:18:58,040 --> 00:18:59,952
זה הולך להצביע
null, ואז

363
00:18:59,952 --> 00:19:01,910
אתה יודע שפגעת ב
סוף הרשימה המקושרת שלך

364
00:19:01,910 --> 00:19:04,076
כאשר המצביע האחרון שלך
אינו מצביע על שום דבר.

365
00:19:04,076 --> 00:19:06,670

366
00:19:06,670 --> 00:19:10,990
>> אז אנחנו הולכים ללכת קצת יותר ב
עומק בנוגע לאופן שאולי אחד היית

367
00:19:10,990 --> 00:19:12,400
חיפוש רשימה מקושרת.

368
00:19:12,400 --> 00:19:15,460
זוכר מה הם כמה מ
חסרונות של הרשימות המקושרות

369
00:19:15,460 --> 00:19:19,340
פסוקים מערך לגבי חיפושים.

370
00:19:19,340 --> 00:19:22,565
מערך אתה יכול לחפש בינארי, אבל
למה אתה לא יכול לעשות את זה ברשימה מקושרת?

371
00:19:22,565 --> 00:19:26,834

372
00:19:26,834 --> 00:19:30,320
>> קהל: כי הם כולם מחוברים,
אבל אתה לא ממש יודע איפה

373
00:19:30,320 --> 00:19:31,330
[לא ברור].

374
00:19:31,330 --> 00:19:34,600
>> ANDI פנג: כן, בדיוק כך זוכר
שהברק של מערך

375
00:19:34,600 --> 00:19:37,190
הייתה העובדה שהיו לנו
זיכרון גישה אקראית שבי

376
00:19:37,190 --> 00:19:41,580
אם אני רוצה את הערך ממדד
שש, אני יכול רק לומר מדד שישה,

377
00:19:41,580 --> 00:19:42,407
תן לי ערך ש.

378
00:19:42,407 --> 00:19:45,240
וזה בגלל מערכים מסודרים
בשטח רציף של זיכרון

379
00:19:45,240 --> 00:19:48,020
במקום אחד, ואילו
סוג של רשימות מקושרות

380
00:19:48,020 --> 00:19:52,820
הם באופן אקראי ביניהם בכל רחבי,
והדרך היחידה שאתה יכול למצוא אחד

381
00:19:52,820 --> 00:19:56,890
הוא באמצעות מצביע שאומר לך
את הכתובת של איפה שהצומת הבאה היא.

382
00:19:56,890 --> 00:20:00,290
>> וכך כתוצאה מכך, הדרך היחידה
לחפש ברשימה מקושרת

383
00:20:00,290 --> 00:20:01,560
הוא חיפוש ליניארי.

384
00:20:01,560 --> 00:20:05,890
כי אני לא בדיוק יודע איפה
ערך ה -12 ברשימה המקושרת הוא,

385
00:20:05,890 --> 00:20:08,780
אני חייב לעבור את השלמות
של שאחד הרשימה המקושרת

386
00:20:08,780 --> 00:20:12,450
על ידי אחד מן הראש אל הצומת הראשונה,
לצומת השנייה, לצומת השלישית,

387
00:20:12,450 --> 00:20:17,690
כל הדרך למטה עד שלבסוף אני מקבל
לשם צומת שאני מחפש היא.

388
00:20:17,690 --> 00:20:22,110
וכך, במובן זה, חיפוש
ברשימה מקושרת הוא תמיד n.

389
00:20:22,110 --> 00:20:23,040
זה תמיד n.

390
00:20:23,040 --> 00:20:25,690
זה תמיד בזמן ליניארי.

391
00:20:25,690 --> 00:20:28,470
>> וכך את הקוד שב
אנו ליישם את זה, וזה

392
00:20:28,470 --> 00:20:32,620
זה קצת חדש בשבילכם מאז ש
בחורים לא ממש דיברו על או אי פעם

393
00:20:32,620 --> 00:20:35,000
מצביעים ראו באיך
חיפוש באמצעות מצביעים,

394
00:20:35,000 --> 00:20:37,670
כך יהיה לנו ללכת דרך
זה מאוד, מאוד לאט.

395
00:20:37,670 --> 00:20:40,200
אז חיפוש בול, נכון,
בואו אניח שאנחנו רוצים

396
00:20:40,200 --> 00:20:42,820
כדי ליצור פונקציה שנקראת
חיפוש שמחזיר אמת

397
00:20:42,820 --> 00:20:46,820
אם מצא ערך בתוך קשור
רשימה, והיא מחזירה שקר אחר.

398
00:20:46,820 --> 00:20:50,030
רשימת כוכבים צומת היא
כרגע רק את המצביע

399
00:20:50,030 --> 00:20:52,960
לפריט הראשון ברשימה המקושרת שלך.

400
00:20:52,960 --> 00:20:56,700
n int הוא הערך שאתה
מחפש ברשימה.

401
00:20:56,700 --> 00:20:58,770
>> אז מצביע כוכב צומת שווה רשימה.

402
00:20:58,770 --> 00:21:00,970
זה אומר שאנחנו הגדרה
ויצירת מצביע

403
00:21:00,970 --> 00:21:03,592
שלצומת הראשונה בתוך הרשימה.

404
00:21:03,592 --> 00:21:04,300
כולם איתי?

405
00:21:04,300 --> 00:21:06,530
אז אם היינו ללכת
אחזור לכאן, שיהיה לי

406
00:21:06,530 --> 00:21:13,850
אותחל מצביע המצביע על
ראש מה שהרשימה היא.

407
00:21:13,850 --> 00:21:18,600
>> ואז ברגע שאתה מקבל כאן למטה,
בעוד מצביע אינו null שווה,

408
00:21:18,600 --> 00:21:22,160
כך שהיא הלולאה שבו אנו נמצאים
הולך להיות בהמשך חוצים

409
00:21:22,160 --> 00:21:25,940
שאר הרשימה שלנו, כי מה ש
קורה כאשר מצביע null שווה?

410
00:21:25,940 --> 00:21:27,550
אנחנו יודעים שאנחנו נו--

411
00:21:27,550 --> 00:21:28,450
>> קהל: [לא ברור]

412
00:21:28,450 --> 00:21:31,491
>> ANDI פנג: בדיוק, כך שאנחנו יודעים ש
אנחנו כבר הגענו לסוף הרשימה, נכון?

413
00:21:31,491 --> 00:21:34,470
אם לחזור לכאן, כל צומת
יש המצביע על צומת אחר

414
00:21:34,470 --> 00:21:36,550
וכן הלאה וכן הלאה
עד שתגיע סופו של דבר

415
00:21:36,550 --> 00:21:41,589
הזנב של הרשימה המקושרת שלך,
שבו יש מצביע שרק

416
00:21:41,589 --> 00:21:43,130
אינו מצביע בכל מקום אחר מאשר לא.

417
00:21:43,130 --> 00:21:47,510
ואז אתה בעצם יודע ש
יש ברשימה שלך היא עדיין את

418
00:21:47,510 --> 00:21:50,900
עד מצביע אינו שווה
null כי ברגע שזה שווה null,

419
00:21:50,900 --> 00:21:53,310
אתה יודע שאין יותר דברים.

420
00:21:53,310 --> 00:21:56,930
>> אז זה הלולאה שבו אנו נמצאים
הולך להיות החיפוש בפועל.

421
00:21:56,930 --> 00:22:01,690
ואם אתה רואה pointer--
סוג זה של פונקצית חץ שם?

422
00:22:01,690 --> 00:22:06,930
אז אם מצביע מצביע לn, אם
המצביע בn שווה שווה n,

423
00:22:06,930 --> 00:22:09,180
אז זה אומר שאם
המצביע שאתה

424
00:22:09,180 --> 00:22:13,420
מחפש בסופו של כל
הצומת היא למעשה שווה הערך

425
00:22:13,420 --> 00:22:15,990
שאתה מחפש, אז
אתה רוצה לחזור אמיתי.

426
00:22:15,990 --> 00:22:19,280
אז בעצם, אם אתה נמצא בצומת ש
יש הערך שאתה מחפש,

427
00:22:19,280 --> 00:22:23,550
אתה יודע שאתה כבר
תוכל לחפש בהצלחה.

428
00:22:23,550 --> 00:22:27,150
>> אחרת, אתה רוצה להגדיר
המצביע שלך לצומת הבאה.

429
00:22:27,150 --> 00:22:28,850
זה מה שהוא עושה כאן הקו.

430
00:22:28,850 --> 00:22:31,750
פוינטר שווה מצביע הבא.

431
00:22:31,750 --> 00:22:33,360
כולם לראות איך זה עובד?

432
00:22:33,360 --> 00:22:36,580
>> ובעצם אתה הולך רק
חוצה את השלמות של הרשימה,

433
00:22:36,580 --> 00:22:41,920
איפוס המצביע שלך בכל פעם עד ש
סופו של דבר פגע בסוף הרשימה.

434
00:22:41,920 --> 00:22:45,030
ואתה יודע שאין
יותר צמתים לחפש דרך,

435
00:22:45,030 --> 00:22:47,999
ואז אתה יכול לחזור שווא
בגלל שאתה יודע את זה, אה, כן,

436
00:22:47,999 --> 00:22:50,540
אם אני כבר יכול לחפש
דרך השלמות של הרשימה.

437
00:22:50,540 --> 00:22:54,530
אם בדוגמא זו, אם אני רוצה
לחפש את הערך של 10,

438
00:22:54,530 --> 00:22:57,250
ואני מתחיל בראש, ו
אני מחפש כל הדרך למטה,

439
00:22:57,250 --> 00:23:00,550
וסופו של דבר הגיע לזה, ש
מצביע המצביע על null,

440
00:23:00,550 --> 00:23:04,415
אני יודע את זה, חרא, אני מניח 10 הוא לא ב
רשימה זו, כי לא הצלחתי למצוא אותו.

441
00:23:04,415 --> 00:23:06,520
ואני בסוף הרשימה.

442
00:23:06,520 --> 00:23:11,040
ובכל מקרה אתה יודע
אני הולך לחזור שווא.

443
00:23:11,040 --> 00:23:12,900
>> בואו שלטבול לקצת.

444
00:23:12,900 --> 00:23:17,350
זה יהיה די
חשוב לpset.

445
00:23:17,350 --> 00:23:21,140
ההיגיון שלו הוא פשוט מאוד, אולי
מבחינה תחבירית פשוט ליישם אותה.

446
00:23:21,140 --> 00:23:23,365
אתם רוצים לעשות
בטוח שאתה מבין.

447
00:23:23,365 --> 00:23:25,870

448
00:23:25,870 --> 00:23:27,650
לְהִתְקַרֵר.

449
00:23:27,650 --> 00:23:32,560
>> אוקיי, אז איך היינו
הוספת צמתים, תקין,

450
00:23:32,560 --> 00:23:35,380
לרשימה לזכור כי
מה הם מה היתרונות

451
00:23:35,380 --> 00:23:39,230
שיש לו רשימה מקושרת לעומת
מערך במונחים של אחסון?

452
00:23:39,230 --> 00:23:41,110
>> קהל: זה דינמי,
לכן קל יותר צריכה--

453
00:23:41,110 --> 00:23:43,180
>> ANDI פנג: בדיוק,
כך שזה דינמי, ש

454
00:23:43,180 --> 00:23:46,880
אומר שזה יכול להרחיב ולכווץ
בהתאם לצרכים של המשתמש.

455
00:23:46,880 --> 00:23:56,570
וכך, במובן זה, אנחנו לא צריכים
לבזבז זיכרון מיותר כי אני

456
00:23:56,570 --> 00:24:00,850
אם אני לא יודע כמה ערכים שאני רוצה
לחנות, זה לא הגיוני לי

457
00:24:00,850 --> 00:24:04,310
כדי ליצור מערך משום
אם אני רוצה לאחסן 10 ערכים

458
00:24:04,310 --> 00:24:08,380
ואני יוצר מערך של 1,000, זה
הרבה זיכרון מבוזבז, שהוקצה.

459
00:24:08,380 --> 00:24:11,180
זו הסיבה שאנחנו רוצים להשתמש קשורים
רשימה כדי להיות מסוגל דינמית

460
00:24:11,180 --> 00:24:13,860
לשנות או לכווץ הגודל שלנו.

461
00:24:13,860 --> 00:24:17,040
>> וכך זה עושה את ההכנסה
קצת יותר מסובך.

462
00:24:17,040 --> 00:24:20,810
מכיוון שאנו לא יכולים באופן אקראי לגשת אלמנטים
האופן שבו היינו של מערך.

463
00:24:20,810 --> 00:24:24,270
אם אני רוצה להכניס אלמנט
למדד השביעי,

464
00:24:24,270 --> 00:24:26,930
אני רק יכול להכניס אותו
למדד השביעי.

465
00:24:26,930 --> 00:24:30,020
ברשימה מקושרת, זה לא
די לעבוד בקלות,

466
00:24:30,020 --> 00:24:34,947
ולכן אם אנחנו רוצים להכניס
אחד כאן ברשימה המקושרת,

467
00:24:34,947 --> 00:24:36,280
מבחינה ויזואלית, זה קל מאוד לראות.

468
00:24:36,280 --> 00:24:39,363
אנחנו רק רוצים להכניס אותו ממש שם,
ממש בתחילת הרשימה,

469
00:24:39,363 --> 00:24:40,840
מייד אחרי הראש.

470
00:24:40,840 --> 00:24:44,579
>> אבל האופן שבו יש לנו להקצות מחדש
המצביעים הוא קצת מפותלים

471
00:24:44,579 --> 00:24:47,620
או, באופן הגיוני, זה הגיוני, אבל
אתה רוצה לוודא שיש לך את זה

472
00:24:47,620 --> 00:24:50,250
לגמרי כי
הדבר האחרון שאתה רוצה

473
00:24:50,250 --> 00:24:52,990
הוא להקצות מחדש מצביע
דרך שאנחנו עושים כאן.

474
00:24:52,990 --> 00:24:58,170
אם אתה dereference
מצביע מהראש ועד 1,

475
00:24:58,170 --> 00:25:01,086
אז כל פתאומי
שאר הרשימה המקושרת שלך

476
00:25:01,086 --> 00:25:04,680
הוא הפסיד בגלל שאתה צריך לא ממש
יצר משהו זמני.

477
00:25:04,680 --> 00:25:06,220
זה הצביע על 2.

478
00:25:06,220 --> 00:25:10,080
אם אתה להקצות מחדש את המצביע, ולאחר מכן
שאר הרשימה שלך הולך לאיבוד לחלוטין.

479
00:25:10,080 --> 00:25:13,310
אז אתה רוצה להיות
מאוד, מאוד זהיר כאן

480
00:25:13,310 --> 00:25:17,010
לראשון להקצות
מצביע מכל מה שאתה

481
00:25:17,010 --> 00:25:20,150
רוצה להכניס לתוך כל מקום
אתה רוצה, ואז אתה

482
00:25:20,150 --> 00:25:22,710
יכול dereference שאר הרשימה שלך.

483
00:25:22,710 --> 00:25:25,250
>> אז זה חל על כל מקום
אתה מנסה להכניס לתוך.

484
00:25:25,250 --> 00:25:27,520
אם אתה רוצה להכניס ב
ראש, אם ברצונך לענות כאן,

485
00:25:27,520 --> 00:25:29,455
אם ברצונך להוסיף ב
הסוף, גם, אני הסוף

486
00:25:29,455 --> 00:25:30,910
מניח שאתה פשוט היית
אין לי מצביע, אבל אתה

487
00:25:30,910 --> 00:25:33,830
רוצה לוודא שאתה לא
לאבד את שאר הרשימה שלך.

488
00:25:33,830 --> 00:25:36,640
אתה תמיד רוצה לוודא
הצומת החדשה שלך מצביעה

489
00:25:36,640 --> 00:25:39,330
לקראת כל מה שאתה
רוצה להכניס לתוך,

490
00:25:39,330 --> 00:25:42,170
ואז אתה יכול להוסיף את השרשור ב.

491
00:25:42,170 --> 00:25:43,330
כולם ברורים?

492
00:25:43,330 --> 00:25:45,427
>> זה הולך להיות
אחד הנושאים האמיתיים.

493
00:25:45,427 --> 00:25:48,010
אחת הסוגיות המרכזיות ביותר
אתה הולך להיות על pset

494
00:25:48,010 --> 00:25:51,340
הוא שאתה הולך לנסות ליצור
רשימה מקושרת ודברים להוסיף

495
00:25:51,340 --> 00:25:53,340
אבל אז רק להפסיד
שאר הרשימה המקושרת שלך.

496
00:25:53,340 --> 00:25:54,900
ואתה הולך להיות כמו, אני
לא יודע למה זה קורה?

497
00:25:54,900 --> 00:25:58,040
וזה כאב לעבור
ולחפש את כל המצביעים שלך.

498
00:25:58,040 --> 00:26:02,100
>> ואני מבטיח לך בpset זה,
כתיבה וציור צמתים אלה מתוך

499
00:26:02,100 --> 00:26:03,344
יהיה מאוד, מאוד מועיל.

500
00:26:03,344 --> 00:26:06,010
אז אתה יכול לעקוב אחר לחלוטין
היכן כל המצביעים שלך,

501
00:26:06,010 --> 00:26:08,540
מה השתבש,
שבו כל צמתים שלך הם,

502
00:26:08,540 --> 00:26:12,660
מה שאתה צריך לעשות כדי לגשת או
להוסיף או למחוק או מי מהם.

503
00:26:12,660 --> 00:26:14,550
כולם טובים בזה?

504
00:26:14,550 --> 00:26:15,050
לְהִתְקַרֵר.

505
00:26:15,050 --> 00:26:19,300

506
00:26:19,300 --> 00:26:22,600
>> אז אם אנחנו רוצים להסתכל על הקוד?

507
00:26:22,600 --> 00:26:24,470
אה, אני לא יודע אם אנחנו
יכול לראות כל-- בסדר, אז

508
00:26:24,470 --> 00:26:27,940
בראש כל זה היא פונקציה
הכנס שם שבו אנו רוצים

509
00:26:27,940 --> 00:26:31,365
להכניס n int לרשימה המקושרת.

510
00:26:31,365 --> 00:26:32,740
אנחנו הולכים לעבור את זה.

511
00:26:32,740 --> 00:26:34,770
זה הרבה קוד, הרבה תחביר חדש.

512
00:26:34,770 --> 00:26:36,220
נהיה בסדר.

513
00:26:36,220 --> 00:26:39,120
>> אז למעלה בחלק העליון, בכל פעם ש
אנחנו רוצים ליצור משהו

514
00:26:39,120 --> 00:26:42,380
מה שאנחנו צריכים לעשות, במיוחד אם אתה
רוצה שזה לא יאוחסן בערימה

515
00:26:42,380 --> 00:26:43,920
אבל בערימה?

516
00:26:43,920 --> 00:26:45,460
אנחנו הולכים לmalloc, נכון?

517
00:26:45,460 --> 00:26:48,240
אז אנחנו הולכים ליצור מצביע.

518
00:26:48,240 --> 00:26:52,074
צומת, מצביע, שווים חדשים
malloc בגודל של צומת

519
00:26:52,074 --> 00:26:53,740
כי אנחנו רוצים שצומת להיווצר.

520
00:26:53,740 --> 00:26:56,720
אנחנו רוצים את הסכום של
זיכרון שצומת תופסת

521
00:26:56,720 --> 00:26:59,300
שיוקצה ל
יצירה של הצומת החדשה.

522
00:26:59,300 --> 00:27:02,270
>> ואז אנחנו הולכים לבדוק ל
לראות אם שווים חדשים שווים null.

523
00:27:02,270 --> 00:27:03,370
זכור את מה שאמרו?

524
00:27:03,370 --> 00:27:06,470
לא משנה מה אתה malloc,
מה אתה חייב תמיד לעשות?

525
00:27:06,470 --> 00:27:09,490
אתה תמיד צריך לבדוק כדי לראות
אם לא שהוא ריק.

526
00:27:09,490 --> 00:27:13,620
>> לדוגמא, אם ההפעלה שלך
המערכת הייתה מלאה לחלוטין,

527
00:27:13,620 --> 00:27:17,060
אם לא היה לך יותר זיכרון ב
כל ואתה מנסה malloc,

528
00:27:17,060 --> 00:27:18,410
זה יחזור null בשבילך.

529
00:27:18,410 --> 00:27:21,094
ולכן אם אתה מנסה להשתמש בו
כאשר הוא מצביע על null,

530
00:27:21,094 --> 00:27:23,260
אתה לא הולך לתוכל
כדי לגשת למידע זה.

531
00:27:23,260 --> 00:27:27,010
וכך כאמור, אנחנו רוצים לעשות
בטוח שבכל פעם שאתה mallocing,

532
00:27:27,010 --> 00:27:30,500
אתה תמיד בודק אם
הזיכרון שניתן לך הוא null.

533
00:27:30,500 --> 00:27:33,670
ואם זה לא, אז אנחנו יכולים לעבור
על עם שאר הקוד שלנו.

534
00:27:33,670 --> 00:27:36,140
>> אז אנחנו הולכים ל
לאתחל את הצומת החדשה.

535
00:27:36,140 --> 00:27:39,050
אנחנו הולכים לעשות n החדש שווה n.

536
00:27:39,050 --> 00:27:42,390
ואז אנחנו הולכים לעשות
קבוצה חדשה מצביע על חדש

537
00:27:42,390 --> 00:27:46,900
לnull כי עכשיו אנחנו לא
רוצה שום דבר על זה כדי להצביע על.

538
00:27:46,900 --> 00:27:48,755
אין לנו מושג איפה
זה הולך לשים אותך,

539
00:27:48,755 --> 00:27:50,630
ואז אם אנחנו רוצים
הכנס אותו בראש,

540
00:27:50,630 --> 00:27:53,820
אז אנחנו יכולים להקצות מחדש
מצביע לראש.

541
00:27:53,820 --> 00:27:58,530
האם כולם לעקוב אחרי ההיגיון
היכן זה קורה?

542
00:27:58,530 --> 00:28:02,502
>> כל מה שאנחנו עושים הוא יצירת חדשה
צומת, הגדרת המצביע null,

543
00:28:02,502 --> 00:28:04,210
ולאחר מכן הקצאה מחדש
זה בראש אם

544
00:28:04,210 --> 00:28:06,320
יודע שאנחנו רוצים להכניס אותו בראש.

545
00:28:06,320 --> 00:28:09,420
ולאחר מכן הראש הולך
מצביע לכיוון שהצומת החדשה.

546
00:28:09,420 --> 00:28:11,060
כולם בסדר עם זה?

547
00:28:11,060 --> 00:28:12,380
>> אז זה תהליך דו-שלבים.

548
00:28:12,380 --> 00:28:14,760
יש לך להקצות ראשון
כל מה שאתה יוצר.

549
00:28:14,760 --> 00:28:18,260
להגדיר מצביע של
הפניה, ואז אתה

550
00:28:18,260 --> 00:28:21,400
יכול סוג של dereference
המצביע הראשון

551
00:28:21,400 --> 00:28:22,972
ולכוון אותו לכיוון הצומת החדשה.

552
00:28:22,972 --> 00:28:25,680
בכל מקום שאתה רוצה להכניס אותו,
ההיגיון שעומד להחזיק נכון.

553
00:28:25,680 --> 00:28:27,530
>> זה כמו סוג של הקצאה
משתנים זמניים.

554
00:28:27,530 --> 00:28:28,700
זכרו, יש לך
כדי לוודא שאתה

555
00:28:28,700 --> 00:28:30,346
לא לאבד אם אתה מחליף.

556
00:28:30,346 --> 00:28:33,470
אתה רוצה לוודא שיש לך
משתנה זמני שסוג של שומר

557
00:28:33,470 --> 00:28:35,620
אחר שבו דבר ש
מאוחסן, כך שאתה

558
00:28:35,620 --> 00:28:41,190
לא לאבד את כל ערך בקורס
כמו להתעסק עם זה.

559
00:28:41,190 --> 00:28:42,710
>> אוקיי, אז קוד יהיה כאן.

560
00:28:42,710 --> 00:28:45,020
אתם תסתכל אחרי הסעיף.

561
00:28:45,020 --> 00:28:48,060
זה יהיה שם.

562
00:28:48,060 --> 00:28:50,280
>> אז אני מניח שאיך עושה
זה שונה אם אנחנו רוצים

563
00:28:50,280 --> 00:28:52,300
להכניס לאמצע או הסוף?

564
00:28:52,300 --> 00:28:57,892
האם יש למישהו מושג מה זה
פסאודו קוד כהתייחסות ההגיונית

565
00:28:57,892 --> 00:29:00,350
שהיינו לוקח אם אנחנו רוצים
כדי להכניס אותו באמצע?

566
00:29:00,350 --> 00:29:03,391
אז אם אנחנו רוצים להכניס אותו ב
הראש, כל מה שאנחנו עושים הוא ליצור צומת חדשה.

567
00:29:03,391 --> 00:29:06,311
אנו קובעים את המצביע של ש
צומת חדשה לכל הראש,

568
00:29:06,311 --> 00:29:08,310
ואז אנו קובעים את הראש
לצומת החדשה, נכון?

569
00:29:08,310 --> 00:29:11,560
אם אנחנו רוצים להכניס אותו באמצע
הרשימה, מה היינו צריכים לעשות?

570
00:29:11,560 --> 00:29:14,108

571
00:29:14,108 --> 00:29:16,110
>> קהל: זה עדיין
להיות תהליך דומה

572
00:29:16,110 --> 00:29:19,114
כמו הקצאת מצביע ו
לאחר מכן הקצאת מצביע ש,

573
00:29:19,114 --> 00:29:20,530
אבל היינו צריך לאתר שם.

574
00:29:20,530 --> 00:29:23,560
>> ANDI פנג: בדיוק, כך בדיוק
אותו התהליך חוץ ממך

575
00:29:23,560 --> 00:29:27,820
יש לאתר איפה בדיוק אתה
רוצה שהמצביע חדש להיכנס ל,

576
00:29:27,820 --> 00:29:44,790
כך שאם אני רוצה להכניס לתוך
אמצע קשור list-- אישור,

577
00:29:44,790 --> 00:29:46,370
נניח שזה הרשימה המקושרת שלנו.

578
00:29:46,370 --> 00:29:49,500
אם אנחנו רוצים להכניס אותו ממש כאן,
אנחנו הולכים ליצור צומת חדשה.

579
00:29:49,500 --> 00:29:50,520
אנחנו הולכים malloc.

580
00:29:50,520 --> 00:29:52,220
אנחנו הולכים ליצור צומת חדשה.

581
00:29:52,220 --> 00:29:55,940
אנחנו הולכים להקצות
מצביע של צומת זו כאן.

582
00:29:55,940 --> 00:29:58,335
>> אבל הבעיה ששונה
מהמקום שבי הראש הוא

583
00:29:58,335 --> 00:30:00,490
הוא שאנחנו יודעים בדיוק
שבו הראש הוא.

584
00:30:00,490 --> 00:30:01,930
זה היה נכון בהתחלה, נכון?

585
00:30:01,930 --> 00:30:04,870
אבל כאן יש לנו לעקוב אחר
של לאן אנחנו מחדירים אותו.

586
00:30:04,870 --> 00:30:07,930
אם אנחנו מכניסים
צומת כאן, יש לנו

587
00:30:07,930 --> 00:30:12,270
לוודא כי
אחד קודם לצומת זה

588
00:30:12,270 --> 00:30:14,172
הוא אחד שreassigns המצביע.

589
00:30:14,172 --> 00:30:16,380
אז אתה צריך סוג של
לעקוב אחר שני דברים.

590
00:30:16,380 --> 00:30:19,420
אם לך לעקוב אחר שבו זה
כיום צומת החדרה לתוך.

591
00:30:19,420 --> 00:30:23,280
אתה גם צריך לעקוב אחר שבי
הצומת הקודמת שאתה מחפש ב

592
00:30:23,280 --> 00:30:24,340
היה גם שם.

593
00:30:24,340 --> 00:30:25,830
כולם טובים בזה?

594
00:30:25,830 --> 00:30:26,500
אוקיי.

595
00:30:26,500 --> 00:30:28,000
>> מה דעתך על הוספה לסוף?

596
00:30:28,000 --> 00:30:34,220
אם אני רוצה להוסיף אותו כאן-- אם אני רוצה
כדי להוסיף צומת חדשה לסוף רשימה,

597
00:30:34,220 --> 00:30:37,009
איך אני יכול ללכת על עושה את זה?

598
00:30:37,009 --> 00:30:39,300
קהל: אז כרגע,
הצביע שעבר אחד לבטלה.

599
00:30:39,300 --> 00:30:40,960
ANDI פנג: כן.

600
00:30:40,960 --> 00:30:43,560
בדיוק, אז זה אחד
כיום הצביע יודע,

601
00:30:43,560 --> 00:30:46,720
ואז אני מניח, במובן זה, זה
קל מאוד להוסיף לסוף הרשימה.

602
00:30:46,720 --> 00:30:51,810
כל מה שאתה צריך לעשות זה להגדיר אותו
שווה ל null ואז בום.

603
00:30:51,810 --> 00:30:53,070
ממש שם, קל מאוד.

604
00:30:53,070 --> 00:30:53,960
פשוט מאד.

605
00:30:53,960 --> 00:30:56,430
>> דומה מאוד ל
ראש, אבל מבחינה הלוגית

606
00:30:56,430 --> 00:30:59,690
רוצה לוודא שהצעדים
אתה לוקח לכיוון עושה את כל זה,

607
00:30:59,690 --> 00:31:01,500
אתה הבא יחד.

608
00:31:01,500 --> 00:31:04,420
זה מאוד קל, באמצע
הקוד שלך, להסתבך ב,

609
00:31:04,420 --> 00:31:05,671
אה, יש לי כל כך הרבה מצביעים.

610
00:31:05,671 --> 00:31:07,461
אני לא יודע איפה
דבר מצביע על.

611
00:31:07,461 --> 00:31:09,170
אני אפילו לא יודע שאני בצומת.

612
00:31:09,170 --> 00:31:11,490
מה הולך?

613
00:31:11,490 --> 00:31:13,620
>> תירגע, יירגע, קח נשימה עמוקה.

614
00:31:13,620 --> 00:31:15,530
לצייר את הרשימה המקושרת שלך.

615
00:31:15,530 --> 00:31:18,800
אם אתה אומר, אני יודע איפה בדיוק
אני צריך להכניס את זה ל

616
00:31:18,800 --> 00:31:22,970
ואני יודע בדיוק איך להקצות מחדש שלי
מצביעים, הרבה, הרבה יותר קלים לדמיין

617
00:31:22,970 --> 00:31:27,200
out-- הרבה, הרבה יותר קל לא
ללכת לאיבוד בבאגים של הקוד שלך.

618
00:31:27,200 --> 00:31:29,410
כולם בסדר עם זה?

619
00:31:29,410 --> 00:31:31,380
אוקיי.

620
00:31:31,380 --> 00:31:35,120
>> אז אני מניח שרעיון שיש לנו לא
באמת דיבר על לפני עכשיו,

621
00:31:35,120 --> 00:31:38,131
ואני מניח שאתה כנראה
לא נתקל בהרבה yet--

622
00:31:38,131 --> 00:31:40,880
זה סוג של concept-- מתקדם
הוא שבעצם יש לנו נתונים

623
00:31:40,880 --> 00:31:43,900
מבנה נקרא רשימה מקושרת כפליים.

624
00:31:43,900 --> 00:31:46,390
אז כפי שאתם יכולים לראות,
כל מה שאנחנו עושים הוא יצירת

625
00:31:46,390 --> 00:31:50,400
ערך בפועל, נוסף
מצביע על כל אחד מצומת שלנו

626
00:31:50,400 --> 00:31:52,660
שגם מצביע על הצומת הקודמת.

627
00:31:52,660 --> 00:31:58,170
אז לא רק שיש לנו שלנו
צמתים מצביעים על הבא.

628
00:31:58,170 --> 00:32:01,430
הם גם מצביעים על קודמתה.

629
00:32:01,430 --> 00:32:04,310
אני הולך להתעלם משני אלה עכשיו.

630
00:32:04,310 --> 00:32:06,740
>> אז יש לך שרשרת
שיכול לנוע בשני הכיוונים,

631
00:32:06,740 --> 00:32:09,630
ואז זה קצת יותר קל
פעל יחד באופן הגיוני.

632
00:32:09,630 --> 00:32:11,896
כמו כאן, במקום
שמירה על מסלול של, אה, אני

633
00:32:11,896 --> 00:32:14,520
צריך לדעת שצומת זה
אחד שאני צריך להקצות מחדש,

634
00:32:14,520 --> 00:32:17,532
אני רק יכול ללכת כאן ו
פשוט למשוך הקודם.

635
00:32:17,532 --> 00:32:19,490
ואז אני יודע בדיוק איפה
כלומר, ואז אתה

636
00:32:19,490 --> 00:32:21,130
לא צריך לעבור את
שלמות של הרשימה המקושרת.

637
00:32:21,130 --> 00:32:22,180
זה קצת יותר קל.

638
00:32:22,180 --> 00:32:24,960
>> אבל כאמור, יש לך כפליים
כמות המצביעים,

639
00:32:24,960 --> 00:32:26,960
זה כמות כפולה של זיכרון.

640
00:32:26,960 --> 00:32:28,950
זה הרבה מצביעים כדי לעקוב אחר.

641
00:32:28,950 --> 00:32:32,140
זה קצת יותר מורכב, אבל זה
קצת יותר ידידותי למשתמש, בהתאם

642
00:32:32,140 --> 00:32:34,080
על מה שאתה מנסה להשיג.

643
00:32:34,080 --> 00:32:36,910
>> אז זה סוג של נתונים
מבנה לחלוטין קיים,

644
00:32:36,910 --> 00:32:40,280
והמבנה למאוד, מאוד
פשוט מלבד כל שיש לך הוא,

645
00:32:40,280 --> 00:32:43,850
במקום רק מצביע לבא,
יש לך גם מצביע לקודם.

646
00:32:43,850 --> 00:32:45,940
זה כל ההבדל היה.

647
00:32:45,940 --> 00:32:47,740
כולם טובים בזה?

648
00:32:47,740 --> 00:32:48,240
לְהִתְקַרֵר.

649
00:32:48,240 --> 00:32:50,940

650
00:32:50,940 --> 00:32:53,280
>> בסדר, אז עכשיו אני
באמת לבלות כנראה

651
00:32:53,280 --> 00:32:56,870
כמו 15 עד 20 דקות או בתפזורת
של שאר הזמן בסעיף

652
00:32:56,870 --> 00:32:58,360
מדבר על שולחנות חשיש.

653
00:32:58,360 --> 00:33:02,590
כמה מכם
קראו מפרט pset5?

654
00:33:02,590 --> 00:33:03,620
בסדר, טוב.

655
00:33:03,620 --> 00:33:06,160
זה גבוה יותר מאשר 50% מכלל.

656
00:33:06,160 --> 00:33:07,560
זה בסדר.

657
00:33:07,560 --> 00:33:10,345
>> אז כפי שאתם רואים,
אתה אתגר בpset5

658
00:33:10,345 --> 00:33:16,790
יהיה ליישם מילון
שבו אתה טוען מעל 140,000 מילות

659
00:33:16,790 --> 00:33:20,610
כי אנחנו נותנים לך ובדיקת איות
זה נגד את כל הטקסט.

660
00:33:20,610 --> 00:33:22,580
אנחנו ניתן לכם אקראיים
חתיכות של ספרות.

661
00:33:22,580 --> 00:33:23,520
אנחנו ניתן לכם אודיסיאה.

662
00:33:23,520 --> 00:33:24,561
אנחנו ניתן לכם את האיליאדה.

663
00:33:24,561 --> 00:33:26,350
אנחנו ניתן לכם אוסטין פאוורס.

664
00:33:26,350 --> 00:33:28,220
>> והאתגר שלך
יהיה בדיקת איות

665
00:33:28,220 --> 00:33:31,760
כל מילה ומילה בכל
מילונים אלה

666
00:33:31,760 --> 00:33:34,960
בעצם עם בודק האיות שלנו.

667
00:33:34,960 --> 00:33:38,620
ולכן יש כמה חלקים
יצירת pset זה,

668
00:33:38,620 --> 00:33:41,970
ראשון שאתה רוצה להיות
תוכל לטעון למעשה

669
00:33:41,970 --> 00:33:43,970
כל המילים לך
מילון, ואז אתה

670
00:33:43,970 --> 00:33:45,530
רוצה להיות מסוגל ל
לאיית לבדוק את כולן.

671
00:33:45,530 --> 00:33:48,780
וכך כאמור, אתה הולך לדרוש
מבנה נתונים שיכולים לעשות את זה מהר

672
00:33:48,780 --> 00:33:50,790
וביעילות ודינמית.

673
00:33:50,790 --> 00:33:52,900
>> אז אני מניח שהכי קל
דרך לעשות זאת, אתה

674
00:33:52,900 --> 00:33:55,010
כנראה היה ליצור מערך, נכון?

675
00:33:55,010 --> 00:33:58,910
הדרך הקלה ביותר של האחסון היא
יכול ליצור מערך של 140,000 מילות

676
00:33:58,910 --> 00:34:03,400
ורק למקם את כולם שם ו
לאחר מכן לעבור אותם על ידי חיפוש בינארי

677
00:34:03,400 --> 00:34:06,780
או על ידי בחירה או not--
מצטער שזה מיון.

678
00:34:06,780 --> 00:34:10,729
אתה יכול למיין אותם ולאחר מכן לעבור אותם
על ידי חיפוש בינארי או חיפוש פשוט יניארי

679
00:34:10,729 --> 00:34:13,730
ורק סופי המילים, אבל ש
לוקח כמות עצומה של זיכרון,

680
00:34:13,730 --> 00:34:15,190
וזה לא יעיל מאוד.

681
00:34:15,190 --> 00:34:18,350
>> וכך אנחנו הולכים להתחיל
מדבר על דרכים להרוויח

682
00:34:18,350 --> 00:34:20,110
זמן הריצה שלנו יותר יעיל.

683
00:34:20,110 --> 00:34:23,190
והמטרה שלנו היא להגיע
זמן שבו קבוע

684
00:34:23,190 --> 00:34:25,810
זה כמעט כמו מערכים, שבו
יש לך גישה מיידית.

685
00:34:25,810 --> 00:34:28,560
אם אני רוצה לחפש משהו,
אני רוצה להיות מסוגל פשוט,

686
00:34:28,560 --> 00:34:30,810
בום, למצוא אותו בדיוק, ולמשוך אותו החוצה.

687
00:34:30,810 --> 00:34:34,100
וכך מבנה שבי
נהיה קרוב מאוד להפוך ל

688
00:34:34,100 --> 00:34:37,569
כדי להיות מסוגל לגשת קבוע
זמן, גביע קדוש זה

689
00:34:37,569 --> 00:34:41,370
בתכנות קבוע
הזמן נקרא שולחן חשיש.

690
00:34:41,370 --> 00:34:45,370
וכך דוד ציינו בעבר
[לא ברור] קצת בהרצאה,

691
00:34:45,370 --> 00:34:49,100
אבל אנחנו הולכים באמת
צלילה בעומק השבוע

692
00:34:49,100 --> 00:34:51,780
על פיסה זה עניין
איך שולחן חשיש עובד.

693
00:34:51,780 --> 00:34:53,949
>> לכן הדרך שחשיש
עבודות שולחן, למשל,

694
00:34:53,949 --> 00:35:00,230
אם אני רוצה לאחסן חבורה של מילות,
חבורה של מילות בשפה האנגלית,

695
00:35:00,230 --> 00:35:02,940
באופן תיאורטי אני יכול לשים
בננה, תפוח, קיווי, מנגו, זוג,

696
00:35:02,940 --> 00:35:04,980
ומלון כל רק על מערך.

697
00:35:04,980 --> 00:35:07,044
הם יכולים כל להשתלב ולהיות מוצאים.

698
00:35:07,044 --> 00:35:09,210
זה יהיה סוג של כאב ל
חיפוש דרך וגישה,

699
00:35:09,210 --> 00:35:12,920
אבל הדרך קלה יותר לעשות זאת היא
שאנחנו יכולים ליצור למעשה מבנה

700
00:35:12,920 --> 00:35:15,680
נקרא טבלת חשיש שבו אנו חשיש.

701
00:35:15,680 --> 00:35:19,880
אנו מפעילים את כל המפתחות שלנו דרך
פונקצית חשיש, משוואה,

702
00:35:19,880 --> 00:35:22,600
שהופך את כולם ל
איזה ערך

703
00:35:22,600 --> 00:35:28,740
כי אז אנחנו יכולים לאחסן על גבי
בעצם מערך של רשימה מקושרת.

704
00:35:28,740 --> 00:35:32,570
>> וכך כאן, אם אנחנו רוצים
כדי לאחסן מילות באנגלית,

705
00:35:32,570 --> 00:35:37,250
אנחנו עלולים רק, אני לא
יודע, להפוך את כל האותיות הראשונות

706
00:35:37,250 --> 00:35:39,630
לסוג מסוים של מספר.

707
00:35:39,630 --> 00:35:43,140
וכך, למשל, אם אני רוצה
להיות שם נרדף לapple--

708
00:35:43,140 --> 00:35:47,460
או עם המדד של 0, ו
B להיות שם נרדף ל1,

709
00:35:47,460 --> 00:35:51,030
יכול להיות לנו 26 ערכים
שרק יכול לאחסן

710
00:35:51,030 --> 00:35:53,610
כל מכתבים
אלף-בית שנתחיל עם.

711
00:35:53,610 --> 00:35:56,130
ואז יכול להיות לנו
תפוח במדד של 0.

712
00:35:56,130 --> 00:35:59,160
אנחנו יכולים להיות בננה במדד
1, מלון במדד של 2,

713
00:35:59,160 --> 00:36:00,540
וכן הלאה וכן הלאה.

714
00:36:00,540 --> 00:36:04,460
ולכן אם אני רוצה לחפש
השולחן והגישה תפוח החשיש שלי,

715
00:36:04,460 --> 00:36:07,560
אני יודע תפוח מתחיל עם
, ואני יודע בדיוק

716
00:36:07,560 --> 00:36:10,860
כי הוא חייב להיות והחשיש
שולחן במדד 0 כי

717
00:36:10,860 --> 00:36:13,620
של הפונקציה שהוקצה בעבר.

718
00:36:13,620 --> 00:36:16,572
>> אז אני לא יודע, אנחנו
תכנית משתמש בי

719
00:36:16,572 --> 00:36:18,780
תחויב ב
arbitrarily-- לא באופן שרירותי,

720
00:36:18,780 --> 00:36:22,530
עם הניסיון בהרהור
לחשוב על משוואות טובות

721
00:36:22,530 --> 00:36:25,460
כדי להיות מסוגל להתפשט
את כל הערכים שלך

722
00:36:25,460 --> 00:36:29,370
בדרך הם יכולים בקלות לגשת ל
זה בשלב מאוחר יותר עם כמו משוואה

723
00:36:29,370 --> 00:36:31,130
שאתה, בעצמך, יודע.

724
00:36:31,130 --> 00:36:35,210
אז במובן אם אני רוצה ללכת ל
מנגו, אני יודע, הו, זה מתחיל עם מטר.

725
00:36:35,210 --> 00:36:37,134
זה חייב להיות במדד של 12.

726
00:36:37,134 --> 00:36:38,800
אני לא צריך לחפש דרך כל דבר.

727
00:36:38,800 --> 00:36:42,080
אני יודע exactly-- אני פשוט יכול ללכת ל
המדד של 12 ולמשוך את זה.

728
00:36:42,080 --> 00:36:45,520
>> כולם ברורים על איך
הפונקציה של טבלת חשיש עובדת?

729
00:36:45,520 --> 00:36:48,380
זה סוג של רק מערך מורכב יותר.

730
00:36:48,380 --> 00:36:50,010
זה כל מה שזה.

731
00:36:50,010 --> 00:36:51,630
אוקיי.

732
00:36:51,630 --> 00:36:57,690
>> אז אני מניח שאנחנו נתקלים ב
גיליון זה של מה ש

733
00:36:57,690 --> 00:37:06,390
קורה אם יש לך דברים רבים
שתיתן לך את אותו מדד?

734
00:37:06,390 --> 00:37:10,570
אז אומר הפונקציה שלנו, את כל זה
עשה היה לקחת את זה המכתב ראשון

735
00:37:10,570 --> 00:37:14,490
ולהפוך את זה ל
בהתאמה 0 עד 25 מדד.

736
00:37:14,490 --> 00:37:17,137
זה לגמרי בסדר אם
יש לך רק אחד מכל אחד.

737
00:37:17,137 --> 00:37:18,970
אבל השני שאתה מתחיל
שיש יותר, אתה

738
00:37:18,970 --> 00:37:20,910
הולך להיות מה שנקרא התנגשות.

739
00:37:20,910 --> 00:37:25,580
>> אז אם אני מנסה להכניס לקבור לחשיש
שולחן שכבר יש בננה על זה,

740
00:37:25,580 --> 00:37:27,870
מה יקרה כאשר
אתה מנסה להכניס את זה?

741
00:37:27,870 --> 00:37:30,930
דברים רעים, כי בננה
כבר קיים בתוך המדד

742
00:37:30,930 --> 00:37:33,800
שאתה רוצה לאחסן אותו ב.

743
00:37:33,800 --> 00:37:35,560
ברי הוא כמו סוג של, אה, מה עליי לעשות?

744
00:37:35,560 --> 00:37:37,080
אני לא יודע לאן ללכת.

745
00:37:37,080 --> 00:37:38,410
כיצד אוכל לפתור זאת?

746
00:37:38,410 --> 00:37:41,150
>> וכך אתם יהיו סוג של
רואה שאנחנו עושים דבר זה מסובך

747
00:37:41,150 --> 00:37:44,810
שבו אנחנו יכולים למעשה סוג של
ליצור רשימה מקושרת במערכים שלנו.

748
00:37:44,810 --> 00:37:46,840
ולכן הדרך הקלה ביותר
לחשוב על זה,

749
00:37:46,840 --> 00:37:50,830
כל שולחן חשיש
מערך של רשימות מקושרות.

750
00:37:50,830 --> 00:37:55,670
וכך, במובן זה, יש לך
מערך יפה זה של מצביעים,

751
00:37:55,670 --> 00:37:58,740
ולאחר מכן כל מצביע ב
ערך ש, במדד זה,

752
00:37:58,740 --> 00:38:00,740
באמת יכול להצביע על דברים אחרים.

753
00:38:00,740 --> 00:38:05,720
ואז יש לך את כל אלה נפרדים
רשתות יורדים ממערך אחד גדול.

754
00:38:05,720 --> 00:38:07,960
>> וכך כאן, אם אני
רציתי להכניס פירות יער,

755
00:38:07,960 --> 00:38:11,220
אני יודע, בסדר, אני הולך קלט
זה דרך פונקצית החשיש שלי.

756
00:38:11,220 --> 00:38:15,070
אני הולך בסופו של המדד
1, ולאחר מכן אני הולך להיות מסוגל לקבל

757
00:38:15,070 --> 00:38:20,410
רק קבוצת משנה קטן יותר של זה
140,000-מילת מילון ענק.

758
00:38:20,410 --> 00:38:24,220
ואז אני יכול רק להסתכל
באמצעות 1/26 של ש.

759
00:38:24,220 --> 00:38:27,910
>> ואז אני יכול רק להוסיף
ברי לפני או אחרי הבננה

760
00:38:27,910 --> 00:38:28,820
במקרה הזה?

761
00:38:28,820 --> 00:38:29,700
אחרי, נכון?

762
00:38:29,700 --> 00:38:33,920
ואז אתה הולך רוצה
הכנס צומת זה לאחר בננה,

763
00:38:33,920 --> 00:38:36,667
ואז אתה הולך להכניס
בזנב של שהרשימה המקושרת.

764
00:38:36,667 --> 00:38:38,500
אני הולך לחזור
לשקופית קודמת זה,

765
00:38:38,500 --> 00:38:40,680
כך שאתם יכולים לראות איך
פונקצית חשיש עובדת.

766
00:38:40,680 --> 00:38:43,980
>> אז פונקצית חשיש היא משוואה זו
שאתה מפעיל סוג של הקלט שלך

767
00:38:43,980 --> 00:38:46,940
דרך להשיג כל מה שמדד
אתה רוצה להקצות אותו לכיוון.

768
00:38:46,940 --> 00:38:51,130
וכך, בדוגמא זו, כל מה שאנחנו רוצים
לעשות היה לקחת את האות הראשונה,

769
00:38:51,130 --> 00:38:55,890
להפוך את זה למדד, אז אנחנו
יכול לאחסן כי בפונקצית החשיש שלנו.

770
00:38:55,890 --> 00:39:00,160
כל מה שאנחנו עושים כאן הוא אנחנו
המרת האות הראשונה.

771
00:39:00,160 --> 00:39:04,770
[0] הוא רק האות הראשונה אז keykey
מכל מחרוזת אנו עורכים,

772
00:39:04,770 --> 00:39:05,720
אנחנו עוברים ב.

773
00:39:05,720 --> 00:39:09,740
אנחנו המרה שלעליונה, ו
אנחנו הפחתה באותיות גדולה,

774
00:39:09,740 --> 00:39:11,740
אז כל מה שהוא עושה
הוא נותן לנו מספר

775
00:39:11,740 --> 00:39:13,670
שבו אנו יכולים חשיש הערכים שלנו על.

776
00:39:13,670 --> 00:39:16,550
>> ואז אנחנו הולכים ל
לחזור גודל מודולוס חשיש.

777
00:39:16,550 --> 00:39:19,340
להיות מאוד, מאוד זהיר
כי, באופן תיאורטי, כאן

778
00:39:19,340 --> 00:39:21,870
ערך Hash שלך יכול להיות אינסופי.

779
00:39:21,870 --> 00:39:23,660
זה פשוט יכול להמשיך עוד ועוד ועוד.

780
00:39:23,660 --> 00:39:26,080
זה יכול להיות כמה באמת,
באמת ערך גדול,

781
00:39:26,080 --> 00:39:29,849
אבל בגלל שולחן החשיש ש
שיצרת יש רק 26 מדדים,

782
00:39:29,849 --> 00:39:31,890
אתה רוצה לוודאך
modulusing, כך שאתה

783
00:39:31,890 --> 00:39:33,848
לא run-- זה אותו
הדבר queue--

784
00:39:33,848 --> 00:39:36,320
כך שאתה לא בורח
תחתון של פונקצית החשיש שלך.

785
00:39:36,320 --> 00:39:39,210
>> אתה רוצה לעטוף אותו בחזרה סביב
באותו אופן ב[ לא ברור] כש

786
00:39:39,210 --> 00:39:41,750
היה כמוך מאוד,
מכתב גדול מאוד, אתה

787
00:39:41,750 --> 00:39:43,740
לא רצה של
רק להפעיל את הסוף.

788
00:39:43,740 --> 00:39:46,948
אותו דבר כאן, אתה רוצה לוודא
זה לא לברוח סוף על ידי עטיפה

789
00:39:46,948 --> 00:39:48,330
סביב לחלק העליון של הטבלה.

790
00:39:48,330 --> 00:39:50,530
אז זה פשוט מאוד
פונקצית חשיש פשוטה.

791
00:39:50,530 --> 00:39:56,570
כל מה שעשה היה לקחת הראשון
מכתב של מה שהקלט שלנו היה

792
00:39:56,570 --> 00:40:01,660
ולהפוך את זה למדד ש
אנחנו יכולים להכניס לטבלת הגיבוב שלנו.

793
00:40:01,660 --> 00:40:05,450
>> כן, ואז כמו שאמרתי לפני,
אופן שבו אנו פותרים התנגשויות

794
00:40:05,450 --> 00:40:09,330
בהחשיש שולחנות שיש,
מה שאנחנו קוראים, שרשור.

795
00:40:09,330 --> 00:40:13,860
אז אם אתה מנסה להכניס מספר
מילות שמתחילות באותו הדבר,

796
00:40:13,860 --> 00:40:16,145
אתה הולך להיות ערך Hash אחד.

797
00:40:16,145 --> 00:40:18,770
אבוקדו ותפוחים, אם יש לך
להפעיל אותו באמצעות פונקצית החשיש שלנו,

798
00:40:18,770 --> 00:40:21,450
הולכים לתת לך
אותו מספר, מספר 0.

799
00:40:21,450 --> 00:40:24,550
וכך הדרך בה אנו לפתור שהוא
שאנחנו יכולים למעשה סוג של לקשר אותם

800
00:40:24,550 --> 00:40:27,010
יחד באמצעות רשימות מקושרות.

801
00:40:27,010 --> 00:40:29,600
>> וכך, במובן זה,
אתם יכולים לראות סוג

802
00:40:29,600 --> 00:40:32,640
כיצד מבני נתונים ש
אנחנו כבר בעבר הגדרה

803
00:40:32,640 --> 00:40:35,870
כמו סוג רשימת צימוקים קשורים
של יכול לבוא יחד לאחד.

804
00:40:35,870 --> 00:40:38,860
ואז אתה יכול ליצור הרבה
מבני נתונים יעילים יותר

805
00:40:38,860 --> 00:40:43,350
שיכול להתמודד עם כמויות גדולות יותר של
הנתונים, שבאופן דינמי לשנות את הגודל בהתאם

806
00:40:43,350 --> 00:40:44,870
בצרכים שלך.

807
00:40:44,870 --> 00:40:45,620
כולם ברורים?

808
00:40:45,620 --> 00:40:47,580
סוג כולם ברורים
על מה שקורה כאן?

809
00:40:47,580 --> 00:40:52,110
>> אם אני רוצה insert-- מה
פירות שמתחיל ב, אני לא יודע,

810
00:40:52,110 --> 00:40:54,726
B, אחר מאשר ברי, בננה.

811
00:40:54,726 --> 00:40:55,710
>> קהל: Blackberry.

812
00:40:55,710 --> 00:40:57,910
>> ANDI פנג: Blackberry, בלקברי.

813
00:40:57,910 --> 00:41:00,530
איפה הפטל ללכת כאן?

814
00:41:00,530 --> 00:41:04,251
ובכן, אנחנו באמת לא מסודרים
זה עדיין, אבל תיאורטית

815
00:41:04,251 --> 00:41:06,250
אם אנחנו רוצים שנהיה לי זה
בסדר אלפביתי,

816
00:41:06,250 --> 00:41:07,944
שבו צריך ללכת פטל שחור?

817
00:41:07,944 --> 00:41:09,210
>> קהל: [לא ברור]

818
00:41:09,210 --> 00:41:11,100
>> ANDI פנג: בדיוק, אחרי כאן, נכון?

819
00:41:11,100 --> 00:41:14,950
אבל מכיוון שזה קשה מאוד
reorder-- אני מניח שזה תלוי בכם.

820
00:41:14,950 --> 00:41:17,920
לגמרי אתם יכולים
ליישם את מה שאתה רוצה.

821
00:41:17,920 --> 00:41:20,730
הדרך יעילה יותר
לעשות את זה אולי

822
00:41:20,730 --> 00:41:24,570
יהיה למיין צמוד שלך
רשימה לתוך סדר אלפביתי,

823
00:41:24,570 --> 00:41:26,520
ולכן כאשר אתה
החדרת דברים, אתה רוצה

824
00:41:26,520 --> 00:41:28,632
כדי להיות בטוח כדי להכניס אותם
לסדר אלפביתי

825
00:41:28,632 --> 00:41:30,590
כך שלאחר מכן, כאשר אתה
מנסה לחפש אותם,

826
00:41:30,590 --> 00:41:32,410
אתה לא צריך לעבור את הכל.

827
00:41:32,410 --> 00:41:35,290
אתה יודע בדיוק איפה
זה, וזה יותר קל.

828
00:41:35,290 --> 00:41:39,100
>> אבל אם אתה סוג של יש לי
דברים ביניהם באופן אקראי,

829
00:41:39,100 --> 00:41:41,420
אתה עדיין הולך להיות
לעבור את זה בכל מקרה.

830
00:41:41,420 --> 00:41:44,990
ולכן אם אני רוצה רק
הכנס פטל כאן

831
00:41:44,990 --> 00:41:47,470
ואני רוצה לחפש
זה, אני יודע, הו, פטל שחור

832
00:41:47,470 --> 00:41:52,012
חייב להתחיל עם המדד של 1, אז אני
יודע באופן מיידי רק לחפש ב1.

833
00:41:52,012 --> 00:41:53,970
ואז אני יכול סוג של
חוצה את הרשימה המקושרת

834
00:41:53,970 --> 00:41:56,120
עד שאני מקבל לפטל שחור,
ואז-- כן?

835
00:41:56,120 --> 00:41:59,550
>> קהל: אם אתה מנסה create--
אני מניח שזה כמו חשיש פשוט מאוד

836
00:41:59,550 --> 00:42:00,050
פוּנקצִיָה.

837
00:42:00,050 --> 00:42:02,835
ואם אנחנו רוצים לעשות
מספר שכבות של כזה,

838
00:42:02,835 --> 00:42:05,870
אישור, אנחנו רוצים להפריד ל
כמו כל האותיות אלף-בית

839
00:42:05,870 --> 00:42:09,040
ולאחר מכן שוב לרוצה קבוצה נוספת
מכתבי אלפביתי בתוך כך,

840
00:42:09,040 --> 00:42:11,715
אנחנו לשים כמו חשיש
טבלה בתוך טבלת חשיש,

841
00:42:11,715 --> 00:42:13,256
או כמו פונקציה בתוך פונקציה?

842
00:42:13,256 --> 00:42:14,880
או הוא לראות--

843
00:42:14,880 --> 00:42:17,510
>> ANDI פנג: אז החשיש שלך
function-- שולחן החשיש שלך

844
00:42:17,510 --> 00:42:19,360
יכול להיות גדול כמו שאתה רוצה אותו.

845
00:42:19,360 --> 00:42:21,930
אז במובן הזה, חשבתי
זה היה קל מאוד, מאוד

846
00:42:21,930 --> 00:42:25,320
פשוט בשבילי מבוססים רק סוג
באותיות של המילה הראשונה.

847
00:42:25,320 --> 00:42:28,690
וכך יש רק 26 אפשרויות.

848
00:42:28,690 --> 00:42:32,650
אני יכול רק לקבל 26 אופציות מ
0 עד 25, כי הם יכולים רק

849
00:42:32,650 --> 00:42:36,510
תתחיל מ- A עד Z. אבל אם אתה רוצה
להוסיף, אולי, מורכבות יותר

850
00:42:36,510 --> 00:42:39,260
או יותר מהר לרוץ זמן שלך
שולחן חשיש, אתה בהחלט

851
00:42:39,260 --> 00:42:40,760
יכול לעשות כל מיני דברים.

852
00:42:40,760 --> 00:42:43,330
אתה יכול להפוך את עצמו
משוואה שנותנת לך

853
00:42:43,330 --> 00:42:48,000
יותר הפצה בך
מילות, אז כשאתה מחפש,

854
00:42:48,000 --> 00:42:49,300
זה הולך להיות מהיר יותר.

855
00:42:49,300 --> 00:42:52,100
>> זה לגמרי תלוי בך חבר '
איך אתה רוצה ליישם את זה.

856
00:42:52,100 --> 00:42:55,140
תחשוב על זה כפשוט דליים.

857
00:42:55,140 --> 00:42:57,376
אם אני רוצה שאהיה לי
26 דליים, אני הולך

858
00:42:57,376 --> 00:42:59,420
כדי למיין דברים לסלים אלה.

859
00:42:59,420 --> 00:43:02,980
אבל אני הולך יש לי חבורה
דברים בכל אחד מהסלים,

860
00:43:02,980 --> 00:43:05,890
כך שאם אתה רוצה לעשות את זה
מהר יותר ויעיל יותר,

861
00:43:05,890 --> 00:43:07,190
תן לי מאה דליים.

862
00:43:07,190 --> 00:43:09,290
>> אבל אז יש לך להבין
דרך כדי למיין את הדברים כך שהם

863
00:43:09,290 --> 00:43:11,040
בדלי הנכון שהם צריכים להיות ב.

864
00:43:11,040 --> 00:43:13,331
אבל אז כאשר אתה בעצם
רוצה להסתכל על דלי ש,

865
00:43:13,331 --> 00:43:16,410
זה הרבה יותר מהר, כי יש
דברים פחות בכל אחד מהסלים.

866
00:43:16,410 --> 00:43:20,250
וכך, כן, זה בעצם
הטריק בשבילכם בpset5

867
00:43:20,250 --> 00:43:22,360
הוא שאתה תהיה
תיגר רק כדי ליצור

868
00:43:22,360 --> 00:43:26,170
מה הוא יעיל ביותר
פונקציה אתה יכול לחשוב על להיות

869
00:43:26,170 --> 00:43:28,520
תוכל לאחסן ולבדוק את הערכים הללו.

870
00:43:28,520 --> 00:43:30,840
>> לגמרי תלוי בך חבר '
עם זאת אתה רוצה לעשות את זה,

871
00:43:30,840 --> 00:43:32,229
אבל זה נקודה ממש טובה.

872
00:43:32,229 --> 00:43:34,520
כי הסוג של היגיונך
רוצה להתחיל לחשוב על

873
00:43:34,520 --> 00:43:37,236
הוא, ובכן, למה אני לא עושה יותר דליים.

874
00:43:37,236 --> 00:43:39,527
ואז אני צריך לחפש
פחות דברים, ואז אולי אני

875
00:43:39,527 --> 00:43:41,640
יש להם תפקיד חשיש שונה.

876
00:43:41,640 --> 00:43:45,500
>> כן, יש הרבה דרכים לעשות את זה
pset, חלקם מהר יותר מאחרים.

877
00:43:45,500 --> 00:43:50,630
אני לגמרי הולך רק כדי לראות איך
מהיר היו אתם המהירים ביותר

878
00:43:50,630 --> 00:43:55,170
להיות מסוגל לקבל הפונקציות שלך לעבודה.

879
00:43:55,170 --> 00:43:58,176
אישור, על כולם טוב
שולחנות שרשור וחשיש?

880
00:43:58,176 --> 00:44:00,800
זה בעצם כמו פשוט מאוד
מושג אם אתה חושב על זה.

881
00:44:00,800 --> 00:44:05,160
כל זה הוא הפרדה מה
התשומות שלך לסלים,

882
00:44:05,160 --> 00:44:10,670
מיונם, ולאחר מכן בחיפוש
רשימות שיש משויך.

883
00:44:10,670 --> 00:44:11,852
>> לְהִתְקַרֵר.

884
00:44:11,852 --> 00:44:18,160
בסדר, עכשיו יש לנו סוג אחר
של מבנה נתונים שנקרא עץ.

885
00:44:18,160 --> 00:44:20,850
בואו נלך על ולדבר על ניסיונות
שהם שונים במובהק,

886
00:44:20,850 --> 00:44:22,330
אבל באותה הקטגוריה.

887
00:44:22,330 --> 00:44:29,010
בעיקרו של דבר, כל עץ הוא במקום
של ארגון הנתונים באופן ליניארי

888
00:44:29,010 --> 00:44:32,560
כי שולחן חשיש does--
יודעים, זה שיש לי עליון ותחתון

889
00:44:32,560 --> 00:44:37,900
ואז אתה סוג של לקשר את של it--
יש עץ עליון שבו אתה קורא את השורש,

890
00:44:37,900 --> 00:44:40,220
ואז יש לו עלים סביבו.

891
00:44:40,220 --> 00:44:42,390
>> וכך כל מה שאתה צריך כאן
רק הצומת העליונה

892
00:44:42,390 --> 00:44:45,980
המצביע על צמתים אחרים, שנקודות
ליותר צמתים, וכן הלאה וכן הלאה.

893
00:44:45,980 --> 00:44:48,130
ואז אתה פשוט צריך ענפי פיצול.

894
00:44:48,130 --> 00:44:53,255
זה פשוט דרך של ארגון שונה
הנתונים, וכי אנחנו קוראים לזה עץ,

895
00:44:53,255 --> 00:44:56,270
אתם פשוט- זה רק
מודל לנראה כמו עץ.

896
00:44:56,270 --> 00:44:57,670
זו הסיבה שאנחנו קוראים לזה עצים.

897
00:44:57,670 --> 00:44:59,370
>> שולחן חשיש נראה כמו שולחן.

898
00:44:59,370 --> 00:45:01,310
עץ פשוט נראה כמו עץ.

899
00:45:01,310 --> 00:45:03,300
כל זה הוא נפרד
דרך לארגן צמתים

900
00:45:03,300 --> 00:45:06,020
תלוי מה הם הצרכים שלך.

901
00:45:06,020 --> 00:45:11,810
>> אז יש לך שורש ו
אז יש לך עלים.

902
00:45:11,810 --> 00:45:15,380
הדרך שאנחנו יכולים במיוחד
תחשוב על זה הוא עץ בינארי,

903
00:45:15,380 --> 00:45:18,150
עץ בינארי הוא רק
סוג מסוים של עץ

904
00:45:18,150 --> 00:45:22,450
שבו כל צומת נקודות בלבד
ל, על מקסימום, שני צמתים אחרים.

905
00:45:22,450 --> 00:45:25,434
ואז הנה יש לך ברור
סימטריה בעץ שלך

906
00:45:25,434 --> 00:45:28,600
זה עושה את זה קל יותר להסתכל סוג של
על מה אתה מעריך כי אז אתה

907
00:45:28,600 --> 00:45:30,150
יש תמיד שמאל או ימין.

908
00:45:30,150 --> 00:45:33,150
אף פעם אין כמו שליש שמאלי מ
השמאל או רביעים מהשמאל.

909
00:45:33,150 --> 00:45:36,358
זה פשוט שיש לך משמאל וימין
ואתה יכול לחפש אחד משני אלה.

910
00:45:36,358 --> 00:45:38,980
ואז למה זה שימושי?

911
00:45:38,980 --> 00:45:40,980
הדרך שזה הוא
שימושי הוא אם אתה מחפש

912
00:45:40,980 --> 00:45:42,890
לחפש בערכים, נכון?

913
00:45:42,890 --> 00:45:45,640
במקום יישום בינארי
חיפוש במערך שגיאה,

914
00:45:45,640 --> 00:45:49,260
אם אתה רוצה להיות מסוגל להכניס צמתים
ולקחת את צמתים ברצון וגם

915
00:45:49,260 --> 00:45:52,185
לשמר את החיפוש
יכולות של חיפוש בינארי.

916
00:45:52,185 --> 00:45:54,560
אז בדרך זו, אנחנו סוג של
tricking-- זוכר ש

917
00:45:54,560 --> 00:45:56,530
אמר רשימות מקושרות לא יכולה לחפש בינארי?

918
00:45:56,530 --> 00:46:01,700
אנחנו סוג של אתה יוצרים מבנה נתונים
שטריקים שלעבודה.

919
00:46:01,700 --> 00:46:05,034
>> וזאת משום שרשימות מקושרים ליניארי,
הם מקושרים רק אחד אחרי השני.

920
00:46:05,034 --> 00:46:06,950
סוג של יכול יש לנו
סוג של מצביעים שונים

921
00:46:06,950 --> 00:46:09,408
נקודה שלבלוטות שונות
שיכול לעזור לנו עם חיפוש.

922
00:46:09,408 --> 00:46:12,590
וכך כאן, אם אני רוצה
יש לי עץ חיפוש בינארי,

923
00:46:12,590 --> 00:46:14,090
אני יודע שהתיכון שלי, אם 55.

924
00:46:14,090 --> 00:46:18,280
אני רק הולך ליצור ש
כאמצעי שלי, כמו השורש שלי,

925
00:46:18,280 --> 00:46:20,770
ואז אני הולך יש לי
ערכי ספין אוף שלה.

926
00:46:20,770 --> 00:46:25,610
>> אז הנה, אם אני הולך לחפש
הערך של 66, אני יכול להתחיל ב 55.

927
00:46:25,610 --> 00:46:27,310
זה 66 יותר מ 55?

928
00:46:27,310 --> 00:46:30,970
כן, זה הוא, אז אני יודע שאני mus חיפוש
אני n המצביע הימני של העץ הזה.

929
00:46:30,970 --> 00:46:32,440
אני הולך ל -77.

930
00:46:32,440 --> 00:46:35,367
אישור, הוא 66 פחות או יותר מ -77?

931
00:46:35,367 --> 00:46:37,950
זה פחות מ, כך שאתה יודע, הו,
שצריך להיות הצומת עזבה.

932
00:46:37,950 --> 00:46:41,410
>> ואז הנה אנחנו סוג של שמירה
כל הדברים הגדולים על מערכים,

933
00:46:41,410 --> 00:46:44,420
כך כמו שינוי גודל דינמי
של אובייקטים, ש

934
00:46:44,420 --> 00:46:49,530
תוכל להוסיף ולמחוק בכל העת,
מבלי לדאוג הקבוע

935
00:46:49,530 --> 00:46:50,370
כמות השטח.

936
00:46:50,370 --> 00:46:52,820
אנחנו עדיין לשמור על כל
דברים נפלאים אלה

937
00:46:52,820 --> 00:46:57,140
גם בעת היותו מסוגל לשמר את
להיכנס ולחפש זמן של חיפוש בינארי

938
00:46:57,140 --> 00:47:00,450
שהיינו רק בעבר
תוכל לקבל ביטוי.

939
00:47:00,450 --> 00:47:06,310
>> מבנה נתונים מגניב, סוג של
מורכב ליישום, הצומת.

940
00:47:06,310 --> 00:47:08,311
כפי שניתן לראות, כל מה ש
הוא struct של הצומת

941
00:47:08,311 --> 00:47:10,143
הוא שיש לך שמאלי
ומצביע נכון.

942
00:47:10,143 --> 00:47:11,044
זה כל מה שזה.

943
00:47:11,044 --> 00:47:12,960
אז לא רק
יש x או קודם.

944
00:47:12,960 --> 00:47:15,920
יש לך שמאלי או ימני, ולאחר מכן
סוג של אתה יכול לקשר אותם יחד

945
00:47:15,920 --> 00:47:16,836
אבל אתה כל כך לבחור.

946
00:47:16,836 --> 00:47:21,080

947
00:47:21,080 --> 00:47:24,270
>> אישור, אנחנו בעצם הולכים
רק לקחת כמה דקות.

948
00:47:24,270 --> 00:47:25,790
אז אנחנו הולכים לחזור לכאן.

949
00:47:25,790 --> 00:47:28,270
כפי שאמרתי בעבר,
אני סוג של הסברתי

950
00:47:28,270 --> 00:47:31,520
ההיגיון מאחורי איך אנחנו
יחפש את זה.

951
00:47:31,520 --> 00:47:33,860
אנחנו הולכים לנסות
pseudocoding את זה כדי לראות

952
00:47:33,860 --> 00:47:38,000
אם אנחנו סוג של יכולים ליישם
אותו היגיון של חיפוש בינארי

953
00:47:38,000 --> 00:47:40,055
לסוג של מבנה נתונים שונה.

954
00:47:40,055 --> 00:47:45,049
אם אתם רוצים לקחת כמו זוג
דקות לחשוב על זה רק.

955
00:47:45,049 --> 00:48:45,927

956
00:48:45,927 --> 00:48:46,925
אוקיי.

957
00:48:46,925 --> 00:48:51,407
בסדר, אני הולך
למעשה רק לתת לך כל-- לא,

958
00:48:51,407 --> 00:48:52,990
נדבר על פסאודו הקוד ראשון.

959
00:48:52,990 --> 00:48:56,580
אז האם מישהו רוצה
לתת דקירה במה

960
00:48:56,580 --> 00:49:02,100
הדבר הראשון שאתה רוצה לעשות כש
אתה מתחיל חיפוש הוא?

961
00:49:02,100 --> 00:49:04,460
אם אנחנו מחפשים
הערך של 66, מה

962
00:49:04,460 --> 00:49:07,940
הדבר הראשון שאנחנו רוצים לעשות, אם
אנחנו רוצים בינארית לחפש את העץ הזה?

963
00:49:07,940 --> 00:49:10,760
>> קהל: אתה רוצה להיראות תקין
ולחפש שמאל ותראה [לא ברור]

964
00:49:10,760 --> 00:49:11,230
מספר גדול יותר.

965
00:49:11,230 --> 00:49:12,271
>> ANDI פנג: כן, בדיוק.

966
00:49:12,271 --> 00:49:15,350
אז אתה הולך להסתכל על השורש שלך.

967
00:49:15,350 --> 00:49:18,180
יש הרבה דרכים אתה יכול להתקשר
זה, אנשי צומת ההורה שלך אומרים.

968
00:49:18,180 --> 00:49:21,317
אני רוצה לומר כי שורש
זה כמו השורש של העץ.

969
00:49:21,317 --> 00:49:23,400
אתה הולך להסתכל על
צומת השורש שלך, ואתה

970
00:49:23,400 --> 00:49:26,940
הולך לראות הוא 66 יותר
מ או פחות מ -55.

971
00:49:26,940 --> 00:49:30,360
ואם זה גדול מ, טוב, זה הוא
גדול מ, שבו אנחנו רוצים להיראות?

972
00:49:30,360 --> 00:49:32,000
לאן שאנחנו רוצים לחפש עכשיו, נכון?

973
00:49:32,000 --> 00:49:34,340
אנחנו רוצים לחפש
מחצית ימנית של העץ הזה.

974
00:49:34,340 --> 00:49:38,390
>> אז יש לנו, בנוחות,
מצביע שמצביע לימין.

975
00:49:38,390 --> 00:49:44,325
ואז אנו יכולים להגדיר
השורש החדש שלנו להיות 77.

976
00:49:44,325 --> 00:49:46,450
אנחנו פשוט יכולים ללכת לכל מקום
המצביע הוא מצביע.

977
00:49:46,450 --> 00:49:49,100
ובכן, הו, כאן אנחנו מתחילים
ב 77, ואנחנו רק יכולים

978
00:49:49,100 --> 00:49:51,172
לעשות את זה באופן רקורסיבי שוב ושוב.

979
00:49:51,172 --> 00:49:52,880
בדרך זו, אתה סוג
יש לי של פונקציה.

980
00:49:52,880 --> 00:49:57,430
יש לך דרך של חיפוש ש
רק יכול לחזור שוב ושוב ושוב,

981
00:49:57,430 --> 00:50:02,720
תלוי איפה אתה רוצה להיראות
עד שסופו של דבר להגיע לערך

982
00:50:02,720 --> 00:50:04,730
שאתה מחפש.

983
00:50:04,730 --> 00:50:05,230
הגיוני?

984
00:50:05,230 --> 00:50:07,800
>> אני עומד להראות לך בפועל
קוד, וזה הרבה קוד.

985
00:50:07,800 --> 00:50:08,674
אין צורך להתחרפן.

986
00:50:08,674 --> 00:50:09,910
נדבר דרכו.

987
00:50:09,910 --> 00:50:13,410

988
00:50:13,410 --> 00:50:14,020
>> בעצם לא.

989
00:50:14,020 --> 00:50:15,061
זה היה רק ​​פסאודו קוד.

990
00:50:15,061 --> 00:50:17,860
אישור, שהיה רק ​​פסאודו הקוד,
אשר הוא קצת מורכב,

991
00:50:17,860 --> 00:50:19,751
אבל זה לגמרי בסדר.

992
00:50:19,751 --> 00:50:21,000
כולם הבא יחד כאן?

993
00:50:21,000 --> 00:50:24,260
אם השורש הוא null, תמורה
שווא כי אמצעים ש

994
00:50:24,260 --> 00:50:26,850
אפילו אין לך שם שום דבר.

995
00:50:26,850 --> 00:50:31,376
>> אם n השורש הוא הערך, כך שאם זה
במקרה אחד אתה מסתכל,

996
00:50:31,376 --> 00:50:34,000
אז אתה הולך לחזור אמיתי
כי אתה יודע שאתה נמצא בו.

997
00:50:34,000 --> 00:50:36,250
אבל אם הערך הוא פחות
משורש של n, אתה

998
00:50:36,250 --> 00:50:38,332
הולך לחפש השמאל
ילד או עלה השמאל,

999
00:50:38,332 --> 00:50:39,540
כל מה שאתה רוצה לקרוא לזה.

1000
00:50:39,540 --> 00:50:41,750
ואם הערך הוא גדול יותר משורש,
אתה הולך לחפש את העץ הנכון,

1001
00:50:41,750 --> 00:50:44,610
אז פשוט להפעיל את הפונקציה
באמצעות חיפוש שוב.

1002
00:50:44,610 --> 00:50:48,037
>> ואם השורש הוא null, ש
פירוש שהגעת לסוף?

1003
00:50:48,037 --> 00:50:50,120
זה אומר שאין לך
יותר יותר עלים לחפש,

1004
00:50:50,120 --> 00:50:52,230
אז אתה יודע, הו, אני
מניח שזה לא כאן

1005
00:50:52,230 --> 00:50:55,063
כי אחרי שהסתכלתי דרך
כל הדבר וזה לא כאן,

1006
00:50:55,063 --> 00:50:56,930
זה פשוט לא יכול להיות כאן.

1007
00:50:56,930 --> 00:50:58,350
>> האם זה הגיוני לכולם?

1008
00:50:58,350 --> 00:51:03,230
אז זה כמו חיפוש בינארי שמירה
היכולות של רשימות מקושרות.

1009
00:51:03,230 --> 00:51:09,200
וכך הסוג מגניב, השני
בחורים מבנה הנתונים ש

1010
00:51:09,200 --> 00:51:13,180
יכול לנסות ליישם בpset,
אתה רק צריך לבחור שיטה אחת.

1011
00:51:13,180 --> 00:51:19,430
אבל אולי שיטה חלופית ל
שולחן החשיש הוא מה שאנו מכנים את איירי.

1012
00:51:19,430 --> 00:51:24,080
>> כל איירי היא היא
סוג מסוים של עץ ש

1013
00:51:24,080 --> 00:51:28,600
יש ערכים שהולכים לערכים אחרים.

1014
00:51:28,600 --> 00:51:31,450
אז במקום שיש בינארי
עץ במובן זה שרק אחד

1015
00:51:31,450 --> 00:51:35,940
דבר יכול להצביע על שני, אתה יכול לקבל
נקודת דבר אחד לרבים, הרבה דברים.

1016
00:51:35,940 --> 00:51:39,450
בעצם יש לך מערכים
בתוכה אתה מאחסן

1017
00:51:39,450 --> 00:51:41,790
מצביעים שיצביעו למערכים אחרים.

1018
00:51:41,790 --> 00:51:45,210

1019
00:51:45,210 --> 00:51:49,460
>> אז את הצומת של איך אנחנו
הייתי מגדיר את איירי

1020
00:51:49,460 --> 00:51:52,590
הוא שאנחנו רוצים שנהיה לי
בוליאנית, מילת ג, נכון?

1021
00:51:52,590 --> 00:51:54,920
אז את הצומת היא בוליאנית
כמו אמת או שקר,

1022
00:51:54,920 --> 00:51:58,490
קודם כל בראש
מערך זה, היא זו מילה?

1023
00:51:58,490 --> 00:52:03,620
שנית, אתה רוצה להיות מצביעים
לכל השאר מהם.

1024
00:52:03,620 --> 00:52:07,470
קצת מורכב, מופשט קצת, אבל
אני אסביר מה שכל האמצעים.

1025
00:52:07,470 --> 00:52:13,800
>> אז הנה, בראש, אם אתה
יש מערך הכריז כבר,

1026
00:52:13,800 --> 00:52:17,040
צומת שבו יש לך בוליאנית
הערך המאוחסן בחזית

1027
00:52:17,040 --> 00:52:19,490
שאומר לך היא זו מילה?

1028
00:52:19,490 --> 00:52:20,520
האם זה לא מילה?

1029
00:52:20,520 --> 00:52:23,240
ואז יש לך
שאר המערך שלך ש

1030
00:52:23,240 --> 00:52:26,040
מאחסן למעשה כל
אפשרויות של מה זה יכול להיות.

1031
00:52:26,040 --> 00:52:28,660
כך, למשל, כמו
בראש יש לך

1032
00:52:28,660 --> 00:52:32,140
הדבר הראשון שאומר או אמיתי
שקר, כן או לא, זו מילה.

1033
00:52:32,140 --> 00:52:38,130
>> ואז יש לך 0 עד 26 מ
המכתבים שאתה יכול לאחסן.

1034
00:52:38,130 --> 00:52:42,790
אם אני רוצה לחפש כאן
לעטלף, אני הולך לעליון

1035
00:52:42,790 --> 00:52:49,200
ואני מחפש ב אני מוצא את B בי
מערך, ואז אני יודע, בסדר, הוא B מילה?

1036
00:52:49,200 --> 00:52:53,010
B הוא לא מילה, כך וכך
אני חייב להמשיך לחפש.

1037
00:52:53,010 --> 00:52:56,410
אני הולך מB, ואני מסתכל ל
מצביע שמצביע לכיוון B

1038
00:52:56,410 --> 00:53:00,900
ואני רואה את מערך נוסף של מידע,
אותו המבנה שהיה לנו בעבר.

1039
00:53:00,900 --> 00:53:05,240
>> וכאן-- הו, הבא
מכתב ב[ לא ברור] הוא א

1040
00:53:05,240 --> 00:53:07,210
אז אנחנו מסתכלים במערך ש.

1041
00:53:07,210 --> 00:53:10,860
אנו מוצאים את הערך השמיני,
ואז אנחנו מסתכלים כדי לראות, הו,

1042
00:53:10,860 --> 00:53:12,840
היי, הוא שמילה, הוא B-מילה?

1043
00:53:12,840 --> 00:53:13,807
זה לא מילה.

1044
00:53:13,807 --> 00:53:14,890
אנחנו חייבים להמשיך לחפש.

1045
00:53:14,890 --> 00:53:17,850
>> ואז אנחנו מסתכלים למקום שבי
המצביע של נקודות,

1046
00:53:17,850 --> 00:53:21,130
וזה מצביע על דרך אחרת ב
שיש לנו מאוחסן ערך רב יותר.

1047
00:53:21,130 --> 00:53:24,150
וסופו של דבר, אנחנו מגיעים ל
B-A-T, שהיא מילה.

1048
00:53:24,150 --> 00:53:25,970
וכך בפעם הבאה
אתה מסתכל, אתה הולך

1049
00:53:25,970 --> 00:53:30,850
יש לבדוק ששל, כן,
פונקציה בוליאנית זה נכון.

1050
00:53:30,850 --> 00:53:35,450
וכך, במובן שאנחנו סוג
שיש לו עץ עם מערכים.

1051
00:53:35,450 --> 00:53:39,890
>> אז אתה סוג של יכול לחפש למטה.

1052
00:53:39,890 --> 00:53:43,650
במקום hashing פונקציה ו
הקצאת ערכים על ידי רשימה מקושרת,

1053
00:53:43,650 --> 00:53:49,190
רק אתה יכול ליישם
איירי שמחפשת downwords.

1054
00:53:49,190 --> 00:53:50,850
באמת, באמת מסובך דברים.

1055
00:53:50,850 --> 00:53:54,060
לא קל לחשוב על כי אני כמו
יריקת מבני נתונים כל כך הרבה

1056
00:53:54,060 --> 00:53:58,710
עליך, אבל כולם עושה סוג של
להבין כיצד ההיגיון של זה עובד?

1057
00:53:58,710 --> 00:54:01,920
>> בסדר מגניב.

1058
00:54:01,920 --> 00:54:05,600
אז B-A-T, ולאחר מכן
אתה הולך לחפש.

1059
00:54:05,600 --> 00:54:07,940
בפעם הבאה שאתה הולך
לראות, הו, היי, זה נכון,

1060
00:54:07,940 --> 00:54:09,273
כך אני יודע שזה חייב להיות מילה.

1061
00:54:09,273 --> 00:54:12,030

1062
00:54:12,030 --> 00:54:13,770
>> אותו דבר לגן חיות.

1063
00:54:13,770 --> 00:54:17,960
אז הנה הדבר נכון עכשיו, אם אנחנו
רציתי לחפש את גן חיות, עכשיו,

1064
00:54:17,960 --> 00:54:20,780
כיום גן החיות היא לא
מילה במילון שלנו

1065
00:54:20,780 --> 00:54:25,300
כי, כפי שאתם יכולים לראות,
המקום הראשון שיש לנו בוליאנית

1066
00:54:25,300 --> 00:54:28,590
לחזור אמיתי הוא בסופו של זום.

1067
00:54:28,590 --> 00:54:30,430
יש לנו Z-O-O-M.

1068
00:54:30,430 --> 00:54:33,900
>> וכך כאן, לא באמת יש לנו
המילה, גן החיות, במילון שלנו

1069
00:54:33,900 --> 00:54:36,070
כי תיבת סימון זו אינה מסומנת.

1070
00:54:36,070 --> 00:54:39,540
אז המחשב לא
יודע שגן החיות היא מילה

1071
00:54:39,540 --> 00:54:42,430
בגלל האופן שבו יש לנו
מאוחסן בו, רק זום כאן

1072
00:54:42,430 --> 00:54:44,920
למעשה יש ערך בוליאני
זה כבר הפך אמיתי.

1073
00:54:44,920 --> 00:54:49,380
אז אם אנחנו רוצים להכניס את
מילה, גן חיות, למילון שלנו,

1074
00:54:49,380 --> 00:54:51,770
איך היינו ללכת על עושה את זה?

1075
00:54:51,770 --> 00:54:55,960
מה יש לנו לעשות כדי לוודא שלנו
מחשב יודע שZ-O-O הוא מילה

1076
00:54:55,960 --> 00:54:58,130
ולא את המילה הראשונה הוא Z-O-O-M?

1077
00:54:58,130 --> 00:54:59,360
>> קהל: [לא ברור]

1078
00:54:59,360 --> 00:55:01,450
>> ANDI פנג: בדיוק, אנחנו
רוצה לוודא שזה

1079
00:55:01,450 --> 00:55:07,890
כאן, כי ערך בוליאני הוא
בדק את שזה נכון.

1080
00:55:07,890 --> 00:55:13,297
Z-O-O, אז אנחנו הולכים לבדוק את זה,
כך שאנחנו יודעים בדיוק, היי, גן החיות היא מילה.

1081
00:55:13,297 --> 00:55:15,380
אני הולך לספר לי
מחשב שזה מילה כל כך

1082
00:55:15,380 --> 00:55:18,000
כי כאשר בודק את המחשב,
הוא יודע שגן החיות היא מילה.

1083
00:55:18,000 --> 00:55:21,269
>> כי תזכור את כל הנתונים האלה
מבנים, זה קל מאוד עבורנו

1084
00:55:21,269 --> 00:55:22,310
לומר, הו, בת מילה.

1085
00:55:22,310 --> 00:55:22,851
גן חיות של מילה.

1086
00:55:22,851 --> 00:55:23,611
זום מילה.

1087
00:55:23,611 --> 00:55:25,860
אבל כאשר אתה בונה אותו,
יש המחשב אין לי מושג.

1088
00:55:25,860 --> 00:55:28,619
>> אז אתה צריך להגיד את זה בדיוק
באיזה שלב היא זו מילה?

1089
00:55:28,619 --> 00:55:29,910
באיזה שלב זה לא מילה?

1090
00:55:29,910 --> 00:55:31,784
ובאיזו נקודה אני
צריך לחפש דברים,

1091
00:55:31,784 --> 00:55:34,000
ובאיזו נקודה אני צריך ללכת הלאה?

1092
00:55:34,000 --> 00:55:37,010
כולם ברורים של זה?

1093
00:55:37,010 --> 00:55:39,540
לְהִתְקַרֵר.

1094
00:55:39,540 --> 00:55:42,530
>> ואז מגיע
בעיה של איך היינו

1095
00:55:42,530 --> 00:55:45,560
ללכת על החדרת משהו
זה בעצם לא שם?

1096
00:55:45,560 --> 00:55:49,090
אז בואו רק אומרים שאנחנו רוצים להכניס
המילה, אמבטיה, לאיירי.

1097
00:55:49,090 --> 00:55:53,589
כפי שאתה יכול לראות בחורים כמו כרגע
כל שיש לנו כרגע הוא B-A-T,

1098
00:55:53,589 --> 00:55:55,630
ומבנה נתונים חדש
יש לי ליטר ש

1099
00:55:55,630 --> 00:55:59,740
הצבעתי על null כי אנחנו מניחים
כי, אה, אין מילות אחרי B-A-T,

1100
00:55:59,740 --> 00:56:02,530
למה אנחנו צריכים לשמור
יש דברים שאחרי ט

1101
00:56:02,530 --> 00:56:06,581
>> אבל הבעיה מתעוררת אם אנחנו עושים לך
רוצה להיות מילה שבאה אחרי

1102
00:56:06,581 --> 00:56:07,080
T של.

1103
00:56:07,080 --> 00:56:09,500
אם יש לך אמבטיה, אתה
הולך רוצה תקין H.

1104
00:56:09,500 --> 00:56:13,290
ולכן הדרך שאנחנו הולכים לעשות את זה היא
אנחנו הולכים ליצור צומת נפרדת.

1105
00:56:13,290 --> 00:56:16,840
אנחנו לא תקצה כל סכום
זיכרון למערך חדש זה,

1106
00:56:16,840 --> 00:56:20,720
ואנחנו הולכים להקצות מחדש מצביעים.

1107
00:56:20,720 --> 00:56:22,947
>> אנחנו הולכים להקצות
H, קודם כל, זה null,

1108
00:56:22,947 --> 00:56:24,030
אנחנו הולכים להיפטר.

1109
00:56:24,030 --> 00:56:26,590
אנחנו הולכים לי
מטה נקודת H.

1110
00:56:26,590 --> 00:56:30,600
אם אנו רואים H, אנחנו רוצים את זה
ללכת למקום אחר.

1111
00:56:30,600 --> 00:56:33,910
>> כאן, אז אנחנו יכולים לבדוק את כן.

1112
00:56:33,910 --> 00:56:38,170
אם פגעו שעות לאחר T, הו,
אז אנחנו יודעים שזו מילה.

1113
00:56:38,170 --> 00:56:41,110
בוליאנית הולכת לחזור אמיתי.

1114
00:56:41,110 --> 00:56:42,950
כולם ברור על איך זה קרה?

1115
00:56:42,950 --> 00:56:45,110
אוקיי.

1116
00:56:45,110 --> 00:56:47,214
>> אז, כל מהותו
מבני נתונים אלה

1117
00:56:47,214 --> 00:56:50,130
שעברנו על היום, יש לי
הלך עליהם באמת, באמת במהירות

1118
00:56:50,130 --> 00:56:52,192
ולא בהרבה
פרט, וזה בסדר.

1119
00:56:52,192 --> 00:56:53,900
ברגע שאתה מתחיל להתעסק
עם זה, אתה תהיה

1120
00:56:53,900 --> 00:56:55,733
שמירה על מסלול של בי
כל המצביעים הם,

1121
00:56:55,733 --> 00:56:58,060
מה קורה בך
מבני נתונים, וכולי.

1122
00:56:58,060 --> 00:56:59,810
הם יהיו מאוד שימושיים,
וזה תלוי בך

1123
00:56:59,810 --> 00:57:03,890
בחורים להבין לחלוטין איך
אתה רוצה ליישם את הדברים.

1124
00:57:03,890 --> 00:57:07,650
>> וכך pset4, של 5-- הו, זה לא בסדר.

1125
00:57:07,650 --> 00:57:10,140
Pset5 הוא שגיאות כתיב.

1126
00:57:10,140 --> 00:57:13,710
כפי שאמרתי קודם, שאתה הולך, ברגע ש
שוב, להוריד את קוד מקור מאתנו.

1127
00:57:13,710 --> 00:57:16,210
יש הולך להיות שלוש עיקרי
דברים שאתה תהיה הורדה.

1128
00:57:16,210 --> 00:57:18,470
אתה להוריד מילונים,
kers, וטקסטים.

1129
00:57:18,470 --> 00:57:21,660
>> כל הדברים האלה הם הם
או מילונים של מילות

1130
00:57:21,660 --> 00:57:25,190
כי אנחנו רוצים אותך כדי לבדוק
או בדיקה של מידע

1131
00:57:25,190 --> 00:57:26,930
כי אנחנו רוצים שבדיקת איות.

1132
00:57:26,930 --> 00:57:29,670
וכך המילונים
אנחנו נותנים לך הולכים

1133
00:57:29,670 --> 00:57:34,870
כדי לתת לך מילות אמיתיות שאנחנו רוצים
לך לאחסן איכשהו בדרך זה

1134
00:57:34,870 --> 00:57:36,530
יעיל יותר ממערך.

1135
00:57:36,530 --> 00:57:38,470
ולאחר מכן הטקסטים
הולך להיות מה שאנחנו

1136
00:57:38,470 --> 00:57:43,900
מבקש ממך בדיקת איות לוודא
כל המילים יש מילות אמיתיות.

1137
00:57:43,900 --> 00:57:47,970
>> וכך שלושה בלוקים של
תוכניות שניתן לך

1138
00:57:47,970 --> 00:57:51,130
נקראים dictionary.c,
dictionary.h, וspeller.c.

1139
00:57:51,130 --> 00:57:56,500
וכך כל dictionary.c עושה הוא
מה שאתה ביקש ליישם.

1140
00:57:56,500 --> 00:57:57,880
הוא טוען מילות.

1141
00:57:57,880 --> 00:58:02,000
זה לאיית בודק אותם, וזה גורם בטוח
כל מה שמוכנס כראוי.

1142
00:58:02,000 --> 00:58:05,180
>> diction.h הוא רק קובץ ספרייה
שמצהיר כל פונקציות אלה.

1143
00:58:05,180 --> 00:58:07,650
וspeller.c, אנחנו הולכים לתת לך.

1144
00:58:07,650 --> 00:58:09,290
אתה לא צריך לשנות את כל זה.

1145
00:58:09,290 --> 00:58:14,290
כל speller.c אין הוא לקחת את זה,
המון זה, בודק את המהירות שלו,

1146
00:58:14,290 --> 00:58:19,190
בדיקות benchmark כמו איך
במהירות אתה מסוגל לעשות דברים.

1147
00:58:19,190 --> 00:58:20,410
>> זה איות.

1148
00:58:20,410 --> 00:58:23,920
רק לא מתעסקים עם זה, אבל לעשות
בטוח שאתה מבין מה הוא עושה.

1149
00:58:23,920 --> 00:58:28,090
אנו משתמשים בפונקציה שנקראת getrusage ש
בודק את הביצועים של הכישוף שלך

1150
00:58:28,090 --> 00:58:28,590
בּוֹדֵק.

1151
00:58:28,590 --> 00:58:32,200
כל מה שעשה זה בעצם לבדוק
זמן של כל דבר במילון שלך,

1152
00:58:32,200 --> 00:58:33,680
כדי לוודא שאתה מבין את זה.

1153
00:58:33,680 --> 00:58:36,660
היזהר שלא להתעסק עם זה או
דברים אחר לא יפעלו כראוי.

1154
00:58:36,660 --> 00:58:39,740

1155
00:58:39,740 --> 00:58:44,170
>> ואת חלק הארי של האתגר הזה הוא בשביל
אתם באמת לשנות dictionary.c.

1156
00:58:44,170 --> 00:58:48,526
אנחנו הולכים לתת לך
140,000 מילות במילון.

1157
00:58:48,526 --> 00:58:50,900
אנחנו הולכים לתת לך את טקסט
קובץ שיש את המילים האלה,

1158
00:58:50,900 --> 00:58:54,840
ואנחנו רוצים שתהיו מסוגלים לארגן
אותם לשולחן חשיש או איירי

1159
00:58:54,840 --> 00:58:58,140
משום שכאשר אנו מבקשים מכם לאיית
check-- לדמיין אם אתה כישוף

1160
00:58:58,140 --> 00:59:00,690
בדיקה כמו האודיסיאה של הומרוס.

1161
00:59:00,690 --> 00:59:03,010
זה כמו מבחן ענק, ענק.

1162
00:59:03,010 --> 00:59:05,190
>> תארו לעצמכם אם כל אחד
מילה שאתה הייתי צריך לחפש

1163
00:59:05,190 --> 00:59:08,100
באמצעות מערך של 140,000 ערכים.

1164
00:59:08,100 --> 00:59:10,350
שתיקח לנצח
למכונה שלך לרוץ.

1165
00:59:10,350 --> 00:59:14,490
זאת הסיבה שאנחנו רוצים לארגננו
נתונים למבני נתונים יעילים יותר

1166
00:59:14,490 --> 00:59:17,270
כגון שולחן חשיש או איירי.

1167
00:59:17,270 --> 00:59:20,700
ואז אתם יכולים סוג
בעת החיפוש של גישה

1168
00:59:20,700 --> 00:59:22,570
דברים יותר בקלות ובמהירות יותר.

1169
00:59:22,570 --> 00:59:24,934
>> וכדי להיות זהיר כדי לפתור התנגשויות.

1170
00:59:24,934 --> 00:59:27,350
אתה הולך לקבל חבורה
מילים של התחלה שעם א '

1171
00:59:27,350 --> 00:59:29,957
אתה הולך לקבל מילות חבורה
שתתחיל עם ב 'עד ש

1172
00:59:29,957 --> 00:59:31,290
בחורים איך אתה רוצה לפתור אותה.

1173
00:59:31,290 --> 00:59:34,144
אולי יש יותר
פונקצית חשיש יעילה

1174
00:59:34,144 --> 00:59:36,810
לא רק את האות הראשונה של
משהו, ואז זה תלוי בך

1175
00:59:36,810 --> 00:59:38,190
בחורים לעשות סוג של מה שאתה רוצה.

1176
00:59:38,190 --> 00:59:40,148
>> אולי אתה רוצה להוסיף
כל האותיות יחד.

1177
00:59:40,148 --> 00:59:43,410
אולי אתה רוצה רוצה לעשות דברים מוזרים
לחשבון מספר האותיות,

1178
00:59:43,410 --> 00:59:43,970
מה שתגיד.

1179
00:59:43,970 --> 00:59:45,386
עד איך אתה רוצה לעשות.

1180
00:59:45,386 --> 00:59:49,262
אם אתה רוצה לעשות שולחן חשיש, אם אתה
רוצה לנסות את איירי, לגמרי תלוי בך.

1181
00:59:49,262 --> 00:59:52,470
אני מזהיר אותך מראש ש
איירי היא בדרך כלל קצת יותר קשה

1182
00:59:52,470 --> 00:59:54,520
רק בגלל שיש הרבה
יותר מצביעים כדי לעקוב אחר.

1183
00:59:54,520 --> 00:59:55,645
אבל לגמרי תלוי בך חבר '.

1184
00:59:55,645 --> 00:59:58,742
זה הרבה יותר יעיל
ברוב המקרים.

1185
00:59:58,742 --> 01:00:01,450
אתה באמת רוצה להיות מסוגל לשמור
אחר כל המצביעים שלך.

1186
01:00:01,450 --> 01:00:03,850
כמו לעשות את אותו הדבר
שאני עושה כאן.

1187
01:00:03,850 --> 01:00:06,871
כאשר אתה מנסה להכניס
ערכים בטבלת חשיש או למחוק,

1188
01:00:06,871 --> 01:00:08,620
לוודא שאתה
באמת שמירה על מסלול

1189
01:00:08,620 --> 01:00:11,860
של שבו הכל בגלל
זה ממש קל לאם אני

1190
01:00:11,860 --> 01:00:14,727
מנסה להכניס כמו המילה, אנדי.

1191
01:00:14,727 --> 01:00:16,810
בואו נגיד שזה
מילה אמיתית, המילה, אנדי,

1192
01:00:16,810 --> 01:00:19,640
לרשימה ענקית של מילות.

1193
01:00:19,640 --> 01:00:22,450
>> אם במקרה אני פשוט להקצות מחדש
הלא נכון מצביע, אופס,

1194
01:00:22,450 --> 01:00:24,940
שם הולך שלמות של
שאר הרשימה המקושרת שלי.

1195
01:00:24,940 --> 01:00:26,897
עכשיו המילה היחידה שאני
יש לי הוא אנדי, ועכשיו

1196
01:00:26,897 --> 01:00:29,230
כל המילים האחרות ב
מילון אבד.

1197
01:00:29,230 --> 01:00:31,370
ואז אתה רוצה לוודא שאתה
לעקוב אחר כל המצביעים שלך

1198
01:00:31,370 --> 01:00:33,661
או שאתה הולך לקבל
בעיות עצומות בקוד שלך.

1199
01:00:33,661 --> 01:00:35,840
לצייר דברים בזהירות צעד אחר צעד.

1200
01:00:35,840 --> 01:00:37,870
זה עושה את זה הרבה יותר קל לחשוב עליו.

1201
01:00:37,870 --> 01:00:40,910
>> ולבסוף, אתה רוצה להיות מסוגל
לבדוק את הביצועים של התכנית שלך שלך

1202
01:00:40,910 --> 01:00:41,618
על הלוח הגדול.

1203
01:00:41,618 --> 01:00:43,710
אם אתם לוקחים
להסתכל CS50 עכשיו,

1204
01:00:43,710 --> 01:00:45,210
יש לנו מה שנקרא הלוח הגדול.

1205
01:00:45,210 --> 01:00:50,200
זה גיליון הציון של המהיר ביותר
לאיית פעמים בדיקה על פני כל CS50

1206
01:00:50,200 --> 01:00:55,720
עכשיו, אני חושב שחלק העליון כמו 10
פעמים אני חושב ששמונה מהם צוות.

1207
01:00:55,720 --> 01:00:57,960
אנחנו באמת רוצים שבחורים להכות אותנו.

1208
01:00:57,960 --> 01:01:00,870
>> כולנו מנסים ליישם
הקוד המהיר ביותר האפשרי.

1209
01:01:00,870 --> 01:01:04,880
אנחנו רוצים אתכם לנסות לאתגר
שלנו וליישם מהר יותר מכל אחד מאיתנו

1210
01:01:04,880 --> 01:01:05,550
פַּחִית.

1211
01:01:05,550 --> 01:01:07,970
ואז זה באמת
בפעם הראשונה שאנחנו

1212
01:01:07,970 --> 01:01:12,680
שואל אתכם לעשות pset ש
אתה באמת יכול לעשות בכל שיטה

1213
01:01:12,680 --> 01:01:13,760
אתה רוצה.

1214
01:01:13,760 --> 01:01:17,730
>> אני תמיד אומר, זה משול יותר
לפתרון אמיתי, נכון?

1215
01:01:17,730 --> 01:01:19,550
אני אומר, היי, אני צריך אותך לעשות את זה.

1216
01:01:19,550 --> 01:01:21,380
לבנות תכנית שעושה את זה בשבילי.

1217
01:01:21,380 --> 01:01:22,630
לעשות את זה איך שאתה רוצה.

1218
01:01:22,630 --> 01:01:24,271
אני רק יודע שאני רוצה לצום.

1219
01:01:24,271 --> 01:01:25,770
זה האתגר שלך לזה שבוע.

1220
01:01:25,770 --> 01:01:27,531
אתם, אנחנו הולכים
כדי לתת לך משימה.

1221
01:01:27,531 --> 01:01:29,030
אנחנו הולכים לתת לך אתגר.

1222
01:01:29,030 --> 01:01:31,559
ואז זה תלוי בכם
ללגמרי פשוט להבין

1223
01:01:31,559 --> 01:01:34,100
מה המהיר ביותר ורוב
דרך יעילה ליישום זה.

1224
01:01:34,100 --> 01:01:34,600
כֵּן?

1225
01:01:34,600 --> 01:01:37,476
>> קהל: האם מותר לנו אם
רציתי לחקור דרכים מהירות יותר

1226
01:01:37,476 --> 01:01:40,821
לעשות שולחנות חשיש באינטרנט, אנחנו יכולים לעשות
ושלצטט קוד של מישהו אחר?

1227
01:01:40,821 --> 01:01:42,070
ANDI פנג: כן, בסדר גמור.

1228
01:01:42,070 --> 01:01:44,320
אז אם אתם קוראים את
מפרט, יש קו

1229
01:01:44,320 --> 01:01:48,310
במפרט שאומר לכם
הם לגמרי בחינם למחקר חשיש

1230
01:01:48,310 --> 01:01:51,070
פונקציות על מה הם כמה
של פונקציות חשיש מהירות

1231
01:01:51,070 --> 01:01:54,720
לנהל את העניינים דרך כ
כל עוד אתה מצטט קוד ש.

1232
01:01:54,720 --> 01:01:57,220
אז כמה אנשים כבר
הבין דרכים מהירות

1233
01:01:57,220 --> 01:02:00,250
לעשות דמקה כישוף, של מהר
דרכים לשמירת מידע.

1234
01:02:00,250 --> 01:02:02,750
לגמרי תלוי בך אם אתה בחורים
רוצה רק לקחת את זה, נכון?

1235
01:02:02,750 --> 01:02:04,045
ודא שאתה מצטט.

1236
01:02:04,045 --> 01:02:06,170
האתגר כאן באמת
שאנחנו מנסים לבדוק

1237
01:02:06,170 --> 01:02:09,750
הוא לוודא שאתה יודע
בדרך שלך סביב המצביעים.

1238
01:02:09,750 --> 01:02:12,700
ככל שאתה מיישם
פונקצית החשיש בפועל

1239
01:02:12,700 --> 01:02:15,070
ולבוא עם כמו
המתמטיקה כדי לעשות את זה,

1240
01:02:15,070 --> 01:02:17,570
אתם יכולים לחקור מה
שיטות מקוונות אתם רוצים.

1241
01:02:17,570 --> 01:02:17,996
כֵּן?

1242
01:02:17,996 --> 01:02:19,700
>> קהל: האם אנחנו יכולים לצטט רק
על ידי שימוש ב[ לא ברור]?

1243
01:02:19,700 --> 01:02:20,120
>> ANDI פנג: כן.

1244
01:02:20,120 --> 01:02:22,328
אתה יכול פשוט, בתגובה שלך,
אתה יכול לצטט כמו, אה,

1245
01:02:22,328 --> 01:02:26,127
נלקח מבלה בלה,
בלה, פונקצית חשיש.

1246
01:02:26,127 --> 01:02:27,210
מישהו יש לך שאלות?

1247
01:02:27,210 --> 01:02:29,694
אנחנו למעשה חלפנו
באמצעות סעיף היום.

1248
01:02:29,694 --> 01:02:31,610
אני אהיה כאן ל
לענות על שאלות גם כן.

1249
01:02:31,610 --> 01:02:36,570
>> כמו כן, כפי שאמרתי, משרד
שעות הלילה ומחר.

1250
01:02:36,570 --> 01:02:40,307
המפרט זה שבוע הוא למעשה
סופר קל וסופר קצר לקרוא.

1251
01:02:40,307 --> 01:02:43,140
הייתי מציע להעיף מבט, רק
קראת את השלמות שלו.

1252
01:02:43,140 --> 01:02:45,730
>> וZamyla הולך אתה בעצם
באמצעות כל אחד מהפונקציות

1253
01:02:45,730 --> 01:02:49,796
אתה צריך ליישם, ואז זה
מאוד, מאוד ברור איך לעשות את הכל.

1254
01:02:49,796 --> 01:02:51,920
רק כדי לוודא שאתה
שמירה על המסלול של מצביעים.

1255
01:02:51,920 --> 01:02:53,650
זה pset מאוד מאתגר.

1256
01:02:53,650 --> 01:02:56,744
>> זה לא מאתגר, כי כמו,
הו, המושגים כל כך הרבה יותר

1257
01:02:56,744 --> 01:02:59,160
קשה, או שאתה צריך ללמוד
כל כך הרבה תחביר חדש בדרך

1258
01:02:59,160 --> 01:03:00,650
שעשית לpset האחרון.

1259
01:03:00,650 --> 01:03:03,320
pset זה קשה כי
יש כל כך הרבה מצביעים,

1260
01:03:03,320 --> 01:03:06,980
ואז זה מאוד, מאוד קל לפעם
יש לך באג בקוד שלך לא תוכל

1261
01:03:06,980 --> 01:03:08,315
למצוא בו באג שהוא.

1262
01:03:08,315 --> 01:03:13,200
>> וכך מלא ומוחלטת אמונה בך
בחורים להיות מסוגלים להכות [לא הברור] שלנו

1263
01:03:13,200 --> 01:03:13,700
איות.

1264
01:03:13,700 --> 01:03:16,640
אני ממש לא כולי בכתב
עדיין, אבל אני עומד לכותבי.

1265
01:03:16,640 --> 01:03:19,070
אז בזמן שאתה כותב
שלך, אני כותב.

1266
01:03:19,070 --> 01:03:21,070
אני הולך לנסות לעשות
שלי מהר יותר משלך.

1267
01:03:21,070 --> 01:03:23,940
אנחנו תראו שיש לו את המהירות אחד.

1268
01:03:23,940 --> 01:03:27,340
>> וכן, אני רואה את כל
אתם כאן ביום שלישי.

1269
01:03:27,340 --> 01:03:29,510
אני ארוץ סוג כמו סדנת pset.

1270
01:03:29,510 --> 01:03:32,640
כל הסעיפים זה
שבוע סדנאות pset,

1271
01:03:32,640 --> 01:03:36,690
אז יש לך בחורים הרבה הזדמנויות
לעזרה, לשעתי עבודה כמו תמיד,

1272
01:03:36,690 --> 01:03:41,330
ואני באמת מצפה ל
לקרוא את כל הקוד "הבחורים שלך.

1273
01:03:41,330 --> 01:03:44,160
יש לי חידונים כאן אם אתה
בחורים רוצים לבוא לקבל אותם.

1274
01:03:44,160 --> 01:03:45,880
זה הכל.

1275
01:03:45,880 --> 01:03:48,180