1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [Дел 6: Помалку Комфорни]

2
00:00:02,730 --> 00:00:05,040
[Нејт Hardison] [Универзитетот Харвард]

3
00:00:05,040 --> 00:00:07,320
[Ова е CS50.] [CS50.TV]

4
00:00:07,320 --> 00:00:11,840
Во ред. Добредојдовте во делот 6.

5
00:00:11,840 --> 00:00:14,690
Оваа недела, ние ќе се зборува за структури на податоци во делот,

6
00:00:14,690 --> 00:00:19,780
првенствено затоа проблем оваа недела поставени на spellr

7
00:00:19,780 --> 00:00:24,410
прави еден куп на различни податоци структура истражување.

8
00:00:24,410 --> 00:00:26,520
Постојат еден куп на различни начини можете да отидете со проблемот во собата,

9
00:00:26,520 --> 00:00:31,570
и повеќе структури на податоци знаете за, толку повеќе кул работи што можете да направите.

10
00:00:31,570 --> 00:00:34,990
>> Па ајде да започнете. Прво ние ќе зборуваме за Купишта,

11
00:00:34,990 --> 00:00:37,530
на магацинот и задачата структури на податоци кои ние ќе се зборува.

12
00:00:37,530 --> 00:00:40,560
Купишта и редици се навистина корисни кога ќе почнам да зборувам за графикони,

13
00:00:40,560 --> 00:00:44,390
која ние нема да направи толку многу за право сега.

14
00:00:44,390 --> 00:00:52,820
Но тие се навистина добри за да се разбере една од големите основните структури на податоци за CS.

15
00:00:52,820 --> 00:00:54,880
Описот во проблемот сет спецификација,

16
00:00:54,880 --> 00:00:59,260
ако го повлече нагоре, зборува за Купишта како слично на

17
00:00:59,260 --> 00:01:05,239
купот на јадење коцки кои ги имате во кафетеријата на јадење сали

18
00:01:05,239 --> 00:01:09,680
каде што кога јадење персонал доаѓа и го става на јадење пепелниците откако тие ги чистат,

19
00:01:09,680 --> 00:01:12,000
тие ги магацинот еден на врвот на другите.

20
00:01:12,000 --> 00:01:15,050
И тогаш кога децата доаѓаат во да добијат храна,

21
00:01:15,050 --> 00:01:19,490
тие се повлече на коцки исклучување, првиот на врвот, а потоа тој под него, тогаш еден под тоа.

22
00:01:19,490 --> 00:01:25,190
Така, всушност, првиот послужавник дека јадење на персоналот спушти е последниот кој добива соблече.

23
00:01:25,190 --> 00:01:32,330
За последен пат дека јадење на персоналот стави на е првиот кој добива соблече за вечера.

24
00:01:32,330 --> 00:01:38,100
Во спец проблемот сет, што може да го симнете, ако веќе не сте,

25
00:01:38,100 --> 00:01:46,730
зборуваме за моделирање оџак податоци stucture со користење на овој вид на struct.

26
00:01:46,730 --> 00:01:51,070
>> Значи она што ние го добивме тука, ова е слично на она што беше презентиран во предавањето,

27
00:01:51,070 --> 00:01:58,120
освен во предавање го презентиравме со ints наспроти char * s.

28
00:01:58,120 --> 00:02:06,250
Ова ќе биде конзола која продавници што?

29
00:02:06,250 --> 00:02:09,009
Даниел? Што сме ние чување во оваа оџакот?

30
00:02:09,009 --> 00:02:15,260
[Даниел] Стрингови? >> Ние сме чување низи во оваа магацинот, точно.

31
00:02:15,260 --> 00:02:20,950
Сите треба да имате со цел да се создаде магацинот е низа

32
00:02:20,950 --> 00:02:23,920
на одреден капацитет, кој во овој случај,

33
00:02:23,920 --> 00:02:28,020
капацитет ќе биде во сите капи, бидејќи тоа е константа.

34
00:02:28,020 --> 00:02:36,340
А потоа и во прилог на низа, сите ние треба да се следи е сегашната големина на низата.

35
00:02:36,340 --> 00:02:38,980
Една работа е да се напомене тука дека е вид на кул

36
00:02:38,980 --> 00:02:47,060
е дека ние сме создавање на рангирани податоци структура на врвот на друга структура податоци, на низата.

37
00:02:47,060 --> 00:02:50,110
Постојат различни начини да се спроведе Купишта.

38
00:02:50,110 --> 00:02:54,250
Ние нема да го направи тоа уште доста, но се надевам дека откако ќе го направите на поврзани листа на проблеми,

39
00:02:54,250 --> 00:03:00,520
ќе видите како можете лесно може да се спроведе оџак на врвот на поврзани листа, како и.

40
00:03:00,520 --> 00:03:02,640
Но, за сега, ние ќе се држиме до низи.

41
00:03:02,640 --> 00:03:06,350
Значи, повторно, сите ние треба е низа а ние само треба да ги пратите на големината на низата.

42
00:03:06,350 --> 00:03:09,850
[Сем] За жал, зошто е тоа што ти рече дека магацинот е на врвот на жици?

43
00:03:09,850 --> 00:03:13,440
За мене ми се чини дека конците се во рамките на магацинот.

44
00:03:13,440 --> 00:03:16,790
[Hardison] Да. Ние сме создавање, ние сме преземање на нашите низа податоци структура -

45
00:03:16,790 --> 00:03:22,130
тоа е големо прашање. Значи, прашањето е зошто, за луѓето кои се гледаат оваа онлајн,

46
00:03:22,130 --> 00:03:24,140
зошто сме велејќи дека магацинот е на врвот на стрингови,

47
00:03:24,140 --> 00:03:27,990
бидејќи тука личи на жици се во внатрешноста на оџакот?

48
00:03:27,990 --> 00:03:31,050
Кој е целосно случајот.

49
00:03:31,050 --> 00:03:34,660
Она што го мислеше е дека имаме низа податоци структура.

50
00:03:34,660 --> 00:03:39,290
Имаме низа на char * s, оваа низа на стрингови,

51
00:03:39,290 --> 00:03:45,300
и ние се случува да додадете на тоа, со цел да се создаде рангирани податоци структура.

52
00:03:45,300 --> 00:03:48,620
>> Значи оџак е малку покомплексно отколку низа.

53
00:03:48,620 --> 00:03:51,890
Можеме да го користиме низа за изградба на магацинот.

54
00:03:51,890 --> 00:03:55,810
Значи тоа е каде што ние велиме дека магацинот е изграден на врвот на низа.

55
00:03:55,810 --> 00:04:02,510
Исто така, како што реков претходно, ние може да се изгради оџак на врвот на поврзани листа.

56
00:04:02,510 --> 00:04:04,960
Наместо да се користи низа да ја одржиме нашата елементи,

57
00:04:04,960 --> 00:04:10,070
ние може да се користи поврзани со листата за да ја одржиме нашата елементи и да се изгради на магацинот околу тоа.

58
00:04:10,070 --> 00:04:12,420
Ајде да одиме преку неколку примери, гледајќи некои код,

59
00:04:12,420 --> 00:04:14,960
да видиме што навистина се случува овде.

60
00:04:14,960 --> 00:04:23,400
На лево, јас сум фрлени она што магацинот struct ќе изгледа во меморијата

61
00:04:23,400 --> 00:04:28,330
ако капацитет беа # дефиниран да биде четири.

62
00:04:28,330 --> 00:04:33,490
Имаме нашите четири елемент char * низа.

63
00:04:33,490 --> 00:04:38,110
Имаме стрингови [0], стрингови [1], стрингови [2], стрингови [3],

64
00:04:38,110 --> 00:04:43,800
а потоа дека минатата простор за нашата големина број.

65
00:04:43,800 --> 00:04:46,270
Дали ова има смисла? Во ред.

66
00:04:46,270 --> 00:04:48,790
Тоа е она што се случува ако тоа што го правам на десната страна,

67
00:04:48,790 --> 00:04:55,790
кој ќе биде мојот код, е само да се изјасни за struct, а рангирани struct наречен s.

68
00:04:55,790 --> 00:05:01,270
Ова е она што го добиваме. Таа утврдува оваа стапало во меморијата.

69
00:05:01,270 --> 00:05:05,590
Првото прашање тука е она што се содржините на овој магацинот struct?

70
00:05:05,590 --> 00:05:09,250
Токму сега тие се ништо, но тие не се сосема ништо.

71
00:05:09,250 --> 00:05:13,300
Тие се на овој вид на отпад. Немаме поим што е во нив.

72
00:05:13,300 --> 00:05:17,000
Кога ќе се изјасни оџакот е, ние сме само фрлање дека надолу на врвот на меморија.

73
00:05:17,000 --> 00:05:19,840
Тоа е вид на како прогласување int i, а не тоа иницијализацијата.

74
00:05:19,840 --> 00:05:21,730
Вие не знаете што е таму. Можете да го прочитате она што е таму,

75
00:05:21,730 --> 00:05:27,690
но тоа не може да биде супер корисни.

76
00:05:27,690 --> 00:05:32,680
Една работа што сакам да се сеќавам да направите е да се иницијализира она што треба да биде иницијализиран.

77
00:05:32,680 --> 00:05:35,820
Во овој случај, ние ќе треба да се иницијализира со големина да биде нула,

78
00:05:35,820 --> 00:05:39,960
затоа што тоа се случува да испаднат да биде многу важно за нас.

79
00:05:39,960 --> 00:05:43,450
Ние би можеле да одат напред и се иницијализира сите покажувачи, сите char * s,

80
00:05:43,450 --> 00:05:49,670
да бидат некои разбирливо вредност, веројатно нула.

81
00:05:49,670 --> 00:05:58,270
Но тоа не е сосема неопходно што правиме тоа.

82
00:05:58,270 --> 00:06:04,200
>> Сега, двете главни операции на Купишта се?

83
00:06:04,200 --> 00:06:07,610
Секој се сеќавам од предавање она што го правите со Купишта? Да?

84
00:06:07,610 --> 00:06:09,700
[Стела] Туркање и пукање? >> Токму така.

85
00:06:09,700 --> 00:06:13,810
Туркање и пукање, се двете главни операции на Купишта.

86
00:06:13,810 --> 00:06:17,060
И она што не притисни направам? >> Таа го става нешто кон врвот

87
00:06:17,060 --> 00:06:19,300
на магацинот, а потоа пукање го соблекува.

88
00:06:19,300 --> 00:06:23,150
[Hardison] Токму така. Значи туркање турка нешто на врвот на магацинот.

89
00:06:23,150 --> 00:06:27,700
Тоа е како јадење на персоналот ставање на јадење лента надолу на шанкот.

90
00:06:27,700 --> 00:06:33,630
И пукање е со земање на јадење лента исклучување на магацинот.

91
00:06:33,630 --> 00:06:36,460
Ајде да одиме преку неколку примери на она што се случува

92
00:06:36,460 --> 00:06:39,720
кога ќе им помогнам на работите во магацинот.

93
00:06:39,720 --> 00:06:45,110
Ако бевме да им помогнам на стринг "hello" врз нашата оџакот,

94
00:06:45,110 --> 00:06:49,760
тоа е она што нашите дијаграм ќе изгледа сега.

95
00:06:49,760 --> 00:06:53,410
Погледнете што се случува?

96
00:06:53,410 --> 00:06:56,530
Ние се наметнува на првиот елемент на нашата жици низа

97
00:06:56,530 --> 00:07:01,420
и ние покренато нашата големина брои да биде 1.

98
00:07:01,420 --> 00:07:05,340
Значи, ако ние се погледне на разликата помеѓу двете слајдови, тука е 0, еве пред притисок.

99
00:07:05,340 --> 00:07:08,690
Тука е по притисок.

100
00:07:08,690 --> 00:07:13,460
Пред бута, по притискање.

101
00:07:13,460 --> 00:07:16,860
И сега имаме еден елемент во нашата оџак.

102
00:07:16,860 --> 00:07:20,970
Тоа е стринг "hello", и тоа е тоа.

103
00:07:20,970 --> 00:07:24,440
Сè друго во низа, во нашата жици низа, се уште е ѓубре.

104
00:07:24,440 --> 00:07:27,070
Ние не го иницијализира.

105
00:07:27,070 --> 00:07:29,410
Да речеме дека ние им помогнам на некој стринг врз нашата оџак.

106
00:07:29,410 --> 00:07:32,210
Ние ќе им помогнам на "светот" на ова време.

107
00:07:32,210 --> 00:07:35,160
Така можете да видите "светот" тука се на врвот на "здраво",

108
00:07:35,160 --> 00:07:40,040
и големината брои оди до 2.

109
00:07:40,040 --> 00:07:44,520
Сега можеме да им помогнам на "CS50", и дека ќе одиме на врвот повторно.

110
00:07:44,520 --> 00:07:51,110
Ако се вратиме, можете да видите како ние сме туркање работи на врвот на магацинот.

111
00:07:51,110 --> 00:07:53,320
И сега ние да се појави.

112
00:07:53,320 --> 00:07:58,910
Кога ќе се појави нешто надвор од магацинот, што се случило?

113
00:07:58,910 --> 00:08:01,540
Секој видите разликата? Тоа е прилично суптилна.

114
00:08:01,540 --> 00:08:05,810
[Студентски] Големината. >> Да, големината промени.

115
00:08:05,810 --> 00:08:09,040
>> Што друго би се очекува да се промени?

116
00:08:09,040 --> 00:08:14,280
[Студентски] На жици, исто така. >> Право. Конците премногу.

117
00:08:14,280 --> 00:08:17,110
Излегува дека кога ќе си го прави тоа на овој начин,

118
00:08:17,110 --> 00:08:21,960
бидејќи ние не сме копирање на елементи во нашата оџакот,

119
00:08:21,960 --> 00:08:24,670
ние всушност не треба да правите ништо, ние само може да се користи големина

120
00:08:24,670 --> 00:08:28,630
да ги пратите на бројот на нештата во нашата низа

121
00:08:28,630 --> 00:08:33,780
така што кога ќе се појави повторно, повторно ние само декриминирачките нашата големина до 1.

122
00:08:33,780 --> 00:08:39,440
Нема потреба да се всушност оди во и пребришете ништо.

123
00:08:39,440 --> 00:08:41,710
Вид на фанки.

124
00:08:41,710 --> 00:08:46,520
Излегува дека ние обично само остави работите сами, бидејќи тоа е помалку работа за нас да се направи.

125
00:08:46,520 --> 00:08:50,060
Ако ние не треба да се вратиш назад и замени нешто, тогаш зошто го прави тоа?

126
00:08:50,060 --> 00:08:54,150
Па кога ќе се појави двапати надвор од магацинот, сето тоа не е некоја вредност за големината неколку пати.

127
00:08:54,150 --> 00:08:59,120
И повторно, ова е само затоа што не сте копирање нешта во нашиот оџак.

128
00:08:59,120 --> 00:09:01,320
Да? Оди напред.

129
00:09:01,320 --> 00:09:04,460
[Студент, неразбирливо] >> И тогаш што се случува кога ќе им помогнам нешто повторно?

130
00:09:04,460 --> 00:09:08,570
Кога ќе се притисне нешто повторно, каде се оди?

131
00:09:08,570 --> 00:09:12,390
Каде се оди, Василиј? >> Во стрингови [1]? >> Право.

132
00:09:12,390 --> 00:09:14,530
Зошто не се оди во низи [3]?

133
00:09:14,530 --> 00:09:19,410
[Василиј] Поради тоа што заборавил дека има нешто во низи [1] и [2]?

134
00:09:19,410 --> 00:09:24,040
[Hardison] Токму така. Нашите магацинот, во суштина, "заборавил" дека тој, за да ништо

135
00:09:24,040 --> 00:09:29,480
во низи [1] или жици [2], па кога ќе им помогнам на "woot"

136
00:09:29,480 --> 00:09:36,670
тоа само го става тоа во елемент на стрингови [1].

137
00:09:36,670 --> 00:09:41,590
Дали постојат било какви прашања за тоа како тоа функционира, на основно ниво?

138
00:09:41,590 --> 00:09:45,160
[Сем] Значи ова не е динамичен во било кој начин, во однос на износот

139
00:09:45,160 --> 00:09:47,620
или во однос на големината на оџакот?

140
00:09:47,620 --> 00:09:56,750
[Hardison] Токму така. Ова е - поентата е дека ова не е динамички growning оџак.

141
00:09:56,750 --> 00:10:02,850
Ова е конзола која може да се одржи, најмногу, четири char * а, најмногу четири нешта.

142
00:10:02,850 --> 00:10:07,580
Ако бевме да се обиде и да се поттикнат една петтина нешто, што мислите треба да се случи?

143
00:10:07,580 --> 00:10:11,870
[Студентите, неразбирливо]

144
00:10:11,870 --> 00:10:14,600
[Hardison] Токму така. Постојат голем број на нешта што може да се случи.

145
00:10:14,600 --> 00:10:19,330
Тоа би можело евентуално секунда грешка, во зависност од она што сме биле -

146
00:10:19,330 --> 00:10:22,530
како точно бевме спроведување на back-end.

147
00:10:22,530 --> 00:10:31,740
Тоа би можело да запишете врз неа. Тоа може да го имаат тоа buffer overflow кои ние разговаравме за во класата.

148
00:10:31,740 --> 00:10:35,240
Што ќе биде на повеќето очигледно нешто што може да бидат препишани

149
00:10:35,240 --> 00:10:42,370
ако се обидовме да им помогнам на дополнителна работа за нашите оџакот?

150
00:10:42,370 --> 00:10:44,550
Така што ги спомна на buffer overflow.

151
00:10:44,550 --> 00:10:47,870
Што би можело да биде нешто што ќе се напишани во текот или изгазил

152
00:10:47,870 --> 00:10:52,320
ако ние преплави случајно од страна се обидуваат да им помогнам на екстра нешто?

153
00:10:52,320 --> 00:10:54,730
[Даниел, неразбирливо] >> можно.

154
00:10:54,730 --> 00:10:58,440
Но на почетокот, што може да се случи? Што ако ние се обидовме да им помогнам на четвртата работа?

155
00:10:58,440 --> 00:11:06,220
Тоа би можело да ја пребришете големина, барем со оваа меморија дијаграм кој ние го добивме.

156
00:11:06,220 --> 00:11:10,880
>> Во проблемот сет спецификација, што е она што ние ќе треба да се спроведува и денес,

157
00:11:10,880 --> 00:11:16,030
она што сакам да направите е само да се врати лажни.

158
00:11:16,030 --> 00:11:20,030
Нашите притисни метод ќе се врати логичка вредност,

159
00:11:20,030 --> 00:11:22,920
и дека логичка вредност ќе биде вистина ако притисни успева

160
00:11:22,920 --> 00:11:29,730
и лажни ако не можеме да помогнам нешто повеќе, бидејќи на магацинот е полна.

161
00:11:29,730 --> 00:11:33,620
Ајде да одиме преку малку на тој код во моментов.

162
00:11:33,620 --> 00:11:36,400
Тука е нашата притисни функција.

163
00:11:36,400 --> 00:11:40,380
Нашите притисни функција за магацинот се случува да се земе во низа да се стави на магацинот.

164
00:11:40,380 --> 00:11:45,820
Тоа се случува да се вратат вистина ако стрингот беше успешно се наметнува

165
00:11:45,820 --> 00:11:51,820
на магацинот и лажни поинаку.

166
00:11:51,820 --> 00:11:59,740
Било какви предлози за тоа што може да биде добра првото нешто да направите овде?

167
00:11:59,740 --> 00:12:20,630
[Сем] Ако големина е еднаква на капацитетот потоа се врати лажни?

168
00:12:20,630 --> 00:12:23,320
[Hardison] Бинго. Ница работа.

169
00:12:23,320 --> 00:12:26,310
Ако големината е капацитетот, ние ќе се врати лажни.

170
00:12:26,310 --> 00:12:29,270
Ние не можеме да се стави нешто повеќе во нашите оџак.

171
00:12:29,270 --> 00:12:36,900
Инаку, ние сакаме да се стави нешто на врвот на магацинот.

172
00:12:36,900 --> 00:12:41,670
Што е "на врвот на магацинот", првично?

173
00:12:41,670 --> 00:12:43,650
[Даниел] Големина на 0? >> Големина на 0.

174
00:12:43,650 --> 00:12:49,990
Што е на врвот на магацинот по има едно нешто во магацинот? Ма, знаеш?

175
00:12:49,990 --> 00:12:52,720
[Ма] Еден. >> Големина е еден, точно. Можете да ја задржите додавањето на големината,

176
00:12:52,720 --> 00:13:01,690
и секој пат кога ќе се стави во нов елемент на индекс големина во низа.

177
00:13:01,690 --> 00:13:05,470
Ние можеме да го направи тоа со таква една лагер, ако тоа го прави смисла.

178
00:13:05,470 --> 00:13:11,910
Па ние го добивме нашиот жици низа, ние ќе го пристап во големината индекс,

179
00:13:11,910 --> 00:13:14,780
и ние сме само ќе да ја запази нашите char * таму.

180
00:13:14,780 --> 00:13:19,340
Забележи како нема стринг копирање случува овде,

181
00:13:19,340 --> 00:13:29,680
Нема динамична алокација на меморија?

182
00:13:29,680 --> 00:13:34,440
А потоа Missy израснати она што ние сега треба да направите,

183
00:13:34,440 --> 00:13:40,570
бидејќи ние се чуваат на стрингот во соодветно место во низа,

184
00:13:40,570 --> 00:13:49,230
и таа ми рече дека имавме за зголемување на големината на еден така што ние сме подготвени за следниот притисок.

185
00:13:49,230 --> 00:13:53,950
Значи можеме да го направите тоа со s.size + +.

186
00:13:53,950 --> 00:13:59,330
Во овој момент, ние сме турна во нашата низа. Што е последното нешто што треба да направите?

187
00:13:59,330 --> 00:14:10,110
[Студентски] Врати се вистина. >> Врати вистина.

188
00:14:10,110 --> 00:14:14,690
Така, тоа е прилично едноставна, прилично едноставен код. Не премногу.

189
00:14:14,690 --> 00:14:17,070
Откако ќе заврши вашата глава околу тоа како оџакот работи,

190
00:14:17,070 --> 00:14:21,910
ова е прилично едноставно да се имплементира.

191
00:14:21,910 --> 00:14:26,390
>> Сега, следниот дел од ова е пукање низа исклучување на магацинот.

192
00:14:26,390 --> 00:14:29,410
Одам да ви даде момци некои време да работат на ова малку.

193
00:14:29,410 --> 00:14:34,320
Тоа е речиси суштина обратна од она што ние го направивме тука притисок.

194
00:14:34,320 --> 00:14:38,510
Она што го направив е всушност - Упс.

195
00:14:38,510 --> 00:14:48,160
Сум стартува апаратот овде, и во апаратот,

196
00:14:48,160 --> 00:14:53,600
Сум застана на проблемот постави 5 спецификација.

197
00:14:53,600 --> 00:15:02,560
Ако ние зумирате тука, можеме да видиме сум во cdn.cs50.net/2012/fall/psets/pset5.pdf.

198
00:15:02,560 --> 00:15:08,590
Дали сте момци преземале оваа код кој се наоѓа тука, section6.zip?

199
00:15:08,590 --> 00:15:15,030
Во ред. Ако не сте го направиле тоа, го направи тоа право сега, навистина брзо.

200
00:15:15,030 --> 00:15:22,130
Јас ќе го направи тоа во мојот терминален прозорец.

201
00:15:22,130 --> 00:15:25,090
Јас всушност тоа го правеше до тука. Да.

202
00:15:25,090 --> 00:15:34,730
Да, Сем? >> Имам едно прашање за тоа зошто рековте s.string ги загради на големината = ул?

203
00:15:34,730 --> 00:15:42,910
Што е ул? Е тоа што се дефинира некаде пред, или - ох, во char * ул?

204
00:15:42,910 --> 00:15:47,160
[Hardison] Да, точно. Тоа беше аргумент. >> О, во ред. Жал ми е.

205
00:15:47,160 --> 00:15:49,470
[Hardison] Ние сме специфицирање на стринг за да им помогнам внатре

206
00:15:49,470 --> 00:15:55,220
На друго прашање што може да дојде до што ние навистина не зборуваме за тука беше

207
00:15:55,220 --> 00:15:58,810
ние зеде здраво за готово дека имавме оваа променлива наречена ги

208
00:15:58,810 --> 00:16:02,710
тоа беше во обем и достапни за нас.

209
00:16:02,710 --> 00:16:06,960
Ние зеде здраво за готово дека е беше ова магацинот структурата.

210
00:16:06,960 --> 00:16:08,930
Така гледајќи назад во оваа притисни код,

211
00:16:08,930 --> 00:16:13,450
можете да видите дека ние сме прави работи со овој стринг кој доби помина во

212
00:16:13,450 --> 00:16:19,210
но потоа одеднаш, ние сме пристап s.size, како, каде и да доаѓаат од?

213
00:16:19,210 --> 00:16:23,020
Во код кој ние ќе го разгледаме во делот архива

214
00:16:23,020 --> 00:16:27,100
а потоа работи што ќе се прави во вашиот проблем поставува,

215
00:16:27,100 --> 00:16:32,440
ние направивме нашиот магацинот struct глобалната променлива

216
00:16:32,440 --> 00:16:36,380
така што можеме да имаме пристап до него, во сите наши различни функции

217
00:16:36,380 --> 00:16:40,630
без рачно да го помине околу и да го со упатување,

218
00:16:40,630 --> 00:16:44,870
направи сето она што вид на работи на него.

219
00:16:44,870 --> 00:16:52,280
Ние сме само мамење малку, ако сакате, да се направат работите поубаво.

220
00:16:52,280 --> 00:16:57,430
И тоа е нешто што го правиме тука, бидејќи тоа е за забава, тоа е полесно.

221
00:16:57,430 --> 00:17:02,800
Често, ќе видите луѓе го направите ова, ако тие имаат една голема податочна структура

222
00:17:02,800 --> 00:17:07,750
тоа е се работи на во рамките на нивната програма.

223
00:17:07,750 --> 00:17:09,560
>> Да се ​​вратиме во текот на апаратот.

224
00:17:09,560 --> 00:17:15,240
Дали сите успешно го добиете section6.zip?

225
00:17:15,240 --> 00:17:20,440
Сите го отпакувате користење отпакувате section6.zip?

226
00:17:20,440 --> 00:17:27,200
Ако одите во делот 6 директориум -

227
00:17:27,200 --> 00:17:29,220
Aah, насекаде -

228
00:17:29,220 --> 00:17:32,840
и листата што е тука, ќе видите дека имате различни три. в датотеки.

229
00:17:32,840 --> 00:17:38,350
Имаш дното, на SLL, што е одделно поврзана листа, и оџак.

230
00:17:38,350 --> 00:17:44,600
Ако се отвори stack.c,

231
00:17:44,600 --> 00:17:47,330
можете да видите дека ние го добивме ова struct дефинирани за нас,

232
00:17:47,330 --> 00:17:51,330
точната struct дека ние едноставно зборуваше за во слајдовите.

233
00:17:51,330 --> 00:17:56,340
Имаме нашата глобална променлива за оџакот,

234
00:17:56,340 --> 00:18:00,110
ние го добивме нашиот притисни функција,

235
00:18:00,110 --> 00:18:04,230
а потоа ние го добивме нашата поп функција.

236
00:18:04,230 --> 00:18:08,320
Ќе стави код за притисни назад на слајд тука,

237
00:18:08,320 --> 00:18:10,660
но она што јас би сакал вие момци треба да направите е, на најдоброто од вашата способност,

238
00:18:10,660 --> 00:18:13,790
одат и спроведување на поп функција.

239
00:18:13,790 --> 00:18:18,480
Откако ќе го спроведува, може да ги собере со направи оџакот,

240
00:18:18,480 --> 00:18:22,540
а потоа извршете ја произлегуваат магацинот извршна,

241
00:18:22,540 --> 00:18:28,390
и дека ќе работи на сите на овој тест код овде долу тоа е во главниот.

242
00:18:28,390 --> 00:18:31,060
И главните грижи на всушност правејќи го притисни и поп повици

243
00:18:31,060 --> 00:18:33,220
и што си сигурен дека сето тоа оди преку ред.

244
00:18:33,220 --> 00:18:36,820
Таа, исто така иницијализира на магацинот големина тука

245
00:18:36,820 --> 00:18:39,780
така да не мора да се грижите за иницијализирање на тоа.

246
00:18:39,780 --> 00:18:42,310
Може да се претпостави дека тоа е правилно иницијализиран

247
00:18:42,310 --> 00:18:48,000
од страна на време дека пристап до неа во pop функција.

248
00:18:48,000 --> 00:18:53,530
Дали тоа има смисла?

249
00:18:53,530 --> 00:19:00,100
Значи тука ќе одиме. Има притискање код.

250
00:19:00,100 --> 00:19:13,210
Јас ќе ви даде момци 5 или 10 минути.

251
00:19:13,210 --> 00:19:15,690
И ако имате било какви прашања во меѓувреме додека сте кодирање,

252
00:19:15,690 --> 00:19:17,710
обратете се кај нив гласно.

253
00:19:17,710 --> 00:19:23,080
Значи, ако дојде до камен на сопнување, само побарајте.

254
00:19:23,080 --> 00:19:26,030
Дозволете ми да знам, нека секој друг знаат.

255
00:19:26,030 --> 00:19:28,160
Работи со вашиот сосед премногу.

256
00:19:28,160 --> 00:19:30,360
[Даниел] Ние сме само спроведување поп во моментов? >> Само поп.

257
00:19:30,360 --> 00:19:34,200
Иако можете да копирате спроведувањето на притисни ако сакате

258
00:19:34,200 --> 00:19:37,780
така што на тестирањето ќе работат.

259
00:19:37,780 --> 00:19:41,940
Затоа што тоа е тешко да се тестираат работи навлегува во -

260
00:19:41,940 --> 00:19:49,030
или, тешко е да се тестира пукање работи надвор од магацинот ако не постои ништо во магацинот за да започнете со.

261
00:19:49,030 --> 00:19:55,250
>> Што е поп би требало да се врати? На елементот од врвот на магацинот.

262
00:19:55,250 --> 00:20:01,260
Тоа би требало да добие елемент исклучување на врвот на магацинот

263
00:20:01,260 --> 00:20:05,780
а потоа декриминирачките големината на магацинот,

264
00:20:05,780 --> 00:20:07,810
и сега сте изгубиле на елемент на врвот.

265
00:20:07,810 --> 00:20:11,420
И тогаш ќе се вратите на елементот на врвот.

266
00:20:11,420 --> 00:20:20,080
[Студент, неразбирливо]

267
00:20:20,080 --> 00:20:28,810
[Hardison] Значи она што се случува ако го правиш тоа? [Студент, неразбирливо]

268
00:20:28,810 --> 00:20:34,000
Што завршува случува е најверојатно пристап или

269
00:20:34,000 --> 00:20:37,350
елемент кој не е иницијализиран уште, па вашиот пресметка

270
00:20:37,350 --> 00:20:39,990
од каде на последниот елемент е е исклучено.

271
00:20:39,990 --> 00:20:46,260
Па еве, ако забележите, во бута, ние сме пристап до жиците на s.size елемент

272
00:20:46,260 --> 00:20:48,560
бидејќи тоа е нов индекс.

273
00:20:48,560 --> 00:20:51,460
Тоа е новиот врвот на магацинот.

274
00:20:51,460 --> 00:21:01,100
Додека во поп, s.size ќе биде следниот простор,

275
00:21:01,100 --> 00:21:05,210
просторот што е на врвот на сите елементи во вашиот оџак.

276
00:21:05,210 --> 00:21:10,050
Значи топ-повеќето елемент не е во s.size,

277
00:21:10,050 --> 00:21:14,930
туку тоа е под него.

278
00:21:14,930 --> 00:21:19,640
>> Од друга работа да направите кога ќе - во поп,

279
00:21:19,640 --> 00:21:22,030
ви треба да декриминирачките големина.

280
00:21:22,030 --> 00:21:28,750
Ако се сеќавате назад кон нашата мала дијаграм токму тука,

281
00:21:28,750 --> 00:21:30,980
навистина, единственото нешто што сме го виделе случува кога вика поп-

282
00:21:30,980 --> 00:21:36,150
беше дека оваа големина падна, прво до 2, потоа на 1.

283
00:21:36,150 --> 00:21:42,620
Тогаш кога се наметнува нов елемент, тоа ќе оди на на соодветна самото место.

284
00:21:42,620 --> 00:21:49,610
[Василиј] Ако s.size е 2, тогаш тоа не ќе оди во елемент 2,

285
00:21:49,610 --> 00:21:54,400
и тогаш ќе сакате да pop тој елемент надвор?

286
00:21:54,400 --> 00:21:59,510
Значи, ако отидовме - >> Па ајде да погледнеме повторно.

287
00:21:59,510 --> 00:22:07,730
Ако ова е нашата магацинот во овој момент

288
00:22:07,730 --> 00:22:12,130
и ние го нарекуваме поп,

289
00:22:12,130 --> 00:22:16,150
на која индекс е топ-повеќето елемент?

290
00:22:16,150 --> 00:22:19,300
[Василиј] На 2, но тоа се случува да pop-3. >> Право.

291
00:22:19,300 --> 00:22:24,220
Значи тоа е каде што нашата големина е 3, но ние сакаме да pop-елемент на индексот 2.

292
00:22:24,220 --> 00:22:29,900
Тоа е толку типичен вид на надвор од оној што го имаме со нулто индексирање на низи.

293
00:22:29,900 --> 00:22:36,430
Значи вие не сакате да pop третиот елемент, но третиот елемент не е во индекс 3.

294
00:22:36,430 --> 00:22:39,430
И причина ние не треба да го направите тоа минус 1, кога сме туркање

295
00:22:39,430 --> 00:22:44,120
е затоа што токму сега, ќе забележите дека топ-повеќето елемент,

296
00:22:44,120 --> 00:22:47,600
ако ние требаше да им помогнам на нешто друго врз оџакот во овој момент,

297
00:22:47,600 --> 00:22:50,360
ние би сакале да им помогнам на индекс 3.

298
00:22:50,360 --> 00:23:03,550
И тоа само така се случува, дека големината и индексите се редат кога сте туркање.

299
00:23:03,550 --> 00:23:06,960
>> Кој доби работна магацинот имплементација?

300
00:23:06,960 --> 00:23:09,690
Имаш работа магацинот еден. Дали имате поп работат уште?

301
00:23:09,690 --> 00:23:11,890
[Даниел] Да. Јас мислам така.

302
00:23:11,890 --> 00:23:14,610
>> Програмата работи и не секунда Разлом, тоа е печатење?

303
00:23:14,610 --> 00:23:17,520
Дали го испечатите "успех", кога ќе го стартувате?

304
00:23:17,520 --> 00:23:22,630
Да. Направете магацинот, работи, ако тоа отпечатоци од "успехот" и не оди бум,

305
00:23:22,630 --> 00:23:26,000
тогаш сите е добро.

306
00:23:26,000 --> 00:23:34,070
Во ред. Ајде да одиме во текот на апаратот навистина брзо,

307
00:23:34,070 --> 00:23:46,100
и ние ќе одиме преку ова.

308
00:23:46,100 --> 00:23:51,110
Ако ги погледнеме во она што се случува тука со поп,

309
00:23:51,110 --> 00:23:55,220
Даниел, што е првото нешто што си направил?

310
00:23:55,220 --> 00:23:58,850
[Даниел] Ако s.size е поголем од 0.

311
00:23:58,850 --> 00:24:03,120
[Hardison] Во ред. И зошто го правите тоа?

312
00:24:03,120 --> 00:24:05,610
[Даниел] За да бидете сигурни дека има нешто во внатрешноста на оџакот.

313
00:24:05,610 --> 00:24:10,950
[Hardison] Десен. Сакате да пробате да бидете сигурни дека s.size е поголема од 0;

314
00:24:10,950 --> 00:24:13,280
Инаку, она што сакаш да се случи?

315
00:24:13,280 --> 00:24:16,630
[Даниел] Врати нула? >> Врати нула, точно.

316
00:24:16,630 --> 00:24:20,740
Значи, ако s.size е поголем од 0. Тогаш што ќе правиме?

317
00:24:20,740 --> 00:24:25,890
Што ќе правиме ако магацинот не е празен?

318
00:24:25,890 --> 00:24:31,210
[Стела] Вие декриминирачките големината? >> Можете декриминирачките големината, во ред.

319
00:24:31,210 --> 00:24:34,440
Па, како го правиш тоа? >> S.size--.

320
00:24:34,440 --> 00:24:37,030
[Hardison] Велики. А потоа она што го правиш?

321
00:24:37,030 --> 00:24:44,140
[Стела] И тогаш реков враќање s.string [s.size].

322
00:24:44,140 --> 00:24:48,560
[Hardison] Велики.

323
00:24:48,560 --> 00:24:51,940
Инаку ќе се врати нула. Да, Сем?

324
00:24:51,940 --> 00:24:55,510
[Сем] Зошто не треба да биде s.size + 1?

325
00:24:55,510 --> 00:24:58,430
[Hardison] Плус 1? >> Да. >> Го зедов тоа.

326
00:24:58,430 --> 00:25:00,980
[Сем] Мислев дека затоа сте земање 1 надвор,

327
00:25:00,980 --> 00:25:04,290
тогаш ќе треба да се врати не е оној дека тие побарале.

328
00:25:04,290 --> 00:25:09,400
[Hardison] И ова е само она што се зборува со целата оваа прашање од 0 индекси.

329
00:25:09,400 --> 00:25:11,380
Значи, ако ние враќање овде.

330
00:25:11,380 --> 00:25:15,650
Ако ги погледнеме во овој човек овде, што можете да видите дека кога ќе поп,

331
00:25:15,650 --> 00:25:19,340
ние сме пукање на елемент на индекс 2.

332
00:25:19,340 --> 00:25:25,200
>> Значи ние се намали нашата големина, а потоа нашата големина одговара на нашиот индекс.

333
00:25:25,200 --> 00:25:39,650
Ако ние не декриминирачките големината, а потоа ние треба да направите големина -1, а потоа декриминирачките.

334
00:25:39,650 --> 00:25:45,270
Велики. Сите добри?

335
00:25:45,270 --> 00:25:47,530
Било какви прашања за тоа?

336
00:25:47,530 --> 00:25:54,050
Постојат голем број на различни начини да се напише тоа како добро.

337
00:25:54,050 --> 00:26:03,290
Всушност, можеме да сториме и нешто - можеме да направиме една лагер.

338
00:26:03,290 --> 00:26:05,770
Ние може да направи една линија враќање.

339
00:26:05,770 --> 00:26:12,980
Значи ние всушност може да декриминирачките пред да се врати со тоа.

340
00:26:12,980 --> 00:26:18,320
Значи ставање на - пред s.size.

341
00:26:18,320 --> 00:26:22,060
Тоа го прави на линијата навистина густ.

342
00:26:22,060 --> 00:26:30,940
Каде што разликата помеѓу -. Големината и s.size--

343
00:26:30,940 --> 00:26:40,130
е дека ова postfix - тие го нарекуваат тоа postfix бидејќи - доаѓа по s.size--

344
00:26:40,130 --> 00:26:47,430
значи дека s.size се оценува за целите на изнаоѓање на индексот

345
00:26:47,430 --> 00:26:50,410
како што е во моментов кога оваа линија се извршува,

346
00:26:50,410 --> 00:26:54,290
и тогаш ова - се случува по линија добива извршува.

347
00:26:54,290 --> 00:27:00,340
По елемент на индекс s.size се пристапува.

348
00:27:00,340 --> 00:27:07,260
И тоа не е она што го сакаме, затоа што ние сакаме некоја вредност за да се случи прво.

349
00:27:07,260 --> 00:27:10,990
Othewise, ние ќе треба да се пристапува на низа, ефикасно, надвор од границите.

350
00:27:10,990 --> 00:27:16,850
Ние ќе се пристапува на елемент над оној што ние всушност сакате да пристапите.

351
00:27:16,850 --> 00:27:23,840
Да, Сем? >> Е тоа побрзо или користи помалку меморија да се направи во една линија или не?

352
00:27:23,840 --> 00:27:29,620
[Hardison] Искрено, тоа навистина зависи.

353
00:27:29,620 --> 00:27:34,220
[Сем, неразбирливо] >> Да, тоа зависи. Можете да го направите компајлерот трикови

354
00:27:34,220 --> 00:27:41,580
за да го добиете компајлерот да се признае дека, вообичаено, се замисли.

355
00:27:41,580 --> 00:27:44,840
>> Значи ние сме споменати малку за оваа компајлерот оптимизација работи

356
00:27:44,840 --> 00:27:47,400
што можете да направите во составувањето,

357
00:27:47,400 --> 00:27:50,580
и тоа е вид на нешто што компајлерот може да биде во можност да дознаам,

358
00:27:50,580 --> 00:27:54,710
како ох, еј, можеби можам да направам сето ова во една операција,

359
00:27:54,710 --> 00:27:59,420
што е спротивно на вчитување на големината променлива во од RAM меморија,

360
00:27:59,420 --> 00:28:03,770
намалување за тоа, чување на тоа назад, а потоа вчитување назад во повторно

361
00:28:03,770 --> 00:28:08,000
за обработка на остатокот од оваа операција.

362
00:28:08,000 --> 00:28:10,710
Но, обично, не, ова не е вид на нешто

363
00:28:10,710 --> 00:28:20,770
што се случува да се направи вашата програма значително побрзо.

364
00:28:20,770 --> 00:28:26,000
Повеќе прашања во врска со Купишта?

365
00:28:26,000 --> 00:28:31,360
>> Значи туркање и пукање. Ако вие момци сакате да пробате хакер издание,

366
00:28:31,360 --> 00:28:33,660
она што ние го направивме во хакер издание е всушност помина

367
00:28:33,660 --> 00:28:37,670
и направи овој магацинот расте динамично.

368
00:28:37,670 --> 00:28:43,190
Предизвикот не е првенствено се тука во притисни функција,

369
00:28:43,190 --> 00:28:48,820
да дознаам како да се направи таа низа расте

370
00:28:48,820 --> 00:28:52,450
како што се задржи туркање повеќе и повеќе елементи за да магацинот.

371
00:28:52,450 --> 00:28:56,000
Тоа е, всушност, не премногу дополнителен код.

372
00:28:56,000 --> 00:29:00,080
Само повик до - мора да се сеќавам да се добие повици кон Примерок таму правилно,

373
00:29:00,080 --> 00:29:03,310
а потоа дознаам кога ќе одиш да се јавите realloc.

374
00:29:03,310 --> 00:29:06,090
Тоа е забавно предизвик ако сте заинтересирани.

375
00:29:06,090 --> 00:29:11,550
>> Но, засега, да се движи, и ајде да разговараме за редици.

376
00:29:11,550 --> 00:29:15,680
Движете се низ овде.

377
00:29:15,680 --> 00:29:19,340
На дното е близок роднина на магацинот.

378
00:29:19,340 --> 00:29:25,380
Значи во магацинот, она што се стави во последните

379
00:29:25,380 --> 00:29:28,810
беа првите работи кои треба да потоа биде откриена.

380
00:29:28,810 --> 00:29:33,600
Имаме оваа последна во прво надвор, или LIFO, нарачување.

381
00:29:33,600 --> 00:29:38,390
Додека во редот, како што би очекувале од кога си стојат во ред,

382
00:29:38,390 --> 00:29:41,980
првиот човек да се во согласност, првото нешто да се влезе во редот,

383
00:29:41,980 --> 00:29:47,630
е првото нешто што добива извадени од дното.

384
00:29:47,630 --> 00:29:51,490
Редици се исто така често се користи кога ние сме се занимаваат со графикони,

385
00:29:51,490 --> 00:29:55,560
како што зборуваше за кратко со Купишта,

386
00:29:55,560 --> 00:30:00,260
и редици се исто така корисна за еден куп други работи.

387
00:30:00,260 --> 00:30:06,180
Едно нешто што доаѓа до често се обидуваат да се одржи, на пример,

388
00:30:06,180 --> 00:30:12,310
сортирани листа на елементи.

389
00:30:12,310 --> 00:30:17,650
И можете да го направите ова со низа. Можете да одржите подредени листа на работи во низа,

390
00:30:17,650 --> 00:30:20,650
но каде што станува незгодно е тогаш вие секогаш треба да се најде

391
00:30:20,650 --> 00:30:26,160
соодветно место за да вметнете следниот нешто.

392
00:30:26,160 --> 00:30:28,250
Значи, ако имате низа од броеви, од 1 до 10,

393
00:30:28,250 --> 00:30:31,630
а потоа ќе сакаат да го прошират дека до сите броеви од 1 до 100,

394
00:30:31,630 --> 00:30:33,670
а ти си добивање на овие броеви по случаен редослед и се обидува да се задржи сето

395
00:30:33,670 --> 00:30:40,650
подредени како да одиш преку, ќе се заокружи има да се направи многу на менувањето.

396
00:30:40,650 --> 00:30:43,910
Со одредени видови на редици и одредени видови на основните структури на податоци,

397
00:30:43,910 --> 00:30:46,670
вие всушност може да го задржи тоа прилично едноставна.

398
00:30:46,670 --> 00:30:50,640
Вие не треба да додадете нешто, а потоа реконструкција на целата работа секој пат.

399
00:30:50,640 --> 00:30:56,770
Ниту, пак, ќе мора да направи многу на менувањето на внатрешната елементи наоколу.

400
00:30:56,770 --> 00:31:02,990
Кога ќе се погледне во ред, ќе го видите тоа - исто така и во queue.c во делот код -

401
00:31:02,990 --> 00:31:10,950
на struct дека ние сме ви даде е навистина слични на struct кој ние ќе ви даде за оџак.

402
00:31:10,950 --> 00:31:13,770
>> Има еден исклучок од ова, и дека еден исклучок

403
00:31:13,770 --> 00:31:21,700
е дека имаме овој дополнителен број нарекува глава,

404
00:31:21,700 --> 00:31:28,120
и шефот тука е за следење на главата на дното,

405
00:31:28,120 --> 00:31:32,160
или првиот елемент во редот.

406
00:31:32,160 --> 00:31:37,470
Со магацинот, бевме во можност да ги пратите на елементот што бевме за да се добие,

407
00:31:37,470 --> 00:31:40,800
или на врвот на магацинот, користејќи само големината,

408
00:31:40,800 --> 00:31:44,220
а со задача, ние мора да се справи со спротивните краеви.

409
00:31:44,220 --> 00:31:49,000
Ние се обидуваме да тактика работите на крајот, но потоа се врати работите од напред.

410
00:31:49,000 --> 00:31:54,640
Толку ефектно, со главата, имаме индексот на почетокот на редот,

411
00:31:54,640 --> 00:31:58,920
и големината ни дава индексот на крајот од редот

412
00:31:58,920 --> 00:32:03,730
така што можеме да добијам работите од главата и додадете нешта за да на опашката.

413
00:32:03,730 --> 00:32:06,890
Додека кај магацинот, бевме само некогаш се занимаваат со врвот на магацинот.

414
00:32:06,890 --> 00:32:08,900
Ние никогаш не мораше да пристапите до дното на магацинот.

415
00:32:08,900 --> 00:32:12,220
Ние само додаде работи на врвот и ги зедоа работите надвор од врвните

416
00:32:12,220 --> 00:32:17,470
па ние не треба дополнителна дека областа во нашите struct.

417
00:32:17,470 --> 00:32:20,590
Дали тоа воопшто има смисла?

418
00:32:20,590 --> 00:32:27,670
Во ред. Да, Шарлот? [Шарлот, неразбирливо]

419
00:32:27,670 --> 00:32:32,660
[Hardison] Тоа е големо прашање, а тоа беше оној кој дојде во предавање.

420
00:32:32,660 --> 00:32:36,290
Можеби прошетка низ неколку примери ќе ги илустрираат зошто

421
00:32:36,290 --> 00:32:41,400
ние не сакаме да ги користат стрингови [0] како шеф на задачата.

422
00:32:41,400 --> 00:32:46,770
>> Значи замислете дека ние имаме задача, ние ќе го наречеме задача.

423
00:32:46,770 --> 00:32:49,210
На почетокот, кога ние сме само тоа instantiated,

424
00:32:49,210 --> 00:32:53,330
кога сте само да го прогласи, не сме иницијализира ништо.

425
00:32:53,330 --> 00:32:56,790
Сето тоа е ѓубре. Па се разбира, ние сакаме да се осигураме дека можеме иницијализирам

426
00:32:56,790 --> 00:33:00,950
и големината и шефот полиња да биде 0, нешто разумно.

427
00:33:00,950 --> 00:33:05,770
Ние, исто така може да оди напред и нула на елементите во нашата задача.

428
00:33:05,770 --> 00:33:09,930
И да се направи овој дијаграм се вклопуваат, забележите дека сега нашата задача само може да се одржи три елементи;

429
00:33:09,930 --> 00:33:13,150
додека нашата магацинот би можеле да одржат четири, нашата задача само може да се одржи три.

430
00:33:13,150 --> 00:33:18,680
И тоа е само да се направи дијаграм одговара.

431
00:33:18,680 --> 00:33:26,150
Првото нешто што се случува овде е дека ние Стави во ред стринг "Здраво".

432
00:33:26,150 --> 00:33:30,380
И исто како што направивме со магацинот, ништо страшно различни тука,

433
00:33:30,380 --> 00:33:39,230
ние фрли стринг за на стрингови [0] и зголемување нашата големина од 1.

434
00:33:39,230 --> 00:33:42,720
Ние Стави во ред "збогум", станува облечете.

435
00:33:42,720 --> 00:33:45,870
Значи ова личи на магацинот во најголем дел.

436
00:33:45,870 --> 00:33:53,230
Ние започна тука, нов елемент, нов елемент, големината држи случува до.

437
00:33:53,230 --> 00:33:56,330
Што се случува во овој момент, кога сакаме да dequeue нешто?

438
00:33:56,330 --> 00:34:01,280
Кога сакаме да dequeue, која е елемент кој сакаме да dequeue?

439
00:34:01,280 --> 00:34:04,110
[Василиј] Стрингови [0]. >> Нула. Точно во право, Василиј.

440
00:34:04,110 --> 00:34:10,960
Ние сакаме да се ослободиме од првата низа, овој, "Здраво".

441
00:34:10,960 --> 00:34:13,170
Значи она што е друга работа што се промени?

442
00:34:13,170 --> 00:34:17,010
Забележите кога ние појави нешто надвор од оџакот, ние едноставно се промени големината,

443
00:34:17,010 --> 00:34:22,080
но тука, имаме неколку работи таа промена.

444
00:34:22,080 --> 00:34:27,440
Не само што големина промени, но главата промени.

445
00:34:27,440 --> 00:34:31,020
Ова е да се вратам на поентата на Charlotte порано:

446
00:34:31,020 --> 00:34:38,699
зошто имаме оваа глава, како?

447
00:34:38,699 --> 00:34:42,110
Дали има смисла сега, Шарлот? >> Вид.

448
00:34:42,110 --> 00:34:47,500
[Hardison] Вид на? Значи она што се случи кога ќе dequeued?

449
00:34:47,500 --> 00:34:54,340
Што главата направи тоа сега е интересно?

450
00:34:54,340 --> 00:34:56,449
[Шарлот] О, бидејќи тоа се промени - во ред. Гледам.

451
00:34:56,449 --> 00:35:02,090
Бидејќи глава - каде главата е да се покажува промени во однос на локацијата.

452
00:35:02,090 --> 00:35:07,200
Тоа веќе не е секогаш нула индекс на еден. >> Да, точно.

453
00:35:07,200 --> 00:35:17,660
Она што се случи е ако dequeueing висок елемент

454
00:35:17,660 --> 00:35:20,590
беше направено и ние не ја имаат оваа глава поле

455
00:35:20,590 --> 00:35:26,880
затоа што ние секогаш се повикува овој стринг во 0 индексот на чело на нашата листа на чекање,

456
00:35:26,880 --> 00:35:30,170
тогаш ќе треба да се префрлат на остатокот од дното надолу.

457
00:35:30,170 --> 00:35:36,010
Ние ќе мора да се префрлат "збогум" од од стрингови [1] на стрингови [0].

458
00:35:36,010 --> 00:35:38,760
И стрингови [2] до стрингови [1].

459
00:35:38,760 --> 00:35:43,050
И ние ќе мора да го стори тоа за целата листа на елементи,

460
00:35:43,050 --> 00:35:45,110
целата низа на елементи.

461
00:35:45,110 --> 00:35:50,490
И кога ние го правиме ова со низа, која добива навистина скапи.

462
00:35:50,490 --> 00:35:53,340
Па еве, тоа не е голема работа. Ние само треба три елементи во нашата низа.

463
00:35:53,340 --> 00:35:57,230
Но, ако имавме задача од илјада елементи или еден милион елементи,

464
00:35:57,230 --> 00:36:00,060
а потоа одеднаш, ние почнат да прават еден куп на dequeue повикува сите во еден циклус,

465
00:36:00,060 --> 00:36:03,930
работите се навистина се случува да го успори како што се менува се надолу постојано.

466
00:36:03,930 --> 00:36:07,320
Знаете, се префрлат од 1, промена од 1, промена од 1, промена од 1.

467
00:36:07,320 --> 00:36:13,650
Наместо тоа, ние ги користиме оваа глава, ние ја нарекуваме "покажувач", иако тоа не е навистина покажувач

468
00:36:13,650 --> 00:36:16,430
во строга смисла на зборот, тоа не е покажувачот тип.

469
00:36:16,430 --> 00:36:19,410
Тоа не е int * или char * или нешто слично.

470
00:36:19,410 --> 00:36:28,930
Но тоа е посочувајќи или укажува на чело на нашата задача. Да?

471
00:36:28,930 --> 00:36:38,800
>> [Студентски] Како dequeue знаат само убивам она што е на чело?

472
00:36:38,800 --> 00:36:43,620
[Hardison] Како dequeue знаат како да убивам она што е на чело? >> Право, да.

473
00:36:43,620 --> 00:36:49,050
>> Што е во потрага по е само што главата поле е наместено да.

474
00:36:49,050 --> 00:36:52,710
Така што во овој првиот случај, ако гледаме тука,

475
00:36:52,710 --> 00:36:55,690
нашата глава е 0, индексот на 0. >> Право.

476
00:36:55,690 --> 00:37:00,500
[Hardison] Па тоа само вели во ред, добро, елемент на индекс 0, стрингот "Здраво",

477
00:37:00,500 --> 00:37:03,050
е елемент на чело на нашата задача.

478
00:37:03,050 --> 00:37:05,570
Па ние ќе dequeue тоа момче.

479
00:37:05,570 --> 00:37:09,800
И дека ќе биде елемент кој добива се врати на повикувачот.

480
00:37:09,800 --> 00:37:14,540
Да, Saad? >> Значи главата основа поставува - каде што ви се случува да индексира тоа?

481
00:37:14,540 --> 00:37:17,750
Тоа е почеток на тоа? >> Да. >> Океј.

482
00:37:17,750 --> 00:37:22,900
[Hardison] Тоа е да стане нов почеток за нашата низа.

483
00:37:22,900 --> 00:37:28,930
Па кога ќе dequeue нешто, сите што треба да направите е да пристапите на елемент во индекс q.head,

484
00:37:28,930 --> 00:37:32,240
и дека ќе биде елемент кој сакате да го dequeue.

485
00:37:32,240 --> 00:37:34,930
Можете исто така треба да декриминирачките големина.

486
00:37:34,930 --> 00:37:39,430
Ќе видиме во малку каде што нештата се малку слабо со ова.

487
00:37:39,430 --> 00:37:46,520
Ние dequeue, и сега, ако ние Стави во ред, повторно,

488
00:37:46,520 --> 00:37:51,300
каде сме ние Стави во ред?

489
00:37:51,300 --> 00:37:55,000
Каде следниот елемент одат во нашата задача?

490
00:37:55,000 --> 00:37:57,980
Велат сакаме да Стави во ред на стрингот "CS".

491
00:37:57,980 --> 00:38:02,240
Во која индекс ќе одиме? [Студентите] Стрингови [2]. >> Два.

492
00:38:02,240 --> 00:38:04,980
Зошто 2 и не 0?

493
00:38:04,980 --> 00:38:13,570
[Василиј] Бидејќи сега главата е 1, па тоа е како на почетокот на листата?

494
00:38:13,570 --> 00:38:21,220
[Hardison] Десен. И она што го означува крајот на листата?

495
00:38:21,220 --> 00:38:23,290
Што бевме користење за да се означи крајот на нашите дното?

496
00:38:23,290 --> 00:38:25,970
Главата е на чело на нашата листа на чекање, на почетокот на нашата задача.

497
00:38:25,970 --> 00:38:29,530
Што е крајот на нашата задача? [Студентите] Големина. >> Големина, точно.

498
00:38:29,530 --> 00:38:36,360
Па нашите нови елементи одат во во големина, и елементите кои ние ги тргнеме падне на глава.

499
00:38:36,360 --> 00:38:45,390
Кога ќе Стави во ред следниот елемент, ние го стави во во големина.

500
00:38:45,390 --> 00:38:48,530
[Студентски] Пред да се стави дека во сепак, големината е 1, нели?

501
00:38:48,530 --> 00:38:55,690
[Hardison] Десен. Па не е сосема во големина. Големина + не, 1, но + главата.

502
00:38:55,690 --> 00:38:59,990
Бидејќи ние се префрли што од страна на шефот износ.

503
00:38:59,990 --> 00:39:14,270
Па еве, сега ние го добивме задача на големина 1, која почнува на индекс 1.

504
00:39:14,270 --> 00:39:20,730
Опашката е индекс 2. Да?

505
00:39:20,730 --> 00:39:25,780
>> [Студентски] Што се случува кога ќе dequeue стрингови [0], и стрингови 'слотови во меморијата

506
00:39:25,780 --> 00:39:29,420
само да се испразни, во основа, или само заборавен?

507
00:39:29,420 --> 00:39:34,700
[Hardison] Да. Во оваа смисла, ние сме само ги забораваат.

508
00:39:34,700 --> 00:39:42,640
Ако бевме чување на копии од нив за -

509
00:39:42,640 --> 00:39:46,310
многу структури на податоци често ќе ги чувате своите сопствени копии на елементите

510
00:39:46,310 --> 00:39:51,760
така што лицето кое раководи со податочна структура не мора да се грижите

511
00:39:51,760 --> 00:39:53,650
за тоа каде сите тие совети се случува.

512
00:39:53,650 --> 00:39:56,000
Податочна структура има за да сè, има за да сите копии,

513
00:39:56,000 --> 00:39:59,580
да бидете сигурни дека сè продолжува соодветно.

514
00:39:59,580 --> 00:40:03,140
Меѓутоа, во овој случај, овие структури на податоци само за едноставност,

515
00:40:03,140 --> 00:40:05,580
не се прават копии на нешто што ние сме чување во нив.

516
00:40:05,580 --> 00:40:08,630
[Студентски] Значи ова е континуирана низа на - >> Да.

517
00:40:08,630 --> 00:40:14,350
Ако ги погледнеме назад во она што дефиницијата беше на оваа структура, тоа е.

518
00:40:14,350 --> 00:40:19,110
Тоа е само стандарден низа како сте виделе,

519
00:40:19,110 --> 00:40:24,280
низа на char * s.

520
00:40:24,280 --> 00:40:26,340
Дали тоа - >> Да, јас бев само се прашувам

521
00:40:26,340 --> 00:40:29,130
ако сте на крајот ќе снема меморија, до одреден степен,

522
00:40:29,130 --> 00:40:32,330
ако имате сите овие празни места во вашиот низа?

523
00:40:32,330 --> 00:40:36,390
[Hardison] Да, тоа е добра точка.

524
00:40:36,390 --> 00:40:41,530
>> Ако ги погледнеме во она што се случи сега во овој момент,

525
00:40:41,530 --> 00:40:46,350
ние сме полни нашата задача, изгледа.

526
00:40:46,350 --> 00:40:50,390
Но, ние не се навистина полни нашата задача

527
00:40:50,390 --> 00:40:57,710
бидејќи имаме задача која е со големина од 2, но тоа започнува на индекс 1,

528
00:40:57,710 --> 00:41:02,160
бидејќи тоа е местото каде нашата глава покажувач.

529
00:41:02,160 --> 00:41:08,400
Како што велеа, тој елемент на стрингови [0], на индекс 0, не е навистина таму.

530
00:41:08,400 --> 00:41:10,450
Тоа не е во нашата задача веќе.

531
00:41:10,450 --> 00:41:16,460
Ние само не се мачат да одат во и пребришете го кога ќе го dequeued.

532
00:41:16,460 --> 00:41:18,700
Па дури и покрај тоа што изгледа како ние сме снема меморија, ние навистина не треба.

533
00:41:18,700 --> 00:41:23,270
Тоа место е достапен за нас да го користите.

534
00:41:23,270 --> 00:41:29,310
На соодветно однесување, ако ние требаше да се обиде и првиот dequeue нешто

535
00:41:29,310 --> 00:41:34,420
како "збогум", која ќе pop-bye исклучени.

536
00:41:34,420 --> 00:41:38,460
Сега нашата задача започнува во индекс 2 и е со големина од 1.

537
00:41:38,460 --> 00:41:42,240
И сега, ако ние се обидуваме и Стави во ред нешто повторно, да речеме 50,

538
00:41:42,240 --> 00:41:47,880
50 треба да одат во ова место на индекс 0

539
00:41:47,880 --> 00:41:51,270
затоа што тоа е се уште на располагање за нас. Да, Saad?

540
00:41:51,270 --> 00:41:53,630
[Саад] Дали тоа се случи автоматски?

541
00:41:53,630 --> 00:41:56,150
[Hardison] Тоа не се случи сосема автоматски. Мора да го направите математика

542
00:41:56,150 --> 00:42:00,380
да го направите да работи, но во суштина она што ние го направивме е што сме само обвиткана околу.

543
00:42:00,380 --> 00:42:04,070
[Saad] И тоа е во ред, ако тоа има дупка во средината од него?

544
00:42:04,070 --> 00:42:08,720
[Hardison] Тоа е ако можеме да се направи математика работат надвор правилно.

545
00:42:08,720 --> 00:42:15,470
>> И излегува дека тоа е всушност и не е толку тешко да се направи со современи оператор.

546
00:42:15,470 --> 00:42:20,040
Значи исто како што направивме со Цезар и работи крипто,

547
00:42:20,040 --> 00:42:25,190
користење на современи, ние може да се работи за да заврши околу и продолжувам да одам

548
00:42:25,190 --> 00:42:28,090
околу и наоколу и околу со нашите дното,

549
00:42:28,090 --> 00:42:32,180
имајќи дека главата покажувачот се движи наоколу.

550
00:42:32,180 --> 00:42:38,840
Забележете дека големината е секогаш почитувајќи го бројот на елементи всушност во рамките на редот.

551
00:42:38,840 --> 00:42:43,110
И тоа е само главата покажувач што ги држи возење велосипед низ.

552
00:42:43,110 --> 00:42:49,660
Ако ги погледнеме во она што се случи тука, ако ние се вратиме на почетокот,

553
00:42:49,660 --> 00:42:55,020
и ти само се види она што се случува во главата

554
00:42:55,020 --> 00:42:58,240
кога Стави во ред нешто, ништо не се случи во главата.

555
00:42:58,240 --> 00:43:00,970
Кога ќе enqueued нешто друго, ништо не се случи во главата.

556
00:43:00,970 --> 00:43:04,130
Штом ќе dequeued нешто, шефот оди по еден.

557
00:43:04,130 --> 00:43:06,600
Ние enqueued нешто, ништо не се случува во главата.

558
00:43:06,600 --> 00:43:11,060
Кога ќе dequeue нешто, одеднаш главата добива зголемува.

559
00:43:11,060 --> 00:43:14,660
Кога ќе Стави во ред нешто, ништо не се случува во главата.

560
00:43:14,660 --> 00:43:20,240
>> Што ќе се случи во овој момент, ако ние требаше да dequeue нешто повторно?

561
00:43:20,240 --> 00:43:23,240
Секој мисли? Што ќе се случи на главата?

562
00:43:23,240 --> 00:43:27,190
Што треба да се случи на главата

563
00:43:27,190 --> 00:43:32,990
ако ние требаше да dequeue нешто друго?

564
00:43:32,990 --> 00:43:35,400
Главата во моментов е во индекс 2,

565
00:43:35,400 --> 00:43:38,920
што значи дека на чело на листа на чекање е стрингови [2].

566
00:43:38,920 --> 00:43:44,280
[Студентски] Кои се враќа 0? >> Тоа треба да се врати на 0. Тоа треба да заврши назад наоколу, точно.

567
00:43:44,280 --> 00:43:48,440
Досега, секој пат кога ние се нарекува dequeue, ние сме додавање на една на главата,

568
00:43:48,440 --> 00:43:50,960
додадете една до главата, додадете една до главата, додадете една до главата.

569
00:43:50,960 --> 00:43:58,400
Штом дека главата покажувачот добива до последниот индекс во нашата низа,

570
00:43:58,400 --> 00:44:05,650
тогаш ние треба да ја заврши назад околу на почетокот, врати се назад на 0.

571
00:44:05,650 --> 00:44:09,900
[Шарлот] Што го одредува капацитетот на дното во оџак?

572
00:44:09,900 --> 00:44:13,120
[Hardison] Во овој случај, ние само се користи # дефинирана константа. >> Океј.

573
00:44:13,120 --> 00:44:19,590
[Hardison] Во вистински. В датотека, можете да одат во и секрети со неа малку

574
00:44:19,590 --> 00:44:21,710
и да ја направат толку голема или малку, како сакате.

575
00:44:21,710 --> 00:44:25,310
[Шарлот] Значи, кога сте го прави задача, како да се направи на компјутерот знае

576
00:44:25,310 --> 00:44:29,120
колку е голема дека сакате оџакот да биде?

577
00:44:29,120 --> 00:44:31,700
[Hardison] Тоа е големо прашање.

578
00:44:31,700 --> 00:44:34,800
Постојат неколку начини. Една од нив е само да го дефинираат однапред

579
00:44:34,800 --> 00:44:42,050
и велат дека ова ќе биде задача која има 4 елементи или 50 елементи или 10.000.

580
00:44:42,050 --> 00:44:45,430
Другиот начин е да го направи она што на хакерите издание луѓе се прави

581
00:44:45,430 --> 00:44:52,310
и да се создаде функции да имате задача да расте динамички како повеќе работи се додаде внатре

582
00:44:52,310 --> 00:44:54,740
>> [Шарлот] Па да одам со првата опција, што синтакса го користите

583
00:44:54,740 --> 00:44:57,830
да му кажете на програмата што е големината на задачата?

584
00:44:57,830 --> 00:45:04,780
[Hardison] Ах. Значи, да излезе од ова.

585
00:45:04,780 --> 00:45:12,650
Јас сум уште во stack.c тука, па јас сум само ќе дојдете до врвот тука.

586
00:45:12,650 --> 00:45:17,920
Можете да видите ова право тука? Ова е # define капацитет 10.

587
00:45:17,920 --> 00:45:24,600
И ова е речиси иста синтакса која ја имаме за задача.

588
00:45:24,600 --> 00:45:28,390
Освен во ред, ние го добивме дека екстра struct областа тука.

589
00:45:28,390 --> 00:45:32,760
[Шарлот] О, јас мислев на капацитетот значеше капацитет за стринг.

590
00:45:32,760 --> 00:45:36,770
[Hardison] Ах. >> Тоа е максималната должина на зборот. >> Го зедов тоа.

591
00:45:36,770 --> 00:45:41,180
Да. Капацитетот тука - тоа е голема точка.

592
00:45:41,180 --> 00:45:44,000
И ова е нешто што е незгодно

593
00:45:44,000 --> 00:45:49,480
затоа што она што ние го прогласи тука е низа од char * s.

594
00:45:49,480 --> 00:45:52,770
Низа на совети.

595
00:45:52,770 --> 00:45:56,690
Ова е низа од знаци.

596
00:45:56,690 --> 00:46:01,690
Ова е веројатно она што го виделе кога сте биле прогласување вашиот амортизери за датотеката I / O,

597
00:46:01,690 --> 00:46:06,840
кога сте биле создавање жици рачно на магацинот.

598
00:46:06,840 --> 00:46:09,090
Сепак, она што ние го добивме тука е низа од char * s.

599
00:46:09,090 --> 00:46:13,400
Така, тоа е низа на совети.

600
00:46:13,400 --> 00:46:18,350
Всушност, ако зумирате назад и гледаме што се случува тука

601
00:46:18,350 --> 00:46:23,140
во презентацијата, ќе видите дека вистинските елементи, ликот на податоци

602
00:46:23,140 --> 00:46:26,180
не се чуваат во низа себе.

603
00:46:26,180 --> 00:46:42,690
Што се чуваат во нашата низа тука се совети за карактерот на податоци.

604
00:46:42,690 --> 00:46:52,560
Во ред. Така видовме како големината на задачата е исто како со оџакот,

605
00:46:52,560 --> 00:46:58,670
големината секогаш почитува бројот на елементи во моментов на листа на чекање.

606
00:46:58,670 --> 00:47:02,720
По правењето 2 enqueues, големината е 2.

607
00:47:02,720 --> 00:47:07,110
По донесување на dequeue големината е сега 1.

608
00:47:07,110 --> 00:47:09,330
По што друго Стави во ред големината е назад до 2.

609
00:47:09,330 --> 00:47:12,340
Па големината дефинитивно почитува бројот на елементи во редот,

610
00:47:12,340 --> 00:47:15,580
а потоа на главата само чува велосипед.

611
00:47:15,580 --> 00:47:20,210
Тоа оди од 0-1-2, 0-1-2, 0-1-2.

612
00:47:20,210 --> 00:47:25,620
И секој пат кога ние го нарекуваме dequeue, шеф покажувачот добива зголемува на наредниот индекс.

613
00:47:25,620 --> 00:47:29,930
И ако главата е за да поминат, тоа петелки назад околу да се 0.

614
00:47:29,930 --> 00:47:34,870
Така да со тоа, ние може да напише на dequeue функција.

615
00:47:34,870 --> 00:47:40,200
И ние ќе го напушти Стави во ред функција за вас момци да се спроведе наместо тоа.

616
00:47:40,200 --> 00:47:45,880
>> Кога ќе dequeue елемент надвор од нашата задача,

617
00:47:45,880 --> 00:47:55,490
она што беше првото нешто што Даниел направи кога почнавме пишување на поп функција за Купишта?

618
00:47:55,490 --> 00:48:00,490
Дозволете ми да се слушне од некој кој не зборува уште.

619
00:48:00,490 --> 00:48:06,710
Ајде да видиме, Саад, се сеќаваш ли што Даниел направив како првото нешто кога тој напиша поп?

620
00:48:06,710 --> 00:48:08,860
[Саад] Имаше, тоа беше - >> Тој тестиран за нешто.

621
00:48:08,860 --> 00:48:12,140
[Саад] Ако големина е поголема од 0. >> Токму така.

622
00:48:12,140 --> 00:48:14,390
И што беше тоа тестирање за?

623
00:48:14,390 --> 00:48:19,090
[Саад] Тоа беше тестирање за да се види дали има нешто внатре во низа.

624
00:48:19,090 --> 00:48:23,210
[Hardison] Да. Точно. Така да не може да pop-ништо надвор од магацинот ако е празна.

625
00:48:23,210 --> 00:48:26,510
Исто така, не можете да dequeue ништо од редот ако е празна.

626
00:48:26,510 --> 00:48:30,420
Што е првото нешто што треба да правиме во dequeue функцијата тука, мислите?

627
00:48:30,420 --> 00:48:33,860
[Саад] Ако големина е поголема од 0? >> Да.

628
00:48:33,860 --> 00:48:37,710
Во овој случај, јас сум всушност само се тестираат за да видат дали тоа е 0.

629
00:48:37,710 --> 00:48:42,240
Ако е 0, ние може да се врати нула.

630
00:48:42,240 --> 00:48:45,280
Но иста логика.

631
00:48:45,280 --> 00:48:49,110
И нека продолжи со ова.

632
00:48:49,110 --> 00:48:54,600
Ако големината не е 0, каде што е елемент кој сакаме да dequeue?

633
00:48:54,600 --> 00:48:58,550
[Саад] На чело? >> Токму така.

634
00:48:58,550 --> 00:49:01,720
Ние само може да се повлече од првиот елемент во нашата задача

635
00:49:01,720 --> 00:49:07,040
со пристап на елемент во главата.

636
00:49:07,040 --> 00:49:14,630
Ништо луд.

637
00:49:14,630 --> 00:49:19,620
После тоа, она што треба да направам? Што треба да се случи?

638
00:49:19,620 --> 00:49:23,740
Што е друга работа што ние разговаравме за во dequeue?

639
00:49:23,740 --> 00:49:28,130
Две работи треба да се случи, бидејќи нашата задача е променет.

640
00:49:28,130 --> 00:49:35,640
[Даниел] Намалување на големина. >> Мораме да ја намали големината, и да се зголеми на главата? Точно.

641
00:49:35,640 --> 00:49:40,600
Да се ​​зголеми на главата, не можеме само слепо се зголеми на главата, се сеќавам.

642
00:49:40,600 --> 00:49:45,080
Ние не само може да го направи queue.head + +.

643
00:49:45,080 --> 00:49:51,630
Имаме исто така да вклучуваат овој мод со капацитет.

644
00:49:51,630 --> 00:49:54,740
И зошто МО од капацитетот, Стела?

645
00:49:54,740 --> 00:49:58,680
[Стела] Поради тоа треба да заврши околу. >> Токму така.

646
00:49:58,680 --> 00:50:04,750
Ние МО со капацитет бидејќи мора да заврши назад околу да се 0.

647
00:50:04,750 --> 00:50:07,400
Па сега, во овој момент, ние може да го направи она што Даниел рече.

648
00:50:07,400 --> 00:50:12,700
Ние можеме да декриминирачките големина.

649
00:50:12,700 --> 00:50:29,170
А потоа ние едноставно може да се врати на елемент, кој беше на врвот на задачата.

650
00:50:29,170 --> 00:50:34,000
Тоа изгледа вид на чепат во прв план. Можете да имате прашање. Жал ми е?

651
00:50:34,000 --> 00:50:37,260
>> [Сем] Зошто е прв на врвот на редот? Каде што одат?

652
00:50:37,260 --> 00:50:42,480
[Hardison] Таа доаѓа од четвртиот ред од дното.

653
00:50:42,480 --> 00:50:46,060
Откако ќе тестира за да бидете сигурни дека нашата задача не е празна,

654
00:50:46,060 --> 00:50:54,100
ние се повлече char * Прво, ние се повлече елемент кој седи на чело индекс

655
00:50:54,100 --> 00:50:58,680
на нашата низа, на нашите жици низа, >> и повик дека првиот?

656
00:50:58,680 --> 00:51:04,500
[Hardison] И ние го нарекуваме прв план. Да.

657
00:51:04,500 --> 00:51:09,850
Само да се надоврзе на тоа, зошто мислите моравме да го направите тоа?

658
00:51:09,850 --> 00:51:18,270
[Сем] Секоја првиот е само враќање q.strings [q.head]? >> Да.

659
00:51:18,270 --> 00:51:23,830
>> Бидејќи ние го правиме ова менување на q.head со современи функција,

660
00:51:23,830 --> 00:51:27,810
и не постои начин да го направите тоа во рамките враќање линија, исто така.

661
00:51:27,810 --> 00:51:31,640
[Hardison] Токму така. Ти си место на. Сем целосно самото место на.

662
00:51:31,640 --> 00:51:36,800
Причината поради која мораше да се повлече од првиот елемент во нашата задача и чувајте го во променлива

663
00:51:36,800 --> 00:51:43,030
е затоа што оваа линија, каде што имавме само q.head,

664
00:51:43,030 --> 00:51:47,030
има МО оператор таму не е нешто што можеме да направиме

665
00:51:47,030 --> 00:51:51,230
и да го имаат во сила на глава без - во една линија.

666
00:51:51,230 --> 00:51:54,480
Значи ние всушност треба да се повлече од првиот елемент, потоа се приспособат на главата,

667
00:51:54,480 --> 00:52:00,430
прилагодите големина, а потоа се врати на елементот што ќе се извади.

668
00:52:00,430 --> 00:52:02,680
И ова е нешто што ќе видиме излезе подоцна со

669
00:52:02,680 --> 00:52:04,920
поврзани листи, како што се позанимавам со нив.

670
00:52:04,920 --> 00:52:08,410
Често кога ќе се ослободи или отстранување на поврзани листи

671
00:52:08,410 --> 00:52:13,500
што треба да се сеќавам на следниот елемент, следниот покажувачот на поврзани листа

672
00:52:13,500 --> 00:52:16,330
пред отстранување на тековната.

673
00:52:16,330 --> 00:52:23,580
Затоа што во спротивно фрлаат на информации за тоа што е оставена во листата.

674
00:52:23,580 --> 00:52:34,160
Сега, ако одите во Вашиот уред ќе се отвори queue.c--x надвор од ова.

675
00:52:34,160 --> 00:52:39,390
Значи, ако јас се отвори queue.c, дозволете ми да зумирате тука,

676
00:52:39,390 --> 00:52:44,970
ќе видите дека имате слични изглед на датотека.

677
00:52:44,970 --> 00:52:49,200
Слични изглед на датотека, за да она што го имавме порано со stack.c.

678
00:52:49,200 --> 00:52:54,690
Имаме нашите struct за задача дефинирани само како што видовме на слајдови.

679
00:52:54,690 --> 00:52:59,870
>> Ние имаме Стави во ред функција која е за вас да се направи.

680
00:52:59,870 --> 00:53:04,340
И ние имаме dequeue функција овде.

681
00:53:04,340 --> 00:53:06,870
На dequeue функција во датотеката е имплементиран,

682
00:53:06,870 --> 00:53:13,230
но јас ќе ја ставам врати на PowerPoint, така што можете да го напишете, ако сакате.

683
00:53:13,230 --> 00:53:16,690
Значи за следните 5 минути или така, вие момци работат на Стави во ред

684
00:53:16,690 --> 00:53:22,570
што е речиси токму спротивното од dequeue.

685
00:53:22,570 --> 00:53:29,560
Вие не треба да се прилагоди главата кога сте enqueueing, но она што мора да се приспособат?

686
00:53:29,560 --> 00:53:38,920
Големина. Па кога ќе Стави во ред, шеф останува недопрена, големината се пресоблекува.

687
00:53:38,920 --> 00:53:46,920
Но тоа не се малку - ќе мора да се позанимавам со тоа МО

688
00:53:46,920 --> 00:53:57,560
да дознаам што точно индекс новиот елемент треба да се вметнат во.

689
00:53:57,560 --> 00:54:03,080
Затоа јас ќе ви даде момци малку, стави dequeue врати на слајд,

690
00:54:03,080 --> 00:54:05,200
и како вие момци имате прашања, да им викне надвор, така што можеме да

691
00:54:05,200 --> 00:54:09,220
сите зборуваат за нив како група.

692
00:54:09,220 --> 00:54:13,960
Исто така, со големина don't - кога ќе се приспособи на големината, можете да секогаш само -

693
00:54:13,960 --> 00:54:18,720
имаш да МО на големината некогаш? [Даниел] бр >> Вие не треба да МО на големината, нели.

694
00:54:18,720 --> 00:54:24,260
Поради големината ќе и секогаш, ако Ти си - претпоставувајќи сте управување со работи соодветно,

695
00:54:24,260 --> 00:54:30,840
големината секогаш ќе биде помеѓу 0 и 3.

696
00:54:30,840 --> 00:54:38,680
Каде што треба да МО кога правиш Стави во ред?

697
00:54:38,680 --> 00:54:41,060
[Студентски] Само за главата. >> Само за глава, точно.

698
00:54:41,060 --> 00:54:44,620
И зошто треба да МО на сите во Стави во ред?

699
00:54:44,620 --> 00:54:48,830
Кога е ситуација во која ќе треба да МО?

700
00:54:48,830 --> 00:54:53,630
[Студентски] Ако имаш нешто во простори, како на простори 1 и 2,

701
00:54:53,630 --> 00:54:55,950
а потоа ви се потребни за да додадете нешто на 0.

702
00:54:55,950 --> 00:55:02,570
[Hardison] Да, точно. Значи, ако вашиот шеф покажувачот е на самиот крај,

703
00:55:02,570 --> 00:55:14,210
или ако вашата големина плус вашата глава е поголема, или подобро кажано, се случува да се заврши околу задача.

704
00:55:14,210 --> 00:55:17,830
>> Значи во оваа ситуација дека ние го добивме се тука на слајд токму сега,

705
00:55:17,830 --> 00:55:24,370
ако сакам да Стави во ред нешто во право сега,

706
00:55:24,370 --> 00:55:31,110
ние сакаме да Стави во ред нешто во индекс 0.

707
00:55:31,110 --> 00:55:35,450
Значи, ако се погледне каде што 50 оди, и јас го нарекувам Стави во ред 50,

708
00:55:35,450 --> 00:55:40,840
оди таму долу на дното. Тоа оди во индекс 0.

709
00:55:40,840 --> 00:55:44,160
Тоа ја заменува "hi", која веќе беше dequeued.

710
00:55:44,160 --> 00:55:46,210
[Даниел] Не се грижи за тоа во dequeue веќе?

711
00:55:46,210 --> 00:55:50,550
Зошто го направи тоа нешто со главата во Стави во ред?

712
00:55:50,550 --> 00:55:55,770
[Hardison] О, па вие не сте промената на главата, жалам.

713
00:55:55,770 --> 00:56:02,310
Но вие мора да ја користи современи оператор кога ќе се пристапува

714
00:56:02,310 --> 00:56:04,250
елементот што сакате да Стави во ред кога ќе бидете пристап

715
00:56:04,250 --> 00:56:06,960
следниот елемент во вашата задача.

716
00:56:06,960 --> 00:56:10,960
[Василиј] Јас не го стори тоа, и јас добив "успех" таму.

717
00:56:10,960 --> 00:56:13,370
[Даниел] О, јас се разбере она што си ти што зборуваш.

718
00:56:13,370 --> 00:56:16,240
[Hardison] Значи ти didn't - вие само не во q.size?

719
00:56:16,240 --> 00:56:20,670
[Василиј] Да. Јас само смени страни, јас не направив ништо со глава.

720
00:56:20,670 --> 00:56:24,300
[Hardison] Вие не всушност треба да го ресетирате главата да биде ништо,

721
00:56:24,300 --> 00:56:31,650
но кога ќе индекс во низи низа,

722
00:56:31,650 --> 00:56:39,500
вие всушност треба да оди напред и да се пресмета каде следниот елемент е,

723
00:56:39,500 --> 00:56:44,230
бидејќи withe на магацинот, следниот елемент во вашиот магацинот секогаш беше

724
00:56:44,230 --> 00:56:48,740
на индекс одговара на големината.

725
00:56:48,740 --> 00:56:55,850
Ако ги погледнеме назад во нашата магацинот притисни функција,

726
00:56:55,850 --> 00:57:03,100
ние секогаш може долар во нашиот нов елемент право на индекс големина.

727
00:57:03,100 --> 00:57:06,710
А со задача, не можеме да го направи тоа

728
00:57:06,710 --> 00:57:10,340
затоа што ако ние сме во оваа ситуација,

729
00:57:10,340 --> 00:57:18,130
ако ние enqueued 50 нашиот нов стринг ќе одат право во низи [1]

730
00:57:18,130 --> 00:57:20,540
што ние не сакаме да се направи.

731
00:57:20,540 --> 00:57:41,200
Ние сакаме да имаме нов стринг одат во индекс 0.

732
00:57:41,200 --> 00:57:44,320
>> Дали некој - да? [Студентски] Имам едно прашање, но тоа не е навистина поврзани.

733
00:57:44,320 --> 00:57:48,160
Што значи тоа кога некој само го нарекува нешто како pred покажувачот?

734
00:57:48,160 --> 00:57:51,260
Што е тоа име краток за? Знам дека е само името.

735
00:57:51,260 --> 00:57:59,110
[Hardison] pred покажувачот? Ајде да видиме. Во она контекст?

736
00:57:59,110 --> 00:58:01,790
[Студентски] Тоа беше за внесување. Можам да ве прашам подоцна ако сакате

737
00:58:01,790 --> 00:58:03,920
бидејќи тоа не е навистина поврзани, но јас само -

738
00:58:03,920 --> 00:58:07,300
[Hardison] Од вметнете код Давид од лекција?

739
00:58:07,300 --> 00:58:10,860
Ние можеме да се повлече дека и зборува за тоа.

740
00:58:10,860 --> 00:58:15,550
Ќе зборуваме за тоа следниот, штом ќе стигнете до поврзани листи.

741
00:58:15,550 --> 00:58:21,440
>> Па ајде навистина брзо погледнеме во она што Стави во ред функција изгледа.

742
00:58:21,440 --> 00:58:26,530
Што беше првото нешто што луѓето се обиделе да направите во вашиот Стави во ред линија? Во оваа задача?

743
00:58:26,530 --> 00:58:29,960
Слични на она што го направи за магацинот туркање.

744
00:58:29,960 --> 00:58:32,080
Што и да правите, Стела?

745
00:58:32,080 --> 00:58:35,050
[Стела, неразбирливо]

746
00:58:35,050 --> 00:58:45,700
[Hardison] Токму така. Ако (q.size == Капацитет) -

747
00:58:45,700 --> 00:58:54,720
Јас треба да ставам протези на право место - се врати лажни.

748
00:58:54,720 --> 00:59:01,370
Зум во малку. Во ред.

749
00:59:01,370 --> 00:59:03,800
Сега она што е следното нешто што моравме да направам?

750
00:59:03,800 --> 00:59:11,370
Исто како и со магацинот, и додава на вистинското место.

751
00:59:11,370 --> 00:59:16,010
И така она што беше на право место да вметнете тоа?

752
00:59:16,010 --> 00:59:23,170
Со оџакот беше индекс големина, со ова не е сосема тоа.

753
00:59:23,170 --> 00:59:30,210
[Даниел] Имам q.head--или - >> q.strings? >> Да.

754
00:59:30,210 --> 00:59:40,470
q.strings [q.head + q.size современи КАПАЦИТЕТ]?

755
00:59:40,470 --> 00:59:42,740
[Hardison] Ние веројатно сакате да се стави загради околу ова

756
00:59:42,740 --> 00:59:48,830
така што ние сме добивање на соодветен приоритет и така тоа е cleart за сите.

757
00:59:48,830 --> 00:59:55,800
И го постави тоа еднакви? >> Да ул? >> Да ул. Велики.

758
00:59:55,800 --> 01:00:00,160
И сега што е последното нешто што ние треба да направите?

759
01:00:00,160 --> 01:00:06,780
Исто како што направивме во магацинот. >> Наголемува големината? >> Наголемува големина.

760
01:00:06,780 --> 01:00:13,830
Бум. А потоа, откако стартер код само што се врати лажни по дифолт,

761
01:00:13,830 --> 01:00:27,460
сакаме да ја промените оваа да важи ако се оди преку и се оди добро.

762
01:00:27,460 --> 01:00:33,050
Во ред. Тоа е многу информации за секција.

763
01:00:33,050 --> 01:00:39,480
Ние не сме сосема завршена. Ние сакаме да се зборува навистина брзо за одделно поврзани листи.

764
01:00:39,480 --> 01:00:44,010
Јас ќе се стави ова горе за да можеме да се вратиме на тоа подоцна.

765
01:00:44,010 --> 01:00:50,850
Но, да се вратиме на нашата презентација за само неколку слајдови.

766
01:00:50,850 --> 01:00:53,790
Значи Стави во ред е TODO, сега ние сме го направиле.

767
01:00:53,790 --> 01:00:57,430
>> Сега ајде да ги разгледаме во одделно поврзани листи.

768
01:00:57,430 --> 01:01:00,040
Ние разговаравме за овие малку повеќе во предавање.

769
01:01:00,040 --> 01:01:02,540
Како и многумина од вас момци видов демо каде што имаше луѓе

770
01:01:02,540 --> 01:01:08,220
чудно што укажува на едни со други и одржување броеви? >> Бев во тоа.

771
01:01:08,220 --> 01:01:16,620
>> Што ви момци мислите? Сторив тоа, се надевам демистифицира овие малку?

772
01:01:16,620 --> 01:01:25,990
Со листа, излегува дека ние се справи со овој вид дека ние ќе треба да се јавите на јазол.

773
01:01:25,990 --> 01:01:32,520
А со дното и на магацинот имавме structs дека ние би ја нарекол задача во магацинот,

774
01:01:32,520 --> 01:01:34,860
имавме овие нови дното во магацинот видови,

775
01:01:34,860 --> 01:01:39,240
тука список е навистина само составена од еден куп на јазли.

776
01:01:39,240 --> 01:01:45,920
Во истиот начин на кој стрингови се само еден куп на карактери сите наредени една до друга.

777
01:01:45,920 --> 01:01:50,650
А поврзани листа е само еден јазол и друг јазол и друг јазол и друг јазол.

778
01:01:50,650 --> 01:01:55,080
И наместо кршејќи сите јазли заедно и складирање на нив contiguously

779
01:01:55,080 --> 01:01:58,090
сите веднаш до едни со други во меморијата,

780
01:01:58,090 --> 01:02:04,470
има следниот покажувачот ни овозможува да ги чувате јазли каде, по случаен избор.

781
01:02:04,470 --> 01:02:10,500
А потоа вид на жица сите нив заедно за да се укаже од една до друга.

782
01:02:10,500 --> 01:02:15,850
>> И она што беше голема предност што овој има над низа?

783
01:02:15,850 --> 01:02:21,680
Над чување се contiguously само се држат до друг?

784
01:02:21,680 --> 01:02:24,190
Се сеќаваш? Да? >> Динамички алокација на меморија?

785
01:02:24,190 --> 01:02:27,220
>> Динамички алокација на меморија во која смисла?

786
01:02:27,220 --> 01:02:31,780
[Студентски] Во таа може да се задржи што го прави поголеми и не треба да се движи вашата целата низа?

787
01:02:31,780 --> 01:02:40,940
[Hardison] Токму така. Значи со низа, кога сакате да се стави нов елемент во средината на неа,

788
01:02:40,940 --> 01:02:45,320
ќе треба да се сврти се за да се направи простор.

789
01:02:45,320 --> 01:02:47,880
И како ние разговаравме за со задача,

790
01:02:47,880 --> 01:02:50,080
тоа е причината зошто ние се задржи таа глава покажувач,

791
01:02:50,080 --> 01:02:52,050
така што ние не сме постојано менување на нештата.

792
01:02:52,050 --> 01:02:54,520
Затоа што тоа добива скапи ако имаш голема низа

793
01:02:54,520 --> 01:02:57,130
и вие ќе бидете постојано прави овие случајни инсерции.

794
01:02:57,130 --> 01:03:00,820
А со листа, сите што треба да направите е да се фрли на нов јазол,

795
01:03:00,820 --> 01:03:06,330
прилагодување на покажувачи, и ќе завршиш.

796
01:03:06,330 --> 01:03:10,940
Што смрди врска со ова?

797
01:03:10,940 --> 01:03:16,830
Настрана од фактот дека тоа не е толку лесно да се работи со како низа? Да?

798
01:03:16,830 --> 01:03:22,980
[Даниел] Па, претпоставувам дека тоа е многу потешко да пристапите специфичен елемент во поврзани листа?

799
01:03:22,980 --> 01:03:30,470
[Hardison] Вие не може само да скокне до произволна елемент во средината на вашата поврзани листа.

800
01:03:30,470 --> 01:03:33,800
Како ви треба да го направи тоа наместо неа? >> Мора да влезете низ целата работа.

801
01:03:33,800 --> 01:03:35,660
[Hardison] Да. Треба да се оди преку едно по едно време, еден по еден.

802
01:03:35,660 --> 01:03:38,480
Тоа е огромен - тоа е болката.

803
01:03:38,480 --> 01:03:41,550
Што е другата - има уште една пропаст на ова.

804
01:03:41,550 --> 01:03:45,340
[Василиј] Вие не може да оди напред и назад? Треба да се оди во една насока?

805
01:03:45,340 --> 01:03:48,570
[Hardison] Да. Така како ние да се реши тоа, понекогаш?

806
01:03:48,570 --> 01:03:53,370
[Василиј] двојно-поврзани листи? >> Токму така. Постојат двојно-поврзани листи.

807
01:03:53,370 --> 01:03:55,540
Постојат, исто така, - е жал?

808
01:03:55,540 --> 01:03:57,620
>> [Сем] Дали е тоа исто како употребувајќи го pred нешто што -

809
01:03:57,620 --> 01:04:01,090
Јас само се сети, не е дека она што pred нешто е за?

810
01:04:01,090 --> 01:04:05,850
Зарем тоа не е меѓу двојно и одделно?

811
01:04:05,850 --> 01:04:10,020
[Hardison] Ајде да погледнеме во она што точно прави.

812
01:04:10,020 --> 01:04:15,760
Значи тука ќе одиме. Тука е листа код.

813
01:04:15,760 --> 01:04:25,620
Тука имаме predptr, тука. Дали е ова она што го зборуваш?

814
01:04:25,620 --> 01:04:30,750
Значи ова беше - тој е ослободување на листа и тој се обидува да ја запази покажувач кон неа.

815
01:04:30,750 --> 01:04:35,000
Ова не е двојно, поединечно поврзани листи.

816
01:04:35,000 --> 01:04:40,090
Ние можеме да разговараме повеќе за ова подоцна, бидејќи ова се зборува за ослободување на листата

817
01:04:40,090 --> 01:04:42,900
и сакам да покажам некои други нешта во прв план.

818
01:04:42,900 --> 01:04:51,480
но тоа е само - тоа е сеќавајќи се на вредноста на кон меморија

819
01:04:51,480 --> 01:04:54,170
[Студентски] О, тоа е preceeding покажувачот? >> Да.

820
01:04:54,170 --> 01:05:04,070
Така што ние тогаш може прираст кон меморија себе пред да тогаш слободно она што predptr е.

821
01:05:04,070 --> 01:05:09,130
Затоа што не е слободен кон меморија, а потоа може да се јавите кон меморија = кон меморија следната, нели?

822
01:05:09,130 --> 01:05:11,260
Тоа би било лошо.

823
01:05:11,260 --> 01:05:20,940
Да видиме, да се вратиме овој човек.

824
01:05:20,940 --> 01:05:23,900
>> Од друга лоша работа за листи е дека додека со низа

825
01:05:23,900 --> 01:05:26,520
ние само ги имаат сите елементи се наредени еден до друг,

826
01:05:26,520 --> 01:05:29,050
тука ние исто така имаат воведено овој покажувач.

827
01:05:29,050 --> 01:05:34,060
Значи има дополнителни парче на меморија, дека ние сме морале да користите

828
01:05:34,060 --> 01:05:37,910
за секој елемент, дека ние сме чување во нашата листа.

829
01:05:37,910 --> 01:05:40,030
Ние се флексибилност, но тоа доаѓа во цена.

830
01:05:40,030 --> 01:05:42,230
Тоа доаѓа со овој пат цена,

831
01:05:42,230 --> 01:05:45,270
и што доаѓа со оваа меморија цена е премногу.

832
01:05:45,270 --> 01:05:47,800
Време во смисла дека ние сега треба да поминат низ секој елемент во низата

833
01:05:47,800 --> 01:05:58,670
да се најде еден на индекс 10, или дека би биле индекс 10 во низа.

834
01:05:58,670 --> 01:06:01,230
>> Само навистина брзо, кога ќе дијаграм на овие листи,

835
01:06:01,230 --> 01:06:05,980
обично ние се одржи на чело на листата или прв покажувачот на листата

836
01:06:05,980 --> 01:06:08,010
и напомене дека ова е вистински покажувач.

837
01:06:08,010 --> 01:06:11,100
Тоа е само 4 бајти. Тоа не е вистински јазол себе.

838
01:06:11,100 --> 01:06:17,120
Така што гледате дека нема int вредност во него, не следната покажувачот во него.

839
01:06:17,120 --> 01:06:20,790
Тоа е буквално само покажувач.

840
01:06:20,790 --> 01:06:23,550
Тоа се случува да се укаже на нешто што е вистински јазол struct.

841
01:06:23,550 --> 01:06:28,480
[Сем] А покажувач кој се нарекува јазол? >> Ова е - не. Ова е покажувач кон нешто од типот јазол.

842
01:06:28,480 --> 01:06:32,540
Тоа е покажувач кон еден јазол struct. >> О, во ред.

843
01:06:32,540 --> 01:06:36,870
Дијаграмот на лево, кодот на правото.

844
01:06:36,870 --> 01:06:42,190
Ние можеме да го поставите на нула, што е добар начин да се започне.

845
01:06:42,190 --> 01:06:49,850
Кога ќе го дијаграм, можете или пишуваат како нула или ќе се стави линија преку тоа така.

846
01:06:49,850 --> 01:06:53,910
>> Еден од најлесните начини да работат со списоци,

847
01:06:53,910 --> 01:06:57,430
и ние ќе побара од вас да и ставете пред и додаваат за да ја видите разликите помеѓу двете,

848
01:06:57,430 --> 01:07:01,320
но prepending е дефинитивно полесно.

849
01:07:01,320 --> 01:07:05,790
Кога ќе ставете пред, ова е местото каде што - кога ќе ставете пред (7),

850
01:07:05,790 --> 01:07:10,050
да одите и да се создаде јазол struct

851
01:07:10,050 --> 01:07:13,870
и ќе се постави првиот да се укаже на тоа, бидејќи сега, бидејќи ние тоа prepended,

852
01:07:13,870 --> 01:07:17,240
тоа ќе биде на почетокот на листата.

853
01:07:17,240 --> 01:07:22,540
Ако ние ставете пред (3), кој создава друг јазол, но сега 3 доаѓа пред 7.

854
01:07:22,540 --> 01:07:31,130
Па ние сме во суштина туркање работи кон нашата листа.

855
01:07:31,130 --> 01:07:34,720
Сега, може да се види дека ставете пред, понекогаш луѓето го нарекуваат помогнам,

856
01:07:34,720 --> 01:07:39,600
затоа што ти си туркаат нов елемент на вашиот список.

857
01:07:39,600 --> 01:07:43,270
Тоа е исто така лесно да ја избришете на напред на листата.

858
01:07:43,270 --> 01:07:45,650
Па луѓето често ќе се јавите дека поп.

859
01:07:45,650 --> 01:07:52,200
И на тој начин, можете да емулира оџак користење на поврзани листа.

860
01:07:52,200 --> 01:07:57,880
Whoops. За жал, сега ние сме добивање на додавај. Па овде prepended (7), сега ние ставете пред (3).

861
01:07:57,880 --> 01:08:02,600
Ако ние prepended нешто друго врз оваа листа, ако ние prepended (4),

862
01:08:02,600 --> 01:08:06,540
Тогаш би имале 4, а потоа 3 и потоа 7.

863
01:08:06,540 --> 01:08:14,220
Па тогаш ние би можеле да pop и отстранете 4, отстранете 3, извадете 7.

864
01:08:14,220 --> 01:08:16,500
Често повеќе интуитивен начин да се размислува за ова е со додавај.

865
01:08:16,500 --> 01:08:20,310
Па јас diagrammed од она што ќе изгледа како со припојување тука.

866
01:08:20,310 --> 01:08:23,380
Еве, дополнети (7) не изгледа поинаку

867
01:08:23,380 --> 01:08:25,160
бидејќи има само еден елемент во листата.

868
01:08:25,160 --> 01:08:28,620
И МЕНУВАЊЕ (3) го става на крајот.

869
01:08:28,620 --> 01:08:31,020
Можеби може да се види токму сега трик со додавај

870
01:08:31,020 --> 01:08:36,600
е дека, бидејќи ние знаеме само каде на почетокот на листата е,

871
01:08:36,600 --> 01:08:39,450
да се додаде на листата мора да одат по целиот пат низ листата

872
01:08:39,450 --> 01:08:46,500
да се дојде до крајот, да застане, а потоа се изгради на вашата јазол и бухвам се надолу.

873
01:08:46,500 --> 01:08:50,590
Жица сите работи до.

874
01:08:50,590 --> 01:08:55,170
Значи со ставете пред, како што само искинале преку ова навистина брзо,

875
01:08:55,170 --> 01:08:58,170
кога ќе ставете пред да листа, тоа е прилично едноставна.

876
01:08:58,170 --> 01:09:02,960
>> Вие направете ја вашата нова јазол, вклучуваат некои динамична алокација на меморија.

877
01:09:02,960 --> 01:09:09,830
Значи тука правиме еден јазол struct користење Примерок.

878
01:09:09,830 --> 01:09:14,710
Значи Примерок ние користиме затоа што тоа ќе издвои меморија за нас, за подоцна

879
01:09:14,710 --> 01:09:20,350
бидејќи ние не сакаме тоа - ние сакаме оваа меморија да се истрае за долго време.

880
01:09:20,350 --> 01:09:25,350
И ние се добие покажувачот на простор во меморијата дека ние само распределени.

881
01:09:25,350 --> 01:09:29,260
Ние ги користиме големината на јазол, ние не сумира полиња.

882
01:09:29,260 --> 01:09:31,899
Ние не рачно да генерира бројот на бајти,

883
01:09:31,899 --> 01:09:39,750
наместо ние ги користиме sizeof, така што знаеме ние сме добивање на соодветен број на бајти.

884
01:09:39,750 --> 01:09:43,660
Ние бидете сигурни дека за да го тестирате дека нашите Примерок повик успеа.

885
01:09:43,660 --> 01:09:47,939
Ова е нешто што сакате да го направите во целина.

886
01:09:47,939 --> 01:09:52,590
На современи машини, истекува на меморија не е нешто што е лесно

887
01:09:52,590 --> 01:09:56,610
освен ако не сте распределба еден тон работи и прави огромна листа,

888
01:09:56,610 --> 01:10:02,220
но ако сте градење нешто за, да речеме, како на iPhone или Андроид,

889
01:10:02,220 --> 01:10:05,230
имате ограничен меморија ресурси, особено ако правиш нешто интензивна.

890
01:10:05,230 --> 01:10:08,300
Така, тоа е добро да се добие во пракса.

891
01:10:08,300 --> 01:10:10,510
>> Забележете дека јас сум користел неколку различни функции тука

892
01:10:10,510 --> 01:10:12,880
дека сте виделе кои се вид на нов.

893
01:10:12,880 --> 01:10:15,870
Значи fprintf е исто како printf

894
01:10:15,870 --> 01:10:21,320
освен првиот аргумент е поток на кој сакате да се печати.

895
01:10:21,320 --> 01:10:23,900
Во овој случај, ние сакаме да се печати стандардна грешка стринг

896
01:10:23,900 --> 01:10:29,410
кој е различен од стандардниот outstream.

897
01:10:29,410 --> 01:10:31,620
По дифолт тоа што се појавува на истото место.

898
01:10:31,620 --> 01:10:34,600
Исто така, отпечатоци излез на терминал, но можете да -

899
01:10:34,600 --> 01:10:38,790
користење на овие команди што го научиле за, редирекција техники

900
01:10:38,790 --> 01:10:42,290
го научиле за во видео Tommy за проблемот сет 4, можете да го насочи

901
01:10:42,290 --> 01:10:47,900
во различни области, а потоа излезете, токму тука, излегува вашата програма.

902
01:10:47,900 --> 01:10:50,440
Тоа е суштински како се враќаат од главните,

903
01:10:50,440 --> 01:10:53,600
освен ние ги користиме излез бидејќи тука се врати ќе не направи ништо.

904
01:10:53,600 --> 01:10:57,140
Ние не сме во главната, па враќање не излезете од програмата како што сакаме.

905
01:10:57,140 --> 01:11:03,020
Па ние ги користиме на излез функција и го даде грешка во кодот.

906
01:11:03,020 --> 01:11:11,890
Потоа тука се постави вредност областа на новиот јазол, нејзините i поле, за да биде еднаква на i, а потоа го жица до.

907
01:11:11,890 --> 01:11:15,530
Ние во собата следната покажувачот новиот јазол да се укаже прва,

908
01:11:15,530 --> 01:11:20,460
а потоа првата сега ќе укажуваат на нов јазол.

909
01:11:20,460 --> 01:11:25,120
Овие првите линии на код, ние сме всушност градењето на новиот јазол.

910
01:11:25,120 --> 01:11:27,280
Не на последните две линии на оваа функција, но првите.

911
01:11:27,280 --> 01:11:30,290
Ти всушност може да се повлече во функција, во помошна функција.

912
01:11:30,290 --> 01:11:32,560
Тоа е често она што го правам е, јас го повлече во функција,

913
01:11:32,560 --> 01:11:36,040
Јас го наречеме нешто како да се изгради јазол,

914
01:11:36,040 --> 01:11:40,410
и дека го задржува ставете пред функција прилично мал, тоа е само 3 линии тогаш.

915
01:11:40,410 --> 01:11:48,710
Јас се јавам на моите гради јазол функција, а потоа жица сè што.

916
01:11:48,710 --> 01:11:51,970
>> Конечниот нешто што сакам да ти покажам,

917
01:11:51,970 --> 01:11:54,030
и јас ќе ви овозможи да направите додавај и сето тоа на свој,

918
01:11:54,030 --> 01:11:57,500
е како да iterate во текот на листата.

919
01:11:57,500 --> 01:12:00,780
Постојат еден куп на различни начини да iterate во текот на листата.

920
01:12:00,780 --> 01:12:03,140
Во овој случај, ние ќе треба да се најде должината на листата.

921
01:12:03,140 --> 01:12:06,570
Значи ние започнуваме со должина = 0.

922
01:12:06,570 --> 01:12:11,580
Ова е многу сличен на пишување strlen за низа.

923
01:12:11,580 --> 01:12:17,780
Ова е она што сакам да ти покажам, ова за јамка овде.

924
01:12:17,780 --> 01:12:23,530
Тоа изгледа kinda фанки, тоа не е вообичаениот int i = 0, I <што, i + +.

925
01:12:23,530 --> 01:12:34,920
Наместо тоа иницијализацијата нашите променлива n да биде на почетокот на листата.

926
01:12:34,920 --> 01:12:40,620
А потоа, додека нашите iterator променлива не е нула, ние продолжувам да одам.

927
01:12:40,620 --> 01:12:46,340
Тоа е затоа што, од конвенцијата, на крајот на нашата листа ќе биде нула.

928
01:12:46,340 --> 01:12:48,770
А потоа за зголемување, наместо да прави + +,

929
01:12:48,770 --> 01:12:57,010
на поврзани листа еквивалент на + + е n = n-> следната.

930
01:12:57,010 --> 01:13:00,410
>> Јас ќе те оставам да се пополнат празнините тука, бидејќи ние сме надвор од времето.

931
01:13:00,410 --> 01:13:09,300
Но, имајте го ова на ум како што работат на вашиот spellr psets.

932
01:13:09,300 --> 01:13:11,650
Поврзани листи, ако сте спроведување на хаш табелата,

933
01:13:11,650 --> 01:13:14,010
дефинитивно ќе дојде во многу корисна.

934
01:13:14,010 --> 01:13:21,780
И со тоа идиом за looping врз нештата ќе го направи животот многу полесно, се надевам.

935
01:13:21,780 --> 01:13:25,910
Било какви прашања, брзо?

936
01:13:25,910 --> 01:13:28,920
[Сем] Ќе испратиме заврши SLL и АД?

937
01:13:28,920 --> 01:13:38,360
[Hardison] Да. Јас ќе испрати завршени слајдови и заврши SLL магацинот и queue.cs.

938
01:13:38,360 --> 01:13:41,360
[CS50.TV]