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

2
00:00:03,381 --> 00:00:04,604

3
00:00:04,604 --> 00:00:05,520
דאג LLOYD: בסדר.

4
00:00:05,520 --> 00:00:07,860
אז אם אתה רק סיימת ש
וידאו ברשימות ביחידות צמודות מצטער

5
00:00:07,860 --> 00:00:09,568
עזבתי אותך ב
קצת סחרור מסוכן.

6
00:00:09,568 --> 00:00:12,790
אבל אני שמח שאתה כאן כדי לסיים
הסיפור של רשימות כפולים צמודות.

7
00:00:12,790 --> 00:00:15,250
>> אז אם אתה זוכר מ
וידאו ש, דיברנו

8
00:00:15,250 --> 00:00:18,500
על איך ביחידות צמודות
רשימות לעשות להשתתף היכולת שלנו

9
00:00:18,500 --> 00:00:22,090
כדי להתמודד עם מידע
שבו מספר האלמנטים

10
00:00:22,090 --> 00:00:24,442
או את מספר הפריטים ב
רשימה יכולה לגדול או להתכווץ.

11
00:00:24,442 --> 00:00:26,400
כעת אנו יכולים להתמודד עם
משהו כזה, שבו

12
00:00:26,400 --> 00:00:28,310
אנו לא יכולים להתמודד עם זה עם מערכים.

13
00:00:28,310 --> 00:00:30,560
>> אבל הם סובלים מאחד
מגבלה קריטית ש

14
00:00:30,560 --> 00:00:33,790
הוא שעם יחידים צמודים
רשימה, אנחנו יכולים רק פעם לעבור

15
00:00:33,790 --> 00:00:36,200
בכיוון אחד ברשימה.

16
00:00:36,200 --> 00:00:39,010
ואת המצב האמיתי רק
איפה זה יכול להיות בעיה

17
00:00:39,010 --> 00:00:41,250
היה כאשר אנחנו מנסים
למחוק אלמנט בודד.

18
00:00:41,250 --> 00:00:46,000
ואנחנו אפילו לא לדון איך לעשות את זה
ברשימה ביחידות צמודה בפסאודו קוד.

19
00:00:46,000 --> 00:00:48,797
זה בהחלט אפשרי, אבל
זה יכול להיות קצת טרחה.

20
00:00:48,797 --> 00:00:50,630
אז אם אתה מוצא את עצמך
במצב שבו

21
00:00:50,630 --> 00:00:53,175
אתה מנסה למחוק
אלמנטים יחידים מהרשימה

22
00:00:53,175 --> 00:00:55,430
או שזה הולך להיות נדרשת
כי אתה תהיה מחיקה

23
00:00:55,430 --> 00:00:57,970
אלמנטים יחידים מ
הרשימה, ייתכן שתרצי

24
00:00:57,970 --> 00:01:02,090
לשקול שימוש כפול צמוד
רשימה במקום רשימת יחידות צמודה.

25
00:01:02,090 --> 00:01:06,320
בגלל רשימות כפולים צמודות תאפשר לך
כדי להזיז את שני קדימה ואחורה

26
00:01:06,320 --> 00:01:09,340
ברשימה במקום
רק קדימה דרך list--

27
00:01:09,340 --> 00:01:13,950
רק על ידי הוספת אלמנט אחד נוסף
להגדרת המבנה שלנו

28
00:01:13,950 --> 00:01:16,690
לצומת הרשימה כפליים צמודה.

29
00:01:16,690 --> 00:01:19,770
>> שוב, אם אתה לא הולך ל
להיות מחיקת אלמנטים בודדים

30
00:01:19,770 --> 00:01:24,810
מlist-- כי אנו מוסיפים
שדה נוסף למבנה שלנו

31
00:01:24,810 --> 00:01:28,340
הגדרה, בלוטות עצמם
לרשימות כפולים צמודות

32
00:01:28,340 --> 00:01:29,550
הולכים להיות גדול יותר.

33
00:01:29,550 --> 00:01:31,600
הם הולכים לקחת
יותר בתים של זיכרון.

34
00:01:31,600 --> 00:01:34,160
ולכן אם זה לא משהו
אתה הולך צריך לעשות,

35
00:01:34,160 --> 00:01:36,300
אולי אתה מחליט שזה
לא שווה את הסחר מ

36
00:01:36,300 --> 00:01:39,360
צריך להשקיע נוסף
בתים של זיכרון הנדרש

37
00:01:39,360 --> 00:01:43,940
לרשימה כפליים צמודה אם אתה לא
הולכים להיות מחיקת אלמנטים בודדים.

38
00:01:43,940 --> 00:01:46,760
אבל הם גם מגניבים
לדברים אחרים גם.

39
00:01:46,760 --> 00:01:51,260
>> אז כמו שאמרתי, אנחנו רק צריכים להוסיף
שדה אחד למבנה שלנו

40
00:01:51,260 --> 00:01:55,360
definition-- הרעיון הזה
של מצביע קודם.

41
00:01:55,360 --> 00:01:58,620
אז עם רשימה ביחידות צמודה, אנחנו
יש ערך והמצביע הבא,

42
00:01:58,620 --> 00:02:02,850
כך הרשימה כפליים צמודה רק ל
דרך להעביר אחורה גם כן.

43
00:02:02,850 --> 00:02:04,960
>> עכשיו בצמוד ליחידים
וידאו רשימה, שדברנו

44
00:02:04,960 --> 00:02:07,210
על אלה חמש
דברים עיקריים שאתה צריך להיות

45
00:02:07,210 --> 00:02:09,449
תוכל לעשות כדי לעבוד עם רשימות מקושרות.

46
00:02:09,449 --> 00:02:12,880
ועבור רוב אלה, העובדה
שזה רשימה כפליים צמודה

47
00:02:12,880 --> 00:02:14,130
הוא לא ממש קפיצה גדולה.

48
00:02:14,130 --> 00:02:17,936
אנחנו עדיין יכולים לחפש דרך רק על ידי
לנוע קדימה מהתחלה ועד סופו.

49
00:02:17,936 --> 00:02:20,810
אנחנו עדיין יכולים ליצור צומת מ
אוויר דליל, פחות או יותר באותה צורה.

50
00:02:20,810 --> 00:02:23,591
אנחנו יכולים למחוק את הרשימות די
בדרך הדומה מדי.

51
00:02:23,591 --> 00:02:25,340
הדברים היחידים ש
הם שונים בעדינות,

52
00:02:25,340 --> 00:02:28,970
באמת, מכניסים
בלוטות חדשות לרשימה,

53
00:02:28,970 --> 00:02:33,722
ואנחנו סוף הסוף מדברים על מחיקה
אלמנט יחיד מהרשימה גם כן.

54
00:02:33,722 --> 00:02:35,430
שוב, פחות או יותר
שלוש האחרים, אנחנו

55
00:02:35,430 --> 00:02:37,888
לא הולך לדבר עליהם
עכשיו בגלל שהם פשוט

56
00:02:37,888 --> 00:02:43,920
tweaks קטן מאוד על הרעיונות שנדון
בוידאו רשימת יחידות הצמודות.

57
00:02:43,920 --> 00:02:46,292
>> אז בואו נכניס צומת חדשה
לרשימה כפליים צמודה.

58
00:02:46,292 --> 00:02:48,750
דברנו על לעשות את זה ל
ביחידים צמודים רשימות, כמו גם,

59
00:02:48,750 --> 00:02:52,020
אבל יש כמה נוסף
תופס עם רשימות כפולים צמודות.

60
00:02:52,020 --> 00:02:55,280
אנחנו [? עובר?] בראש
רשימה כאן וכמה ערך שרירותי,

61
00:02:55,280 --> 00:02:58,600
ואנחנו רוצים לקבל את הראש החדש
הרשימה מתוך פונקציה זו.

62
00:02:58,600 --> 00:03:01,414
זו הסיבה לכך שהוא חוזר לכוכב dllnode.

63
00:03:01,414 --> 00:03:02,330
אז מה הם השלבים?

64
00:03:02,330 --> 00:03:04,496
הם, שוב, מאוד דומים
ליחידים צמודים רשימות

65
00:03:04,496 --> 00:03:05,670
עם תוספת אחת נוספת.

66
00:03:05,670 --> 00:03:08,900
אנחנו רוצים מקצה מקום לחדש
צומת וסימון כדי לוודא שהוא תקף.

67
00:03:08,900 --> 00:03:11,510
אנחנו רוצים למלא את הצומת ש
עם כל מידע שאנו

68
00:03:11,510 --> 00:03:12,564
רוצה לשים את זה.

69
00:03:12,564 --> 00:03:15,480
הדבר האחרון שאנחנו צריכים do--
דבר נוסף שאנחנו צריכים לעשות, rather--

70
00:03:15,480 --> 00:03:19,435
הוא לתקן את המצביע הקודם
של ראש הרשימה הישן.

71
00:03:19,435 --> 00:03:21,310
זכור כי בגלל
רשימות של כפליים צמודות,

72
00:03:21,310 --> 00:03:23,110
אנחנו יכולים להתקדם
וbackwards-- ש

73
00:03:23,110 --> 00:03:27,080
משמעות הדבר היא כי כל צומת מצביעה למעשה
לשני צמתים אחרים רק במקום אחד.

74
00:03:27,080 --> 00:03:29,110
ולכן אנחנו צריכים לתקן
ראש הרשימה הישן

75
00:03:29,110 --> 00:03:32,151
להצביע אחורה לראש החדש של
הרשימה המקושרת, שהיה משהו

76
00:03:32,151 --> 00:03:33,990
אנו לא צריכים לעשות לפני.

77
00:03:33,990 --> 00:03:37,420
וכמו בעבר, אנחנו פשוט לחזור
מצביע לראש החדש של הרשימה.

78
00:03:37,420 --> 00:03:38,220
>> אז הנה רשימה.

79
00:03:38,220 --> 00:03:40,144
אנחנו רוצים להכניס 12 לרשימה זו.

80
00:03:40,144 --> 00:03:42,060
שים לב שהתרשים
הוא מעט שונה.

81
00:03:42,060 --> 00:03:47,710
כל צומת מכיל שלוש fields--
הנתונים, ומצביע הבא באדום,

82
00:03:47,710 --> 00:03:50,170
ומצביע קודם בכחול.

83
00:03:50,170 --> 00:03:54,059
שום דבר לא בא לפני הצומת 15,
כך המצביע הקודם שלה הוא null.

84
00:03:54,059 --> 00:03:55,350
זוהי תחילתה של הרשימה.

85
00:03:55,350 --> 00:03:56,560
אין שום דבר לפני זה.

86
00:03:56,560 --> 00:04:03,350
ושום דבר לא בא אחרי 10 הצומת, ו
אז זה המצביע הבא הוא null גם כן.

87
00:04:03,350 --> 00:04:05,616
>> אז בואו נוסיף 12 לרשימה זו.

88
00:04:05,616 --> 00:04:08,070
אנחנו צריכים [לא ברורים] מקום לצומת.

89
00:04:08,070 --> 00:04:11,480
אנחנו שמים 12 בתוכו.

90
00:04:11,480 --> 00:04:14,840
ואז שוב, אנחנו צריכים להיות באמת
היזהר שלא לשבור את השרשרת.

91
00:04:14,840 --> 00:04:17,144
אנחנו רוצים לארגן מחדש את
מצביעים בסדר הנכונה.

92
00:04:17,144 --> 00:04:19,519
ולפעמים שעשוי mean--
כפי שנראה במיוחד

93
00:04:19,519 --> 00:04:24,120
עם delete-- שיש להם כמה אנחנו
מצביעים מיותרים, אבל זה בסדר.

94
00:04:24,120 --> 00:04:25,750
>> אז מה אנחנו רוצים לעשות קודם?

95
00:04:25,750 --> 00:04:28,290
אני ממליץ
דברים שאתה כנראה צריך

96
00:04:28,290 --> 00:04:35,350
לעשות הם למלא את המצביעים של 12
צומת לפני שתיגע אף אחד אחר.

97
00:04:35,350 --> 00:04:38,640
אז מה הוא 12 הולכים להצביע הבא?

98
00:04:38,640 --> 00:04:39,860
15.

99
00:04:39,860 --> 00:04:42,430
מה בא לפני 12?

100
00:04:42,430 --> 00:04:43,640
לא כלום.

101
00:04:43,640 --> 00:04:46,280
עכשיו אנחנו כבר מילאתי
מידע נוסף ב -12

102
00:04:46,280 --> 00:04:49,320
כך יש לו, בשלב הבא, וערך קודמים.

103
00:04:49,320 --> 00:04:53,505
>> עכשיו אנחנו יכולים להיות 15-- זה נוסף
צעד שאנחנו מדברים על--

104
00:04:53,505 --> 00:04:56,590
יכול להיות 15 נקודות בחזרה ל -12.

105
00:04:56,590 --> 00:04:59,634
ועכשיו אנחנו יכולים להזיז את ראש
הרשימה המקושרת להיות גם 12.

106
00:04:59,634 --> 00:05:02,550
אז זה די דומה למה ש
עושים עם רשימות ביחידות צמודות,

107
00:05:02,550 --> 00:05:06,940
פרט לצעד הנוסף של
חיבור ראש הרשימה הישן

108
00:05:06,940 --> 00:05:09,810
לגבות לראש החדש של הרשימה.

109
00:05:09,810 --> 00:05:12,170
>> עכשיו בואו סוף סוף להסיר
צומת מרשימה מקושרת.

110
00:05:12,170 --> 00:05:14,350
אז בואו נגיד שיש לנו
תפקיד אחר ש

111
00:05:14,350 --> 00:05:18,080
הוא מציאת צומת אנחנו רוצים למחוק
ונתן לנו מצביע בדיוק

112
00:05:18,080 --> 00:05:19,710
הצומת שאנחנו רוצים למחוק.

113
00:05:19,710 --> 00:05:22,360
אנחנו אפילו לא אומרים need--
הראש עדיין הכריז באופן גלובלי.

114
00:05:22,360 --> 00:05:23,590
אנחנו לא צריכים את הראש כאן.

115
00:05:23,590 --> 00:05:26,830
כל פונקציה זו עושה היא שיש לנו
מצאתי מצביע בדיוק אנחנו הצומת

116
00:05:26,830 --> 00:05:28,090
רוצה להיפטר מ.

117
00:05:28,090 --> 00:05:28,940
בואו להיפטר ממנו.

118
00:05:28,940 --> 00:05:31,859
זה הרבה יותר קל עם
כפליים צמוד רשימות.

119
00:05:31,859 --> 00:05:33,650
First-- זה בעצם
רק כמה דברים.

120
00:05:33,650 --> 00:05:38,760
אנחנו רק צריכים לתקן מקיפים
מצביעים 'בלוטות, כך שהם לדלג על

121
00:05:38,760 --> 00:05:40,240
הצומת שאנחנו רוצים למחוק.

122
00:05:40,240 --> 00:05:43,484
ואז אנחנו יכולים למחוק את הצומת.

123
00:05:43,484 --> 00:05:45,150
אז שוב, אנחנו רק עוברים כאן.

124
00:05:45,150 --> 00:05:49,625
אנחנו החלטנו כנראה ש
אנחנו רוצים למחוק את X. הצומת

125
00:05:49,625 --> 00:05:51,500
ושוב, מה שאני
עושה כאן-- על ידי way--

126
00:05:51,500 --> 00:05:54,580
הוא מקרה כללי ל
צומת שנמצאת באמצע.

127
00:05:54,580 --> 00:05:56,547
יש כמה
אזהרות נוספות ש

128
00:05:56,547 --> 00:05:59,380
צריך לקחת בחשבון כאשר אתה מוחק
תחילתה של הרשימה מאוד

129
00:05:59,380 --> 00:06:01,040
או הסוף של הרשימה.

130
00:06:01,040 --> 00:06:03,730
יש כמה מיוחד
מקרי פינה להתמודד עם שם.

131
00:06:03,730 --> 00:06:07,960
>> אז זה עובד למחיקה כל צומת
באמצע list-- אחד ש

132
00:06:07,960 --> 00:06:11,550
יש מצביע לגיטימי קדימה
ומצביע לגיטימי לאחור,

133
00:06:11,550 --> 00:06:14,460
המצביע קודם והבא לגיטימי.

134
00:06:14,460 --> 00:06:16,530
שוב, אם אתה עובד
עם הקצוות,

135
00:06:16,530 --> 00:06:18,500
צריך לטפל באותם
בצורה קצת שונה,

136
00:06:18,500 --> 00:06:19,570
ואנחנו לא הולכים ל
לדבר על זה עכשיו.

137
00:06:19,570 --> 00:06:21,319
אבל כנראה שאתה יכול
להבין את מה שצריך

138
00:06:21,319 --> 00:06:24,610
להיעשות רק על ידי צפייה בסרטון זה.

139
00:06:24,610 --> 00:06:28,910
>> X X. אז אנחנו כבר מבודדים הוא הצומת
אנחנו רוצים למחוק מהרשימה.

140
00:06:28,910 --> 00:06:30,140
מה אנחנו עושים?

141
00:06:30,140 --> 00:06:32,800
ראשית, אנחנו צריכים לארגן מחדש
המצביעים מחוץ.

142
00:06:32,800 --> 00:06:35,815
אנחנו צריכים לארגן מחדש
9 של הבא כדי לדלג מעל 13

143
00:06:35,815 --> 00:06:38,030
ונקודה ל10-- ש
מה בדיוק עשינו.

144
00:06:38,030 --> 00:06:41,180
ואנחנו גם צריכים
לארגן מחדש 10 של קודם

145
00:06:41,180 --> 00:06:44,610
כדי להצביע על 9 במקום להצביע על 13.

146
00:06:44,610 --> 00:06:46,490
>> אז שוב, זה היה
תרשים להתחיל עם.

147
00:06:46,490 --> 00:06:47,730
זה היה השרשרת שלנו.

148
00:06:47,730 --> 00:06:51,027
אנחנו צריכים לדלג מעל 13,
אבל אנחנו צריכים גם לשמר

149
00:06:51,027 --> 00:06:52,110
השלמות של הרשימה.

150
00:06:52,110 --> 00:06:54,680
אנחנו לא רוצים לאבד את כל
מידע בכל כיוון.

151
00:06:54,680 --> 00:06:59,620
אז אנחנו צריכים לארגן מחדש
המצביעים בזהירות

152
00:06:59,620 --> 00:07:02,240
ולכן אנחנו לא לשבור את השרשרת בכל.

153
00:07:02,240 --> 00:07:05,710
>> אז אנו יכולים לומר המצביע הבא של 9
מצביע לאותו המקום

154
00:07:05,710 --> 00:07:08,040
כי של שלושה עשר הבא
מצביע מצביע עכשיו.

155
00:07:08,040 --> 00:07:10,331
כי אנחנו סופו של דבר
הולך רוצה לדלג על 13.

156
00:07:10,331 --> 00:07:13,750
אז בכל מקום בי 13 נקודות הבאות, ש
רוצה תשע להצביע במקום שם.

157
00:07:13,750 --> 00:07:15,200
אז זהו זה.

158
00:07:15,200 --> 00:07:20,370
ולאחר מכן בכל מקום 13 נקודות בחזרה
ל, כל מה שבא לפני 13,

159
00:07:20,370 --> 00:07:24,800
אנחנו רוצים 10 להצביע
שלבמקום 13.

160
00:07:24,800 --> 00:07:29,290
עכשיו שמו לב, אם אתה מבין
החיצים, אנחנו יכולים להוריד 13

161
00:07:29,290 --> 00:07:32,380
מבלי לאבד את כל מידע.

162
00:07:32,380 --> 00:07:36,002
אנחנו שמרנו על שלמות הרשימה,
נע גם קדימה ואחורה.

163
00:07:36,002 --> 00:07:38,210
ואז אנחנו יכולים רק סוג
של לנקות אותו קצת

164
00:07:38,210 --> 00:07:40,930
על ידי משיכת הרשימה יחד.

165
00:07:40,930 --> 00:07:43,270
אז אנחנו מחדש
מצביעים מכל צד.

166
00:07:43,270 --> 00:07:46,231
ואז אנחנו משוחררים X
צומת שהכילה 13,

167
00:07:46,231 --> 00:07:47,480
ואנחנו לא לשבור את השרשרת.

168
00:07:47,480 --> 00:07:50,980
אז עשינו טוב.

169
00:07:50,980 --> 00:07:53,000
>> ההערה אחרונה כאן ברשימות מקושרות.

170
00:07:53,000 --> 00:07:55,990
אז שני singly- וכפליים צמוד
רשימות, כפי שראינו,

171
00:07:55,990 --> 00:07:58,959
החדרה באמת יעילה תמיכה
ומחיקה של אלמנטים.

172
00:07:58,959 --> 00:08:00,750
אתה פחות או יותר יכול לעשות
זה בזמן קבוע.

173
00:08:00,750 --> 00:08:03,333
מה שאנחנו צריכים לעשות כדי למחוק
אלמנט רק שנייה לפני?

174
00:08:03,333 --> 00:08:04,440
עברנו מצביע אחד.

175
00:08:04,440 --> 00:08:05,920
עברנו מצביע אחר.

176
00:08:05,920 --> 00:08:07,915
אנחנו שחררתי X-- לקח שלושה ניתוחים.

177
00:08:07,915 --> 00:08:14,500
זה תמיד לוקח שלושה ניתוחים ל
למחוק node-- שלשחרר צומת.

178
00:08:14,500 --> 00:08:15,280
>> איך להכניס?

179
00:08:15,280 --> 00:08:17,280
ובכן, אנחנו פשוט תמיד
tacking על תחילת

180
00:08:17,280 --> 00:08:19,400
אם אנחנו מכניסים ביעילות.

181
00:08:19,400 --> 00:08:21,964
אז אנחנו צריכים rearrange--
תלוי אם זה

182
00:08:21,964 --> 00:08:24,380
singly- או כפול צמוד
רשימה, שאולי צריך לעשות שלוש

183
00:08:24,380 --> 00:08:26,824
או מקסימום ארבע פעולות.

184
00:08:26,824 --> 00:08:28,365
אבל שוב, זה תמיד שלוש או ארבעה.

185
00:08:28,365 --> 00:08:30,531
זה לא משנה כמה
אלמנטים נמצאים ברשימה שלנו,

186
00:08:30,531 --> 00:08:33,549
זה תמיד שלוש או ארבעה operations--
בדיוק כמו מחיקה היא תמיד

187
00:08:33,549 --> 00:08:35,320
שלוש או ארבע פעולות.

188
00:08:35,320 --> 00:08:36,919
זה זמן קבוע.

189
00:08:36,919 --> 00:08:38,169
אז זה ממש נהדר.

190
00:08:38,169 --> 00:08:40,620
>> עם מערכים, אנחנו עושים
משהו כמו מיון הכנסה.

191
00:08:40,620 --> 00:08:44,739
אתה בטח זוכר הכנסה ש
סוג הוא לא אלגוריתם זמן קבוע.

192
00:08:44,739 --> 00:08:46,030
זה בעצם די יקר.

193
00:08:46,030 --> 00:08:48,840
אז זה הרבה יותר טוב להוספת.

194
00:08:48,840 --> 00:08:51,840
אבל כפי שציינתי ב
ביחידים צמודים וידאו רשימה,

195
00:08:51,840 --> 00:08:54,030
יש לנו חסרון גם כאן, נכון?

196
00:08:54,030 --> 00:08:57,580
איבדנו את היכולת
באופן אקראי לגשת אלמנטים.

197
00:08:57,580 --> 00:09:02,310
אנחנו לא יכולים להגיד, אני רוצה מספר אלמנט ארבעה
או מספר אלמנט של 10 רשימה מקושרת

198
00:09:02,310 --> 00:09:04,990
באותו אופן שאנחנו יכולים
לעשות את זה עם מערך

199
00:09:04,990 --> 00:09:08,630
או שאנחנו יכולים רק ישירות מדד
לאלמנט של המערך שלנו.

200
00:09:08,630 --> 00:09:10,930
>> וכך מנסה למצוא
אלמנט בlist-- קשור

201
00:09:10,930 --> 00:09:15,880
אם החיפוש הוא important--
אולי עכשיו ייקח זמן ליניארי.

202
00:09:15,880 --> 00:09:18,330
כרשימה מתארכת, זה
עלול לקחת צעד אחד נוסף

203
00:09:18,330 --> 00:09:22,644
לכל אלמנט ברשימה ב
כדי למצוא את מה שאנחנו מחפשים.

204
00:09:22,644 --> 00:09:23,560
אז יש מחיקות סחר.

205
00:09:23,560 --> 00:09:25,780
יש קצת פרו
ואלמנט קון כאן.

206
00:09:25,780 --> 00:09:29,110
>> ורשימות כפולים צמודות אינן
סוג אחרון של שילוב מבנה נתונים

207
00:09:29,110 --> 00:09:32,840
שנדברנו על,
לוקח את כל הבניין הבסיסי

208
00:09:32,840 --> 00:09:34,865
בלוקים של C לשים יחד.

209
00:09:34,865 --> 00:09:37,900
כי למעשה, אנחנו יכולים
אפילו לעשות יותר טוב מזה

210
00:09:37,900 --> 00:09:41,970
כדי ליצור מבנה נתונים ש
ייתכן שתוכל לחפש ב

211
00:09:41,970 --> 00:09:43,360
גם בזמן קבוע.

212
00:09:43,360 --> 00:09:46,080
אבל עוד על כך בוידאו אחר.

213
00:09:46,080 --> 00:09:47,150
>> אני דאג לויד.

214
00:09:47,150 --> 00:09:49,050
זה CS50.

215
00:09:49,050 --> 00:09:50,877