1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Seksyon 6] [Higit pang mga kumportableng]

2
00:00:01,000 --> 00:00:04,000
[Rob Bowden] [Harvard University]

3
00:00:04,000 --> 00:00:09,000
[Ito ay CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Maaari naming magtungo sa aming seksyon ng mga tanong.

5
00:00:11,000 --> 00:00:17,000
Naipadala ko ang URL para sa puwang bago.

6
00:00:17,000 --> 00:00:22,000
Ang simula ng seksyon ng tanong sabihin-

7
00:00:22,000 --> 00:00:26,000
tila hindi ako ganap na unsick-ay isang madaling tanong

8
00:00:26,000 --> 00:00:28,000
lamang kung ano ang valgrind?

9
00:00:28,000 --> 00:00:30,000
Ano ang valgrind gawin?

10
00:00:30,000 --> 00:00:34,000
Sinuman na nais upang sabihin kung ano valgrind ginagawa?

11
00:00:34,000 --> 00:00:36,000
[Mag-aaral] tseke memory paglabas.

12
00:00:36,000 --> 00:00:41,000
Oo, valgrind ay isang pangkalahatang memory checker.

13
00:00:41,000 --> 00:00:44,000
Ito, sa dulo, ay nagsasabi sa iyo kung mayroon kang anumang mga paglabas ng memorya,

14
00:00:44,000 --> 00:00:49,000
na halos kung ano ang ginagamit namin ito para sa dahil kung gusto mong

15
00:00:49,000 --> 00:00:54,000
gawin na rin sa hanay ng problema o kung nais mong

16
00:00:54,000 --> 00:00:59,000
sa malaking board, kailangan mong magkaroon ng hindi paglabas ng memory sa anumang,

17
00:00:59,000 --> 00:01:01,000
at kung sakaling mayroon kang isang memory mahayag na hindi mo mahanap,

18
00:01:01,000 --> 00:01:04,000
ring tandaan na tuwing magbubukas ka ng isang file

19
00:01:04,000 --> 00:01:07,000
at kung hindi mo isara ito, na ang isang memory mahayag.

20
00:01:07,000 --> 00:01:10,000
>> Maraming mga tao ay naghahanap para sa ilang mga node na hindi nila pagbabakante

21
00:01:10,000 --> 00:01:15,000
kapag talagang, hindi nila isara ang diksyunaryo sa unang hakbang.

22
00:01:15,000 --> 00:01:19,000
Din ito ay nagsasabi sa iyo kung mayroon kang anumang mga di-wastong bumabasa o nagsusulat,

23
00:01:19,000 --> 00:01:22,000
na nangangahulugan na kung mong subukan at magtakda ng isang halaga

24
00:01:22,000 --> 00:01:26,000
na higit sa dulo ng magbunton at hindi ito mangyayari sa seg fault

25
00:01:26,000 --> 00:01:30,000
ngunit valgrind catches ito, dahil hindi na aktwal mong dapat pagsusulat doon,

26
00:01:30,000 --> 00:01:33,000
at kaya talagang hindi dapat magkaroon ng anumang ng mga alinman.

27
00:01:33,000 --> 00:01:38,000
Paano mo ginagamit ang valgrind?

28
00:01:38,000 --> 00:01:42,000
Paano mo ginagamit ang valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Ito ay isang pangkalahatang tanong ng

30
00:01:45,000 --> 00:01:49,000
uri ng patakbuhin ito at tingnan ang output.

31
00:01:49,000 --> 00:01:51,000
Output ay lumalagpas ng maraming beses.

32
00:01:51,000 --> 00:01:54,000
Mayroon ding masaya error kung saan kung mayroon kang ilang mga bagay na lubha mali

33
00:01:54,000 --> 00:01:59,000
nangyayari sa isang loop, pagkatapos ito ay malaon sabihin, "Way masyadong maraming mga error.

34
00:01:59,000 --> 00:02:03,000
Ako pagpunta sa itigil ang pagbibilang ngayon. "

35
00:02:03,000 --> 00:02:08,000
Ito ay isa lamang tekstuwal output na mayroon ka upang i-parse.

36
00:02:08,000 --> 00:02:13,000
Sa pagtatapos, ito ay sabihin sa iyo ang anumang mga paglabas ng memorya na mayroon kang,

37
00:02:13,000 --> 00:02:16,000
kung gaano karaming mga bloke, na maaaring maging kapaki-pakinabang dahil

38
00:02:16,000 --> 00:02:20,000
kung ito isang bloke unfreed, ito ay karaniwang mas madaling mahanap

39
00:02:20,000 --> 00:02:23,000
sa 1,000 bloke unfreed.

40
00:02:23,000 --> 00:02:26,000
1,000 bloke unfreed marahil ay nangangahulugan na ang hindi ka pagbabakante

41
00:02:26,000 --> 00:02:30,000
iyong naka-link mga listahan sa naaangkop o isang bagay.

42
00:02:30,000 --> 00:02:32,000
Na valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Ngayon ay mayroon kaming ang aming seksyon ng mga tanong,

44
00:02:35,000 --> 00:02:38,000
na hindi mo kailangang i-download.

45
00:02:38,000 --> 00:02:41,000
Maaari kang mag-click sa aking pangalan at hilahin ang mga ito sa puwang.

46
00:02:41,000 --> 00:02:44,000
Ngayon mag-click sa akin.

47
00:02:44,000 --> 00:02:46,000
Rebisyon 1 stack, na ginagawa namin unang.

48
00:02:46,000 --> 00:02:55,000
Rebisyon 2 queue, at Pagbabago 3 ay isa-isa na naka-link na listahan.

49
00:02:55,000 --> 00:02:58,000
Simula off sa aming stack.

50
00:02:58,000 --> 00:03:02,000
Tulad ng sinasabi dito, ang stack ay isa sa mga pinaka-pangunahing,

51
00:03:02,000 --> 00:03:07,000
pangunahing istraktura ng data ng computer science.

52
00:03:07,000 --> 00:03:11,000
Ang prototypical halimbawa ay

53
00:03:11,000 --> 00:03:13,000
ang stack ng mga trays sa dining hall.

54
00:03:13,000 --> 00:03:16,000
Ito ay isa lamang sa tuwing ikaw ay ipinakilala sa isang stack,

55
00:03:16,000 --> 00:03:20,000
isang tao ay pagpunta sa sabihin, "Oh, tulad ng isang stack ng mga trays."

56
00:03:20,000 --> 00:03:22,000
Mong stack ang trays.

57
00:03:22,000 --> 00:03:24,000
Pagkatapos kapag pumunta ka sa hilahin ng tray,

58
00:03:24,000 --> 00:03:31,000
ang unang tray na nagsisimula na nakuha ang huling na ilagay sa stack.

59
00:03:31,000 --> 00:03:34,000
Ang stack din-tulad ng ito sabi dito-

60
00:03:34,000 --> 00:03:37,000
Mayroon namin ang segment ng memory na tinatawag ng stack.

61
00:03:37,000 --> 00:03:40,000
At bakit ito tinatawag ang stack?

62
00:03:40,000 --> 00:03:42,000
>> Dahil tulad ng isang istraktura ng data ng stack,

63
00:03:42,000 --> 00:03:46,000
ito pushes at magpa-pop stack frame sa stack,

64
00:03:46,000 --> 00:03:53,000
kung saan ang stack frame ay tulad ng isang partikular na tawag ng isang function.

65
00:03:53,000 --> 00:03:57,000
At tulad ng isang stack, ikaw ay laging may upang bumalik

66
00:03:57,000 --> 00:04:03,000
mula sa isang function na tawag bago kang makakuha sa mas mababang frame stack muli.

67
00:04:03,000 --> 00:04:08,000
Hindi ka maaaring magkaroon ng mga pangunahing foo tawag tawag bar at bar ng bumalik sa pangunahing direkta.

68
00:04:08,000 --> 00:04:14,000
Palagi itong nakuha upang sundin ang tamang pagtulak ng stack at popping.

69
00:04:14,000 --> 00:04:18,000
Ang dalawang pagpapatakbo, tulad ng sinabi ko, push at mga pop.

70
00:04:18,000 --> 00:04:20,000
Iyon ang unibersal na mga tuntunin.

71
00:04:20,000 --> 00:04:26,000
Na dapat mong malaman sa push at mga pop sa mga tuntunin ng mga stack ng kahit na ano.

72
00:04:26,000 --> 00:04:28,000
Gagamitin namin ang queues uri ng iba't ibang.

73
00:04:28,000 --> 00:04:32,000
Ito ay hindi talagang isang universal na termino, ngunit push at mga pop unibersal para sa stack.

74
00:04:32,000 --> 00:04:34,000
Push ay lamang ilagay sa stack.

75
00:04:34,000 --> 00:04:37,000
Pop off ang stack.

76
00:04:37,000 --> 00:04:43,000
At makita namin dito namin ang aming typedef struct stack,

77
00:04:43,000 --> 00:04:46,000
kaya kami ay may pansamantalang trabaho string **.

78
00:04:46,000 --> 00:04:51,000
Hindi natatakot sa pamamagitan ng anumang **.

79
00:04:51,000 --> 00:04:54,000
Ito ay pagpunta sa isang array ng mga string

80
00:04:54,000 --> 00:04:58,000
o isang hanay ng mga payo sa mga character, kung saan

81
00:04:58,000 --> 00:05:00,000
pointer sa character ay may posibilidad na ang mga string.

82
00:05:00,000 --> 00:05:05,000
Hindi ito na string, ngunit dito, sila ay pagpunta sa maging ang mga string.

83
00:05:05,000 --> 00:05:08,000
>> Mayroon kaming isang array ng mga string.

84
00:05:08,000 --> 00:05:14,000
Mayroon kaming ng laki, na kumakatawan sa kung gaano karaming mga elemento ay kasalukuyang sa stack,

85
00:05:14,000 --> 00:05:19,000
at pagkatapos ay mayroon kaming ang kapasidad, na kung saan ay kung paano maraming mga sangkap na maaari sa stack.

86
00:05:19,000 --> 00:05:22,000
Kapasidad ay dapat magsimula bilang isang bagay na mas malaki kaysa sa 1,

87
00:05:22,000 --> 00:05:27,000
ngunit ang laki upang simulan ang bilang sa 0.

88
00:05:27,000 --> 00:05:36,000
Ngayon, may mga talaga tatlong iba't ibang mga paraan na maaari mong isipin ng isang stack.

89
00:05:36,000 --> 00:05:39,000
Well, may mga marahil higit pa, ngunit sa dalawang pangunahing paraan ay

90
00:05:39,000 --> 00:05:43,000
maaari mong ipatupad ito gamit ang isang array, o maaari mong ipatupad ang mga ito gamit ang isang naka-link na listahan.

91
00:05:43,000 --> 00:05:48,000
Naka-link na listahan ay uri ng trivia gumawa ng mga stack mula sa.

92
00:05:48,000 --> 00:05:51,000
Ito ay lubos na madaling gumawa ng stack gamit ang naka-link na listahan,

93
00:05:51,000 --> 00:05:55,000
kaya dito, kami ay upang gumawa ng stack gamit ang array,

94
00:05:55,000 --> 00:05:59,000
at pagkatapos gamit ang array, mayroong dalawang mga paraan na maaari mong isipin ang tungkol dito.

95
00:05:59,000 --> 00:06:01,000
Bago, kapag ako ay sinabi kami ay may isang kapasidad para sa stack,

96
00:06:01,000 --> 00:06:04,000
upang maaari naming magkasya ang isang elemento sa stack.

97
00:06:04,000 --> 00:06:09,000
>> Ang isang paraan na maaaring mangyari sa lalong madaling habang ikaw ay pindutin ang 10 elemento, tapos ka na.

98
00:06:09,000 --> 00:06:13,000
Maaaring alam mo na may mas mataas na masaklawan ng 10 bagay sa mundo

99
00:06:13,000 --> 00:06:16,000
na hindi ka na kailanman magkaroon ng higit sa 10 mga bagay sa iyong stack,

100
00:06:16,000 --> 00:06:20,000
kung saan maaari kang magkaroon ng isang pang-itaas na nakatali sa laki ng iyong stack.

101
00:06:20,000 --> 00:06:23,000
O maaari kang magkaroon ng iyong stack ay walang hanggan,

102
00:06:23,000 --> 00:06:27,000
ngunit kung gumagawa ka ng isang array, na nangangahulugan na ang bawat solong oras mo pindutin ang 10 elemento,

103
00:06:27,000 --> 00:06:29,000
ka pagpunta sa binabalak na palaguin sa 20 elemento, at kapag pinindot ninyo ang 20 elemento,

104
00:06:29,000 --> 00:06:33,000
ka upang palaguin ang iyong array sa 30 elemento o 40 mga elemento.

105
00:06:33,000 --> 00:06:37,000
Ay pagpunta sa kailangan upang dagdagan ang kapasidad, na kung saan ay kung ano ang kami ay pagpunta sa gawin dito.

106
00:06:37,000 --> 00:06:40,000
Bawat solong oras na maabot namin ang maximum na laki ng aming mga stack,

107
00:06:40,000 --> 00:06:46,000
kapag itulak namin ang iba pa sa, kami ay pagpunta sa kailangan mong taasan ang kapasidad.

108
00:06:46,000 --> 00:06:50,000
Dito, push namin ipinahayag bilang bool push (magpasinda * STR).

109
00:06:50,000 --> 00:06:54,000
Magpasinda * STR ay ang string na kami ay itulak papunta sa stack,

110
00:06:54,000 --> 00:06:58,000
at bool lang sabi kung kami nagtagumpay o Nabigo.

111
00:06:58,000 --> 00:07:00,000
>> Paano namin maaaring mabigo?

112
00:07:00,000 --> 00:07:04,000
Ano ay ang tanging pagkakataon na maaari mong isipin ng

113
00:07:04,000 --> 00:07:07,000
kung saan namin kailangan upang bumalik false?

114
00:07:07,000 --> 00:07:09,000
Oo.

115
00:07:09,000 --> 00:07:12,000
[Mag-aaral] Kung ito ay puno na at ginagamit namin ang isang bounded pagpapatupad.

116
00:07:12,000 --> 00:07:17,000
Oo, kaya paano namin tukuyin-siya sumagot

117
00:07:17,000 --> 00:07:23,000
kung ito ay puno na at ginagamit namin bounded pagpapatupad.

118
00:07:23,000 --> 00:07:26,000
Pagkatapos namin talagang bumalik false.

119
00:07:26,000 --> 00:07:31,000
Sa lalong madaling namin pindutin ang 10 bagay sa array, hindi namin maaaring magkasya 11, kaya bumalik kami maling.

120
00:07:31,000 --> 00:07:32,000
Paano kung ito ay walang hanggan? Oo.

121
00:07:32,000 --> 00:07:38,000
Kung hindi mo maaaring palawakin ang hanay para sa ilang mga kadahilanan.

122
00:07:38,000 --> 00:07:43,000
Oo, kaya memory ay isang limitadong mapagkukunan,

123
00:07:43,000 --> 00:07:51,000
at sa kalaunan, kung panatilihin namin itulak ang mga bagay papunta sa stack nang paulit-ulit,

124
00:07:51,000 --> 00:07:54,000
kami ay pagpunta sa subukan at magtalaga ng isang mas malaking array upang magkasya

125
00:07:54,000 --> 00:07:59,000
ang mas malaking kapasidad, at malloc o anumang ginagamit namin upang bumalik false.

126
00:07:59,000 --> 00:08:02,000
Well, malloc ay magbabalik null.

127
00:08:02,000 --> 00:08:05,000
>> Tandaan, ang bawat solong oras sakaling tumawag malloc, dapat ka check upang makita kung ito

128
00:08:05,000 --> 00:08:12,000
nagbabalik null o tao na ay isang pagbawas sa kawastuhan.

129
00:08:12,000 --> 00:08:17,000
Dahil gusto naming magkaroon ng isang walang hanggan stack,

130
00:08:17,000 --> 00:08:21,000
ang tanging kaso kami ay pagpunta sa bumabalik maling kung susubukan namin

131
00:08:21,000 --> 00:08:26,000
dagdagan ang kapasidad at malloc o anumang nagbabalik maling.

132
00:08:26,000 --> 00:08:30,000
Pagkatapos pop tumatagal walang mga argumento,

133
00:08:30,000 --> 00:08:37,000
at nagbabalik ang string na sa tuktok ng stack.

134
00:08:37,000 --> 00:08:41,000
Anuman ay pinaka kamakailan na hunhon sa stack ay kung ano ang pop ay bumabalik,

135
00:08:41,000 --> 00:08:44,000
at ito rin inaalis ito mula sa stack.

136
00:08:44,000 --> 00:08:50,000
At mapansin na nagbabalik null kung wala sa stack.

137
00:08:50,000 --> 00:08:53,000
Ay laging posible na ang stack ay walang laman.

138
00:08:53,000 --> 00:08:55,000
Sa Java, kung ikaw ay ginagamit upang na, o iba pang mga wika,

139
00:08:55,000 --> 00:09:01,000
sinusubukang i-pop mula sa isang walang laman na stack ay maaaring maging sanhi ng isang pagbubukod o isang bagay.

140
00:09:01,000 --> 00:09:09,000
>> Ngunit sa C, null uri ng maraming ng mga kaso kung paano namin pinangangasiwaan ang mga problemang ito.

141
00:09:09,000 --> 00:09:13,000
Bumabalik na null ay kung paano namin upang magpahiwatig na stack ay walang laman.

142
00:09:13,000 --> 00:09:16,000
Nagbigay kami ng code na subukan ang pag-andar ng iyong stack,

143
00:09:16,000 --> 00:09:19,000
ipatupad ang itulak at pop.

144
00:09:19,000 --> 00:09:23,000
Na ito ay hindi ng maraming ng code.

145
00:09:23,000 --> 00:09:40,000
Ako'y-aktwal na, bago gawin namin iyon, pahiwatig, pahiwatig-

146
00:09:40,000 --> 00:09:44,000
kung hindi mo pa ito nakikita, malloc ay hindi lamang ang function na

147
00:09:44,000 --> 00:09:47,000
na allocates memorya sa magbunton para sa iyo.

148
00:09:47,000 --> 00:09:51,000
May isang pamilya ng mga function ng alloc.

149
00:09:51,000 --> 00:09:53,000
Ang una ay malloc, kung saan ka sanay.

150
00:09:53,000 --> 00:09:56,000
Pagkatapos may calloc, na ipinapakita ang parehong bagay bilang malloc,

151
00:09:56,000 --> 00:09:59,000
ngunit ito ay zero ang lahat para sa iyo.

152
00:09:59,000 --> 00:10:04,000
Kung sakaling mo na gusto upang i-set ang lahat sa null pagkatapos mallocing ng isang bagay

153
00:10:04,000 --> 00:10:06,000
dapat lang na ginamit mo calloc sa unang lugar sa halip ng pagsulat

154
00:10:06,000 --> 00:10:09,000
para sa loop sa zero ang buong block ng memory.

155
00:10:09,000 --> 00:10:15,000
>> Realloc tulad malloc at ay may maraming ng mga espesyal na mga kaso,

156
00:10:15,000 --> 00:10:19,000
ngunit isa lamang kung ano ang realloc ginagawa ay

157
00:10:19,000 --> 00:10:24,000
ito ay tumatagal ng isang pointer na ay nai-inilalaan.

158
00:10:24,000 --> 00:10:27,000
Realloc ay ang function na gusto mong pagbibigay pansin sa dito.

159
00:10:27,000 --> 00:10:31,000
Tumatagal ng pointer na ay na bumalik mula malloc.

160
00:10:31,000 --> 00:10:35,000
Sabihin nating humiling ka mula sa malloc ng pointer ng 10 bytes.

161
00:10:35,000 --> 00:10:38,000
Pagkatapos ay natanto gusto mo ng 20 bytes,

162
00:10:38,000 --> 00:10:42,000
kaya tumawag ka realloc sa na pointer na may 20 bytes,

163
00:10:42,000 --> 00:10:47,000
at realloc ay awtomatikong kopyahin higit sa lahat para sa iyo.

164
00:10:47,000 --> 00:10:51,000
Kung kamakailan mo lamang na tinatawag na malloc muli, tulad ng mayroon akong isang bloke ng 10 bytes.

165
00:10:51,000 --> 00:10:53,000
Ngayon ay kailangan ko ng isang bloke ng 20 bytes,

166
00:10:53,000 --> 00:10:58,000
kaya kung malloc ko 20 bytes, pagkatapos ay mayroon akong upang mano-manong kopyahin sa ibabaw ng 10 bytes mula sa unang bagay

167
00:10:58,000 --> 00:11:01,000
sa ikalawang bagay at pagkatapos ay libre ang unang bagay.

168
00:11:01,000 --> 00:11:04,000
Realloc ay pangasiwaan ang para sa iyo.

169
00:11:04,000 --> 00:11:11,000
>> Mapansin lagda ay walang bisa *,

170
00:11:11,000 --> 00:11:15,000
na lang bumabalik sa isang pointer sa bloke ng memorya,

171
00:11:15,000 --> 00:11:17,000
pagkatapos ay walang bisa * ptr.

172
00:11:17,000 --> 00:11:22,000
Maaari mong isipin na walang bisa * bilang isang generic na pointer.

173
00:11:22,000 --> 00:11:27,000
Sa pangkalahatan, hindi mo kailangang makitungo sa walang bisa *,

174
00:11:27,000 --> 00:11:30,000
ngunit malloc bumabalik ng walang bisa *, at pagkatapos lamang ito ay ginagamit tulad ng

175
00:11:30,000 --> 00:11:34,000
ito ay aktwal na pagpunta sa isang pansamantalang trabaho *.

176
00:11:34,000 --> 00:11:37,000
Ang nakaraang * void na ay ibinalik ng malloc

177
00:11:37,000 --> 00:11:41,000
ngayon ang pagpunta sa maipasa sa realloc, at pagkatapos laki

178
00:11:41,000 --> 00:11:49,000
ang bagong bilang ng mga byte na nais mong maglaan, kaya ang iyong bagong kapasidad.

179
00:11:49,000 --> 00:11:57,000
Bibigyan kita ng ilang minuto, at gawin ang mga ito sa aming espasyo.

180
00:11:57,000 --> 00:12:02,000
Magsimula sa Rebisyon 1.

181
00:12:16,000 --> 00:12:21,000
Ko huminto ka pagkatapos sana tungkol sa sapat na panahon upang ipatupad ang push,

182
00:12:21,000 --> 00:12:24,000
at pagkatapos ay kukunin ko na magbibigay sa iyo ng isa pang break na gawin ang pop.

183
00:12:24,000 --> 00:12:27,000
Ngunit ito ay hindi talaga ang ganoong karaming mga code sa lahat.

184
00:12:27,000 --> 00:12:35,000
Ang pinaka code ay maaaring ang pagpapalawak ng mga bagay-bagay, pagpapalawak ng kapasidad.

185
00:12:35,000 --> 00:12:39,000
Okay, walang presyon ikay,

186
00:12:39,000 --> 00:12:47,000
ngunit hangga't sa tingin mo tulad ng ikaw ay sa tamang landas, na mahusay.

187
00:12:47,000 --> 00:12:53,000
>> Ba ang sinuman anumang code na palagay nila ay kumportable sa akin paghila up?

188
00:12:53,000 --> 00:12:59,000
Oo, ako, ngunit ang sinuman anumang code na maaari kong makuha ang?

189
00:12:59,000 --> 00:13:05,000
Okay, maaari mong magsimula, i-save ito, kahit anong ito ay?

190
00:13:05,000 --> 00:13:09,000
Ko laging kalimutan na hakbang.

191
00:13:09,000 --> 00:13:15,000
Okay, pagtingin sa push,

192
00:13:15,000 --> 00:13:18,000
ang gusto mong ipaliwanag ang iyong code?

193
00:13:18,000 --> 00:13:24,000
[Mag-aaral] Una sa lahat, pinataas na ako ang laki.

194
00:13:24,000 --> 00:13:28,000
Hulaan ko siguro dapat na mayroon ako na-pa rin, pinataas na ako ang laki,

195
00:13:28,000 --> 00:13:31,000
at nakikita ko kung ito ay mas mababa kaysa sa kapasidad.

196
00:13:31,000 --> 00:13:36,000
At kung ito ay mas mababa kaysa sa kapasidad, ako idagdag sa array na namin ay mayroon.

197
00:13:36,000 --> 00:13:42,000
At kung hindi, ako multiply ang kapasidad ng 2,

198
00:13:42,000 --> 00:13:50,000
at reallocate ko ang string array sa isang bagay na may isang mas malaking kapasidad laki ngayon.

199
00:13:50,000 --> 00:13:55,000
At pagkatapos ay kung na nabigo, Sinasabi ko sa user at bumalik ang maling,

200
00:13:55,000 --> 00:14:04,000
at kung ito ang masarap na, pagkatapos kong ilagay ang string sa bagong puwesto.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] rin mapapansin na ginamit namin ang isang magaling bitwise operator dito

202
00:14:07,000 --> 00:14:09,000
sa multiply ng 2.

203
00:14:09,000 --> 00:14:11,000
Tandaan, kaliwa shift ay palaging pagpunta sa multiply sa 2.

204
00:14:11,000 --> 00:14:15,000
Kanan shift ay hinati sa pamamagitan ng 2 hangga't tandaan mo na ang ibig sabihin nito

205
00:14:15,000 --> 00:14:18,000
hatiin sa pamamagitan ng 2 sa isang integer na hinati sa pamamagitan ng 2.

206
00:14:18,000 --> 00:14:20,000
Maaaring truncate ng 1 dito o doon.

207
00:14:20,000 --> 00:14:26,000
Ngunit ang shift kaliwa ng 1 ay palaging pagpunta sa multiply sa 2,

208
00:14:26,000 --> 00:14:32,000
maliban kung overflow ang mga hangganan ng integer, at pagkatapos ay hindi ito ay.

209
00:14:32,000 --> 00:14:34,000
Ang isang gilid ng komento.

210
00:14:34,000 --> 00:14:39,000
Gusto ko gawin ito ay hindi baguhin ang coding sa anumang paraan anumang,

211
00:14:39,000 --> 00:14:48,000
ngunit gusto kong gawin ang isang bagay tulad nito.

212
00:14:48,000 --> 00:14:51,000
Aktwal na ito ay upang gawin itong bahagyang na.

213
00:15:04,000 --> 00:15:08,000
Siguro, ito ay hindi ang perpektong kaso upang ipakita ito,

214
00:15:08,000 --> 00:15:14,000
ngunit gusto ko upang i-segment ito sa mga bloke ng-

215
00:15:14,000 --> 00:15:17,000
okay, kung ito kung mangyayari, pagkatapos ako pagpunta sa gawin ang isang bagay,

216
00:15:17,000 --> 00:15:19,000
at pagkatapos ay ang function ay tapos na.

217
00:15:19,000 --> 00:15:22,000
Hindi ko kailangan pagkatapos ay mag-scroll sa aking mga mata ang lahat ng mga paraan pababa sa andar

218
00:15:22,000 --> 00:15:25,000
upang makita kung ano ang mangyayari pagkatapos ng pang tao.

219
00:15:25,000 --> 00:15:27,000
Kung ito kung mangyayari, pagkatapos ko lang ibalik.

220
00:15:27,000 --> 00:15:30,000
Mayroon din ang magaling na idinagdag na pakinabang ng lahat lampas ito

221
00:15:30,000 --> 00:15:33,000
ngayon Paglipat sa kaliwa sabay-sabay.

222
00:15:33,000 --> 00:15:40,000
Hindi ko na kailangan to-kung sakaling malapit ridiculously mahaba ang linya,

223
00:15:40,000 --> 00:15:45,000
pagkatapos 4 bytes na iyon ay maaaring makatulong sa, at din sa mas kaliwa ng isang bagay,

224
00:15:45,000 --> 00:15:48,000
ang hindi gaanong nalulula sa tingin mo kung nais-okay, mayroon akong matandaan

225
00:15:48,000 --> 00:15:53,000
Ako ay kasalukuyang sa isang habang loop sa loob ng isang pang tao sa loob ng isang para sa loop.

226
00:15:53,000 --> 00:15:58,000
Kahit saan maaari mong gawin ito balik agad, ako uri ng tulad ng.

227
00:15:58,000 --> 00:16:05,000
Lubos opsyonal at hindi inaasahan sa anumang paraan.

228
00:16:05,000 --> 00:16:12,000
>> [Mag-aaral] Kung mayroong isang sukat - sa kundisyon ng mabigo?

229
00:16:12,000 --> 00:16:19,000
Ang mabigo kundisyon dito nabigo kaming sa realloc, kaya oo.

230
00:16:19,000 --> 00:16:22,000
Pansinin kung paano sa kundisyon ng mabigo, baka,

231
00:16:22,000 --> 00:16:26,000
maliban kung namin libreng mga bagay-bagay sa ibang pagkakataon, palagi kaming pagpunta sa mabibigo

232
00:16:26,000 --> 00:16:29,000
hindi mahalaga kung gaano karaming beses ang subukan namin upang itulak ang isang bagay.

233
00:16:29,000 --> 00:16:32,000
Kung panatilihin namin pagtulak, panatilihin namin incrementing laki,

234
00:16:32,000 --> 00:16:36,000
kahit na hindi namin paglalagay ng anumang bagay papunta sa stack.

235
00:16:36,000 --> 00:16:39,000
Karaniwan hindi namin dagdagan ang laki hanggang

236
00:16:39,000 --> 00:16:43,000
pagkatapos ng matagumpay na namin na ilagay ang mga ito sa stack.

237
00:16:43,000 --> 00:16:50,000
Nais naming gawin ito, sabihin nating, alinman dito at dito.

238
00:16:50,000 --> 00:16:56,000
At pagkatapos ay sa halip na sinasabi s.size ≤ kapasidad, ito ay mas mababa kaysa sa kapasidad,

239
00:16:56,000 --> 00:17:01,000
lamang dahil namin inilipat kung saan ang lahat ay.

240
00:17:01,000 --> 00:17:07,000
>> At tandaan, ang tanging lugar na maaari kaming posibleng bumalik maling

241
00:17:07,000 --> 00:17:14,000
dito, kung saan realloc ibinalik null,

242
00:17:14,000 --> 00:17:19,000
at kung mangyari mong tandaan ang standard na error,

243
00:17:19,000 --> 00:17:22,000
marahil maaari mong isaalang-alang ang isang kaso kung saan nais mong i-print ang isang karaniwang error,

244
00:17:22,000 --> 00:17:26,000
kaya fprintf stderr sa halip na lamang ang pag-print nang direkta sa pamantayan out.

245
00:17:26,000 --> 00:17:31,000
Muli, na hindi inaasahan, ngunit kung ito ay isang error,

246
00:17:31,000 --> 00:17:41,000
type printf, pagkatapos ay maaari mong upang gawin itong i-print sa standard error sa halip ng karaniwang out.

247
00:17:41,000 --> 00:17:44,000
>> Sinuman ay may anumang bagay upang tandaan? Oo.

248
00:17:44,000 --> 00:17:47,000
[Mag-aaral] Maaari kang pumunta sa ibabaw ng [] hindi marinig?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Oo, ang aktwal na binariness nito o kung ano ito ay?

250
00:17:55,000 --> 00:17:57,000
[Mag-aaral] Kaya multiply mo ito sa pamamagitan ng 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Oo, talaga.

252
00:17:59,000 --> 00:18:11,000
Sa binary lupa, lagi naming ang aming hanay ng mga digit.

253
00:18:11,000 --> 00:18:22,000
Paglilipat na ito kaliwa ng 1 insert talaga na ito dito sa kanang bahagi.

254
00:18:22,000 --> 00:18:25,000
Bumalik sa mga ito, lamang-alala na ang lahat sa binary

255
00:18:25,000 --> 00:18:28,000
ay isang kapangyarihan ng 2, kaya ito ay kumakatawan 2 sa 0,

256
00:18:28,000 --> 00:18:30,000
ang 2 sa 1, ang 2 sa 2.

257
00:18:30,000 --> 00:18:33,000
Sa pamamagitan ng pagpasok ng 0 sa kanang bahagi sa ngayon, kami lang shift ang lahat.

258
00:18:33,000 --> 00:18:38,000
Ano ang ginamit na 2 sa 0 ngayon ay 2 sa 1, 2 sa 2.

259
00:18:38,000 --> 00:18:41,000
Ang kanang bahagi na namin ipinasok

260
00:18:41,000 --> 00:18:44,000
ay kinakailangang pagpunta sa 0,

261
00:18:44,000 --> 00:18:46,000
na saysay.

262
00:18:46,000 --> 00:18:49,000
Kung sakaling multiply ng bilang ng 2, hindi ito upang tapusin ang kakaiba,

263
00:18:49,000 --> 00:18:54,000
kaya ang 2 sa 0 lugar ay dapat na 0,

264
00:18:54,000 --> 00:18:59,000
at ito ay kung ano ang ko kalahati nagbabala tungkol sa bago ay kung ikaw ay mangyayari sa shift

265
00:18:59,000 --> 00:19:01,000
higit sa bilang ng mga piraso sa isang integer,

266
00:19:01,000 --> 00:19:04,000
1 ito ay pagpunta sa pagpunta off.

267
00:19:04,000 --> 00:19:10,000
Na ang tanging mag-alala kung mangyayari sa pagharap sa talagang malaking capacities.

268
00:19:10,000 --> 00:19:15,000
Ngunit sa puntong iyon, pagkatapos ikaw ay pagharap sa isang array ng mga bilyun-bilyong ng mga bagay,

269
00:19:15,000 --> 00:19:25,000
na maaaring hindi umangkop sa memory pa rin.

270
00:19:25,000 --> 00:19:31,000
>> Ngayon ay maaari naming makakuha ng sa pop, na kung saan ay mas madali.

271
00:19:31,000 --> 00:19:36,000
Maaari mo ito gusto kung mangyari mong mag-pop ang maramihang,

272
00:19:36,000 --> 00:19:38,000
at ngayon ikaw muli sa kalahati kapasidad.

273
00:19:38,000 --> 00:19:42,000
Maaari mong realloc upang paliitin ang halaga ng memorya na mayroon ka,

274
00:19:42,000 --> 00:19:47,000
ngunit hindi mo na kailangang mag-alala tungkol sa na, kaya lamang realloc kaso ay magiging

275
00:19:47,000 --> 00:19:50,000
lumalaking memory, hindi pag-urong memory,

276
00:19:50,000 --> 00:19:59,000
na pop napakadaling.

277
00:19:59,000 --> 00:20:02,000
Ngayon queues, na tulad ng stack,

278
00:20:02,000 --> 00:20:06,000
ngunit ang pagkakasunud-sunod mong gawin ang mga bagay ang reverse.

279
00:20:06,000 --> 00:20:10,000
Ang prototypical halimbawa ng isang queue ay isang linya,

280
00:20:10,000 --> 00:20:12,000
kaya hulaan ko kung ikaw ay Ingles, Gusto ko sinabi

281
00:20:12,000 --> 00:20:17,000
isang prototypical halimbawa ng isang queue queue.

282
00:20:17,000 --> 00:20:22,000
Kaya tulad ng isang linya, kung ikaw ang unang tao sa linya,

283
00:20:22,000 --> 00:20:24,000
inaasahan mong ang unang tao ng linya.

284
00:20:24,000 --> 00:20:31,000
Kung ikaw ang huling tao sa linya, ikaw ay pagpunta sa huling tao serviced.

285
00:20:31,000 --> 00:20:35,000
Tinatawag namin na FIFO pattern, kung saan stack LIFO pattern.

286
00:20:35,000 --> 00:20:40,000
Medyo unibersal ang mga salitang iyon.

287
00:20:40,000 --> 00:20:46,000
>> Tulad ng mga stack at hindi tulad ng array, queues karaniwang hindi payagan ang access sa mga elemento sa gitna.

288
00:20:46,000 --> 00:20:50,000
Dito, stack, mayroon kaming push at mga pop.

289
00:20:50,000 --> 00:20:54,000
Narito, mangyari namin na tinatawag na sa kanila ay enqueue at dequeue.

290
00:20:54,000 --> 00:20:58,000
Narinig ko rin kanila tinatawag shift at unshift.

291
00:20:58,000 --> 00:21:02,000
Narinig ko ang mga tao ay sinasabi push at mga pop sa ring ilapat sa queues.

292
00:21:02,000 --> 00:21:05,000
Narinig ko isingit, alisin,

293
00:21:05,000 --> 00:21:11,000
kaya itulak at pop, kung ikaw ay pakikipag-usap tungkol sa mga stack, ikaw ay pagtulak at popping.

294
00:21:11,000 --> 00:21:16,000
Kung ikaw ay pakikipag-usap tungkol sa mga queues, maaari mong piliin ang mga salita na gusto mong gamitin

295
00:21:16,000 --> 00:21:23,000
para sa pagpapasok ng at pag-alis, at walang pinagkaisahan sa kung ano ang dapat ito ay tinatawag na.

296
00:21:23,000 --> 00:21:27,000
Ngunit dito, mayroon kaming enqueue at dequeue.

297
00:21:27,000 --> 00:21:37,000
Ngayon, ang struct ang hitsura halos kapareho ng struct stack.

298
00:21:37,000 --> 00:21:40,000
Ngunit kami ay upang subaybayan ng ulo.

299
00:21:40,000 --> 00:21:44,000
Hulaan ko sinasabi nito pababa dito, ngunit bakit kailangan namin ang ulo?

300
00:21:53,000 --> 00:21:57,000
Ang mga modelo ay talaga magkakahawig upang itulak at pop.

301
00:21:57,000 --> 00:21:59,000
Maaari mong isipin na ito bilang push at pop.

302
00:21:59,000 --> 00:22:08,000
Ang pagkakaiba lamang ay pop ay bumabalik-halip ng huling, ito bumabalik sa unang.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, o isang bagay na.

304
00:22:12,000 --> 00:22:14,000
At dito sa simula.

305
00:22:14,000 --> 00:22:17,000
Aming queue ganap na puno na, kaya may apat na mga elemento sa loob nito.

306
00:22:17,000 --> 00:22:21,000
Ang pagtatapos ng aming queue ay kasalukuyang 2,

307
00:22:21,000 --> 00:22:24,000
at ngayon namin pumunta sa magpasok ng iba pa.

308
00:22:24,000 --> 00:22:29,000
>> Kapag gusto naming isingit na may isang bagay sa ibang tao, kung ano ang ginawa namin para sa bersyon ng stack

309
00:22:29,000 --> 00:22:36,000
ang aming pinalawak ng aming bloke ng memorya.

310
00:22:36,000 --> 00:22:40,000
Ano ang problema na ito?

311
00:22:40,000 --> 00:22:45,000
[Mag-aaral] ilipat mo ang 2.

312
00:22:45,000 --> 00:22:51,000
Ano ang sinabi ko bago tungkol sa dulo ng queue,

313
00:22:51,000 --> 00:22:57,000
ito ay hindi magkaroon ng kahulugan na sisimulan namin sa 1,

314
00:22:57,000 --> 00:23:01,000
gusto naming dequeue 1, pagkatapos dequeue 3, pagkatapos dequeue 4,

315
00:23:01,000 --> 00:23:05,000
pagkatapos dequeue 2, pagkatapos dequeue ang isang ito.

316
00:23:05,000 --> 00:23:08,000
Hindi namin maaaring gamitin ang realloc ngayon,

317
00:23:08,000 --> 00:23:11,000
o sa pinakadulo hindi bababa sa, mayroon kang upang gamitin ang realloc sa isang iba't ibang mga paraan.

318
00:23:11,000 --> 00:23:15,000
Ngunit marahil ay hindi dapat gamitin na lamang ang realloc.

319
00:23:15,000 --> 00:23:18,000
Upang mano-manong kopyahin ang iyong memory.

320
00:23:18,000 --> 00:23:21,000
>> Mayroong dalawang mga function upang kopyahin ang memory.

321
00:23:21,000 --> 00:23:25,000
May memcopy at memmove.

322
00:23:25,000 --> 00:23:29,000
Kasalukuyan ako sa pagbasa ng mga tao upang makita kung ano ang ka pagpunta sa nais na gumamit ng.

323
00:23:29,000 --> 00:23:35,000
Okay, memcopy, ang pagkakaiba ay

324
00:23:35,000 --> 00:23:38,000
na memcopy at memmove, isang humahawak tama ang kaso

325
00:23:38,000 --> 00:23:41,000
kung saan ka pagkopya sa isang rehiyon na mangyayari na nago-overlap sa rehiyon

326
00:23:41,000 --> 00:23:46,000
ka pagkopya mula.

327
00:23:46,000 --> 00:23:50,000
Memcopy ay hindi ito pangasiwaan ang. Memmove ginagawa.

328
00:23:50,000 --> 00:23:59,000
Maaari mong isipin na ang problema bilang-

329
00:23:59,000 --> 00:24:09,000
sabihin nating gusto ko upang kopyahin ito tao,

330
00:24:09,000 --> 00:24:13,000
mga apat sa tao na ito sa paglipas ng.

331
00:24:13,000 --> 00:24:16,000
Sa pagtatapos, ano array ay dapat magmukhang

332
00:24:16,000 --> 00:24:26,000
matapos ang kopya ay 2, 1, 2, 1, 3, 4, at ang ilang mga bagay-bagay sa dulo.

333
00:24:26,000 --> 00:24:29,000
Ngunit ito ay nakasalalay sa pagkakasunud-sunod kung saan namin ang aktwal na kopyahin,

334
00:24:29,000 --> 00:24:32,000
dahil kung hindi namin isaalang-alang ang mga katotohanan na rehiyon ng namin ang pagkopya sa

335
00:24:32,000 --> 00:24:35,000
pumapatong sa isa namin ang pagkopya mula sa,

336
00:24:35,000 --> 00:24:46,000
maaari naming gawin tulad ng simula dito, kopyahin ang 2 sa lugar na gusto naming pumunta,

337
00:24:46,000 --> 00:24:52,000
pagkatapos ay ilipat ang aming mga payo pasulong.

338
00:24:52,000 --> 00:24:56,000
>> Ngayon sinusubukan namin dito at dito, at ngayon ay nais namin upang kopyahin

339
00:24:56,000 --> 00:25:04,000
ito tao sa ang tao na ito at ilipat ang aming mga payo pasulong.

340
00:25:04,000 --> 00:25:07,000
Ano kami ay pagpunta upang tapusin ang pagkuha ng 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
sa halip ng naaangkop na 2, 1, 2, 1, 3, 4 dahil

342
00:25:10,000 --> 00:25:15,000
2, 1 overrode ang orihinal 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove humahawak na tama.

344
00:25:19,000 --> 00:25:23,000
Sa kasong ito, talaga lang laging gamitin ang memmove

345
00:25:23,000 --> 00:25:26,000
dahil ito humahawak ito nang tama.

346
00:25:26,000 --> 00:25:29,000
Sa pangkalahatan ay hindi magsagawa ng anumang mas masahol pa.

347
00:25:29,000 --> 00:25:32,000
Ang ideya ay sa halip na nagsisimula mula sa simula at pagkopya ng ganitong paraan

348
00:25:32,000 --> 00:25:35,000
tulad lang namin ginawa dito, nagsisimula mula sa dulo at kinokopya sa,

349
00:25:35,000 --> 00:25:38,000
at sa kasong iyon, hindi ka maaaring magkaroon ng problema.

350
00:25:38,000 --> 00:25:40,000
Ang pagganap ng hindi mawawala.

351
00:25:40,000 --> 00:25:47,000
Palaging gamitin ang memmove. Huwag kailanman mag-alala tungkol sa memcopy.

352
00:25:47,000 --> 00:25:51,000
At na kung saan ka pagpunta sa hiwalay memmove

353
00:25:51,000 --> 00:26:01,000
balot-around bahagi ng iyong queue.

354
00:26:01,000 --> 00:26:04,000
Walang alalahanin kung hindi ganap na tapos.

355
00:26:04,000 --> 00:26:10,000
Ito ay mas mahirap kaysa sa stack, push, at pop.

356
00:26:10,000 --> 00:26:15,000
>> Sinuman ay may anumang code kami maaaring gumana sa?

357
00:26:15,000 --> 00:26:21,000
Kahit na ganap na hindi kumpleto?

358
00:26:21,000 --> 00:26:23,000
[Mag-aaral] Oo, ito ay ganap na kumpleto, bagaman.

359
00:26:23,000 --> 00:26:27,000
Ganap na hindi kumpleto pinong hangga't namin na maaari mong i-save ang mga rebisyon?

360
00:26:27,000 --> 00:26:32,000
Nakalimutan ko na bawat solong oras.

361
00:26:32,000 --> 00:26:39,000
Okay, pagbalewala sa kung ano ang mangyayari kapag kailangan namin upang baguhin ang laki ng mga bagay.

362
00:26:39,000 --> 00:26:42,000
Ganap na huwag pansinin ang resize.

363
00:26:42,000 --> 00:26:49,000
Ipaliwanag ang code na ito.

364
00:26:49,000 --> 00:26:54,000
Lalabas na ako muna sa lahat kung ang laki ang ay mas mababa kaysa sa ang unang kopya ng lahat ng

365
00:26:54,000 --> 00:27:01,000
at pagkatapos ay matapos na, ako isingit-ako kukuha ulo + laki,

366
00:27:01,000 --> 00:27:05,000
at gumawa ako bang bumabalot sa buong kapasidad ng array,

367
00:27:05,000 --> 00:27:08,000
at ko bang ipasok ang bagong string sa posisyong iyon.

368
00:27:08,000 --> 00:27:12,000
Pagkatapos ko bang dagdagan ang laki at nagbabalik ng tunay.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] na ito ay tiyak ang isa sa mga kasong iyon kung saan ka pagpunta sa nais na gamitin ang mod.

370
00:27:22,000 --> 00:27:25,000
Anumang uri ng kaso kung saan mo wrapping sa paligid, kung sa tingin mo ang pambalot sa paligid,

371
00:27:25,000 --> 00:27:29,000
ang agarang pag-iisip ay dapat mod.

372
00:27:29,000 --> 00:27:36,000
Bilang ng mabilis na pag-optimize / gumawa ng mas maikli ang iyong code isang linya,

373
00:27:36,000 --> 00:27:42,000
napansin mo na linya kaagad na sumusunod ang isang ito

374
00:27:42,000 --> 00:27:53,000
lamang ang laki + +, kaya bumaybay ka na sa line na ito, laki + +.

375
00:27:53,000 --> 00:27:58,000
Ngayon down na dito, mayroon kaming ang kaso

376
00:27:58,000 --> 00:28:01,000
kung saan wala kaming sapat na memorya,

377
00:28:01,000 --> 00:28:05,000
kaya kami ay dagdagan ang aming kapasidad sa pamamagitan ng 2.

378
00:28:05,000 --> 00:28:09,000
Hulaan ko maaari kang magkaroon ng parehong problema dito, ngunit maaari naming huwag pansinin ito ngayon,

379
00:28:09,000 --> 00:28:13,000
kung saan kung nabigong upang taasan ang iyong kapasidad,

380
00:28:13,000 --> 00:28:18,000
ka pagpunta sa nais upang bawasan ang iyong kapasidad ng 2 muli.

381
00:28:18,000 --> 00:28:24,000
Isa pang maikling tala ay tulad lamang ang maaari mong gawin + =,

382
00:28:24,000 --> 00:28:30,000
maaari mo ring gawin << =.

383
00:28:30,000 --> 00:28:43,000
Halos anumang bagay ay maaaring pumunta bago katumbas, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Magpasinda * bagong aming bagong bloke ng memorya.

385
00:28:52,000 --> 00:28:55,000
Oh, sa paglipas dito.

386
00:28:55,000 --> 00:29:02,000
>> Ano ang mga tao na isipin ang tungkol sa mga uri ng aming bagong bloke ng memorya?

387
00:29:02,000 --> 00:29:06,000
[Mag-aaral] dapat magpasinda **.

388
00:29:06,000 --> 00:29:12,000
Iniisip pabalik sa aming struct up dito,

389
00:29:12,000 --> 00:29:14,000
string ay kung ano ang namin ay reallocating.

390
00:29:14,000 --> 00:29:21,000
Nagsasagawa kami ng isang buong bagong dynamic na imbakan para sa mga elemento sa queue.

391
00:29:21,000 --> 00:29:25,000
Ano kami ay pagpunta sa nagtatalaga sa iyong mga string ay kung ano ang namin ang mallocing ngayon,

392
00:29:25,000 --> 00:29:30,000
at kaya bagong pagpunta sa isang pansamantalang trabaho **.

393
00:29:30,000 --> 00:29:34,000
Ito ay pagpunta sa isang array ng mga string.

394
00:29:34,000 --> 00:29:38,000
Pagkatapos kung ano ang kaso sa ilalim kung saan kami ay pagpunta sa bumalik false?

395
00:29:38,000 --> 00:29:41,000
[Mag-aaral] Dapat ba naming paggawa ng pansamantalang trabaho *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Oo, magandang tawag.

397
00:29:44,000 --> 00:29:46,000
[Mag-aaral] Ano na?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Gusto naming gawin ang laki ng magpasinda * dahil hindi na namin

399
00:29:49,000 --> 00:29:53,000
ito ay aktwal na maging isang malaking problema dahil sizeof (pansamantalang trabaho) ay 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof magpasinda * ay pagpunta sa 4,

401
00:29:55,000 --> 00:29:58,000
kaya ng maraming beses kapag ikaw ay pagharap sa ints,

402
00:29:58,000 --> 00:30:01,000
malamang sa iyo upang makakuha ng ang layo dito dahil ang laki ng int at laki ng int *

403
00:30:01,000 --> 00:30:04,000
sa isang 32-bit na sistema ay ang parehong bagay.

404
00:30:04,000 --> 00:30:09,000
Ngunit dito, sizeof (pansamantalang trabaho) at sizeof (pansamantalang trabaho *) na ngayon ang parehong bagay.

405
00:30:09,000 --> 00:30:15,000
>> Ano ang pangyayari na kung saan bumalik kami ng maling?

406
00:30:15,000 --> 00:30:17,000
[Mag-aaral] Bagong null.

407
00:30:17,000 --> 00:30:23,000
Oo, kung ang bagong ay null, bumalik namin maling,

408
00:30:23,000 --> 00:30:34,000
at ako pagpunta sa mahulog dito-

409
00:30:34,000 --> 00:30:37,000
[Mag-aaral] [hindi marinig]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Oo, ito ay pinong.

411
00:30:39,000 --> 00:30:46,000
Maaari mong alinman sa gawin ng 2 beses kapasidad o kapasidad shift 1 at pagkatapos lamang itakda ito dito o anumang.

412
00:30:46,000 --> 00:30:52,000
Gagawin namin ito bilang nagkaroon kami ito.

413
00:30:52,000 --> 00:30:56,000
Kapasidad >> = 1.

414
00:30:56,000 --> 00:31:08,000
At hindi ka pagpunta sa mag-alala tungkol sa pagkawala ng ng 1 lugar ng

415
00:31:08,000 --> 00:31:12,000
dahil ang natitira ka ng Paglipat ng 1, kaya ang 1 lugar ng ay kinakailangang 0,

416
00:31:12,000 --> 00:31:16,000
kaya kanan paglilipat ng 1, ka pa rin ng pagpunta sa fine.

417
00:31:16,000 --> 00:31:19,000
[Mag-aaral] kailangan mong gawin na bago return?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Oo, ito ay gumagawa ng ganap na walang kahulugan.

419
00:31:29,000 --> 00:31:36,000
>> Ngayon ay ipinapalagay namin ay pagpunta sa bumabalik totoo sa dulo.

420
00:31:36,000 --> 00:31:39,000
Ang paraan namin ay pagpunta sa gawin ang mga memmoves,

421
00:31:39,000 --> 00:31:45,000
kailangan namin upang maging maingat sa kung paano gawin namin ang mga ito.

422
00:31:45,000 --> 00:31:50,000
Ba ang sinuman magkaroon ng anumang mga mungkahi para sa kung paano gawin namin ang mga ito?

423
00:32:17,000 --> 00:32:21,000
Narito ang aming pagsisimula.

424
00:32:21,000 --> 00:32:28,000
Walang sala, nais naming upang magsimulang muli sa simula

425
00:32:28,000 --> 00:32:35,000
at kopyahin ang mga bagay mula doon, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Paano mo gawin iyon?

427
00:32:41,000 --> 00:32:52,000
Una, mayroon akong tumingin sa pahina ng tao para sa memmove muli.

428
00:32:52,000 --> 00:32:57,000
Memmove, pagkakasunud-sunod ng mga argumento ay laging mahalaga.

429
00:32:57,000 --> 00:33:01,000
Nais namin ang aming destination una, ang pinagmulan segundo, laki ikatlong.

430
00:33:01,000 --> 00:33:06,000
May maraming ng mga function na baligtarin ng pinagmulan at patutunguhan.

431
00:33:06,000 --> 00:33:11,000
Destination, ang pinagmulan ay may kaugaliang upang maging pare-pareho medyo.

432
00:33:17,000 --> 00:33:21,000
Ilipat, kung ano ang bumabalik?

433
00:33:21,000 --> 00:33:27,000
Ito ay nagbabalik ng pointer sa destination, para sa anumang dahilan baka gusto mo na.

434
00:33:27,000 --> 00:33:32,000
Maaari kong larawan basahin ito, ngunit nais naming upang ilipat sa aming destination.

435
00:33:32,000 --> 00:33:35,000
>> Ano ang aming destination pagpunta sa ay?

436
00:33:35,000 --> 00:33:37,000
[Mag-aaral] Bagong.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Oo, at kung saan kami pagkopya mula?

438
00:33:39,000 --> 00:33:43,000
Ang unang bagay na namin ang pagkopya ito 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Ano ang na ito 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Ano ang address ng ito 1?

441
00:33:55,000 --> 00:33:58,000
Ano ang address ng na 1?

442
00:33:58,000 --> 00:34:01,000
[Mag-aaral] [hindi marinig]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Head + ang address ng unang elemento.

444
00:34:03,000 --> 00:34:05,000
Paano kami makakuha ng sa unang elemento sa array?

445
00:34:05,000 --> 00:34:10,000
[Mag-aaral] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Oo, q.strings.

447
00:34:15,000 --> 00:34:20,000
Tandaan, dito, ang aming mga ulo ay 1.

448
00:34:20,000 --> 00:34:24,000
Darn ito. Ko lang sa tingin ito ay magically-

449
00:34:24,000 --> 00:34:29,000
Narito, ang aming ulo ay 1. Ako pagpunta upang baguhin ang aking kulay masyadong.

450
00:34:29,000 --> 00:34:36,000
At dito ay string.

451
00:34:36,000 --> 00:34:41,000
Ito, maaari naming alinman magsulat ito bilang namin ginawa sa paglipas dito

452
00:34:41,000 --> 00:34:43,000
may ulo + q.strings.

453
00:34:43,000 --> 00:34:51,000
Isang maraming ng mga tao ring sumulat at q.strings [ulo].

454
00:34:51,000 --> 00:34:55,000
Na ito ay hindi talagang anumang hindi gaanong mahusay.

455
00:34:55,000 --> 00:34:58,000
Maaari mong isipin na ito bilang ikaw ay dereferencing ito at pagkatapos ay pagkuha ng address ng,

456
00:34:58,000 --> 00:35:04,000
ngunit tagatala na i-translate ang mga ito sa kung ano ang namin ay may bago pa rin, q.strings + ulo.

457
00:35:04,000 --> 00:35:06,000
Alinman sa paraan na gusto mong mag-isip nito.

458
00:35:06,000 --> 00:35:11,000
>> At kung gaano karaming mga byte gusto naming kopyahin?

459
00:35:11,000 --> 00:35:15,000
[Mag-aaral] Kapasidad - ulo.

460
00:35:15,000 --> 00:35:18,000
Kapasidad - ulo.

461
00:35:18,000 --> 00:35:21,000
At pagkatapos ay maaari mong palaging isulat ang isang halimbawa

462
00:35:21,000 --> 00:35:23,000
upang malaman kung na tama.

463
00:35:23,000 --> 00:35:26,000
[Mag-aaral] Kailangan itong hinati ng 2 pagkatapos.

464
00:35:26,000 --> 00:35:30,000
Oo, kaya hulaan ko maaari naming gamitin ang laki.

465
00:35:30,000 --> 00:35:35,000
Mayroon pa kaming laki pagiging-

466
00:35:35,000 --> 00:35:39,000
paggamit ng laki, mayroon kaming laki katumbas sa 4.

467
00:35:39,000 --> 00:35:42,000
Sa aming size ay 4. Aming ulo ay 1.

468
00:35:42,000 --> 00:35:46,000
Gusto namin upang kopyahin ang mga ito 3 mga elemento.

469
00:35:46,000 --> 00:35:54,000
Iyon katinuan suriin na laki - ulo ay tama 3.

470
00:35:54,000 --> 00:35:58,000
At babalik dito, tulad ng sinabi namin bago,

471
00:35:58,000 --> 00:36:00,000
kung ginamit namin ang kapasidad, pagkatapos ay nais naming hatiin sa pamamagitan ng 2

472
00:36:00,000 --> 00:36:04,000
dahil kami lumaki ang aming kapasidad, kaya sa halip, kami ay pagpunta sa gamitin ang laki.

473
00:36:11,000 --> 00:36:13,000
Na kopya na bahagi.

474
00:36:13,000 --> 00:36:18,000
Ngayon, kailangan namin upang kopyahin sa iba pang mga bahagi, ang bahagi na naiwan ng simula.

475
00:36:18,000 --> 00:36:28,000
>> Na upang memmove sa kung anong posisyon?

476
00:36:28,000 --> 00:36:32,000
[Mag-aaral] Plus laki - ulo.

477
00:36:32,000 --> 00:36:38,000
Oo, kaya na namin kinopya ang laki - bytes ulo,

478
00:36:38,000 --> 00:36:43,000
at iba pa kung saan nais namin upang kopyahin ang mga natitirang bytes bagong

479
00:36:43,000 --> 00:36:48,000
at pagkatapos laki minus-mabuti, ang bilang ng mga byte na namin ang kinopya.

480
00:36:48,000 --> 00:36:52,000
At pagkatapos ay kung saan kami pagkopya mula?

481
00:36:52,000 --> 00:36:54,000
[Mag-aaral] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Oo, q.strings.

483
00:36:56,000 --> 00:37:02,000
Maaaring alinman sa gawin namin & q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Ito ay makabuluhang mas mababa karaniwan kaysa sa.

485
00:37:05,000 --> 00:37:14,000
Kung lamang ito ng pagpunta sa 0, pagkatapos makikita mo may posibilidad upang makita ang mga q.strings.

486
00:37:14,000 --> 00:37:16,000
Kung saan namin ang pagkopya mula sa.

487
00:37:16,000 --> 00:37:18,000
Gaano karaming mga byte namin ang natitira upang kopyahin? >> [Mag-aaral] 10.

488
00:37:18,000 --> 00:37:20,000
Kanan.

489
00:37:20,000 --> 00:37:25,000
[Mag-aaral] namin multiply 5 - 10 beses laki ng bytes o isang bagay?

490
00:37:25,000 --> 00:37:30,000
Oo, kaya ito ay kung saan-kung ano ang eksaktong ay namin ang pagkopya?

491
00:37:30,000 --> 00:37:32,000
[Mag-aaral] [hindi marinig]

492
00:37:32,000 --> 00:37:34,000
Ano ang uri ng bagay na namin ang pagkopya?

493
00:37:34,000 --> 00:37:36,000
[Mag-aaral] [hindi marinig]

494
00:37:36,000 --> 00:37:41,000
Oo, kaya magpasinda * s na namin ang pagkopya, hindi namin alam kung saan ang mga nagmumula.

495
00:37:41,000 --> 00:37:47,000
Well, kung saan sila ay tumuturo sa, tulad ng mga string, kami magtapos itulak ito papunta sa queue

496
00:37:47,000 --> 00:37:49,000
o enqueuing papunta sa pila.

497
00:37:49,000 --> 00:37:51,000
Kung saan ang mga nagmumula, wala kaming ideya.

498
00:37:51,000 --> 00:37:56,000
Kailangan lang namin upang subaybayan ng magpasinda * s ang kanilang mga sarili.

499
00:37:56,000 --> 00:38:00,000
Hindi namin gusto mong kopyahin ang laki - ulo bytes.

500
00:38:00,000 --> 00:38:03,000
Gusto naming upang kopyahin ang laki - ulo magpasinda * s,

501
00:38:03,000 --> 00:38:11,000
kaya kami ay pagpunta sa multiply ito sa pamamagitan ng sizeof (magpasinda *).

502
00:38:11,000 --> 00:38:17,000
Parehong pababa dito, tumungo * sizeof (magpasinda *).

503
00:38:17,000 --> 00:38:24,000
>> [Mag-aaral] Ano ang tungkol sa [hindi marinig]?

504
00:38:24,000 --> 00:38:26,000
Ito dito mismo?

505
00:38:26,000 --> 00:38:28,000
[Mag-aaral] Hindi, sa ibaba na, ang laki - ulo.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] ito karapatan dito?

507
00:38:30,000 --> 00:38:32,000
Pointer aritmetika.

508
00:38:32,000 --> 00:38:35,000
Paano pointer aritmetika ay pagpunta sa trabaho ay

509
00:38:35,000 --> 00:38:40,000
ito awtomatikong multiply ng laki ng uri na kami ay pagharap sa.

510
00:38:40,000 --> 00:38:46,000
Tulad sa paglipas dito, bagong + (laki - ulo)

511
00:38:46,000 --> 00:38:56,000
eksaktong katumbas sa & bagong [laki - ulo]

512
00:38:56,000 --> 00:39:00,000
hanggang inaasahan namin na upang gumana nang tama,

513
00:39:00,000 --> 00:39:04,000
dahil kung kami ay pagharap sa isang int array, pagkatapos ginagawa namin hindi index sa pamamagitan ng pag-int-

514
00:39:04,000 --> 00:39:07,000
o kung ito ng laki ng 5 at gusto mo ang ika-4 na elemento, pagkatapos namin ang pag-index sa

515
00:39:07,000 --> 00:39:10,000
int array [4].

516
00:39:10,000 --> 00:39:14,000
Kang don't [4] * laki ng int.

517
00:39:14,000 --> 00:39:21,000
Na humahawak sa awtomatikong, at ang kasong ito

518
00:39:21,000 --> 00:39:29,000
literal katumbas, kaya ang syntax ng bracket

519
00:39:29,000 --> 00:39:34,000
ay lamang pagpunta upang ma-convert na ito sa lalong madaling mo makatipon.

520
00:39:34,000 --> 00:39:38,000
Iyon ay isang bagay na kailangan mong mag-ingat ng na

521
00:39:38,000 --> 00:39:42,000
kapag ikaw ay pagdaragdag ng laki - ulo

522
00:39:42,000 --> 00:39:45,000
pagdaragdag ng ikaw ay hindi isang byte.

523
00:39:45,000 --> 00:39:53,000
Nagdadagdag ka ng isang pansamantalang trabaho *, na maaaring maging isang byte o anumang.

524
00:39:53,000 --> 00:39:56,000
>> Iba pang mga tanong?

525
00:39:56,000 --> 00:40:04,000
Okay, dequeue ay magiging madali.

526
00:40:04,000 --> 00:40:11,000
Bibigyan kita ng isang minuto upang ipatupad.

527
00:40:11,000 --> 00:40:18,000
Oh, at hulaan ko ito ay ang parehong sitwasyon kung saan

528
00:40:18,000 --> 00:40:21,000
enqueue kaso, kung kami ay enqueuing null,

529
00:40:21,000 --> 00:40:24,000
baka gusto namin upang mahawakan ang mga ito, maaaring hindi namin.

530
00:40:24,000 --> 00:40:27,000
Hindi namin gawin ito muli dito, ngunit parehong bilang aming stack kaso.

531
00:40:27,000 --> 00:40:34,000
Kung enqueue namin null, maaari naming gusto mong balewalain ang mga ito.

532
00:40:34,000 --> 00:40:40,000
Sinuman ay may ilang mga code maaari kong makuha ang?

533
00:40:40,000 --> 00:40:45,000
[Mag-aaral] ko na lang ay dequeue.

534
00:40:45,000 --> 00:40:56,000
Bersyon 2 ay na-okay.

535
00:40:56,000 --> 00:40:59,000
Gusto mong ipaliwanag?

536
00:40:59,000 --> 00:41:01,000
[Mag-aaral] Una, tiyakin mong may isang bagay sa queue

537
00:41:01,000 --> 00:41:07,000
at sukat na iyon ay pagpunta ng 1.

538
00:41:07,000 --> 00:41:11,000
Kailangan mo bang gawin iyon, at pagkatapos mong ibalik ang ulo

539
00:41:11,000 --> 00:41:13,000
at pagkatapos ay ilipat ang mga ulo up 1.

540
00:41:13,000 --> 00:41:19,000
Okay, sa gayon ay isang sulok kaso kami ay upang isaalang-alang. Oo.

541
00:41:19,000 --> 00:41:24,000
[Mag-aaral] Kung ang iyong ulo ay sa huling elemento,

542
00:41:24,000 --> 00:41:26,000
pagkatapos ay hindi mo nais na pinuno upang tumuro sa labas ng array.

543
00:41:26,000 --> 00:41:29,000
>> Oo, ito sa lalong madaling bilang pinuno ay pinindot niya ang dulo ng aming array,

544
00:41:29,000 --> 00:41:35,000
kapag dequeue namin, ang aming mga ulo ay dapat modded pabalik sa 0.

545
00:41:35,000 --> 00:41:40,000
Sa kasamaang-palad, hindi namin gawin iyon sa isang hakbang.

546
00:41:40,000 --> 00:41:44,000
Hulaan ko ang paraan na gusto ko marahil ayusin ito ay

547
00:41:44,000 --> 00:41:52,000
ito ay pagpunta sa isang pansamantalang trabaho *, kung ano ang kami ay bumabalik,

548
00:41:52,000 --> 00:41:55,000
anumang iyong pangalan ng variable ay nais na maging.

549
00:41:55,000 --> 00:42:02,000
Pagkatapos gusto naming mod ang ulo sa pamamagitan ng aming kapasidad

550
00:42:02,000 --> 00:42:10,000
at pagkatapos ay bumalik magpabasa.

551
00:42:10,000 --> 00:42:14,000
Isang maraming ng mga tao dito ay maaaring nilang gawin

552
00:42:14,000 --> 00:42:19,000
ito ang kaso ng you'll makita tao gawin kung ulo

553
00:42:19,000 --> 00:42:29,000
ay mas mataas kaysa sa kapasidad, gawin ang ulo - kapasidad.

554
00:42:29,000 --> 00:42:36,000
At na nagtatrabaho sa paligid ng kung ano ang mod ay.

555
00:42:36,000 --> 00:42:41,000
Head kapasidad mod = magkano cleaner

556
00:42:41,000 --> 00:42:51,000
ng isang wrapping sa paligid kaysa kung ulo na mas malaki kaysa sa ulo ng kapasidad - kapasidad.

557
00:42:51,000 --> 00:42:56,000
>> Mga tanong?

558
00:42:56,000 --> 00:43:02,000
Okay, ang huling bagay na namin ang natitira sa aming mga naka-link na listahan.

559
00:43:02,000 --> 00:43:07,000
Maaari mong gamitin sa ilang ng mga naka-link na pag-uugali ng listahan kung ginawa mo

560
00:43:07,000 --> 00:43:11,000
naka-link na listahan sa iyong hash na mga talahanayan, kung ginawa mo ng hash table.

561
00:43:11,000 --> 00:43:15,000
Ko Minumungkahi paggawa ng hash table.

562
00:43:15,000 --> 00:43:17,000
Maaaring na nagawa mo na trie ng,

563
00:43:17,000 --> 00:43:23,000
ngunit sinusubukan ng mas mahirap.

564
00:43:23,000 --> 00:43:27,000
Sa teorya, hindi sila asymptotically mas mahusay.

565
00:43:27,000 --> 00:43:30,000
Ngunit lamang tumingin sa malaking board,

566
00:43:30,000 --> 00:43:35,000
at hindi kailanman sinusubukan gawin mas mahusay, at sila up ng higit memory.

567
00:43:35,000 --> 00:43:43,000
Lahat ng tungkol sa sinusubukan nagtatapos up pagiging mas masahol pa para sa pang trabaho.

568
00:43:43,000 --> 00:43:49,000
Kung ano ang David Malan ang solusyon ay palaging

569
00:43:49,000 --> 00:43:56,000
siya laging post kanyang trie solusyon, at sabihin makita kung saan siya kasalukuyang.

570
00:43:56,000 --> 00:44:00,000
Ano siya sa ilalim, David J?

571
00:44:00,000 --> 00:44:06,000
Siya ay # 18, kaya na hindi masyado masama,

572
00:44:06,000 --> 00:44:09,000
at na pagpunta sa isa sa mga pinakamahusay na sinusubukan maaari mong isipin ang

573
00:44:09,000 --> 00:44:17,000
o ang isa sa mga pinakamahusay na sinusubukan ng isang trie.

574
00:44:17,000 --> 00:44:23,000
Hindi ito ay kahit na ang kanyang orihinal na solusyon?

575
00:44:23,000 --> 00:44:29,000
Pakiramdam ko ay tulad ng trie solusyon ay may posibilidad na maging mas sa hanay ng RAM paggamit.

576
00:44:29,000 --> 00:44:33,000
>> Bumaba sa pinakatuktok, at RAM paggamit sa isang digit.

577
00:44:33,000 --> 00:44:36,000
Bumaba patungo sa ibaba, at pagkatapos ay simulan mo nakikita sinusubukan

578
00:44:36,000 --> 00:44:41,000
kung saan makakakuha ka talagang napakalaking paggamit ng RAM,

579
00:44:41,000 --> 00:44:45,000
at sinusubukang ay mas mahirap.

580
00:44:45,000 --> 00:44:53,000
Hindi ganap na nagkakahalaga ito ngunit sa pang-edukasyon na karanasan kung ginawa mo ang isa.

581
00:44:53,000 --> 00:44:56,000
Ang huling bagay ay ang aming naka-link na listahan,

582
00:44:56,000 --> 00:45:04,000
at ang tatlong bagay, stack, queues, at mga naka-link na listahan,

583
00:45:04,000 --> 00:45:09,000
anumang mga bagay na sakaling gawin sa computer science

584
00:45:09,000 --> 00:45:12,000
ay ipagpalagay na mayroon kang lubos na pagkikilala sa mga bagay na ito.

585
00:45:12,000 --> 00:45:19,000
Lang nila kaya pangunahing sa lahat.

586
00:45:19,000 --> 00:45:25,000
>> Naka-link na listahan, at dito namin ng isa-isa naka-link na listahan ay pagpunta sa ang aming pagpapatupad.

587
00:45:25,000 --> 00:45:34,000
Ano ay isa-isa na naka-link ibig sabihin laban sa doble-link? Oo.

588
00:45:34,000 --> 00:45:37,000
[Mag-aaral] lamang nito ang mga punto sa susunod na pointer kaysa sa payo,

589
00:45:37,000 --> 00:45:39,000
tulad ng isa na nauuna sa mga ito at matapos itong.

590
00:45:39,000 --> 00:45:44,000
Oo, kaya sa larawan na format, kung ano ang ko lang gawin?

591
00:45:44,000 --> 00:45:48,000
Mayroon akong dalawang bagay. Mayroon akong larawan at larawan.

592
00:45:48,000 --> 00:45:51,000
Sa larawan na format, ang aming isa-isa naka-link na mga listahan,

593
00:45:51,000 --> 00:45:57,000
karaniwan na, mayroon kaming ilang mga uri ng pointer sa ulo ng aming listahan,

594
00:45:57,000 --> 00:46:02,000
at pagkatapos ay sa loob ng aming listahan, kami na lang ay payo,

595
00:46:02,000 --> 00:46:05,000
at marahil ito puntos sa null.

596
00:46:05,000 --> 00:46:08,000
Ito ay pagpunta sa iyong tipikal na pagguhit ng isa-isa naka-link na listahan.

597
00:46:08,000 --> 00:46:14,000
Isang doble-link sa listahan, maaari kang pumunta paurong.

598
00:46:14,000 --> 00:46:19,000
Kung ako magbibigay sa iyo ng anumang node sa listahan, pagkatapos ay maaari mong kinakailangang makarating sa

599
00:46:19,000 --> 00:46:23,000
anumang iba pang mga node sa listahan kung ito ay doble na naka-link sa listahan.

600
00:46:23,000 --> 00:46:27,000
Ngunit kung nakakuha ako sa ikatlong node sa listahan at ito ng isa-isa na naka-link sa listahan,

601
00:46:27,000 --> 00:46:30,000
walang paraan ka upang makakuha ng sa una at ikalawang node.

602
00:46:30,000 --> 00:46:34,000
At may mga benepisyo at detriments, at isang halata na isa

603
00:46:34,000 --> 00:46:42,000
ay mo tumagal ng hanggang sa karagdagang laki, at mayroon kang subaybayan ng kung saan ang mga bagay na ito ay pagturo ngayon.

604
00:46:42,000 --> 00:46:49,000
Ngunit lamang namin pakialam tungkol sa isa-isa na naka-link.

605
00:46:49,000 --> 00:46:53,000
>> Ang ilang mga bagay na kami ay pagpunta upang ipatupad.

606
00:46:53,000 --> 00:47:00,000
Ang iyong typedef node sa struct, int i: struct node * susunod; node.

607
00:47:00,000 --> 00:47:09,000
Na typedef dapat burn sa iyong isip.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 ay dapat bang bigyan isang typedef ng isang listahan ng mga naka-link node,

609
00:47:14,000 --> 00:47:18,000
at dapat mong agad scribble na pababa

610
00:47:18,000 --> 00:47:22,000
walang kahit na pag-iisip tungkol dito.

611
00:47:22,000 --> 00:47:27,000
Hulaan akong mga tanong ng ilang, bakit namin kailangang struct dito?

612
00:47:27,000 --> 00:47:32,000
Bakit hindi sabihin kami ng node *?

613
00:47:32,000 --> 00:47:35,000
[Mag-aaral] [hindi marinig]

614
00:47:35,000 --> 00:47:38,000
Oo.

615
00:47:38,000 --> 00:47:44,000
Ang tanging bagay na tumutukoy sa isang node bilang isang bagay

616
00:47:44,000 --> 00:47:47,000
ay ang typedef mismo.

617
00:47:47,000 --> 00:47:55,000
Ngunit bilang ng puntong ito, kapag hindi namin ang uri ng pag-parse sa pamamagitan ng kahulugan struct node,

618
00:47:55,000 --> 00:48:01,000
tapos hindi pa namin ang aming typedef pa, kaya dahil ang typedef ay hindi pa tapos,

619
00:48:01,000 --> 00:48:05,000
node ay hindi umiiral.

620
00:48:05,000 --> 00:48:12,000
Ngunit struct node, at ito node in dito,

621
00:48:12,000 --> 00:48:14,000
ito ay maaari ring tinatawag na ano pa man.

622
00:48:14,000 --> 00:48:16,000
Ma-tinatawag n.

623
00:48:16,000 --> 00:48:19,000
Maaari itong tinatawag na naka-link na listahan node.

624
00:48:19,000 --> 00:48:21,000
Maaari itong tinatawag na kahit ano.

625
00:48:21,000 --> 00:48:26,000
Ngunit ito struct node ay nangangailangan ng na tinatawag na ang parehong bagay bilang struct node na ito.

626
00:48:26,000 --> 00:48:29,000
Ano tawagan ka ito ay may rin dito,

627
00:48:29,000 --> 00:48:32,000
at sa gayon ay din sumasagot sa pangalawang punto ng tanong

628
00:48:32,000 --> 00:48:37,000
na ang dahilan kung bakit ng maraming mga beses kapag nakita mo structs at typedefs ng structs,

629
00:48:37,000 --> 00:48:42,000
makikita mo ang hindi nakikilalang structs kung saan makikita mo na lang makita ang typedef struct,

630
00:48:42,000 --> 00:48:47,000
pagpapatupad ng struct, diksyunaryo, o anumang.

631
00:48:47,000 --> 00:48:51,000
>> Bakit dito ang kailangan namin upang sabihin ang node?

632
00:48:51,000 --> 00:48:54,000
Bakit hindi ito ay isang hindi nakikilalang struct?

633
00:48:54,000 --> 00:48:56,000
Ito ay halos ang parehong sagot.

634
00:48:56,000 --> 00:48:58,000
[Mag-aaral] Kailangan mong sumangguni sa ito sa loob ng struct.

635
00:48:58,000 --> 00:49:04,000
Oo, sa loob ng struct, kailangan mong mag-refer sa mismong struct.

636
00:49:04,000 --> 00:49:10,000
Kung hindi mo bigyan ang struct ng pangalan, kung ito ay isang hindi nakikilalang struct, hindi ka maaaring sumangguni sa.

637
00:49:10,000 --> 00:49:17,000
At huling ngunit hindi bababa sa mga dapat lahat ay medyo direkta,

638
00:49:17,000 --> 00:49:20,000
at dapat nilang matulungan kang Napagtanto kung ikaw ay sumusulat ito pababa

639
00:49:20,000 --> 00:49:24,000
na ikaw ay gumagawa ng mali kung ang mga uri ng mga bagay na walang kabuluhan.

640
00:49:24,000 --> 00:49:28,000
Huling ngunit hindi bababa sa, kung bakit ito struct node *?

641
00:49:28,000 --> 00:49:34,000
Bakit hindi ito lamang ay struct node susunod?

642
00:49:34,000 --> 00:49:37,000
[Mag-aaral] pointer sa susunod na struct.

643
00:49:37,000 --> 00:49:39,000
Iyon ay tiyak kung ano ang gusto naming.

644
00:49:39,000 --> 00:49:42,000
Bakit hindi ito ma-struct node susunod?

645
00:49:42,000 --> 00:49:50,000
Bakit ang ito sa struct node * susunod? Oo.

646
00:49:50,000 --> 00:49:53,000
[Mag-aaral] Ito ay tulad ng isang walang-katapusang loop.

647
00:49:53,000 --> 00:49:55,000
Oo.

648
00:49:55,000 --> 00:49:57,000
[Mag-aaral] ay ang lahat ng ito sa isa.

649
00:49:57,000 --> 00:50:02,000
Oo, tingin lang kung paano namin gawin ang laki ng o isang bagay.

650
00:50:02,000 --> 00:50:08,000
Sukat ng isang struct ay isa lamang + o - ang ilang mga pattern dito o doon.

651
00:50:08,000 --> 00:50:15,000
Talaga ito ang kabuuan ng laki ng mga bagay sa struct.

652
00:50:15,000 --> 00:50:18,000
Ito dito mismo, nang hindi binabago ang anumang bagay, laki ang pagpunta sa madaling.

653
00:50:18,000 --> 00:50:24,000
Sukat ng struct node ay pagpunta sa laki ng i + laki ng susunod.

654
00:50:24,000 --> 00:50:27,000
Laki ng i pagpunta sa 4. Laki ng susunod na 4.

655
00:50:27,000 --> 00:50:30,000
Sukat ng struct node ay pagpunta sa 8.

656
00:50:30,000 --> 00:50:34,000
Kung hindi namin *, iniisip ng sizeof

657
00:50:34,000 --> 00:50:37,000
pagkatapos sizeof (i) ay magiging 4.

658
00:50:37,000 --> 00:50:43,000
Sukat ng struct node susunod na pagpunta sa laki ng i + laki ng struct node sa tabi

659
00:50:43,000 --> 00:50:46,000
+ Laki ng i + laki ng struct node susunod.

660
00:50:46,000 --> 00:50:55,000
Ito ay isang walang-katapusang recursion ng node.

661
00:50:55,000 --> 00:51:00,000
Ito ay kung bakit ito ay kung paano ang mga bagay ay may upang maging.

662
00:51:00,000 --> 00:51:03,000
>> Muli, talagang kabisaduhin na,

663
00:51:03,000 --> 00:51:06,000
o hindi bababa sa maunawaan ang mga ito nang sapat na maaari mong ma-

664
00:51:06,000 --> 00:51:12,000
dahilan sa pamamagitan ng kung ano ang dapat ito hitsura.

665
00:51:12,000 --> 00:51:14,000
Ang mga bagay na kami ay pagpunta sa nais na ipapatupad.

666
00:51:14,000 --> 00:51:18,000
Kung ang haba ng listahan-

667
00:51:18,000 --> 00:51:21,000
maaari mong impostor at panatilihin sa paligid ng isang

668
00:51:21,000 --> 00:51:24,000
global haba o isang bagay, ngunit hindi namin upang gawin iyon.

669
00:51:24,000 --> 00:51:28,000
Kami ay pagpunta upang mabilang ang haba ng listahan.

670
00:51:28,000 --> 00:51:34,000
Namin ang naglalaman, kaya na talaga tulad ng paghahanap,

671
00:51:34,000 --> 00:51:41,000
kaya kami ay may naka-link na listahan ng mga integer upang makita kung ang integer na ito sa naka-link na listahan.

672
00:51:41,000 --> 00:51:44,000
Ang Prepend ay pagpunta upang ipasok sa simula ng listahan.

673
00:51:44,000 --> 00:51:46,000
Magkabit ay upang ipasok sa dulo.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted ay upang ipasok sa pinagsunod-sunod na posisyon sa listahan.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted uri ng Ipinagpapalagay na hindi mo ginagamit prepend o ikabit ang nasa masamang paraan.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted kapag ikaw ay pagpapatupad insert_sorted-

677
00:52:09,000 --> 00:52:13,000
sabihin nating mayroon kaming ang aming naka-link listahan.

678
00:52:13,000 --> 00:52:18,000
Ito ay kung ano ang kasalukuyang Mukhang, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Gusto kong upang ipasok 3, kaya hangga't sa listahan mismo na pinagsunod-sunod,

680
00:52:24,000 --> 00:52:27,000
madaling hanapin kung saan 3-aari.

681
00:52:27,000 --> 00:52:29,000
Sisimulan ko sa 2.

682
00:52:29,000 --> 00:52:32,000
Okay, 3 ay mas malaki kaysa sa 2, kaya nais kong panatilihin ang pagpunta.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 ay masyadong malaki, kaya alam ko 3 ay pumunta sa pagitan ng 2 at 4,

684
00:52:35,000 --> 00:52:39,000
at mayroon akong upang ayusin ang mga payo at lahat na bagay.

685
00:52:39,000 --> 00:52:43,000
Ngunit kung hindi namin ginawa mahigpit na gamitin insert_sorted,

686
00:52:43,000 --> 00:52:50,000
bang sabihin lamang sinasabi ko prepend 6,

687
00:52:50,000 --> 00:52:55,000
pagkatapos ay ang aking naka-link na listahan ay pagpunta upang maging ito.

688
00:52:55,000 --> 00:53:01,000
Ito ngayon ay hindi gumagawa ng mga kahulugan, kaya para sa insert_sorted, maaari mo lamang ipagpalagay

689
00:53:01,000 --> 00:53:04,000
na listahan ay pinagsunod-sunod, kahit pagpapatakbo umiiral

690
00:53:04,000 --> 00:53:09,000
na maaaring maging sanhi ng hindi ito na pinagsunod-sunod, at na ito.

691
00:53:09,000 --> 00:53:20,000
Maghanap ng isang kapaki-pakinabang na insert-kaya mga ay ang pangunahing bagay ka pagpunta upang ipatupad.

692
00:53:20,000 --> 00:53:24,000
>> Sa ngayon, kumuha nang isang minuto upang gawin ang haba at naglalaman ng,

693
00:53:24,000 --> 00:53:30,000
at mga dapat relatibong mabilis.

694
00:53:41,000 --> 00:53:48,000
Papalapit sa panahon ng pagsasara, kaya't sinuman ay may anumang para sa haba o naglalaman?

695
00:53:48,000 --> 00:53:50,000
Sila ay halos magkakahawig.

696
00:53:50,000 --> 00:53:57,000
[Mag-aaral] Haba.

697
00:53:57,000 --> 00:54:01,000
Natin makita, rebisyon.

698
00:54:01,000 --> 00:54:04,000
Okay.

699
00:54:12,000 --> 00:54:15,000
Gusto mong ipaliwanag?

700
00:54:15,000 --> 00:54:21,000
[Mag-aaral] ko lang lumikha ng isang pointer node at initialize ito sa unang, na ang aming global variable,

701
00:54:21,000 --> 00:54:27,000
at pagkatapos kong suriin upang makita kung null kaya hindi ko makakuha ng seg kasalanan at bumalik ang 0 kung iyon ang kaso.

702
00:54:27,000 --> 00:54:34,000
Kung hindi man, ako loop sa pamamagitan, nang pinapanatili ang track ng loob integer

703
00:54:34,000 --> 00:54:38,000
kung gaano karaming beses ko na access sa susunod na elemento ng listahan

704
00:54:38,000 --> 00:54:43,000
at sa parehong pagpapatakbo ng pagdagdag ring ma-access ang na aktwal na elemento,

705
00:54:43,000 --> 00:54:47,000
at pagkatapos ko patuloy check upang makita kung ito ang null,

706
00:54:47,000 --> 00:54:56,000
at kung null, pagkatapos ito aborts at nagbabalik lamang ang bilang ng mga elemento ko ang access.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] ba ang sinuman anumang mga komento sa anumang?

708
00:55:01,000 --> 00:55:06,000
Mukhang fine kawastuhan matalino.

709
00:55:06,000 --> 00:55:10,000
[Mag-aaral] Hindi sa tingin ko kailangan mo ang node == null.

710
00:55:10,000 --> 00:55:13,000
Oo, kaya kung node == null return 0.

711
00:55:13,000 --> 00:55:18,000
Ngunit kung node == null pagkatapos ito-oh, may ay isang isyu sa kawastuhan.

712
00:55:18,000 --> 00:55:23,000
Ito ay ka bumabalik i, pero hindi sa saklaw ngayon.

713
00:55:23,000 --> 00:55:30,000
Kailangan lang int i, kaya i = 0.

714
00:55:30,000 --> 00:55:34,000
Ngunit kung node ay null, pagkatapos pa rin i ay pagpunta sa 0,

715
00:55:34,000 --> 00:55:39,000
at kami ay pagpunta sa bumalik 0, kaya ang kaso na ito ay kapareho.

716
00:55:39,000 --> 00:55:48,000
Isa pang karaniwang bagay ay upang panatilihin ang deklarasyon

717
00:55:48,000 --> 00:55:51,000
ng node sa loob ng para sa loop.

718
00:55:51,000 --> 00:55:54,000
Maaari mong sabihin-oh, hindi.

719
00:55:54,000 --> 00:55:56,000
Natin panatilihin ito bilang ito.

720
00:55:56,000 --> 00:55:59,000
Gusto ko marahil ilagay int i = 0 dito,

721
00:55:59,000 --> 00:56:05,000
pagkatapos node * node = unang in dito.

722
00:56:05,000 --> 00:56:11,000
At ito ay marahil kung paano inaalis ng ito ngayon.

723
00:56:11,000 --> 00:56:14,000
Marahil ito ay kung paano isinulat ko ito.

724
00:56:14,000 --> 00:56:21,000
Maaari mo ring pagtingin sa ito tulad nito.

725
00:56:21,000 --> 00:56:25,000
Ito para sa loop istraktura dito mismo

726
00:56:25,000 --> 00:56:30,000
dapat halos bilang natural na sa iyo para sa int i = 0

727
00:56:30,000 --> 00:56:33,000
i ay mas mababa kaysa sa haba ng array i + +.

728
00:56:33,000 --> 00:56:38,000
Kung iyon ang kung paano mo umulit sa isang array, ito ay kung paano mo umulit sa loob ng isang naka-link na listahan.

729
00:56:38,000 --> 00:56:45,000
>> Ito ay dapat na maging pangalawang kalikasan sa ilang punto.

730
00:56:45,000 --> 00:56:50,000
Gamit na sa isip, ito ay halos ang parehong bagay.

731
00:56:50,000 --> 00:56:57,000
Ay pagpunta sa nais upang gumalaw sa loob ng isang naka-link na listahan.

732
00:56:57,000 --> 00:57:02,000
Kung ang node-ako ay walang ideya kung ano ang halaga ay tinatawag na.

733
00:57:02,000 --> 00:57:04,000
Node i.

734
00:57:04,000 --> 00:57:15,000
Kung ang halaga sa node na = bumalik i totoo, at na ito.

735
00:57:15,000 --> 00:57:18,000
Pansinin na ang tanging paraan namin kailanman bumalik maling

736
00:57:18,000 --> 00:57:23,000
kung umulit namin sa ibabaw ng buong-link na listahan at hindi nagbabalik ng tunay na,

737
00:57:23,000 --> 00:57:29,000
sa gayon ay kung ano ang ginagawa.

738
00:57:29,000 --> 00:57:36,000
Bilang isang bahagi tandaan namin marahil ay hindi makakuha upang isama o prepend.

739
00:57:36,000 --> 00:57:39,000
>> Quick huling tala.

740
00:57:39,000 --> 00:57:52,000
Kung makita mo ang static keyword, kaya sabihin nating static int count = 0,

741
00:57:52,000 --> 00:57:56,000
ginagawa namin ang bilang ng + +, maaari kang talaga tingin ng mga ito bilang isang global na variable,

742
00:57:56,000 --> 00:58:00,000
kahit ko lang sinabi na ito ay hindi kung paano namin pagpunta sa ipatupad ang haba.

743
00:58:00,000 --> 00:58:06,000
Ako ginagawa ito dito, at pagkatapos ay ang bilang ng + +.

744
00:58:06,000 --> 00:58:11,000
Anumang paraan na maaari naming magpasok ng isang node sa aming naka-link na listahan namin ay incrementing aming count.

745
00:58:11,000 --> 00:58:15,000
Ang punto ng ito ay kung ano ang ibig sabihin ng static keyword.

746
00:58:15,000 --> 00:58:20,000
Kung ko lang may int count = 0 na maging isang regular na lumang global variable.

747
00:58:20,000 --> 00:58:25,000
Ano static int count ay nangangahulugan na ito ay isang pandaigdigang variable para sa file na ito.

748
00:58:25,000 --> 00:58:28,000
Ito ay imposible para sa ilang iba pang mga file,

749
00:58:28,000 --> 00:58:34,000
bang tingin ng pset 5, kung mayroon kang makapagsimula.

750
00:58:34,000 --> 00:58:39,000
Mayroon ka ng parehong speller.c, at mayroon kang dictionary.c,

751
00:58:39,000 --> 00:58:42,000
at kung ipinapahayag mo lang ang isang bagay global, pagkatapos anuman sa speller.c

752
00:58:42,000 --> 00:58:45,000
maaaring ma-access sa dictionary.c at vice versa.

753
00:58:45,000 --> 00:58:48,000
Global variable ay naa-access sa pamamagitan ng anumang file na. C,

754
00:58:48,000 --> 00:58:54,000
ngunit static na mga variable ay naa-access lamang mula sa loob ng mismong file,

755
00:58:54,000 --> 00:59:01,000
ito sa loob ng spell checker o sa loob ng dictionary.c,

756
00:59:01,000 --> 00:59:06,000
ito ay uri ng kung paano ipinapahayag ko ang aking variable para sa laki ng aking array

757
00:59:06,000 --> 00:59:10,000
o ang laki ng aking numero ng mga salita sa diksyunaryo.

758
00:59:10,000 --> 00:59:15,000
Dahil hindi ko nais na idedeklara ng isang global variable na sinuman ay access sa,

759
00:59:15,000 --> 00:59:18,000
Ko talagang lamang pakialam tungkol dito para sa aking sariling mga layunin ng.

760
00:59:18,000 --> 00:59:21,000
>> Ang magandang bagay tungkol dito ay din ang mga buong pangalan ng mga bagay-bagay na banggaan.

761
00:59:21,000 --> 00:59:27,000
Kung sinusubukan ng ilang iba pang mga file sa gumamit ng global variable na tinatawag na bilang ng mga bagay pumunta napaka, napaka mali,

762
00:59:27,000 --> 00:59:33,000
kaya ito mabuti mapigil ang safe ang mga bagay, at lamang ang maaari mong i-access ito,

763
00:59:33,000 --> 00:59:38,000
at walang sinuman ang maaari, at kung ang ibang tao declares isang global variable na tinatawag na bilang ng,

764
00:59:38,000 --> 00:59:43,000
hindi ito makagambala sa iyong static na variable na tinatawag na bilang ng.

765
00:59:43,000 --> 00:59:47,000
Ang static ay. Ito ay isang file na global variable.

766
00:59:47,000 --> 00:59:52,000
>> Tanong sa anumang?

767
00:59:52,000 --> 00:59:59,000
Na. Bye.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]