1
00:00:00,000 --> 00:00:11,460

2
00:00:11,460 --> 00:00:12,250
>> דוד Malan: בסדר.

3
00:00:12,250 --> 00:00:13,860
ברוך שובי לCS50.

4
00:00:13,860 --> 00:00:16,190
זוהי תחילת השבוע 8.

5
00:00:16,190 --> 00:00:21,320
וזוכרים שקבוצת הבעיה 5 הסתיימה
עם קצת אתגר.

6
00:00:21,320 --> 00:00:25,210
אז בהנחה שאתה התאושש את כולך
עמיתי הוראה והתצלומים של CA

7
00:00:25,210 --> 00:00:30,480
בקובץ card.raw, אתה זכאי
עכשיו כדי למצוא את כל האנשים האלה, ו

8
00:00:30,480 --> 00:00:34,510
זוכה מאושר אחד ילך הביתה עם אחד
מהדברים האלה, את תנועת הקפיצה

9
00:00:34,510 --> 00:00:37,450
מכשיר שאתה יכול להשתמש עבור סופי
פרויקטים, למשל.

10
00:00:37,450 --> 00:00:39,860
>> זה, בכל שנה, מוביל
קצת creepiness.

11
00:00:39,860 --> 00:00:43,480
ולכן מה שחשבתי שאני רוצה לעשות הוא לחלוק
איתך כמה מההערות שיש לי

12
00:00:43,480 --> 00:00:47,370
הלך הלוך ושוב על פני
רשימת צוות של המנוח.

13
00:00:47,370 --> 00:00:51,110
לדוגמה, רק אתמול בלילה, ציטוט
סוף ציטוט מהאחד מהצוות

14
00:00:51,110 --> 00:00:55,000
חברים, "פשוט היו לי דפיקה תלמיד
על הדלת שלי לקחת את תמונה איתי.

15
00:00:55,000 --> 00:00:59,020
מטרידנים, אני אומר לך. "התחלתי את
תיאורי למדי ולאחר מכן עברנו

16
00:00:59,020 --> 00:01:02,830
ל, כשעה לאחר מכן, "לא היה לי
תלמיד מחכה לי אחרי הסעיף

17
00:01:02,830 --> 00:01:06,080
והיה לו את כל השמות והתמונות שלנו
בכמה גיליונות של נייר. "בסדר.

18
00:01:06,080 --> 00:01:09,230
כל כך מאורגן, אבל לא
כל מה שמפחיד עדיין.

19
00:01:09,230 --> 00:01:12,520
>> לאחר מכן, "אני היה מחוץ לעיר בסוף השבוע הזה,
וכשחזרתי, לא היה אחד ב

20
00:01:12,520 --> 00:01:12,630
שלי

21
00:01:12,630 --> 00:01:16,740
חדר שינה. "[שחוק]

22
00:01:16,740 --> 00:01:20,410
דוד Malan: הציטוט הבא מצוות
חבר, "תלמיד הגיע לבית שלי ב

23
00:01:20,410 --> 00:01:25,330
סומרוויל ב -4 בבוקר בבוקר ". הבא
צוות, "יש לי למלון שלי בסן

24
00:01:25,330 --> 00:01:30,016
פרנסיסקו ותלמיד חיכו לי
לי בלובי עם שלוש DSLRs ".

25
00:01:30,016 --> 00:01:31,510
סוג של מצלמה.

26
00:01:31,510 --> 00:01:34,980
"אני אפילו לא בסגל בסמסטר הזה,
אבל תלמיד פרץ לבית שלי זה

27
00:01:34,980 --> 00:01:40,480
בוקר והקליט את כל העניין
עם Google זכוכית. "ואז לבסוף,

28
00:01:40,480 --> 00:01:43,650
"לפחות 12 בני אדם בשקיקה
ממתין לי כשיצא משלי

29
00:01:43,650 --> 00:01:44,800
לימוזינה, ואז

30
00:01:44,800 --> 00:01:46,970
התעורר. "בסדר.

31
00:01:46,970 --> 00:01:57,690
אז בין התמונות, כפי שאתה יכול
כזכור, הוא הבחור הזה כאן, מי אתה

32
00:01:57,690 --> 00:02:01,850
אולי יודע כמיל בננה, המתגורר
עם לורן קרבאליו, הראש שלנו

33
00:02:01,850 --> 00:02:02,905
עמית הוראה.

34
00:02:02,905 --> 00:02:05,170
מילו, מילו, בוא הנה בחור.

35
00:02:05,170 --> 00:02:06,320
מילוא.

36
00:02:06,320 --> 00:02:08,650
מילוא.

37
00:02:08,650 --> 00:02:12,230
אכפת לך, שהוא לובש גוגל זכוכית, ולכן
אנחנו אראה לך את כל זה לאחר.

38
00:02:12,230 --> 00:02:16,190
אז זה מיל אם אתה רוצה
לצלם איתו לאחר מכן.

39
00:02:16,190 --> 00:02:18,240
אם ברצונך להסתכל החוצה
בקהל שם.

40
00:02:18,240 --> 00:02:19,430
אישור.

41
00:02:19,430 --> 00:02:20,200
זה סרט טוב.

42
00:02:20,200 --> 00:02:22,556
ובכן, מילו בננה.

43
00:02:22,556 --> 00:02:23,941
אה, לא עושה את זה.

44
00:02:23,941 --> 00:02:29,020
>> [שחוק]

45
00:02:29,020 --> 00:02:29,470
>> אישור.

46
00:02:29,470 --> 00:02:34,550
אז מילה אז על מה שלפנינו,
משום שכפי שאנו מתחילים מעבר,

47
00:02:34,550 --> 00:02:38,410
השבוע במיוחד, מC ב
סביבת שורת הפקודה לPHP ו

48
00:02:38,410 --> 00:02:42,720
JavaScript ו-SQL ו-HTML ו-CSS ב
סביבה מבוססת אינטרנט, נהיה

49
00:02:42,720 --> 00:02:44,490
לצייד אותך בכל
ידע נוסף עבור

50
00:02:44,490 --> 00:02:46,010
פרויקטי גמר פוטנציאליים.

51
00:02:46,010 --> 00:02:49,240
לשם כך, יש כמובן
מסורת של קיום ימי עיון בו

52
00:02:49,240 --> 00:02:50,950
הם בנושאים משיקים
לקורס.

53
00:02:50,950 --> 00:02:54,330
מאוד קשור לתכנות ול
פיתוח אפליקציה וכן הלאה, אבל

54
00:02:54,330 --> 00:02:57,010
לא חקר בהכרח על ידי
הסילבוס של הקורס שלו.

55
00:02:57,010 --> 00:03:00,250
>> אז אם אתה עשוי להיות מעוניין באחד
או יותר מהסמינרים של שנה זו,

56
00:03:00,250 --> 00:03:02,530
להירשם בcs50.net/seminar.

57
00:03:02,530 --> 00:03:06,170
ישנם סמינרים מבוגרים
בcs50.net/seminars.

58
00:03:06,170 --> 00:03:10,620
ובסגל עד כה לשנה זו
הם יישומי אינטרנט מדהימים עם Ruby on

59
00:03:10,620 --> 00:03:13,580
מסילות, אשר מהווה חלופה
שפת PHP.

60
00:03:13,580 --> 00:03:14,900
בלשנות חישובית.

61
00:03:14,900 --> 00:03:18,710
מבוא לiOS, שהוא
פלטפורמה המשמשת עבור iPhone ו

62
00:03:18,710 --> 00:03:19,850
פיתוח האייפד.

63
00:03:19,850 --> 00:03:22,890
JavaScript עבור יישומי אינטרנט, שנכסנו
את זה, אבל בסמינר זה, אתה תלך

64
00:03:22,890 --> 00:03:24,070
לקבלת פרטים נוספים.

65
00:03:24,070 --> 00:03:27,390
>> קפיצת Motion, אז למעשה לא תהיה לנו קצת
מחברינו מתנועת קפיצה,

66
00:03:27,390 --> 00:03:29,160
החברה עצמה, להצטרף אלינו.

67
00:03:29,160 --> 00:03:31,800
מחר, למעשה, על מנת לספק
ידות על סמינר, אם

68
00:03:31,800 --> 00:03:33,320
לעניין אותך.

69
00:03:33,320 --> 00:03:38,770
Meteor.js, טכניקה חלופית עבור
באמצעות JavaScript לא בדפדפן,

70
00:03:38,770 --> 00:03:39,970
אבל בשרת.

71
00:03:39,970 --> 00:03:42,110
Node.js, אשר היא במידה רבה
כמו גם ברוח זו.

72
00:03:42,110 --> 00:03:43,650
עיצוב מלוטש אנדרואיד.

73
00:03:43,650 --> 00:03:46,990
אנדרואיד להיות חלופה פופולרית מאוד
לiOS ו-Windows טלפון

74
00:03:46,990 --> 00:03:48,790
ופלטפורמות ניידים אחרות.

75
00:03:48,790 --> 00:03:51,180
הגנה אקטיבית ואבטחת האינטרנט.

76
00:03:51,180 --> 00:03:54,590
>> אז למעשה, אם אתה רוצה
לעסוק בזה, תן לי

77
00:03:54,590 --> 00:03:55,840
שימו לב לזה.

78
00:03:55,840 --> 00:03:57,790
אנחנו מאוד שמחים לומר כי
החברים שלנו בקפיצה

79
00:03:57,790 --> 00:03:59,140
תנועה, שהוא הפעלה -

80
00:03:59,140 --> 00:04:01,300
מכשיר זה באמת רק בא
לפני כמה חודשים יצאו -

81
00:04:01,300 --> 00:04:05,960
תרם באדיבות 30 מכשירים כאלה
לכיתה ולתלמידים רבים, אם

82
00:04:05,960 --> 00:04:08,670
היית רוצה לשאול את החומרה
לקראת סוף הסמסטר ולהשתמש בו עבור

83
00:04:08,670 --> 00:04:10,390
פרויקט גמר בפועל.

84
00:04:10,390 --> 00:04:11,890
הם תומכים במספר השפות.

85
00:04:11,890 --> 00:04:16,040
אף אחד מהם C, אף אחד מהם PHP, ולכן
מבין אחד או יותר מהסמינרים האלה

86
00:04:16,040 --> 00:04:16,899
אולי להוכיח עניין.

87
00:04:16,899 --> 00:04:19,730
וכולם יהיה מצולם ב
המקרה שאתה לא מסוגל

88
00:04:19,730 --> 00:04:21,380
כדי להשתתף באופן אישי.

89
00:04:21,380 --> 00:04:25,000
לוח הזמנים שהודיעו באמצעות
דוא"ל כפי שאנו לחזק את החדרים.

90
00:04:25,000 --> 00:04:28,460
>> ולבסוף, אם אתה הולך ל
projects.cs.50.net, זה אתר

91
00:04:28,460 --> 00:04:31,450
אנו מקיימים בכל שנה שאנו מזמינים
אנשים מהקהילה, הסגל,

92
00:04:31,450 --> 00:04:36,420
מחלקות, עובדים ושני
במחוץ לCS50

93
00:04:36,420 --> 00:04:37,730
להציע רעיונות לפרויקטים.

94
00:04:37,730 --> 00:04:39,050
דברים שמעניינים את קבוצות סטודנטים.

95
00:04:39,050 --> 00:04:40,600
דברים המעניינים את המחלקות.

96
00:04:40,600 --> 00:04:43,990
אז אל תהפוך לשם אם אתה נאבק
עם אי ודאות לגבי מה שאתה

97
00:04:43,990 --> 00:04:46,700
את עצמך הייתי רוצה להתמודד.

98
00:04:46,700 --> 00:04:51,760
>> אז הפעם האחרונה שהצגנו ללא ספק
מבנה נתונים מורכב יותר ממה שהיינו

99
00:04:51,760 --> 00:04:53,300
ראה בשבועות האחרונים.

100
00:04:53,300 --> 00:04:56,550
היינו כבר משתמשים מערכים די
בשמחה כשימושי אם

101
00:04:56,550 --> 00:04:58,160
מבנה נתונים פשטני.

102
00:04:58,160 --> 00:05:00,570
אחר כך הצגנו את אלה, אשר
כמובן קשורים רשימות.

103
00:05:00,570 --> 00:05:05,470
ומה שהיה אחד מהמניעים ל
מציג מבנה נתונים זה?

104
00:05:05,470 --> 00:05:06,930
כן?

105
00:05:06,930 --> 00:05:07,250
מה זה?

106
00:05:07,250 --> 00:05:08,080
>> קהל: גודל דינמי.

107
00:05:08,080 --> 00:05:09,040
>> דוד Malan: גודל דינמי.

108
00:05:09,040 --> 00:05:11,890
אז אילו במערך, שיש לך
יודע את גודלה מראש מתי

109
00:05:11,890 --> 00:05:12,740
שלך להקצות אותו.

110
00:05:12,740 --> 00:05:14,380
ברשימה מקושרת, שאתה לא יודע
צריך לדעת את זה.

111
00:05:14,380 --> 00:05:17,610
אתה יכול פשוט malloc, או באופן כללי יותר,
הקצאה נוספת

112
00:05:17,610 --> 00:05:20,720
צומת, אם אפשר לומר כך, בכל פעם שאתה
ברצונך להוסיף נתונים נוספים.

113
00:05:20,720 --> 00:05:22,670
וצומת יש משמעות קבועה מראש לא.

114
00:05:22,670 --> 00:05:25,580
זה פשוט מונח גנרי המתאר
איזה סוג של המכל שאנחנו

115
00:05:25,580 --> 00:05:29,610
שימוש במבנה נתונים שלנו לאחסון
איזה פריט של עניין, אשר בזה

116
00:05:29,610 --> 00:05:31,750
מקרה יקרה לך להיות שלמים.

117
00:05:31,750 --> 00:05:33,160
>> אבל תמיד יש תחלופה.

118
00:05:33,160 --> 00:05:38,070
אז אנחנו מקבלים גדלים דינמיים של הנתונים
מבנה, אבל מה מחיר שאנחנו משלמים?

119
00:05:38,070 --> 00:05:40,040
מה החסרון של רשימות מקושרות?

120
00:05:40,040 --> 00:05:41,006
כן?

121
00:05:41,006 --> 00:05:41,980
>> קהל: דורש יותר זיכרון.

122
00:05:41,980 --> 00:05:44,240
>> דוד Malan: זה דורש יותר
זיכרון, איך בדיוק?

123
00:05:44,240 --> 00:05:46,440
>> קהל: [לא ברור].

124
00:05:46,440 --> 00:05:47,050
>> דוד Malan: בדיוק.

125
00:05:47,050 --> 00:05:50,460
אז עכשיו יש לנו מצביעים תופסים
זיכרון נוסף שאנחנו בעבר

126
00:05:50,460 --> 00:05:53,040
לא צריך, כי היתרון
של מערך, כמובן, הוא ש

127
00:05:53,040 --> 00:05:54,860
כל מה שהוא רציף, חזרה
לגב אל הגב, ה

128
00:05:54,860 --> 00:05:56,380
נותן לך גישה אקראית.

129
00:05:56,380 --> 00:06:00,710
כי רק על ידי שימוש בסוגריים מרובעים
סימון, או יותר מבחינה טכנית מצביע

130
00:06:00,710 --> 00:06:03,580
חשבון, בנוסף פשוט מאוד,
אתה יכול לגשת לכל

131
00:06:03,580 --> 00:06:05,700
אלמנטים בזמן קבוע.

132
00:06:05,700 --> 00:06:08,975
ולמעשה, זה סוג של רמז
מחיר נוסף שאנחנו משלמים עם

133
00:06:08,975 --> 00:06:09,760
רשימה מקושרת.

134
00:06:09,760 --> 00:06:13,890
>> מה קורה לזמן הריצה של
משהו כמו חיפוש, אם אני רוצה

135
00:06:13,890 --> 00:06:17,270
למצוא איזה ערך ובתוך
של רשימה מקושרת?

136
00:06:17,270 --> 00:06:20,290
מה זמן הריצה שלי להיות?

137
00:06:20,290 --> 00:06:21,560
ביג O של n.

138
00:06:21,560 --> 00:06:24,060
אם זה מסודרים ל?

139
00:06:24,060 --> 00:06:25,440
מה אם מבנה הנתונים של מסודרים?

140
00:06:25,440 --> 00:06:28,640
האם אני יכול לעשות יותר טוב מגדול
O של n לחיפוש?

141
00:06:28,640 --> 00:06:31,700
לא, כי במקרה הגרוע זה עלול
טוב מאוד להיות מסודר, אבל המספר

142
00:06:31,700 --> 00:06:32,950
שאתה מחפש עשוי להיות גדול.

143
00:06:32,950 --> 00:06:35,370
זה יכול להיות שהמספר 100,
אולי יקרה לך להיות בכל

144
00:06:35,370 --> 00:06:36,410
בסוף הדרך.

145
00:06:36,410 --> 00:06:39,950
ובגלל שאתה רק יכול לגשת מקושר
רשימה ביישום זה על ידי

146
00:06:39,950 --> 00:06:42,690
הדרך של הצומת הראשונה שלה, אתה
עדיין סוג של מזל.

147
00:06:42,690 --> 00:06:47,450
אתה צריך לעבור את כל העניין
מראשון לאחרונה כדי למצוא

148
00:06:47,450 --> 00:06:49,150
כי ערך גדול כמו 100.

149
00:06:49,150 --> 00:06:51,350
או כדי לקבוע אם זה
אפילו לא שם.

150
00:06:51,350 --> 00:06:55,960
>> אז אנחנו לא יכולים לעשות את מה שאלגוריתם בנתונים
מבנה שנראה כמו זה?

151
00:06:55,960 --> 00:06:59,460
אנחנו לא יכולים לעשות חיפוש בינארי, כי
החיפוש בינארי נדרש שהיו לנו

152
00:06:59,460 --> 00:07:00,740
גישה אקראית.

153
00:07:00,740 --> 00:07:04,500
אנחנו יכולים רק לקפוץ ממקום ל
מיקום מבלי לעקוב

154
00:07:04,500 --> 00:07:07,080
פירורי לחם אלה בצורה
של כל מצביעים אלה.

155
00:07:07,080 --> 00:07:08,300
>> עכשיו, איך אנחנו לא ליישם את זה?

156
00:07:08,300 --> 00:07:12,830
ובכן, אם אנחנו הולכים למסך כאן, אם
אנחנו יכולים reimplement במהירות נתונים אלה

157
00:07:12,830 --> 00:07:13,440
מבנה -

158
00:07:13,440 --> 00:07:15,670
כתב היד שלי לא כל כך
גדול כאן, אבל אנחנו ננסה.

159
00:07:15,670 --> 00:07:22,030
struct אז typedef, ומה שעשה לי
רוצה לקרוא את הדבר הזה לכאן?

160
00:07:22,030 --> 00:07:22,960
צומת.

161
00:07:22,960 --> 00:07:24,580
אז אני אגיד לנו להתחיל.

162
00:07:24,580 --> 00:07:27,860
ועכשיו, מה שצריך להיות בתוך
מבנה הנתונים שלביחידים

163
00:07:27,860 --> 00:07:28,430
רשימה מקושרת?

164
00:07:28,430 --> 00:07:29,950
כמה שדות?

165
00:07:29,950 --> 00:07:30,450
>> אז שתיים.

166
00:07:30,450 --> 00:07:31,570
אחד מהם הוא די קל.

167
00:07:31,570 --> 00:07:33,050
אז int n.

168
00:07:33,050 --> 00:07:35,930
ואנחנו יכולים לקרוא לכל דבר שאנחנו רוצים N,
אבל זה צריך להיות int אם אנחנו

169
00:07:35,930 --> 00:07:37,660
יישום רשימה מקושרת לints.

170
00:07:37,660 --> 00:07:41,920
ועכשיו מה עושה שני
שדה צריך להיות?

171
00:07:41,920 --> 00:07:43,460
Struct צומת *.

172
00:07:43,460 --> 00:07:50,570
אז אם אני עושה struct * צומת, ולאחר מכן אני
אפשר לקרוא לזה גם מה שאני רוצה,

173
00:07:50,570 --> 00:07:53,510
אבל רק שיהיה ברור אני אתקשר
שלו הבא, כפי שאנו כבר עושים.

174
00:07:53,510 --> 00:07:55,270
ואז אני אסגור סוגריים המסולסלים שלי.

175
00:07:55,270 --> 00:08:00,700
>> ועכשיו, כמו בפעם קודמת,
שמתי את הצומת כאן למטה.

176
00:08:00,700 --> 00:08:03,830
אבל אם אני הכרזה זו היא כ
צומת, למה אני לא טורח להיות כל כך

177
00:08:03,830 --> 00:08:07,320
מפורט כאן בהכרזת struct
* הצומת הבאה, בניגוד

178
00:08:07,320 --> 00:08:09,210
רק * קשר הבא?

179
00:08:09,210 --> 00:08:09,904
כן?

180
00:08:09,904 --> 00:08:12,810
>> קהל: [לא ברור].

181
00:08:12,810 --> 00:08:14,050
>> דוד Malan: בדיוק.

182
00:08:14,050 --> 00:08:14,530
בדיוק.

183
00:08:14,530 --> 00:08:18,320
כי C באמת לוקח אותך, פשוטו כמשמעו, ו
רק רואה את ההגדרה של צומת

184
00:08:18,320 --> 00:08:21,230
עד לכאן, אתה לא יכול
מתייחס אליו כאן.

185
00:08:21,230 --> 00:08:24,760
אז יש לנו סוג כזה של מנע
הצהרה כאן, שהוא אמנם

186
00:08:24,760 --> 00:08:25,390
יותר מפורט.

187
00:08:25,390 --> 00:08:27,810
Struct צומת, שפירושו
עכשיו אנחנו יכולים לגשת אליו

188
00:08:27,810 --> 00:08:29,760
חלק פנימי של מבנה הנתונים.

189
00:08:29,760 --> 00:08:33,370
>> וכמאמר מוסגר, כי זה
הופך קצת יותר סובייקטיבי עכשיו,

190
00:08:33,370 --> 00:08:36,230
הכוכבים יכולים ללכת כאן מבחינה טכנית,
זה יכול ללכת לכאן, זה יכול

191
00:08:36,230 --> 00:08:37,179
אפילו ללכת באמצע.

192
00:08:37,179 --> 00:08:39,890
אנחנו כבר אימצה, במדריך לסגנון
כמובן, בוועידה של לשים

193
00:08:39,890 --> 00:08:42,299
הכוכב ממש ליד את הנתונים
סוג, אשר במקרה זה,

194
00:08:42,299 --> 00:08:43,460
יהיה צומת struct.

195
00:08:43,460 --> 00:08:46,620
אבל מבין בהרבה ספרי לימוד ו
הפניות באינטרנט, אתה עלול אכן

196
00:08:46,620 --> 00:08:48,450
לראות אותו בצד השני.

197
00:08:48,450 --> 00:08:52,200
אבל רק להבין ששניהם יהיו למעשה
לעבוד ואתה צריך פשוט להיות

198
00:08:52,200 --> 00:08:52,970
עולה בקנה אחד.

199
00:08:52,970 --> 00:08:53,580
>> בסדר.

200
00:08:53,580 --> 00:08:55,630
אז זה הייתה ההצהרה שלנו
מצומת struct.

201
00:08:55,630 --> 00:08:59,430
אבל אז התחלנו לעשות יותר
דברים מתוחכמים.

202
00:08:59,430 --> 00:09:03,410
לדוגמה, החלטנו להציג את
משהו כמו שולחן חשיש.

203
00:09:03,410 --> 00:09:08,160
אז הנה טבלת גיבוב של הגודל n,
אינדקס מ -0 בפינה השמאלית העליונה לn

204
00:09:08,160 --> 00:09:09,690
מינוס 1 בפינה שמאלית התחתונה.

205
00:09:09,690 --> 00:09:11,640
זה יכול להיות חשיש
שולחן לכל דבר.

206
00:09:11,640 --> 00:09:15,340
אבל איזה סוג של דברים שאנו מדברים
על שימוש בשולחן חשיש ל?

207
00:09:15,340 --> 00:09:18,370
אחסון מה?

208
00:09:18,370 --> 00:09:18,800
>> שמות.

209
00:09:18,800 --> 00:09:20,870
אנחנו יכולים לעשות שמות כמו
שעשינו בפעם שעברה.

210
00:09:20,870 --> 00:09:22,200
ובאמת, אתה יכול לאחסן כל דבר.

211
00:09:22,200 --> 00:09:24,640
ואנחנו תראו את זה שוב ב
PHP ו ב-JavaScript.

212
00:09:24,640 --> 00:09:28,550
טבלת גיבוב היא מעין יפה של שוויצרי
אולר שמאפשר לך לאחסן

213
00:09:28,550 --> 00:09:33,690
פחות או יותר מה שאתה רוצה בתוך
זה על ידי שיוך מפתחות עם ערכים.

214
00:09:33,690 --> 00:09:34,770
מפתחות עם ערכים.

215
00:09:34,770 --> 00:09:37,800
>> עכשיו במקרה הפשוט הזה, שלנו
מפתחות הם רק מספרים.

216
00:09:37,800 --> 00:09:40,380
אנחנו מיישמים חשיש
שולחן כמערך.

217
00:09:40,380 --> 00:09:43,500
וכך, את המפתחות הם 0,
1, 2, וכן הלאה.

218
00:09:43,500 --> 00:09:47,200
וכך אנו, כבני אדם, החליטו אחרון
בשבוע שאתה יודע מה, אם תהיה לנו

219
00:09:47,200 --> 00:09:50,410
הולך לשמות חנויות, בואו פשוט
באופן שרירותי, אבל די סביר,

220
00:09:50,410 --> 00:09:54,680
תניח שאליס, שם,
יהיה רק ​​להיות צמוד ל0.

221
00:09:54,680 --> 00:09:58,030
ובוב, שם ב ', יהיה צמוד
ל1, וכן הלאה.

222
00:09:58,030 --> 00:10:02,490
אז היו לנו מיפוי בין תשומות,
אשר הם מחרוזות, והחשיש

223
00:10:02,490 --> 00:10:04,560
מקומות, שהם מספרים.

224
00:10:04,560 --> 00:10:07,740
>> כך שהתהליך ידוע בדרך כלל
פונקציית hash, ואתה יכול באמת

225
00:10:07,740 --> 00:10:09,130
ליישם בקוד זה.

226
00:10:09,130 --> 00:10:12,080
אם אני רוצה ליישם את פונקציית hash
שעושה בדיוק את מה שאנחנו

227
00:10:12,080 --> 00:10:17,070
רק תאר מהפעם האחרונה, אני יכול
להכריז על פונקציה שלוקחת, כמו

228
00:10:17,070 --> 00:10:18,330
קלט למשל -

229
00:10:18,330 --> 00:10:22,190
ובואו נעשינו את זה על זה
מסך לכאן.

230
00:10:22,190 --> 00:10:26,180
אם אני רוצה ליישם חשיש
פונקציה, אני יכול להגיד

231
00:10:26,180 --> 00:10:27,410
משהו כזה.

232
00:10:27,410 --> 00:10:29,030
>> זה הולך לחזור int.

233
00:10:29,030 --> 00:10:33,600
זה הולך להיקרא חשיש, וזה
הולך לקבל כטיעון

234
00:10:33,600 --> 00:10:38,920
מחרוזת, או שאנחנו יכולים להיות נכון יותר עכשיו,
ואומרים * char, אנחנו קוראים לזה ש.

235
00:10:38,920 --> 00:10:43,840
ואז כל מה שפונקציה זו יש לעשות,
סופו של דבר, הוא להחזיר int.

236
00:10:43,840 --> 00:10:45,990
עכשיו, איך היא עושה את זה אולי
לא יהיה כל כך ברור.

237
00:10:45,990 --> 00:10:49,510
אני הולך ליישם את זה בלי שום
טופס של בדיקת שגיאות עכשיו.

238
00:10:49,510 --> 00:10:55,740
אני רק הולך להגיד באופן עיוור, לחזור
כל מה שהוא בסוגר של 0, מינוס,

239
00:10:55,740 --> 00:10:58,850
נניח, הון פסיק.

240
00:10:58,850 --> 00:10:59,960
>> לגמרי שבור.

241
00:10:59,960 --> 00:11:02,620
זה לא מושלם, כי
אחד, מה אם ים הוא ריק?

242
00:11:02,620 --> 00:11:04,000
דברים רעים הולכים לקרות.

243
00:11:04,000 --> 00:11:07,940
שתיים, מה אם האות הראשונה בזה
שם הוא לא אות גדולה?

244
00:11:07,940 --> 00:11:09,860
זה לא הולך להפוך את
יצאתי טוב או.

245
00:11:09,860 --> 00:11:11,970
זה יכול להיות אות קטנה
מכתב או לא בכלל.

246
00:11:11,970 --> 00:11:15,520
אז לחלוטין מקום לשיפור כאן,
אבל זה הרעיון הבסיסי.

247
00:11:15,520 --> 00:11:19,010
>> מה שתארנו בשבוע שעבר בעל פה כמו
רק תהליך של מיפוי אליס

248
00:11:19,010 --> 00:11:23,360
ניתן לבטא 0 ובוב ל1
בהחלט יותר formulaically כC

249
00:11:23,360 --> 00:11:24,320
תפעל כאן.

250
00:11:24,320 --> 00:11:28,630
בשם חשיש שוב, לוקח כמחרוזת
קלט, ולאחר מכן איכשהו עושה משהו

251
00:11:28,630 --> 00:11:31,020
עם קלט שכדי להפיק פלט.

252
00:11:31,020 --> 00:11:34,130
שלא כמו תיאור הקופסה השחור שלנו
כל כך הרבה זמן שעשינו.

253
00:11:34,130 --> 00:11:36,550
אני לא יודע איך זה יכול להיות
עובד מתחת למכסת המנוע.

254
00:11:36,550 --> 00:11:40,120
>> לקבוצת הבעיה 6, אחד האתגרים
הוא בשבילך כדי להחליט מה

255
00:11:40,120 --> 00:11:41,920
תהיה פונקציית hash שלך להיות?

256
00:11:41,920 --> 00:11:45,760
מה הולך להיות בתוך ששחור
תיבה, ומן הסתם, זה יהיה

257
00:11:45,760 --> 00:11:50,380
קצת יותר מעניין מזה, ו
בהחלט נוטה יותר לשגיאות

258
00:11:50,380 --> 00:11:53,180
בדיקה מזה בפרט
יישום.

259
00:11:53,180 --> 00:11:54,580
>> אבל בעיות יכולות להתעורר, נכון?

260
00:11:54,580 --> 00:11:57,760
אם יש לנו מבנה נתונים כגון זה
אחד, מה זה אחת הבעיות

261
00:11:57,760 --> 00:12:01,600
אתה יכול לרוץ לתוך לאורך זמן שאתה מכניס את
יותר ויותר שמות ל

262
00:12:01,600 --> 00:12:02,880
שולחן חשיש?

263
00:12:02,880 --> 00:12:04,630
אתה מקבל התנגשויות, נכון?

264
00:12:04,630 --> 00:12:07,560
מה אם יש לך אליס ואהרון,
שני בני אדם ששמות שקרה

265
00:12:07,560 --> 00:12:08,190
להתחיל עם?

266
00:12:08,190 --> 00:12:11,660
זה מעלה את השאלה, שבו אתה
שם שני שם כזה?

267
00:12:11,660 --> 00:12:15,050
>> ובכן, ייתכן שפשוט לשים אותו בתמימות
שבו בוב שייך, אבל אז בוב הוא

268
00:12:15,050 --> 00:12:17,300
סוג של דפוק אם אתה מנסה
הכנס את שמו וליד

269
00:12:17,300 --> 00:12:18,240
אין מקום בשבילו.

270
00:12:18,240 --> 00:12:21,400
אז אתה יכול לשים בו בוב צ'רלי הוא,
ואתה יכול לדמיין את זה מאוד מהר

271
00:12:21,400 --> 00:12:23,020
צלל לתוך קצת בלגן.

272
00:12:23,020 --> 00:12:25,600
משהו ליניארי בסופו של הדבר, שבו אתה
רק צריך לחפש את כל העניין

273
00:12:25,600 --> 00:12:28,190
מחפש אליס או בוב
או אהרון או צ'רלי.

274
00:12:28,190 --> 00:12:33,230
>> אז במקום שהצענו, ולא רק
ליניארי חיטוט שטחים פתוחים

275
00:12:33,230 --> 00:12:36,450
וקשקושים את השמות שם, אנחנו
הציע גישת מגדלת.

276
00:12:36,450 --> 00:12:41,740
שולחן חשיש מיושם עדיין עם
מערך של מדדים, אבל את סוג הנתונים של

277
00:12:41,740 --> 00:12:44,500
המדדים האלה עכשיו היו מצביעים.

278
00:12:44,500 --> 00:12:47,360
מצביעים למה?

279
00:12:47,360 --> 00:12:48,730
מצביעים לרשימות מקושרות.

280
00:12:48,730 --> 00:12:53,330
>> כי זוכר שרשימה מקושרת היא
באמת רק מצביע לצומת, ו

281
00:12:53,330 --> 00:12:57,110
יש את צומת שדה הבא, ושצומת
יש שדה הבא, וכן הלאה.

282
00:12:57,110 --> 00:13:00,690
אז עכשיו אתה יכול לחשוב על זה במערך
בצד השמאלי של שולחן חשיש כ

283
00:13:00,690 --> 00:13:01,820
שמוביל לרשימה מקושרת.

284
00:13:01,820 --> 00:13:07,000
היתרון שלו הוא שאם אתה מקבל
התנגשות בין אליס ואהרון,

285
00:13:07,000 --> 00:13:09,300
מה אתה עושה עם
אדם כזה שני?

286
00:13:09,300 --> 00:13:14,150
אתה פשוט לצרף לו או לה
הסוף, או אפילו ההתחלה

287
00:13:14,150 --> 00:13:15,490
של רשימה מקושרת.

288
00:13:15,490 --> 00:13:17,340
>> ובעצם, בואו רק דרך אטריות
שרק לשנייה.

289
00:13:17,340 --> 00:13:18,640
איפה היית להפוך את התחושה ביותר?

290
00:13:18,640 --> 00:13:22,060
אם אני מכניס אליס והיא בסופו של דבר
המיקום הראשון, ואז אני מנסה

291
00:13:22,060 --> 00:13:25,310
הכנס את שמו של אהרון, ויש
ברור שהתנגשות, אני צריך לשים

292
00:13:25,310 --> 00:13:27,400
שלו בתחילת
של הרשימה המקושרת?

293
00:13:27,400 --> 00:13:30,944
זה במיקום הראשון,
או בסוף?

294
00:13:30,944 --> 00:13:31,440
>> קהל: [לא ברור].

295
00:13:31,440 --> 00:13:31,990
>> דוד Malan: אישור.

296
00:13:31,990 --> 00:13:32,490
שמעתי מתחיל.

297
00:13:32,490 --> 00:13:33,903
למה בהתחלה?

298
00:13:33,903 --> 00:13:34,750
>> קהל: [לא ברור].

299
00:13:34,750 --> 00:13:34,940
>> דוד Malan: אישור.

300
00:13:34,940 --> 00:13:36,520
זה אלפביתי, כך שזה נחמד.

301
00:13:36,520 --> 00:13:37,330
זה נכס טוב.

302
00:13:37,330 --> 00:13:39,335
זה יחסוך לי קצת זמן פוטנציאלי.

303
00:13:39,335 --> 00:13:43,290
זה לא נותן לי לעשות חיפוש בינארי, אבל אני
אולי לפחות תוכל לפרוץ

304
00:13:43,290 --> 00:13:47,340
של לולאה אם ​​אני מבין, טוב, אני בדרך
בעבר היו אהרון יהיה בזה

305
00:13:47,340 --> 00:13:48,310
מיון רשימה מקושרת.

306
00:13:48,310 --> 00:13:50,360
אני לא צריך לבזבז את הזמן שלי מחפש
כל הדרך עד הסוף.

307
00:13:50,360 --> 00:13:51,530
אז זה סביר.

308
00:13:51,530 --> 00:13:54,710
אחרת, למה שאולי תרצה להוסיף
שם התנגש ב

309
00:13:54,710 --> 00:13:56,660
תחילתה של הרשימה?

310
00:13:56,660 --> 00:13:57,397
מה זה?

311
00:13:57,397 --> 00:13:58,680
>> קהל: [לא ברור].

312
00:13:58,680 --> 00:14:00,820
>> דוד Malan: זה יכול לקחת זמן רב
כדי להגיע לסוף הרשימה.

313
00:14:00,820 --> 00:14:02,490
ואכן, יותר ויותר ארוך.

314
00:14:02,490 --> 00:14:04,920
שמות נוספים שאתה מוסיף
תתחיל עם, שכבר

315
00:14:04,920 --> 00:14:06,280
שרשרת הוא הולכת לקבל.

316
00:14:06,280 --> 00:14:07,890
עוד שמקושר
רשימה הוא הולכת לקבל.

317
00:14:07,890 --> 00:14:09,420
אז אתה באמת רק
מבזבז את הזמן שלך.

318
00:14:09,420 --> 00:14:14,070
אולי עדיף לך שמירה
זמן החדרה מתמיד, גדול O של 1,

319
00:14:14,070 --> 00:14:18,470
על ידי הצבת השם מתנגש בתמיד
תחילתה של הרשימה המקושרת,

320
00:14:18,470 --> 00:14:21,230
ולא לדאוג כל כך הרבה
על מיון.

321
00:14:21,230 --> 00:14:22,600
>> מה התשובה הטובה ביותר?

322
00:14:22,600 --> 00:14:23,320
זה לא ברור.

323
00:14:23,320 --> 00:14:26,140
זה סוג של תלוי במה
החלוקה היא, מהו הדפוס

324
00:14:26,140 --> 00:14:27,850
מהשמות שאתה מכניס.

325
00:14:27,850 --> 00:14:29,430
זה לא בהכרח
תשובה ברורה.

326
00:14:29,430 --> 00:14:33,100
אבל כאן, שוב, הוא
הזדמנות עיצוב.

327
00:14:33,100 --> 00:14:37,220
>> אז לאחר מכן הסתכל על הדבר הזה, שבי
היא באמת ההזדמנות הגדולה האחרת

328
00:14:37,220 --> 00:14:38,180
עבור p-סט 6.

329
00:14:38,180 --> 00:14:41,770
ומבין, אם יש לך כבר,
צלילות Zamyla לשני אלה, חשיש

330
00:14:41,770 --> 00:14:43,260
שולחנות ומנסה, ביתר פירוט.

331
00:14:43,260 --> 00:14:45,630
וההדרכה בוידאו היא
מוטבע במפרט P-סט.

332
00:14:45,630 --> 00:14:46,590
זה היה trie -

333
00:14:46,590 --> 00:14:51,670
T-R-I-E. ומה שהיה מעניין
זה היה שהזמן פועל

334
00:14:51,670 --> 00:14:59,510
בחיפוש אחר שם, כמו מקסוול
בפעם האחרונה, הייתה גדול O של מה?

335
00:14:59,510 --> 00:15:01,040
מה זה?

336
00:15:01,040 --> 00:15:01,920
>> קהל: מספר האותיות.

337
00:15:01,920 --> 00:15:02,550
>> דוד Malan: מספר האותיות.

338
00:15:02,550 --> 00:15:03,210
שמעתי את שני דברים.

339
00:15:03,210 --> 00:15:04,630
מספר האותיות ובזמן קבוע.

340
00:15:04,630 --> 00:15:05,540
אז בואו נלך עם זה ראשון.

341
00:15:05,540 --> 00:15:06,410
מספר האותיות.

342
00:15:06,410 --> 00:15:10,195
ובכן, מבנה נתונים זה, כזכור, הוא
כמו עץ, עץ משפחה, כל אחד

343
00:15:10,195 --> 00:15:12,860
צמתים שמורכבים ממערכים.

344
00:15:12,860 --> 00:15:16,300
ומערכים אלו הם מצביעים ל
צמתים אחרים מסוג זה, או אחר, כגון

345
00:15:16,300 --> 00:15:17,670
מערכים בעץ.

346
00:15:17,670 --> 00:15:22,890
>> אז אם אנחנו רוצים אז כדי לקבוע
אם מקסוול הוא כאן, אני יכול ללכת

347
00:15:22,890 --> 00:15:26,890
למערך הראשון, בחלקו העליון של
העץ, השורש כביכול, החלק העליון של

348
00:15:26,890 --> 00:15:30,521
trie, ולאחר מכן בצעתי את המצביע מ ',
לאחר מכן מצביע, אז X,

349
00:15:30,521 --> 00:15:31,710
W, E, L, l.

350
00:15:31,710 --> 00:15:34,910
ואז כשאני רואה כמה סמל מיוחד,
מסומן כאן כמשולש.

351
00:15:34,910 --> 00:15:38,480
בקוד תראה שאנו מציעים לך
מיושם כבול, רק אומר כן

352
00:15:38,480 --> 00:15:40,540
או לא, מילה עוצרת כאן.

353
00:15:40,540 --> 00:15:45,270
>> ובכן, ברגע שעברנו לM-X--W-E-L-L,
מרגיש כמו שבע, אולי

354
00:15:45,270 --> 00:15:48,910
שמונה אם תלכו אחד בעברו, שמונה
צעדים כדי למצוא מקסוול.

355
00:15:48,910 --> 00:15:53,050
או בואו נקראים לזה ק 'אבל זוכר שעבר
זמן, אני טענתי שאם יש

356
00:15:53,050 --> 00:15:57,540
מציאותי אורך מרבי על
מילה, כמו דמויות של 40 ומשהו,

357
00:15:57,540 --> 00:16:00,810
אורך מרבי מרמז
ערך קבוע.

358
00:16:00,810 --> 00:16:05,770
אז באמת, כן, זה גדול מבחינה טכנית O
של 8 או 7, או O הגדול באמת של ק 'אבל

359
00:16:05,770 --> 00:16:09,420
אם יש כובע סופי על מה
K יכול להיות, זה קבוע.

360
00:16:09,420 --> 00:16:12,080
ואז זה גדול O של 1 ב
סופו של היום.

361
00:16:12,080 --> 00:16:13,040
>> לא בעולם האמיתי.

362
00:16:13,040 --> 00:16:15,960
לא כשאתה בעצם להתחיל לראות
השעון שלך כמו הריצה של התכנית שלך.

363
00:16:15,960 --> 00:16:20,690
זה בהחלט הולך להיות קצת
איטי יותר מאשר באמת מתמדת

364
00:16:20,690 --> 00:16:21,840
פעם בצעד אחד.

365
00:16:21,840 --> 00:16:25,540
זה הולך להיות שבעה או שמונה שלבים,
אבל עדיין זה הרבה, הרבה יותר טוב

366
00:16:25,540 --> 00:16:30,080
מאלגוריתם כמו גדול O של n כי
תלוי בגודל של מה שיש ב

367
00:16:30,080 --> 00:16:31,220
מבנה הנתונים.

368
00:16:31,220 --> 00:16:34,970
>> שימו לב ליתרון כאן הוא שאנחנו יכולים להכניס
מיליון שמות נוספים לזה

369
00:16:34,970 --> 00:16:38,170
מבנה נתונים, אבל כמה צעדים יותר
זה הולך לקחת לנו למצוא

370
00:16:38,170 --> 00:16:40,480
מקסוול במקרה כזה?

371
00:16:40,480 --> 00:16:40,780
אף אחד.

372
00:16:40,780 --> 00:16:41,820
הוא לא נפגע.

373
00:16:41,820 --> 00:16:45,480
ועד היום, אני לא חושב שראינו
דוגמה למבנה נתונים או

374
00:16:45,480 --> 00:16:48,560
אלגוריתם שהיה לחלוטין
אינם מושפע חיצונית

375
00:16:48,560 --> 00:16:50,040
התנהגויות כאלה.

376
00:16:50,040 --> 00:16:51,160
אבל זה לא יכול להיות מדהים.

377
00:16:51,160 --> 00:16:52,900
זה לא יכול להיות הפתרון היחיד
עבור P-הסט

378
00:16:52,900 --> 00:16:53,570
>> וזה לא.

379
00:16:53,570 --> 00:16:55,980
זה לא בהכרח את הנתונים
מבנה שאתה צריך להימשך ל,

380
00:16:55,980 --> 00:16:58,220
כי כמו שולחנות חשיש, איזון.

381
00:16:58,220 --> 00:17:00,500
מה המחיר שאתה משלם כאן?

382
00:17:00,500 --> 00:17:00,940
זיכרון.

383
00:17:00,940 --> 00:17:02,890
אני מתכוון, זה זוועתי
כמות הזיכרון.

384
00:17:02,890 --> 00:17:05,569
ואתה לא ממש יכול לראות את זה כאן, כי
המחבר של תמונה זו

385
00:17:05,569 --> 00:17:09,420
ברור שקטום כל המערכים,
ואנחנו לא רואים הרבה ושל

386
00:17:09,420 --> 00:17:12,700
B ו-C של של וQ של Y ושל
וZ של במערכים אלה.

387
00:17:12,700 --> 00:17:13,630
אבל הם שם.

388
00:17:13,630 --> 00:17:17,660
>> כל אחד מצומת הללו הוא מערך שלם
של כ -26 או יותר, כל אחד מבתים

389
00:17:17,660 --> 00:17:19,170
המייצג את מכתב.

390
00:17:19,170 --> 00:17:22,920
27 במקרה שלנו, כך שנוכל לתמוך
גרשיים בסט הבעיה.

391
00:17:22,920 --> 00:17:27,030
אז מבנה נתונים זה הוא באמת,
ממש צפוף ורחב.

392
00:17:27,030 --> 00:17:30,880
וזה לבדו עשוי בסופו של האטה
דברים למטה, או לפחות עולים לך

393
00:17:30,880 --> 00:17:32,240
הרבה יותר מקום.

394
00:17:32,240 --> 00:17:34,020
אבל שוב, אנחנו יכולים לצייר
השוואות כאן.

395
00:17:34,020 --> 00:17:39,190
>> כזכור, לפני כמה זמן, שהשגנו הרבה יותר
זמן פועל יותר מרגש במיון

396
00:17:39,190 --> 00:17:42,880
כאשר אנו משתמשים בסוג המיזוג, אבל המחיר
שילמנו כדי להשיג n log n למיזוג

397
00:17:42,880 --> 00:17:46,930
הסוג נדרש כי אנחנו מבלים
מה יותר משאבים?

398
00:17:46,930 --> 00:17:47,690
יותר מקום.

399
00:17:47,690 --> 00:17:50,530
היינו זקוקים למערך משני
להעתיק אנשים ל, בדיוק כמו

400
00:17:50,530 --> 00:17:51,620
שעשינו כאן על במה.

401
00:17:51,620 --> 00:17:55,880
אז שוב, אין מנצחים ברורים,
אבל רק עיצוב סובייקטיבי

402
00:17:55,880 --> 00:17:57,710
קבלת החלטות.

403
00:17:57,710 --> 00:17:58,060
>> בסדר.

404
00:17:58,060 --> 00:17:59,130
אז מה דעתך על זה?

405
00:17:59,130 --> 00:18:02,050
כל מי שמכיר בה D-הול?

406
00:18:02,050 --> 00:18:02,440
אישור.

407
00:18:02,440 --> 00:18:03,170
אז שלושתנו לעשות.

408
00:18:03,170 --> 00:18:03,750
בית מאת'ר.

409
00:18:03,750 --> 00:18:05,070
אז זה לאוכל של מאת'ר.

410
00:18:05,070 --> 00:18:09,650
אני מתערב שיש את כל חדרי האוכל
ערימות של מגשים כמו זה.

411
00:18:09,650 --> 00:18:11,950
ואת זה הוא למעשה נציג
של משהו שיש לנו

412
00:18:11,950 --> 00:18:13,050
ברור שראה כבר.

413
00:18:13,050 --> 00:18:14,850
אנחנו קראנו לזה פשוטו כמשמעו מחסנית.

414
00:18:14,850 --> 00:18:18,970
והמחסנית, במונחים שלך
הזיכרון של המחשב, שבו עוברים הנתונים

415
00:18:18,970 --> 00:18:20,460
אילו פונקציות להיקרא.

416
00:18:20,460 --> 00:18:23,410
>> לדוגמה, אילו סוגים של דברים הולכים
על הערימה בגין

417
00:18:23,410 --> 00:18:27,420
פריסת זיכרון שדנו
בשבועות האחרונים?

418
00:18:27,420 --> 00:18:28,736
מה זה?

419
00:18:28,736 --> 00:18:29,670
>> קהל: שיחות לפונקציות.

420
00:18:29,670 --> 00:18:30,260
>> דוד Malan: אני מצטער.

421
00:18:30,260 --> 00:18:31,210
>> קהל: שיחות לפונקציות.

422
00:18:31,210 --> 00:18:33,590
>> דוד Malan: שיחות לפונקציות, אבל
באופן ספציפי, מה יש בפנים של כל אחד

423
00:18:33,590 --> 00:18:35,340
המסגרות האלה?

424
00:18:35,340 --> 00:18:37,220
אילו סוגים של דברים?

425
00:18:37,220 --> 00:18:37,460
כן.

426
00:18:37,460 --> 00:18:38,500
אז משתנים מקומיים.

427
00:18:38,500 --> 00:18:43,080
בכל פעם שהיינו צריכים אחסון מקומי כלשהי,
כמו ויכוח, או int i, או int

428
00:18:43,080 --> 00:18:45,940
טמפ ', או מה שלא מקומי
משתנה, אנחנו כבר

429
00:18:45,940 --> 00:18:47,210
לשים את זה בערימה.

430
00:18:47,210 --> 00:18:49,610
ואנחנו קוראים לזה ערימה כי
רעיון של שכבות ש.

431
00:18:49,610 --> 00:18:52,940
פשוט סוג של משחקים עם מציאות,
המושג מהם.

432
00:18:52,940 --> 00:18:56,650
>> אבל מתברר שאפשר גם ערימה
ניתן לראות כמבנה נתונים,

433
00:18:56,650 --> 00:19:00,110
חלופה למערך, אלטרנטיבי
לרשימה מקושרת.

434
00:19:00,110 --> 00:19:02,770
משהו רעיוני יותר מעניין
כי עדיין יכול להיות

435
00:19:02,770 --> 00:19:06,030
מיושם באמצעות אחת מאלה
דברים, אבל זה סוג של שונה

436
00:19:06,030 --> 00:19:09,140
מבנה נתונים תומך, באמת,
רק שתי פעולות.

437
00:19:09,140 --> 00:19:11,000
אבל אתה יכול להוסיף על מגדלת
תכונות מאלה.

438
00:19:11,000 --> 00:19:12,180
אבל אלה הם היסודות -

439
00:19:12,180 --> 00:19:13,510
לדחוף ופופ.

440
00:19:13,510 --> 00:19:19,240
>> והרעיון הוא עם ערימה שאם אני
יש כאן, עם או בלי אננברג

441
00:19:19,240 --> 00:19:22,880
ידיעה, מגש מחדר הסמוך
עם המספר 9 על זה.

442
00:19:22,880 --> 00:19:23,870
אז רק int.

443
00:19:23,870 --> 00:19:26,990
ואני רוצה לדחוף את זה על הנתונים
מבנה, אשר כיום הוא ריק.

444
00:19:26,990 --> 00:19:28,790
חשוב על זה בתחתית הערימה.

445
00:19:28,790 --> 00:19:33,150
הייתי דוחף את המספר הזה על 9
מחסנית, ועכשיו זה ממש שם.

446
00:19:33,150 --> 00:19:36,040
>> אבל הדבר הכי המעניין על ערימה
הוא שאם עכשיו אני רוצה לדחוף

447
00:19:36,040 --> 00:19:40,210
ערך אחר, כמו 17, ואני דוחף
זה על גבי ערימה, אני הולך לעשות

448
00:19:40,210 --> 00:19:43,290
אינטואיטיבי דבר היחיד, אני פשוט הולך
כדי לשים את זה נכון שבו אנו בני האדם

449
00:19:43,290 --> 00:19:45,180
הייתי נוטה לשים אותו, על העליונה.

450
00:19:45,180 --> 00:19:48,850
אבל מה שהמעניין עכשיו
הוא, איך אני מקבל בשעה 9?

451
00:19:48,850 --> 00:19:50,670
אתה יודע, אני עושה לא בלי מאמץ.

452
00:19:50,670 --> 00:19:54,070
>> אז מה שמעניין
ערימה היא שעל ידי עיצוב,

453
00:19:54,070 --> 00:19:56,330
זה מבנה נתונים LIFO.

454
00:19:56,330 --> 00:19:59,680
דרך מטופשת לתאר
אחרון, את הראשון.

455
00:19:59,680 --> 00:20:03,280
אז המספר האחרון ב
בשלב זה היה בן 17.

456
00:20:03,280 --> 00:20:07,540
אז אם אני רוצה להסתלק משהו
של המחסנית, זה יכול להיות 17 בלבד.

457
00:20:07,540 --> 00:20:11,890
אז יש צו עשה של
הפעילות כאן, שבו הפריט האחרון

458
00:20:11,890 --> 00:20:14,260
בחייב להיות אחד מתוך הראשון.

459
00:20:14,260 --> 00:20:16,440
ומכאן ראשי התיבות, LIFO.

460
00:20:16,440 --> 00:20:19,160
>> אז למה זה יכול להיות שימושי?

461
00:20:19,160 --> 00:20:22,690
האם ההקשרים שבם שהיית
רוצה מבנה נתונים כזה?

462
00:20:22,690 --> 00:20:24,810
ובכן, זה בהחלט היה מועיל
חלק פנימי של מחשב.

463
00:20:24,810 --> 00:20:29,050
מערכות הפעלה באופן ברור כל כך להשתמש בזה
סוג של מבנה נתונים לערימות.

464
00:20:29,050 --> 00:20:32,800
אנחנו גם רואים אותו הרעיון
כשמדובר בדפי אינטרנט.

465
00:20:32,800 --> 00:20:35,890
אז השבוע והשבוע הבא, ומעבר לו,
וכפי שאתה להתחיל ביישום אינטרנט

466
00:20:35,890 --> 00:20:39,490
דפים בשפה שנקראים HTML, אתה יכול
בעצם להשתמש במבנה נתונים כמו

467
00:20:39,490 --> 00:20:42,690
זה כדי לקבוע אם הדף
הוא מעוצב בצורה נכונה.

468
00:20:42,690 --> 00:20:47,170
בגלל שאנחנו תראו את כל דפי האינטרנט לעקוב
סוג של היררכיה, כניסה

469
00:20:47,170 --> 00:20:52,030
כי, בסופו של היום, יהיה
מבנה עץ מתחת למכסת המנוע.

470
00:20:52,030 --> 00:20:53,620
אז עוד על כך בקצת.

471
00:20:53,620 --> 00:20:56,560
>> אבל לעת עתה, בואו נציע ל
רגע, איך אפשר ללכת על

472
00:20:56,560 --> 00:20:58,830
המייצג את מה שהיא ערימה?

473
00:20:58,830 --> 00:21:03,370
הרשה לי להציע שאנחנו ליישם
מחסנית עם קוד כזה.

474
00:21:03,370 --> 00:21:07,990
אז ערימה הולכת להיות בתוכו
שני דברים, מערך, מגשים, הנקרא

475
00:21:07,990 --> 00:21:09,510
רק כדי להיות בקנה אחד עם ההדגמה.

476
00:21:09,510 --> 00:21:12,660
וכל אחד מהפריטים שבמערך
הולך להיות סוג int.

477
00:21:12,660 --> 00:21:14,740
והקיבולת היא ככל הנראה מה?

478
00:21:14,740 --> 00:21:18,796
כי אני כבר לא נכתב
הגדרה מלאה כאן.

479
00:21:18,796 --> 00:21:21,535
>> זה כנראה המקסימום
גודלו של המערך.

480
00:21:21,535 --> 00:21:25,150
וזה כנראה הוכרז כחדה
להגדיר בחלק העליון של הקובץ, כמה

481
00:21:25,150 --> 00:21:28,450
סוג של קבועה כפי שמשתמע
ההיוון בלבד.

482
00:21:28,450 --> 00:21:32,250
אז איפשהו קיבולת מוגדרת
כגודל המרבי האפשרי.

483
00:21:32,250 --> 00:21:35,590
בינתיים, בתוך מבנה הנתונים
המכונה מחסנית תהיה

484
00:21:35,590 --> 00:21:38,630
להיות שלם ידוע רק
פשוט כגודל.

485
00:21:38,630 --> 00:21:43,400
>> אז אם אני היה לייצג את זה עכשיו
ציורי, בואו נניח שזה

486
00:21:43,400 --> 00:21:48,070
כל קופסה שחורה מייצגת הערימה שלי.

487
00:21:48,070 --> 00:21:50,070
בתוכו הוא שני משתנים.

488
00:21:50,070 --> 00:21:54,780
אז אני הולך לצייר
אחת ראשונה כגודל.

489
00:21:54,780 --> 00:21:57,420
והשנייה אני הולך
לצייר כמו מערך.

490
00:21:57,420 --> 00:22:01,060
>> אבל רק כדי לשמור על דברים מסודרים,
בדרך כלל הייתי לצייר כמו מערך

491
00:22:01,060 --> 00:22:04,910
את זה, אבל זה סוג של נחמד
אם אנו מתאימים את המציאות, או

492
00:22:04,910 --> 00:22:06,230
להתאים את המודל המנטלי.

493
00:22:06,230 --> 00:22:12,880
אז תן לי במקום לצייר את המערך
במאונך, וזה רק, שוב,

494
00:22:12,880 --> 00:22:13,840
ביצועו של האמן.

495
00:22:13,840 --> 00:22:16,610
לא ממש משנה מה זה
הוא מתחת למכסת המנוע.

496
00:22:16,610 --> 00:22:20,350
ואנו אומרים, כי, כברירת מחדל,
הקיבולת הולכת להיות שלוש.

497
00:22:20,350 --> 00:22:23,480
אז זה יהיה 0 מיקום, זה
יהיה מיקום 1, זה

498
00:22:23,480 --> 00:22:25,740
יהיה מיקום 2.

499
00:22:25,740 --> 00:22:29,330
>> אם אני לשחד עם כדור לחץ, היית
מישהו רוצה לבוא ולרוץ

500
00:22:29,330 --> 00:22:30,870
מנהלים כאן לרגע?

501
00:22:30,870 --> 00:22:31,960
אוקיי, ראה את היד שלך ראשון.

502
00:22:31,960 --> 00:22:33,950
בואו נעלה.

503
00:22:33,950 --> 00:22:36,500
בסדר.

504
00:22:36,500 --> 00:22:38,760
אז אני מאמין שזה סטיבן.

505
00:22:38,760 --> 00:22:40,035
בואו נעלה.

506
00:22:40,035 --> 00:22:40,770
בסדר.

507
00:22:40,770 --> 00:22:46,760
>> אבל נניח שעכשיו אנחנו אחורה לראשוניים
מצבו של העולם שבו אני

508
00:22:46,760 --> 00:22:52,180
רק הכריז מחסנית, וזה
הולך להיות מקיבולת שלוש.

509
00:22:52,180 --> 00:22:54,470
אבל גודל טרם נקבע.

510
00:22:54,470 --> 00:22:56,100
מגשים טרם נקבע.

511
00:22:56,100 --> 00:22:57,300
ראשון אז כמה שאלות.

512
00:22:57,300 --> 00:23:01,310
ותן לי לתת לך מיקרופון, כך שתוכל
לקחת חלק פעיל יותר בזה.

513
00:23:01,310 --> 00:23:05,190
>> אז מה יש בתוכו בגודל ברגע זה
בזמן אם כל מה שעשיתי הוא

514
00:23:05,190 --> 00:23:09,340
הכריז עם מחסנית
שורה אחת של קוד?

515
00:23:09,340 --> 00:23:10,100
>> סטיבן: לא הרבה.

516
00:23:10,100 --> 00:23:12,080
>> דוד Malan: אוקיי, לא הרבה.

517
00:23:12,080 --> 00:23:14,410
האם אנחנו יודעים מה יש בפנים של גודל,
אנחנו יודעים מה יש בפנים

518
00:23:14,410 --> 00:23:16,330
של מערך זה כאן?

519
00:23:16,330 --> 00:23:18,630
>> סטיבן: קוד אקראי פשוט, נכון?

520
00:23:18,630 --> 00:23:20,220
פשוט -

521
00:23:20,220 --> 00:23:23,230
>> מלאן דוד: כן, אני הולך
קוראים לזה קוד, אבל אקראי -

522
00:23:23,230 --> 00:23:23,820
>> סטיבן: דברים.

523
00:23:23,820 --> 00:23:28,290
>> דוד Malan: דברים כמו אקראי

524
00:23:28,290 --> 00:23:28,870
>> סטיבן: חתיכות.

525
00:23:28,870 --> 00:23:29,530
>> דוד Malan: ביט, נכון?

526
00:23:29,530 --> 00:23:31,190
אז ערכי אשפה, נכון?

527
00:23:31,190 --> 00:23:33,470
אז תמורות של ספרות 0 ו 1 של.

528
00:23:33,470 --> 00:23:35,920
שרידים של שימושים קודמים
מהזיכרון הזה.

529
00:23:35,920 --> 00:23:38,150
ואנחנו לא באמת יודעים מה הערכים
הם, ולכן אנחנו בדרך כלל למשוך אותם

530
00:23:38,150 --> 00:23:38,930
כסימני שאלה.

531
00:23:38,930 --> 00:23:41,990
>> אז הדבר הראשון שאנחנו כנראה
הולך רוצה לעשות כאן -

532
00:23:41,990 --> 00:23:46,630
ותנו לי לתת בתחום זה בתוך
משם שם - מגשים.

533
00:23:46,630 --> 00:23:49,540
מה אנחנו צריכים מן הסתם לאתחל
גודל לאם אנחנו רוצים

534
00:23:49,540 --> 00:23:51,040
להתחיל להשתמש במחסנית זה?

535
00:23:51,040 --> 00:23:53,070
>> סטיבן: מגש הוא תת 3.

536
00:23:53,070 --> 00:23:53,910
>> דוד Malan: אז, בסדר.

537
00:23:53,910 --> 00:23:56,710
כדי להיות ברור, קיבולת מוצהרת
במקומות אחרים כמו שלוש.

538
00:23:56,710 --> 00:23:58,570
וזה מה שאני השתמשתי
כדי להקצות את המערך.

539
00:23:58,570 --> 00:24:03,535
גודל הולך להתייחס לכמה
מגשים כרגע על הערימה.

540
00:24:03,535 --> 00:24:03,880
>> סטיבן: אפס.

541
00:24:03,880 --> 00:24:04,460
>> דוד Malan: אז זה צריך להיות אפס.

542
00:24:04,460 --> 00:24:07,760
אז קדימה, ועם כל אצבע,
לצייר בגודל אפס.

543
00:24:07,760 --> 00:24:08,440
בסדר.

544
00:24:08,440 --> 00:24:10,920
אז עכשיו, מה שבפנים זה
כאן, אנחנו לא יודעים.

545
00:24:10,920 --> 00:24:12,160
אלה הם באמת רק ערכי אשפה.

546
00:24:12,160 --> 00:24:14,800
כדי שנוכל לצייר את סימני שאלה, אבל
בואו לשמור על הלוח נקי לעת עתה

547
00:24:14,800 --> 00:24:16,300
כי זה לא משנה
מה יש שם.

548
00:24:16,300 --> 00:24:19,130
אנחנו לא צריכים לאתחל את המערך
לשום דבר, כי אם אנו יודעים כי

549
00:24:19,130 --> 00:24:23,100
גודל המחסנית הוא אפס, ובכן, אנחנו
לא צריך להיות מחפש בכל דבר ב

550
00:24:23,100 --> 00:24:25,590
מערך זה בכל מקרה ב
נקודה זו בזמן.

551
00:24:25,590 --> 00:24:29,970
>> אז עכשיו נניח שאני דוחף
מספר 9 על המחסנית.

552
00:24:29,970 --> 00:24:33,750
כיצד עלינו לעדכן את מבנה הנתונים
בתוך הקופסה השחורה הזו?

553
00:24:33,750 --> 00:24:35,540
מה ערכים צריכים לשנות?

554
00:24:35,540 --> 00:24:36,200
>> סטיבן: בתוך -

555
00:24:36,200 --> 00:24:37,400
הגודל?

556
00:24:37,400 --> 00:24:37,650
>> דוד Malan: אישור.

557
00:24:37,650 --> 00:24:38,770
גודל צריך להיות מה?

558
00:24:38,770 --> 00:24:39,580
>> סטיבן: גודל יהיה אחד.

559
00:24:39,580 --> 00:24:39,870
>> דוד Malan: אישור.

560
00:24:39,870 --> 00:24:41,110
אז גודל צריך להיות אחד.

561
00:24:41,110 --> 00:24:42,540
אז אתה יכול לעשות את זה בכמה דרכים.

562
00:24:42,540 --> 00:24:46,920
תן לי לתת לך, עכשיו שלך
אצבע היא מחק.

563
00:24:46,920 --> 00:24:47,260
בסדר.

564
00:24:47,260 --> 00:24:49,960
אז עכשיו האצבע שלך היא מברשת.

565
00:24:49,960 --> 00:24:50,330
בסדר.

566
00:24:50,330 --> 00:24:52,820
ועכשיו מה עוד יש לשנות,
כמובן, במבנה נתונים?

567
00:24:52,820 --> 00:24:57,060
>> סטיבן: אנחנו הולכים מ
תחתון עד 9.

568
00:24:57,060 --> 00:24:57,760
>> דוד Malan: 9.

569
00:24:57,760 --> 00:24:58,420
בסדר, טוב.

570
00:24:58,420 --> 00:25:01,550
אז עדיין לא משנה מה השעה
מקום אחד או שתיים, כי הם

571
00:25:01,550 --> 00:25:04,520
ערכי זבל, אבל אנחנו לא צריכים לטרוח
מחפש שם בגלל גודל הוא

572
00:25:04,520 --> 00:25:07,540
אומר לנו שרק האלמנט הראשון
למעשה הוא לגיטימי.

573
00:25:07,540 --> 00:25:10,400
אז עכשיו אני דוחף 17 על גבי רשימה.

574
00:25:10,400 --> 00:25:11,830
מה קורה לתמונה הזאת?

575
00:25:11,830 --> 00:25:14,720
>> סטיבן: אז גודל הוא הולך לשניים.

576
00:25:14,720 --> 00:25:15,300
>> דוד Malan: אישור.

577
00:25:15,300 --> 00:25:16,070
אתה מחק -

578
00:25:16,070 --> 00:25:16,810
אופס.

579
00:25:16,810 --> 00:25:18,026
אתה מחק.

580
00:25:18,026 --> 00:25:18,840
>> סטיבן: מחק.

581
00:25:18,840 --> 00:25:19,720
>> דוד Malan: אתה מברשת.

582
00:25:19,720 --> 00:25:20,560
>> סטיבן: מברשת.

583
00:25:20,560 --> 00:25:20,920
>> דוד Malan: אישור.

584
00:25:20,920 --> 00:25:21,600
ומה עוד?

585
00:25:21,600 --> 00:25:22,600
>> סטיבן: ואז אנחנו -

586
00:25:22,600 --> 00:25:22,915
>> דוד Malan: אנחנו דחפו 17.

587
00:25:22,915 --> 00:25:24,760
>> סטיבן: אנחנו מקל על גבי 17, ולכן -

588
00:25:24,760 --> 00:25:25,710
>> דוד Malan: בסדר, טוב.

589
00:25:25,710 --> 00:25:27,040
>> סטיבן: - שחררת אותו.

590
00:25:27,040 --> 00:25:27,530
>> דוד Malan: בסדר.

591
00:25:27,530 --> 00:25:27,940
זה מתחיל להיות קל.

592
00:25:27,940 --> 00:25:29,300
אני לא הולך לעזור לך הפעם.

593
00:25:29,300 --> 00:25:30,510
Push 22.

594
00:25:30,510 --> 00:25:31,720
>> סטיבן: בוצע.

595
00:25:31,720 --> 00:25:34,870
איך להיות מחק.

596
00:25:34,870 --> 00:25:37,340
אני הופך למברשת.

597
00:25:37,340 --> 00:25:39,340
ואז אני מכניס 22.

598
00:25:39,340 --> 00:25:40,100
>> דוד Malan: 22.

599
00:25:40,100 --> 00:25:40,620
מצוין.

600
00:25:40,620 --> 00:25:41,380
אז עוד פעם אחת.

601
00:25:41,380 --> 00:25:44,280
עכשיו אני הולך לדחוף
על גבי ערימת 26.

602
00:25:44,280 --> 00:25:46,350
>> סטיבן: או.

603
00:25:46,350 --> 00:25:50,278
אוי.

604
00:25:50,278 --> 00:25:52,520
אתה באמת תפסת אותי לא מוכן.

605
00:25:52,520 --> 00:25:53,703
>> דוד Malan: אתה לא
רואה את זה בא?

606
00:25:53,703 --> 00:25:55,930
>> סטיבן: אני לא ראיתי את זה בא.

607
00:25:55,930 --> 00:25:58,756
האם אנו יכולים קיבולת מחדש ראשונית?

608
00:25:58,756 --> 00:25:59,790
>> דוד Malan: זאת שאלה טובה.

609
00:25:59,790 --> 00:26:02,360
אז יש לנו סוג של ציירו את עצמנו
בפינה כאן.

610
00:26:02,360 --> 00:26:06,740
שם הוא באמת לא טוב החוצה לסטיבן
כי אנחנו כבר הוקצו מערך זה

611
00:26:06,740 --> 00:26:09,130
סטטי, כביכול, בתוך
של מבנה הנתונים.

612
00:26:09,130 --> 00:26:12,170
ואנחנו כבר מקודדים למעשה קשים
שזה יהיה בגודל שלוש.

613
00:26:12,170 --> 00:26:14,170
אז אנחנו לא באמת יכולים להקצות מחדש את זה.

614
00:26:14,170 --> 00:26:20,020
>> אנחנו יכולים אם נחזור ב, אנחנו
הגדיר מחדש מגשים להיות מצביע כי

615
00:26:20,020 --> 00:26:22,300
אז אנחנו משתמשים ביד זיכרון לmalloc ל.

616
00:26:22,300 --> 00:26:25,050
כי אם יש לנו זיכרון מ
הערימה באמצעות malloc, אנחנו

617
00:26:25,050 --> 00:26:26,430
אז אפשר לשחרר אותו.

618
00:26:26,430 --> 00:26:29,630
אבל לפני שמשחררים אותו, אנחנו יכולים
להקצות מחדש את נתח גדול יותר של זיכרון,

619
00:26:29,630 --> 00:26:31,330
לעדכן את המצביע, וכן הלאה.

620
00:26:31,330 --> 00:26:33,500
אבל לעת עתה, זה ממש
הטוב ביותר שאנחנו יכולים לעשות.

621
00:26:33,500 --> 00:26:36,360
לדחוף ופופ הולכים ככל הנראה
יש לאותת איזו שגיאה.

622
00:26:36,360 --> 00:26:40,270
>> כך למשל, היישום שלנו
של דחיפה יכולה לחזור בו בול

623
00:26:40,270 --> 00:26:42,390
חזר בעבר אמיתי, נכון, אמיתי.

624
00:26:42,390 --> 00:26:48,390
אבל בפעם הרביעית, זה הולך להיות
לחזור שווא, למשל.

625
00:26:48,390 --> 00:26:48,540
בסדר.

626
00:26:48,540 --> 00:26:49,540
עשה טוב מאוד.

627
00:26:49,540 --> 00:26:50,060
מזל טוב.

628
00:26:50,060 --> 00:26:52,160
אתה ראוי לכדור הלחץ שלך היום.

629
00:26:52,160 --> 00:26:53,110
>> [מחיאות כפות]

630
00:26:53,110 --> 00:26:54,382
>> סטיבן: תודה לך.

631
00:26:54,382 --> 00:26:55,680
>> דוד Malan: תודה לך.

632
00:26:55,680 --> 00:26:59,740
אוקיי, אז זה כנראה לא הרבה
של צעד קדימה, נכון?

633
00:26:59,740 --> 00:27:01,410
אנחנו תאר מבנה נתונים זה.

634
00:27:01,410 --> 00:27:02,320
זה היה משכנע, נכון?

635
00:27:02,320 --> 00:27:03,200
מערכות הפעלה אוהבים את זה.

636
00:27:03,200 --> 00:27:06,360
ככל הנראה, באינטרנט יכול לעשות שימוש בזה,
ויישומים אחרים עדיין.

637
00:27:06,360 --> 00:27:10,870
אבל מה מגבלה טיפשית שאנחנו
לגבות לסוג של שני גבולות שבוע

638
00:27:10,870 --> 00:27:12,880
שבו יש לנו מערכים קבועים גודל.

639
00:27:12,880 --> 00:27:15,010
>> אז יש אכן כמה
דרכים שאנחנו יכולים לפתור את זה.

640
00:27:15,010 --> 00:27:18,750
אנחנו יכולים להקצות דינמי מערך,
לא על ידי קשה קידוד אותו כיש לי

641
00:27:18,750 --> 00:27:22,600
עשה כאן, אבל במקום להכריז מחדש
זה, רק שיהיה ברור, כפי

642
00:27:22,600 --> 00:27:23,830
משהו כזה.

643
00:27:23,830 --> 00:27:29,040
מגשים * int, לא להחליט
על יכולת עדיין.

644
00:27:29,040 --> 00:27:35,460
אבל כאשר אני מצהיר מחסנית במקום אחר
בקוד שלי, שאני יכול ואז להתקשר malloc,

645
00:27:35,460 --> 00:27:38,250
לקבל את הכתובת של נתח של
זיכרון, ויכולתי להקצות

646
00:27:38,250 --> 00:27:39,980
כי כתובת למגשים.

647
00:27:39,980 --> 00:27:43,340
>> ולאחר מכן, בגלל שזה רק נתח של
זיכרון, אני יכול להמשיך ולהשתמש בריבוע

648
00:27:43,340 --> 00:27:45,450
סימון סוגר בדרך הרגילה.

649
00:27:45,450 --> 00:27:49,020
כי שוב, יש סוג של זה
מקבילה תפקודית של מערכים ו

650
00:27:49,020 --> 00:27:50,820
נתחי הזיכרון שמגיעים
חזרה מmalloc.

651
00:27:50,820 --> 00:27:53,090
אנו יכולים להתייחס לאחד כמו השני
באמצעות חשבון מצביע או

652
00:27:53,090 --> 00:27:54,440
סימון סוגר מרובע.

653
00:27:54,440 --> 00:27:55,660
אז זאת גישה אחת.

654
00:27:55,660 --> 00:28:00,120
>> אבל איך עוד נוכל ליישם את זה
אותו מבנה נתונים, באופן פוטנציאלי?

655
00:28:00,120 --> 00:28:00,280
נכון?

656
00:28:00,280 --> 00:28:04,530
אני מרגישה כאילו אנחנו פשוט לפתור את זה
בעיה כמו לפני שבוע.

657
00:28:04,530 --> 00:28:08,860
מה היה הפתרון לבעיה זו
סטיבן שנתקל?

658
00:28:08,860 --> 00:28:10,370
רשימות קשורות כל כך, נכון.

659
00:28:10,370 --> 00:28:13,410
>> אם הבעיה היא שאנחנו מציירים
את עצמנו לפינה על ידי הקצאה

660
00:28:13,410 --> 00:28:17,580
בזיכרון מעט מדי מראש שאנחנו
אז צריכים להתמודד איכשהו עם, ובכן,

661
00:28:17,580 --> 00:28:19,880
למה לא פשוט למנוע את זה
להוציא לגמרי?

662
00:28:19,880 --> 00:28:26,170
למה לא פשוט להכריז על מגשים להיות
מצביע לצומת, ergo רשימה מקושרת,

663
00:28:26,170 --> 00:28:30,740
ואז פשוט להקצות צמתים חדשים
כל זמן דרוש כדי להתאים סטיבן

664
00:28:30,740 --> 00:28:32,400
מספר לתוך מבנה הנתונים.

665
00:28:32,400 --> 00:28:34,200
>> כך שהתמונה הייתי צריך לשנות.

666
00:28:34,200 --> 00:28:38,220
זה לא הולך להיות נקי וכמו
פשוט כמו שרק מערך של שלושה ints.

667
00:28:38,220 --> 00:28:42,970
עכשיו זה הולך להיות מצביע
struct, וstruct כי הוא הולך

668
00:28:42,970 --> 00:28:44,830
יש לי int ומצביע הבא.

669
00:28:44,830 --> 00:28:47,670
זה הולך להוביל באמצעות מצביע ה
לstruct כזה עוד

670
00:28:47,670 --> 00:28:48,600
struct נוסף כזו.

671
00:28:48,600 --> 00:28:50,560
כך שהתמונה הייתה למעשה
לקבל קצת מבולגן.

672
00:28:50,560 --> 00:28:52,950
ואנחנו היינו קשירת חיצים
את הכל ביחד.

673
00:28:52,950 --> 00:28:55,280
>> אבל זה בסדר, נכון, כי
ראינו איך לעשות את זה.

674
00:28:55,280 --> 00:28:58,180
וברגע שאתה מקבל בנוח
משהו כמו יישום מקושר

675
00:28:58,180 --> 00:29:01,450
רשימה, שתהיה לך לעשות אם אתה
תבחר ליישם שולחן חשיש עם

676
00:29:01,450 --> 00:29:05,120
שרשור נפרד לסט P-6, שאתה יכול
להשתמש בו בתור אבן בניין, או

677
00:29:05,120 --> 00:29:08,870
מרכיב, או בגרד לדבר,
הליך, משהו שאתה מכניס, אתה

678
00:29:08,870 --> 00:29:12,560
יצר פיסת הפאזל שלך
כי אז אתה יכול לעשות שימוש חוזר.

679
00:29:12,560 --> 00:29:17,090
פשרות שכן, אבל פתרונות אפשריים
שבעצם אנחנו לא ראינו קודם.

680
00:29:17,090 --> 00:29:20,560
>> אז לעתים קרובות למדי, אתה רואה את זה בכל
שנה או שנים כאשר משחרר אפל

681
00:29:20,560 --> 00:29:23,060
משהו חדש, ואת כל אנשים המשוגעים
בשורה מחוץ לאפל

682
00:29:23,060 --> 00:29:27,050
חנות כדי לקנותם שוליים
שדרוג בחומרה.

683
00:29:27,050 --> 00:29:30,420
אני אומר את זה, זה בסדר, כי
אני אחד מהאנשים האלה.

684
00:29:30,420 --> 00:29:35,140
אז איזה סוג של מבנה נתונים
עשוי לייצג את המציאות הזו?

685
00:29:35,140 --> 00:29:36,980
>> ובכן, בואו נקראים לזה תור, קו.

686
00:29:36,980 --> 00:29:40,270
אז בריטים היינו קוראים לזה בדרך כלל
תור בכל מקרה, כך שזה שם יפה.

687
00:29:40,270 --> 00:29:44,960
ושתי הפעולות שתור
אתמוך אנחנו נתקשר Enqueue

688
00:29:44,960 --> 00:29:48,900
פעולה ופעולת dequeue,
אשר דומים ב

689
00:29:48,900 --> 00:29:50,120
רוח לדחוף ופופ.

690
00:29:50,120 --> 00:29:54,060
זה פשוט סוג של שונה ב
האמנה, מה שאנחנו קוראים להם.

691
00:29:54,060 --> 00:29:57,680
אבל לEnqueue משהו אומר להוסיף
או להוסיף אותו למבנה הנתונים.

692
00:29:57,680 --> 00:29:59,570
לdequeue פירושו להסיר אותה.

693
00:29:59,570 --> 00:30:05,170
אבל בעוד שמחסנית הייתה נתונים LIFO
מבנה, תור הוא בראשון,

694
00:30:05,170 --> 00:30:06,740
ראשון מתוך מבנה הנתונים.

695
00:30:06,740 --> 00:30:10,050
>> אם אתה האדם הראשון בשורה,
אתה תהיה האדם הראשון שיקבל

696
00:30:10,050 --> 00:30:12,420
מתוך קו ולקנות המכשיר החדש שלך.

697
00:30:12,420 --> 00:30:18,070
תארו לעצמכם איך האנשים האלה קלקול יהיו
אם אפל השתמשה בערימה במקום, ל

698
00:30:18,070 --> 00:30:21,250
למשל, כדי ליישם הקטיף
את הצעצוע החדש שלך.

699
00:30:21,250 --> 00:30:24,310
אז תורים הגיוניים, בהחלט, ו
אנחנו יכולים לחשוב על כל מיני

700
00:30:24,310 --> 00:30:27,480
יישומים, ככל הנראה, לתורים,
במיוחד כאשר אתה רוצה הגינות.

701
00:30:27,480 --> 00:30:30,040
אז איך ייתכן שאנו מיישמים אלה
כמבנה נתונים?

702
00:30:30,040 --> 00:30:33,680
>> ובכן, אני מציע שאולי
צריך לעשות את זה בדרך זו.

703
00:30:33,680 --> 00:30:35,225
אז אני הולך עכשיו יש מספרים.

704
00:30:35,225 --> 00:30:38,190
כך יהיה לנו לשמור את זה פשוט ולא
בהכרח מדבר במונחים של מגשים.

705
00:30:38,190 --> 00:30:40,220
רק מספרים שאנשים קיבל.

706
00:30:40,220 --> 00:30:43,760
הקיבולת הולכת, שוב, לתקן את
מספר כולל של אנשים שיכולים להיות ב

707
00:30:43,760 --> 00:30:46,900
קו זה, כשלושה או
כל דבר אחר ערך.

708
00:30:46,900 --> 00:30:50,760
>> אבל אני מציע שאני צריך לעקוב אחר
לא רק מגודלו של

709
00:30:50,760 --> 00:30:52,370
תור, כמה דברים בו.

710
00:30:52,370 --> 00:30:56,310
אז גודל הוא הנוכחית הגודל, הקיבולת
הוא בגודל המקסימאלי.

711
00:30:56,310 --> 00:30:58,540
רק שוב, מינוח
על ידי אמנה.

712
00:30:58,540 --> 00:31:03,680
למה אני צריך int נוסף בפנים
מתור כדי לעקוב אחר מי ב

713
00:31:03,680 --> 00:31:05,365
מול הקו?

714
00:31:05,365 --> 00:31:07,930

715
00:31:07,930 --> 00:31:10,910
למה אני צריך לעשות את זה במקרה זה?

716
00:31:10,910 --> 00:31:14,750

717
00:31:14,750 --> 00:31:16,190
>> ובכן, איך התמונה הזאת
הולך לשנות?

718
00:31:16,190 --> 00:31:19,280
אני כנראה יכול לעשות שימוש חוזר ביותר
מהתמונה הזאת.

719
00:31:19,280 --> 00:31:21,480
תן לי ללכת קדימה ולמחוק את מה יש כאן.

720
00:31:21,480 --> 00:31:24,580
אנחנו אתן את זה מעט
שם אחר לכאן.

721
00:31:24,580 --> 00:31:28,930
בואו להיפטר מ17, בואו להיפטר
של 9, בואו להיפטר מ3.

722
00:31:28,930 --> 00:31:30,410
ובואו נוסיף עוד דבר אחד.

723
00:31:30,410 --> 00:31:34,710
אני מציע שאני צריך לעקוב אחר
מול הרשימה, וזה רק

724
00:31:34,710 --> 00:31:35,570
הולך להיות int גם כן.

725
00:31:35,570 --> 00:31:36,550
ואנחנו הולכים לשמור את זה פשוט.

726
00:31:36,550 --> 00:31:37,740
לא רשימה מקושרת לעת עתה.

727
00:31:37,740 --> 00:31:40,900
>> אנחנו מודה שאנחנו הולכים
להקפיץ את כנגד מגבלה זו.

728
00:31:40,900 --> 00:31:43,720
אבל מה שאני רוצה לראות
יקרה הפעם?

729
00:31:43,720 --> 00:31:47,240
אז נניח שאני הולך קדימה וראשון
אדם עולה בקנה האחד, ו

730
00:31:47,240 --> 00:31:48,560
זה המספר 9.

731
00:31:48,560 --> 00:31:49,680
יש לנו כדורי לחץ.

732
00:31:49,680 --> 00:31:51,330
האם אני יכול לגנוב, אניח, שניים או שלושה אנשים?

733
00:31:51,330 --> 00:31:52,690
אחת, שתיים, שלוש?

734
00:31:52,690 --> 00:31:53,120
בואו נעלה.

735
00:31:53,120 --> 00:31:56,022
זכות מהחזית, כי
אנחנו נעשה את זה מהר אחד.

736
00:31:56,022 --> 00:31:59,415
>> כל אחד מכם היא עכשיו הולך להיות
נער אוהד בתור באפל.

737
00:31:59,415 --> 00:32:03,970

738
00:32:03,970 --> 00:32:06,210
אתה לא יהיה קבלת חומרה אפל
בסוף למרות שזה.

739
00:32:06,210 --> 00:32:06,500
בסדר.

740
00:32:06,500 --> 00:32:09,430
אז אתה מספר 9, אתה
מספר 17, מספר 22.

741
00:32:09,430 --> 00:32:12,130
אלו הם מספרים שרירותיים, כמו
סטודנט מזהים או מה לא.

742
00:32:12,130 --> 00:32:14,550
ובעוד רגע, בואו נתחיל
כדי להתחיל להוסיף דברים.

743
00:32:14,550 --> 00:32:16,000
ואני ארוץ המנהלים כאן הפעם.

744
00:32:16,000 --> 00:32:19,570
>> אז במקרה הזה, אני כבר אותחל
החזית להיות -

745
00:32:19,570 --> 00:32:22,380
אני בעצם לא ממש אכפת לי מה
קדמי הוא, כי הגודל הוא אפס.

746
00:32:22,380 --> 00:32:24,480
אז זה אולי גם פשוט
יהיה סימן שאלה.

747
00:32:24,480 --> 00:32:26,170
כל אלה הם סימני השאלה.

748
00:32:26,170 --> 00:32:29,880
אז עכשיו אנחנו נתחיל ממש לראות כמה
אנשים עומדים בתור בחנות.

749
00:32:29,880 --> 00:32:33,320
>> אז אם מספר 9, אתה ראשון
יש ב -5 לפנות הבוקר, ללכת קדימה ולהסתדר בשורה,

750
00:32:33,320 --> 00:32:34,210
או בלילה שלפני.

751
00:32:34,210 --> 00:32:34,580
אישור.

752
00:32:34,580 --> 00:32:35,940
אז עכשיו הוא כאן 9.

753
00:32:35,940 --> 00:32:37,940
אז 9 הוא בחלק הקדמי של הרשימה.

754
00:32:37,940 --> 00:32:41,440
אז אני הולך להמשיך ולעדכן
בגודל של הנתונים הנוכחי

755
00:32:41,440 --> 00:32:44,740
מבנה כדי לא להיות 0 עוד,
אבל כדי להיות 1.

756
00:32:44,740 --> 00:32:47,630
אני הולך לשים ב9
מול הרשימה.

757
00:32:47,630 --> 00:32:51,020
תן לי ללכת קדימה ולעבור את המסך
כדי שנוכל לראות אותנו כאן בעבר.

758
00:32:51,020 --> 00:32:53,220
>> ועכשיו מה שאני רוצה
לשים בצד קדמי?

759
00:32:53,220 --> 00:32:56,240
אני הולך לעקוב אחר ה
ראש התור עכשיו

760
00:32:56,240 --> 00:32:58,570
הוא במיקום 0.

761
00:32:58,570 --> 00:33:00,510
משום מה הבא שעומד לקרות?

762
00:33:00,510 --> 00:33:03,000
ובכן, נניח שעכשיו אני Enqueue
17 גם כן.

763
00:33:03,000 --> 00:33:04,510
אז לקפוץ בשורה שם.

764
00:33:04,510 --> 00:33:07,060
ושוב, הסוג של דלת
החנות הולכת להיות כאן.

765
00:33:07,060 --> 00:33:08,700
אז עכשיו אני הוספתי 17.

766
00:33:08,700 --> 00:33:10,810
ואף על פי שהחבר 'ה האלה חסימה
המסך, זה בסדר,

767
00:33:10,810 --> 00:33:12,300
כי אנחנו יכולים לראות את זה כאן.

768
00:33:12,300 --> 00:33:12,910
סליחה.

769
00:33:12,910 --> 00:33:13,810
>> קהל: אנחנו יכולים לעבור -

770
00:33:13,810 --> 00:33:14,660
>> מלאן דוד: לא, זה בסדר.

771
00:33:14,660 --> 00:33:16,000
זה ענק לשם.

772
00:33:16,000 --> 00:33:18,580
אז 17 הוא עכשיו בתוך התור.

773
00:33:18,580 --> 00:33:21,332
אני צריך לעדכן אותו
שדות שעכשיו?

774
00:33:21,332 --> 00:33:23,210
אוקיי, בהחלט גודל.

775
00:33:23,210 --> 00:33:26,430
ומה לגבי חזית?

776
00:33:26,430 --> 00:33:27,040
אוקיי, לא.

777
00:33:27,040 --> 00:33:30,200
קדמי לא צריכים להשתנות, כי
בניגוד לערימה, אנחנו

778
00:33:30,200 --> 00:33:31,370
רוצה לשמור על הגינות.

779
00:33:31,370 --> 00:33:35,150
אז אם 9 זכו במקום הראשון, אנחנו רוצים 9
להיות הראשון מחוץ לקו

780
00:33:35,150 --> 00:33:36,420
ונכנס לחנות.

781
00:33:36,420 --> 00:33:37,220
>> למעשה, בואו לראות את זה.

782
00:33:37,220 --> 00:33:42,235
לפני שנכניס 22, בואו
קדימה, dequeue 9.

783
00:33:42,235 --> 00:33:42,970
מה שמך שוב?

784
00:33:42,970 --> 00:33:43,680
>> קהל: ג'ייק.

785
00:33:43,680 --> 00:33:45,440
>> דוד Malan: ג'ייק הולך
להיות dequeued עכשיו.

786
00:33:45,440 --> 00:33:48,050
אז אתה מקבל ללכת לחנות.

787
00:33:48,050 --> 00:33:49,880
ולהעמיד פן שהחנות
הוא שם.

788
00:33:49,880 --> 00:33:51,970
אז עכשיו מה שצריך - dit-dit dit-!

789
00:33:51,970 --> 00:33:53,400
מה צריך לקרות עכשיו?

790
00:33:53,400 --> 00:33:54,490
החלטה עיצובית.

791
00:33:54,490 --> 00:33:56,825
אז לא אינסטינקט רע, אבל -
איך קוראים לך שוב?

792
00:33:56,825 --> 00:33:57,090
>> קהל: דוד.

793
00:33:57,090 --> 00:33:57,500
>> דוד Malan: דוד.

794
00:33:57,500 --> 00:33:58,810
אז מה דוד עשה?

795
00:33:58,810 --> 00:34:02,590
הוא ניסה למיין מלתקן את הנתונים
מבנה ומעבר ממיקומו

796
00:34:02,590 --> 00:34:04,100
למיקומו לשעבר של ג'ייק.

797
00:34:04,100 --> 00:34:06,740
וזה בסדר, אם אנחנו מוכנים
לקבל את העובדה שכפי

798
00:34:06,740 --> 00:34:08,199
יישום פרט ופרט.

799
00:34:08,199 --> 00:34:11,100
אבל קודם כל, בואו לעדכן את הנתונים
מבנה לפני שאנחנו עושים את זה.

800
00:34:11,100 --> 00:34:14,139
כי אני לא אוהב את הרעיון של כל
האנשים עוברים בקו הזה.

801
00:34:14,139 --> 00:34:17,360
>> זה לא עניין גדול אם עושה את זה עם דוד
צעד אחד, אבל שוב, חושב לחזור

802
00:34:17,360 --> 00:34:20,360
כאשר היו לנו שמונה מתנדבים ב
שלב ועשינו כמו הכנסה

803
00:34:20,360 --> 00:34:22,600
סוג שהוא, שבו היינו צריך להתחיל
נע כל הסובבים.

804
00:34:22,600 --> 00:34:23,790
שקבל יקר, נכון?

805
00:34:23,790 --> 00:34:28,330
שגורם לי להתכווץ על גדול O
של n, הגדול O של n בריבוע שוב.

806
00:34:28,330 --> 00:34:30,650
זה לא מרגיש כמו
תוצאה אידיאלית.

807
00:34:30,650 --> 00:34:32,080
>> אז בואו פשוט לעדכן את זה.

808
00:34:32,080 --> 00:34:35,120
אז את הגודל של התור
הוא כבר לא 2.

809
00:34:35,120 --> 00:34:37,090
עכשיו זה פשוט 1.

810
00:34:37,090 --> 00:34:40,360
אבל עכשיו אני יכול לעדכן משהו
אני לא עדכנו בעבר,

811
00:34:40,360 --> 00:34:41,130
מול הרשימה.

812
00:34:41,130 --> 00:34:45,420
אני רק יכול לומר, הוא שהמיקום 1?

813
00:34:45,420 --> 00:34:49,770
אז עכשיו יש לנו ערך אשפה כאן,
ערך אשפה כאן, ודוד ב

814
00:34:49,770 --> 00:34:51,469
אמצע הזבל הזה.

815
00:34:51,469 --> 00:34:54,980
אבל את מבנה הנתונים
עדיין לא נפגע.

816
00:34:54,980 --> 00:34:58,540
>> ולמעשה, אני אפילו לא צריכה
לשנות את המספר לשעבר של ג'ייק

817
00:34:58,540 --> 00:35:00,460
9, כי למי אכפת.

818
00:35:00,460 --> 00:35:04,470
יש לי מספיק מידע בחברה
גודל שאני מכיר אדם אחד שיש ב

819
00:35:04,470 --> 00:35:05,030
התור הזה.

820
00:35:05,030 --> 00:35:08,340
ואני יודע שאותו אדם
הוא במיקום 1, לא 0.

821
00:35:08,340 --> 00:35:09,760
אני לא סומך.

822
00:35:09,760 --> 00:35:11,300
גם אז 1.

823
00:35:11,300 --> 00:35:13,410
אז את מבנה הנתונים עדיין אישור.

824
00:35:13,410 --> 00:35:14,330
>> ובכן, מה קורה בהמשך?

825
00:35:14,330 --> 00:35:15,010
Enqueue בואו -

826
00:35:15,010 --> 00:35:15,370
מה השם שלך?

827
00:35:15,370 --> 00:35:16,160
>> קהל: Callen.

828
00:35:16,160 --> 00:35:16,580
>> דוד Malan: Callen.

829
00:35:16,580 --> 00:35:20,770
בואו Enqueue Callen, ו
22 הוא עכשיו בתור.

830
00:35:20,770 --> 00:35:22,300
אז עכשיו מה שצריך להשתנות כאן?

831
00:35:22,300 --> 00:35:24,380
קבלה היא לא הולכת
לשנות, זה ברור.

832
00:35:24,380 --> 00:35:27,160
גודל הולך לשנות להיות 2 שוב.

833
00:35:27,160 --> 00:35:31,590
ו22 מסתיים כאן, 9 עדיין קיימים,
אבל זה ביעילות

834
00:35:31,590 --> 00:35:32,600
ערך זבל עכשיו.

835
00:35:32,600 --> 00:35:35,910
זה פשוט שריד של עבר ג'ייק.

836
00:35:35,910 --> 00:35:39,200
>> אז עכשיו מה קורה אם
אני dequeue דוד?

837
00:35:39,200 --> 00:35:41,560
הפעולה האחרונה, dequeue דוד.

838
00:35:41,560 --> 00:35:46,070
היינו יכולים לעבור, אבל אני מציע בואו
עושה עבודה מועטת ככל האפשר.

839
00:35:46,070 --> 00:35:50,280
עכשיו מבנה הנתונים שלי הולך
לגבות בגודל 2 ל -1.

840
00:35:50,280 --> 00:35:53,730
אבל החלק הקדמי של התור
עכשיו הופך להיות 2.

841
00:35:53,730 --> 00:35:56,640
אני לא צריך לשנות את המספרים האלה
עדיין, בגלל שהם

842
00:35:56,640 --> 00:35:58,230
רק ערכי אשפה.

843
00:35:58,230 --> 00:35:59,720
>> אבל עכשיו מה קורה?

844
00:35:59,720 --> 00:36:03,280
נניח שאני Enqueue עצמי, 26?

845
00:36:03,280 --> 00:36:05,890
אני מרגיש שאני שייך לכאן יותר.

846
00:36:05,890 --> 00:36:06,890
אז אני שenqueued.

847
00:36:06,890 --> 00:36:08,760
אז אני סוג של שייך לכאן.

848
00:36:08,760 --> 00:36:11,300
ואף על פי שאתה עושה לא ממש
מעריך את זה ויזואלית על הבמה,

849
00:36:11,300 --> 00:36:15,075
כי יש לנו הרבה מקום, אני צריך
לא הייתי עומד כאן, למה?

850
00:36:15,075 --> 00:36:16,290
>> קהל: אתה מחוץ לתחום.

851
00:36:16,290 --> 00:36:16,370
>> דוד Malan: נכון.

852
00:36:16,370 --> 00:36:16,940
אני מחוץ לתחום.

853
00:36:16,940 --> 00:36:19,330
אני כבר מעבר לאינדקס
גבולות של מערך זה.

854
00:36:19,330 --> 00:36:23,420
אני באמת צריכה להיות באחד
שלושה מקומות אפשריים.

855
00:36:23,420 --> 00:36:25,150
עכשיו, איפה הכי טבעי ללכת?

856
00:36:25,150 --> 00:36:27,760
אני מציע שאנחנו ממונף
בשבוע שטריק אחד.

857
00:36:27,760 --> 00:36:30,150
מפעיל mod, אחוז.

858
00:36:30,150 --> 00:36:36,850
כי אני עומד בבחינה טכנית
3 מיקום, אבל אני עושה את קיבולת mod 3,

859
00:36:36,850 --> 00:36:40,250
כך 3, סימן אחוזים, 3 -

860
00:36:40,250 --> 00:36:40,970
קיבולת של 3.

861
00:36:40,970 --> 00:36:41,720
מה זה?

862
00:36:41,720 --> 00:36:43,700
מה השארית כאשר
אתה מחלק 3 על 3?

863
00:36:43,700 --> 00:36:44,070
0.

864
00:36:44,070 --> 00:36:48,140
>> אז זה מעמיד אותי היה היה ג'ייק,
שהוא בעצם טוב.

865
00:36:48,140 --> 00:36:50,370
אז עכשיו את היישום
הדבר הזה הולך

866
00:36:50,370 --> 00:36:51,250
להיות קצת כאב ראש.

867
00:36:51,250 --> 00:36:53,740
זה באמת רק שורה אחת
של כאב ראש, של קוד.

868
00:36:53,740 --> 00:36:56,580
אבל לפחות עכשיו יש זבל
ערך כאן, אבל יש שתיים

869
00:36:56,580 --> 00:36:57,910
ints כאן כחוק.

870
00:36:57,910 --> 00:37:04,160
ואני טוען שעכשיו אנחנו צריכים לעשות
בדיוק מה שאנחנו צריכים לעשות, כל עוד

871
00:37:04,160 --> 00:37:08,600
שלנו לשנות את מה שג'ייק
ערך היה אמור להיות 26.

872
00:37:08,600 --> 00:37:12,110
>> עכשיו יש לנו מספיק מידע עדיין
כדי לשמור על השלמות

873
00:37:12,110 --> 00:37:13,060
מבנה נתונים זה.

874
00:37:13,060 --> 00:37:17,160
אנחנו עדיין סוג של מזל כש
ברצונך להוסיף ארבעה או יותר הכולל

875
00:37:17,160 --> 00:37:20,740
אלמנטים, אבל אני יכול לפחות לעשות די
שימוש יעיל בזה קבוע

876
00:37:20,740 --> 00:37:21,740
פעם, למעשה.

877
00:37:21,740 --> 00:37:27,150
אני לא צריך לדאוג להסטה
כולם, כמו נטייתו של דוד היה.

878
00:37:27,150 --> 00:37:30,816
>> כל שאלות בערימות,
או התור הזה?

879
00:37:30,816 --> 00:37:32,184
>> קהל: האם הסיבה לכך
אתה צריך גודל כך שאתה יודע

880
00:37:32,184 --> 00:37:34,010
היכן יש לאדם?

881
00:37:34,010 --> 00:37:34,770
>> דוד Malan: בדיוק.

882
00:37:34,770 --> 00:37:38,230
אני צריך לדעת את גודלו של המערך
כי אני צריך לדעת בדיוק איך

883
00:37:38,230 --> 00:37:41,940
רבים מהערכים האלה הם לגיטימיים,
וכך אני יכול למצוא איפה לשים

884
00:37:41,940 --> 00:37:42,800
האדם הבא.

885
00:37:42,800 --> 00:37:43,300
בדיוק.

886
00:37:43,300 --> 00:37:44,580
הגודל הוא -

887
00:37:44,580 --> 00:37:46,360
למעשה, אנחנו לא עדכנו את זה עדיין.

888
00:37:46,360 --> 00:37:48,380
אני הוספתי את עצמי בגיל 26.

889
00:37:48,380 --> 00:37:51,760
הגודל הוא עכשיו, לא 1, אבל 2.

890
00:37:51,760 --> 00:37:57,780
אז עכשיו שזה עוזר לי למצוא את אכן
ראש הרשימה, שהוא לא 0, לא

891
00:37:57,780 --> 00:37:59,250
1, אבל הוא 2.

892
00:37:59,250 --> 00:38:01,665
מול הרשימה
אכן מספר 22.

893
00:38:01,665 --> 00:38:05,120
בגלל שהוא זכה במקום הראשון, כך שהוא צריך
יורשה לחנות לפניי,

894
00:38:05,120 --> 00:38:08,780
אף על פי שאני עומד מבחינה ויזואלית
קרוב יותר לחנות.

895
00:38:08,780 --> 00:38:09,220
>> בסדר?

896
00:38:09,220 --> 00:38:12,410
מחיאות כפות לחבר 'ה הללו
ואנו לתת להם לצאת משם.

897
00:38:12,410 --> 00:38:17,090
>> [מחיאות כפות]

898
00:38:17,090 --> 00:38:18,150
>> מלאן דוד: אני יכול לתת לי
לך לשמור על המגש.

899
00:38:18,150 --> 00:38:20,760
אנחנו יכולים לראות מה קורה אם
אתה רוצה, אבל אולי לא.

900
00:38:20,760 --> 00:38:21,590
בסדר.

901
00:38:21,590 --> 00:38:25,380
אז מה עכשיו זה משאיר אותנו?

902
00:38:25,380 --> 00:38:28,900
ובכן, הרשה לי להציע שיש
כמה מבני נתונים אחרים שאנחנו יכולים

903
00:38:28,900 --> 00:38:33,810
להתחיל להוסיף לארגז הכלים שלנו שיהיו
למעשה להיות די, די רלוונטי

904
00:38:33,810 --> 00:38:35,270
אנחנו צוללים לתוך חומר באינטרנט.

905
00:38:35,270 --> 00:38:38,150
אשר שוב, יש איזשהו חיבור
לעצים בצורה של

906
00:38:38,150 --> 00:38:40,550
משהו שנקרא DOM, מסמך
מודל אובייקטים.

907
00:38:40,550 --> 00:38:42,370
אבל אנחנו תראו יותר של
כי לפני זמן רב.

908
00:38:42,370 --> 00:38:46,260
>> הרשה לי להציע שאנחנו definitionally
קורא לעץ עכשיו מה שאתה אולי יודע כ

909
00:38:46,260 --> 00:38:48,820
יותר מעץ משפחה, שבו אתה
יש לי כמה באב קדמון

910
00:38:48,820 --> 00:38:49,790
שורשיו של העץ.

911
00:38:49,790 --> 00:38:54,480
אמנו פטריארכלי או ב
חלקו העליון של העץ.

912
00:38:54,480 --> 00:38:56,700
בלי בן הזוג שלהם, במקרה זה.

913
00:38:56,700 --> 00:39:00,940
אבל עכשיו יש לנו את מה שאנחנו קוראים
ילדים, שהם צמתים שתולים

914
00:39:00,940 --> 00:39:05,480
את הילד השמאלי או הימני הילד,
כחצים מתוארים כאן.

915
00:39:05,480 --> 00:39:10,490
>> במילים אחרות, במבנה נתוני עץ
במחשב, יש לו עץ אפס

916
00:39:10,490 --> 00:39:11,480
או יותר צמתים.

917
00:39:11,480 --> 00:39:13,500
אם יש לו צומת אחד לפחות,
זה נקרא השורש.

918
00:39:13,500 --> 00:39:15,700
זה הדברים חזותי ש
אנו מפנים בראש.

919
00:39:15,700 --> 00:39:20,280
וצומת זה, כמו כל צומת אחרת, יכולה
יש אפס, אחת, או שתיים, או שלוש,

920
00:39:20,280 --> 00:39:23,600
או עם זאת הרבה ילדים
מבנה נתונים תומך.

921
00:39:23,600 --> 00:39:29,150
במקרה זה, השורש, אחסון
ערך אחד, יש לו שני ילדים, 2 ו -3,

922
00:39:29,150 --> 00:39:33,020
כך אנחנו בדרך כלל קוראים 2 מהשמאל
ילד והילד 3 הנכון.

923
00:39:33,020 --> 00:39:36,940
>> ולאחר מכן, כאשר אנו ניגשים ל5, 6, ו
7, 6 שניתן לכנות הילד האמצעי.

924
00:39:36,940 --> 00:39:38,940
אם יש לך ארבעה ילדים,
זה מתחיל לבלבל.

925
00:39:38,940 --> 00:39:42,260
אז הפסיקו להשתמש באותו סוג
של קיצור דרך מילולית.

926
00:39:42,260 --> 00:39:44,580
אבל זה באמת רק עץ משפחה.

927
00:39:44,580 --> 00:39:48,880
והעלים כאן את בלוטות כי
יש להם לא היה ילדים.

928
00:39:48,880 --> 00:39:52,540
הם תולים את חלקו התחתון של העץ.

929
00:39:52,540 --> 00:39:56,940
>> אז איך ייתכן שאנו מיישמים עץ
יש רק שני ילדים צורה מקסימלית?

930
00:39:56,940 --> 00:39:58,410
אנחנו קוראים לזה עץ בינארי.

931
00:39:58,410 --> 00:40:00,960
דו משמעות שתיים שוב, בזה
מקרה, כמו בינארי.

932
00:40:00,960 --> 00:40:04,830
וכך זה יכול להיות אפס, אחת,
או שני ילדים מקסימאליים.

933
00:40:04,830 --> 00:40:08,650
>> אני מציע לנו ליישם את הצומת
למבנה זה עם n int,

934
00:40:08,650 --> 00:40:11,910
ולאחר מכן שני מצביעים, אחד בשם
עזבתי, אחד בשם נכון.

935
00:40:11,910 --> 00:40:14,830
אבל אלה הם רק נחמדים
מוסכמות שרירותיות.

936
00:40:14,830 --> 00:40:18,170
ומה שיפה עכשיו, במיוחד אם אתה
סוג של נאבק עם מושגית

937
00:40:18,170 --> 00:40:21,300
רקורסיה, או שחשבה שזה לא היה
באמת פתרון לכל דבר,

938
00:40:21,300 --> 00:40:23,120
במיוחד אם אתה יכול
נגמרים של זיכרון.

939
00:40:23,120 --> 00:40:26,600
על נתונים עכשיו שאנחנו מדברים
מבנים ואלגוריתמים המאפשרים

940
00:40:26,600 --> 00:40:31,030
לנו לעבור ולטפל בהם,
מתברר כי רקורסיה חוזרת ב

941
00:40:31,030 --> 00:40:34,240
הרבה יותר משכנע
אם לא בדרך יפה.

942
00:40:34,240 --> 00:40:38,670
>> אז זה שאני מציע הוא היישום
של פונקצית חיפוש.

943
00:40:38,670 --> 00:40:39,870
בהתחשב בשתי כניסות -

944
00:40:39,870 --> 00:40:41,570
כל כך חושב על זה כמו קופסה שחורה.

945
00:40:41,570 --> 00:40:46,560
בהתחשב בשתי כניסות, n, int, ו
מצביע לעץ, מצביע ל

946
00:40:46,560 --> 00:40:50,020
הצומת, או באמת השורש של עץ, אני
טענה שפונקציה זו יכולה לחזור

947
00:40:50,020 --> 00:40:53,530
אמת או שקר, שהערך n
הוא בתוך העץ הזה.

948
00:40:53,530 --> 00:40:55,210
>> מה יש בפנים של הקופסה השחורה הזו?

949
00:40:55,210 --> 00:40:57,440
ובכן, ארבעה סניפים.

950
00:40:57,440 --> 00:40:58,385
הראשון פשוט בודק.

951
00:40:58,385 --> 00:41:00,490
אם העץ הוא ריק, רק בתמורת השווא.

952
00:41:00,490 --> 00:41:04,580
אם אין צומת, אין n,
אין מספר, רק בתמורת שווא.

953
00:41:04,580 --> 00:41:12,330
אם כי, n, הערך שאתה מחפש
ל, הוא פחות מחץ העץ N, ו

954
00:41:12,330 --> 00:41:15,180
רק שיהיה ברור, מה זה אומר כאשר
אני כותב את העץ ולאחר מכן על החץ

955
00:41:15,180 --> 00:41:18,150
סימון, n?

956
00:41:18,150 --> 00:41:18,690
בדיוק.

957
00:41:18,690 --> 00:41:21,970
זה אומר שdereference
מצביע הנקרא עץ.

958
00:41:21,970 --> 00:41:26,750
ללכת לשם, ולאחר מכן לקבל בתוך ש
צומת ולקבל תחומו בשם n.

959
00:41:26,750 --> 00:41:30,810
ולאחר מכן להשוות את n בפועל שהיה
עבר לחיפוש נגדה.

960
00:41:30,810 --> 00:41:35,390
>> אז אם n הוא פחות מ, ערך n
בצומת העץ עצמו, טוב,

961
00:41:35,390 --> 00:41:36,720
מה זה אומר?

962
00:41:36,720 --> 00:41:40,690
זה לא אומר כלום במבט הראשון.

963
00:41:40,690 --> 00:41:40,900
נכון?

964
00:41:40,900 --> 00:41:45,560
בדיוק כמו כאשר יש לך מערך של
ערכים, שאולי ירצו להחיל בינארי

965
00:41:45,560 --> 00:41:48,290
לחפש כסוג של פער
ולכבוש.

966
00:41:48,290 --> 00:41:51,790
אבל מה שעשינו הנחה צריך לעשות
לחיפוש בינארי לעבוד בכלל

967
00:41:51,790 --> 00:41:54,510
בספר ובטלפון
דוגמאות מוקדמות יותר?

968
00:41:54,510 --> 00:41:55,530
>> איך להיות מסודר.

969
00:41:55,530 --> 00:41:59,490
אז בואו לחדד את ההגדרה של עץ
כאן לא להיות סתם עץ, שיכול

970
00:41:59,490 --> 00:42:00,880
יש כל מספר של ילדים.

971
00:42:00,880 --> 00:42:04,700
לא רק עץ בינארי, שיכול
יש 0, 1, 2 או מקסימאלי.

972
00:42:04,700 --> 00:42:09,700
אבל כמו עץ ​​בינארי חיפוש, או BST,
וזה רק דרך מפוארת של להגיד

973
00:42:09,700 --> 00:42:15,430
עץ בינארי כך שכל צומת של
ילד שמאלי, אם הוא קיים, הוא

974
00:42:15,430 --> 00:42:16,830
פחות מהצומת.

975
00:42:16,830 --> 00:42:20,170
וזכותו של כל ילד צומת,
אם הוא קיים, הוא גדול יותר

976
00:42:20,170 --> 00:42:21,740
מהצומת עצמו.

977
00:42:21,740 --> 00:42:25,200
>> אז במילים אחרות, אם היית לצייר
העץ החוצה, כל המספרים הם

978
00:42:25,200 --> 00:42:30,620
מאוזנת היטב כמו זה, כך שאם
יש לך 55 כשורש, 33 יכול ללכת

979
00:42:30,620 --> 00:42:33,090
לשמאלו, כי זה פחות מ 55.

980
00:42:33,090 --> 00:42:36,430
77 יכולים ללכת לזכותה, כי
זה יותר מ -55.

981
00:42:36,430 --> 00:42:40,750
אבל עכשיו שם לב, אותה ההגדרה,
זה הגדרה רקורסיבית מילולי,

982
00:42:40,750 --> 00:42:42,600
יש להגיש בקשה ל33.

983
00:42:42,600 --> 00:42:47,610
ילד השמאלי של 33 חייב להיות פחות ממה שהוא,
וזכות ילד של 33, 44, חייב להיות

984
00:42:47,610 --> 00:42:48,580
גדול יותר ממה שהוא.

985
00:42:48,580 --> 00:42:51,670
>> אז זהו עץ חיפוש בינארי, ו
אני מציע, תוך שימוש במעט

986
00:42:51,670 --> 00:42:53,910
רקורסיה, עכשיו אנחנו יכולים למצוא את n.

987
00:42:53,910 --> 00:42:59,160
אז אם n הוא פחות מ n הערך זה
צומת נוכחית, אני הולך ללכת

988
00:42:59,160 --> 00:43:04,090
קדימה ודוגית, אם אפשר לומר כך, ורק
להחזיר כל מה שהתשובה היא של

989
00:43:04,090 --> 00:43:08,470
מחפש n על
הילד השמאלי של העץ.

990
00:43:08,470 --> 00:43:11,370
שים לב שוב, פונקציה זו רק
מצפה כוכבים צומת,

991
00:43:11,370 --> 00:43:12,780
מצביע לצומת.

992
00:43:12,780 --> 00:43:17,360
אז בוודאי שאני יכול פשוט לעשות עץ
חץ שמאלה, שיוביל

993
00:43:17,360 --> 00:43:18,400
שלי לצומת אחרת.

994
00:43:18,400 --> 00:43:19,480
אבל מה היא צומת ש?

995
00:43:19,480 --> 00:43:22,820
>> ובכן, על פי הצהרה זו,
שמאל הוא רק מצביע, כך שרק

996
00:43:22,820 --> 00:43:27,090
אומר שאני עובר לפונקציית החיפוש
מצביע אחר, דהיינו

997
00:43:27,090 --> 00:43:30,750
אחד שמייצג
העץ של הילד השמאלי.

998
00:43:30,750 --> 00:43:36,040
אז במקרה הזה, מצביע ל33, אם
זה קלט המדגם שלנו בינתיים, אם

999
00:43:36,040 --> 00:43:40,740
n הוא גדול יותר מהערך בn
צומת נוכחית בעץ, ולאחר מכן אני

1000
00:43:40,740 --> 00:43:43,370
הולך קדימה ודוגית בשנייה
כיוון ורק אומרים, אני לא

1001
00:43:43,370 --> 00:43:47,280
יודע אם n ערך זה הוא בעץ,
אבל אני יודע שאם זה לא יהיה, זה אותי

1002
00:43:47,280 --> 00:43:49,090
סניף נכון, אם אפשר לומר כך.

1003
00:43:49,090 --> 00:43:53,120
אז הרשה לי לקרוא באופן רקורסיבי לחפש,
עובר n שוב, אבל עובר ב

1004
00:43:53,120 --> 00:43:54,580
מצביע לילד הנכון שלי.

1005
00:43:54,580 --> 00:44:00,020
>> במילים אחרות, אם אני כרגע ב 55
ואני מחפש 99, אני יודע ש99

1006
00:44:00,020 --> 00:44:04,270
גדול מ 55, כל כך פשוט כמו שקרעתי
לפני שבועות ספר הטלפונים ואנחנו

1007
00:44:04,270 --> 00:44:07,140
הלכנו ימינה, בדומה אנחנו
הולך כאן.

1008
00:44:07,140 --> 00:44:11,960
ואני לא יודע אם זה בצד הימין שלי
ילד, וזה לא, 77 הוא שם, אבל

1009
00:44:11,960 --> 00:44:13,210
אני יודע שזה באותו כיוון.

1010
00:44:13,210 --> 00:44:18,770
אז אני קורא לחיפוש על זכות הילד שלי,
77, ושחרר את דמות מחיפוש

1011
00:44:18,770 --> 00:44:24,950
שם אם 99 בזה שרירותי
דוגמה לכך היא למעשה שם.

1012
00:44:24,950 --> 00:44:26,900
>> דבר אחר, מה זה המקרה הסופי?

1013
00:44:26,900 --> 00:44:28,620
אם עץ הוא ריק הוא מקרה אחד.

1014
00:44:28,620 --> 00:44:31,890
אם n הוא פחות מהצומת הנוכחית של
ערך הוא מקרה אחר.

1015
00:44:31,890 --> 00:44:35,120
אם n הוא גדול יותר מנוכחי
הערך של הצומת הוא מקרה שלישי.

1016
00:44:35,120 --> 00:44:38,250
מה זה המקרה הרביעי ואחרון?

1017
00:44:38,250 --> 00:44:39,480
אני חושב שאנחנו ממקרים, נכון?

1018
00:44:39,480 --> 00:44:44,690
זה חייב להיות, כי n הוא ב
צומת נוכחית שאני ב.

1019
00:44:44,690 --> 00:44:49,640
>> אז אם אני מחפש 55 בשלב זה
בסיפור, שהסניף של

1020
00:44:49,640 --> 00:44:51,780
העץ יחזור נכון.

1021
00:44:51,780 --> 00:44:55,380
אז מה שמעניין כאן הוא שאנחנו
למעשה, בניגוד לשבועות האחרון, אנחנו סוג

1022
00:44:55,380 --> 00:44:56,740
יש שני מקרים של בסיס.

1023
00:44:56,740 --> 00:44:58,300
ולא שיש להם
להיות כל בראש.

1024
00:44:58,300 --> 00:45:01,390
העליון הוא מקרה בסיס כי אם
העץ הוא ריק, אין מה לעשות.

1025
00:45:01,390 --> 00:45:03,410
רק לחזור מקודד קשה
ערך של שקר.

1026
00:45:03,410 --> 00:45:07,400
>> הסניף התחתון הוא סוג של
כברירת מחדל, לפיה אם אנחנו כבר בדקנו עבור

1027
00:45:07,400 --> 00:45:11,550
null, בדקנו אם זה צריך להיות
עזבתי, אבל זה לא צריך להיות, יש לנו

1028
00:45:11,550 --> 00:45:14,640
בדק אם זה צריך להיות נכון, אבל זה
לא צריך להיות, באופן ברור שזה צריך להיות

1029
00:45:14,640 --> 00:45:15,870
בדיוק במקום בו אנו נמצאים.

1030
00:45:15,870 --> 00:45:16,780
זה מקרה בסיס.

1031
00:45:16,780 --> 00:45:19,920
אז יש שני מקרים רקורסיבית
דחוקה שם באמצע.

1032
00:45:19,920 --> 00:45:21,630
אבל אני יכול לכתוב
זו בכל סדר.

1033
00:45:21,630 --> 00:45:24,520
פשוט חשבתי שזה סוג של הרגיש טבעי
כדי לבדוק ראשון לשגיאה אפשרית,

1034
00:45:24,520 --> 00:45:28,340
לאחר מכן לבדוק עזב, ואז לבדוק נכון, ולאחר מכן
תניח שאתה בצומת

1035
00:45:28,340 --> 00:45:30,630
אתה בעצם מחפש.

1036
00:45:30,630 --> 00:45:36,240
>> אז למה זה יכול להיות שימושי?

1037
00:45:36,240 --> 00:45:37,910
אז מתברר -

1038
00:45:37,910 --> 00:45:42,110
והרשו לי לקפוץ לטיזר
כאן זה באינטרנט.

1039
00:45:42,110 --> 00:45:44,920
אנחנו הולכים להתחיל להשתמש בלא
שפת תכנות בהתחלה, אבל

1040
00:45:44,920 --> 00:45:46,030
שפת סימון.

1041
00:45:46,030 --> 00:45:48,740
שפת סימון להיות אחד זה
דומה ברוחו לתכנות

1042
00:45:48,740 --> 00:45:51,715
שפה, אבל זה לא נותן לך
היכולת להביע את עצמך באופן הגיוני.

1043
00:45:51,715 --> 00:45:55,070
זה נותן לך רק את היכולת
להביע את עצמך מבחינה מבנית.

1044
00:45:55,070 --> 00:45:57,960
>> לאן אתה רוצה לשים משהו
בדף, דף האינטרנט?

1045
00:45:57,960 --> 00:45:59,200
איזה צבע אתה רוצה לעשות את זה?

1046
00:45:59,200 --> 00:46:00,950
מה גודל גופן שאתה רוצה לעשות את זה?

1047
00:46:00,950 --> 00:46:02,970
מה מילים שאתה בעצם עושות
רוצה בדף האינטרנט?

1048
00:46:02,970 --> 00:46:04,060
אז זה שפת סימון.

1049
00:46:04,060 --> 00:46:07,690
אבל אז נכיר מהר מאוד
JavaScript, שהוא במלוא מובן המילה

1050
00:46:07,690 --> 00:46:08,560
שפת תכנות.

1051
00:46:08,560 --> 00:46:12,530
דומה מאוד במראהו תחבירי
ל-C, אבל זה יהיה לך קצת

1052
00:46:12,530 --> 00:46:15,200
נחמד, יותר חזק, יותר
תכונות ידידותיות למשתמש.

1053
00:46:15,200 --> 00:46:18,050
>> ואחד מהתסכולים על זה
נקודה בסמסטר היא שאנחנו יהיו

1054
00:46:18,050 --> 00:46:22,065
בקרוב ליישם מאית בהרבה פחות
שורות קוד בשימוש בשפות אחרות

1055
00:46:22,065 --> 00:46:25,580
מ C עצמו מאפשר, אבל מסיבה של
אנחנו עוד נבין.

1056
00:46:25,580 --> 00:46:27,750
זה יהיה דף האינטרנט הראשון מסוגו.

1057
00:46:27,750 --> 00:46:30,120
זה יהיה underwhelming לחלוטין,
הראשון שאנחנו עושים.

1058
00:46:30,120 --> 00:46:31,400
פשוט יגיד את זה, שלום עולם.

1059
00:46:31,400 --> 00:46:34,010
אבל אם אף פעם לא ראה אותו
לפני, זה HTML,

1060
00:46:34,010 --> 00:46:35,670
Hypertext Markup Language.

1061
00:46:35,670 --> 00:46:39,310
>> אם אתה הולך לאפשרות בתפריט מסוים ב
ביותר דפדפן בכלל, על כל דף אינטרנט על

1062
00:46:39,310 --> 00:46:43,160
באינטרנט, אתה יכול לראות את ה-HTML
שיש אנשים שכתבו לי

1063
00:46:43,160 --> 00:46:44,400
ליצור דף אינטרנט זה.

1064
00:46:44,400 --> 00:46:47,850
וזה כנראה לא נראה כמו
קצר או מסודר כמו זה.

1065
00:46:47,850 --> 00:46:51,400
אבל זה יהיה לעקוב אחר הדפוס של אלה
סוגריים פתוחים, חתכים,

1066
00:46:51,400 --> 00:46:53,660
אותיות ומספרים. פוטנציאל

1067
00:46:53,660 --> 00:46:56,770
>> חשבתי שאני רוצה לתת לך טיזר
ממה שאתה תהיה מסוגל לעשות

1068
00:46:56,770 --> 00:46:57,950
לאחר נטילת CS50.

1069
00:46:57,950 --> 00:47:02,620
תן לי ללכת לcs.harvard.edu / לשדוד,
בדף הבית שלך רובנו באודן.

1070
00:47:02,620 --> 00:47:06,080
הוא עשה את זה בשבילנו.

1071
00:47:06,080 --> 00:47:07,490
אז בקרוב תוכל להיות מסוגל לעשות את זה.

1072
00:47:07,490 --> 00:47:10,660
וגם, מה ששמעת
הבוקר -

1073
00:47:10,660 --> 00:47:12,480
מה שאתה שמעת את זה בבוקר -

1074
00:47:12,480 --> 00:47:13,780
>> [מוסיקה מחול אוגר]

1075
00:47:13,780 --> 00:47:15,702
>> - ואתה עומד להיות מסוגל לעשות את זה.

1076
00:47:15,702 --> 00:47:16,790
שמחכה לנו ביום רביעי.

1077
00:47:16,790 --> 00:47:17,791
אנחנו אראה אותך לאחר מכן.

1078
00:47:17,791 --> 00:47:22,950
>> [מוסיקה מחול אוגר]

1079
00:47:22,950 --> 00:47:24,300
דוד Malan: בCS50 הבא -

1080
00:47:24,300 --> 00:47:31,670