1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] Programmeerimise, me sageli vaja esindada väärtuste loetelusid,

2
00:00:10,050 --> 00:00:12,840
nagu nimed õpilaste osa

3
00:00:12,840 --> 00:00:15,100
või nende hinded hiljemalt viktoriini.

4
00:00:15,100 --> 00:00:17,430
>> C-keeles, deklareeritud massiivide saab kasutada

5
00:00:17,430 --> 00:00:19,160
salvestada nimekirjad.

6
00:00:19,160 --> 00:00:21,200
See on lihtne loetleda elemendid nimekiri

7
00:00:21,200 --> 00:00:23,390
salvestatakse massiivi, ja kui teil on vaja pääseda

8
00:00:23,390 --> 00:00:25,050
või muuta nda nimekirja element

9
00:00:25,050 --> 00:00:27,570
mõne suvalise indeks i,

10
00:00:27,570 --> 00:00:29,910
mida saab teha pidevalt aega,

11
00:00:29,910 --> 00:00:31,660
kuid massiivid on puudusi ka.

12
00:00:31,660 --> 00:00:33,850
>> Kui me kuulutame neid, me peame ütlema

13
00:00:33,850 --> 00:00:35,900
Esiplaanil kui suur see on,

14
00:00:35,900 --> 00:00:38,160
mis on, kui palju elemente, mida nad saavad salvestada

15
00:00:38,160 --> 00:00:40,780
ja kui suur need elemendid on, mis määrab nende tüüpi.

16
00:00:40,780 --> 00:00:45,450
Näiteks int arr (10)

17
00:00:45,450 --> 00:00:48,220
mahutab 10 vastet

18
00:00:48,220 --> 00:00:50,200
mis suurus int.

19
00:00:50,200 --> 00:00:52,590
>> Me ei saa muuta massiivi suuruse pärast deklaratsiooni.

20
00:00:52,590 --> 00:00:55,290
Me peame tegema uue massiivi kui me tahame säilitada rohkem elemente.

21
00:00:55,290 --> 00:00:57,410
Põhjus, miks see piirang olemas on, et meie

22
00:00:57,410 --> 00:00:59,040
Programm salvestab kogu massiiv

23
00:00:59,040 --> 00:01:02,310
kui külgnevas patakas mälu.

24
00:01:02,310 --> 00:01:04,500
Ütle see on puhver, kus me hoida meie massiivi.

25
00:01:04,500 --> 00:01:06,910
Võib olla teiste muutujatega

26
00:01:06,910 --> 00:01:08,310
asub kohe massiivi

27
00:01:08,310 --> 00:01:10,060
mälu, seega ei saa me

28
00:01:10,060 --> 00:01:12,060
lihtsalt massiivi suurem.

29
00:01:12,060 --> 00:01:15,700
>> Vahel me tahaks kaubelda massiiv on kiire andmetele juurdepääsu kiirus

30
00:01:15,700 --> 00:01:17,650
eest natuke rohkem paindlikkust.

31
00:01:17,650 --> 00:01:20,380
Sisesta seotud nimekirja, teine ​​põhi andmestruktuur

32
00:01:20,380 --> 00:01:22,360
sa ei pruugi olla tuttav.

33
00:01:22,360 --> 00:01:24,200
Kõrgel tasemel,

34
00:01:24,200 --> 00:01:26,840
seotud nimekirja salvestab andmeid jada sõlmede

35
00:01:26,840 --> 00:01:29,280
mis on ühendatud omavahel sidemeid,

36
00:01:29,280 --> 00:01:31,760
sellest ka nimi "seotud nimekirja."

37
00:01:31,760 --> 00:01:33,840
Nagu me näeme, see vahe on disain

38
00:01:33,840 --> 00:01:35,500
toob kaasa erinevad plussid ja miinused

39
00:01:35,500 --> 00:01:37,000
kui massiivi.

40
00:01:37,000 --> 00:01:39,840
>> Siin on mõned C koodi väga lihtne seotud nimekirja täisarvud.

41
00:01:39,840 --> 00:01:42,190
Te näete, et meil on esindatud iga sõlm

42
00:01:42,190 --> 00:01:45,520
Nimekirja nagu struct mis sisaldab 2 asja,

43
00:01:45,520 --> 00:01:47,280
täisarv salvestada nimega "Val"

44
00:01:47,280 --> 00:01:50,460
ja linki järgmise sõlme nimekiri

45
00:01:50,460 --> 00:01:52,990
mis me esindame nagu osuti nimega "kõrval."

46
00:01:54,120 --> 00:01:56,780
Nii, me saame jälgida kogu nimekiri

47
00:01:56,780 --> 00:01:58,790
vaid ühe kursor 1. sõlme,

48
00:01:58,790 --> 00:02:01,270
ja siis saame jälgida kõrval viiteid

49
00:02:01,270 --> 00:02:03,130
kuni 2. sõlme,

50
00:02:03,130 --> 00:02:05,280
aasta 3. sõlme,

51
00:02:05,280 --> 00:02:07,000
aasta 4. sõlme,

52
00:02:07,000 --> 00:02:09,889
ja nii edasi, kuni jõuame loetelu lõppu.

53
00:02:10,520 --> 00:02:12,210
>> Sul võib olla võimalik näha 1 eelis see on

54
00:02:12,210 --> 00:02:14,490
üle staatiline maatriksstruktuur - koos seotud nimekirja,

55
00:02:14,490 --> 00:02:16,450
me ei pea suur patakas mälu kokku.

56
00:02:17,400 --> 00:02:20,530
1. sõlme loetelu võiks elada selles kohas mälu,

57
00:02:20,530 --> 00:02:23,160
ja 2. sõlme võiks olla kogu tee siia.

58
00:02:23,160 --> 00:02:25,780
Saame kõik sõlmed ükskõik kus mälu nad on,

59
00:02:25,780 --> 00:02:28,890
sest alates 1. sõlme, iga tipp järgmiseks pointer

60
00:02:28,890 --> 00:02:31,700
ütleb meile täpselt, kuhu minna järgmiseks.

61
00:02:31,700 --> 00:02:33,670
>> Lisaks ei ole meil öelda, kuni ees

62
00:02:33,670 --> 00:02:36,740
kui suur lingitud nimekiri on kuidas me teeme koos staatilise massiivid

63
00:02:36,740 --> 00:02:39,060
kuna suudame hoida lisades sõlmede nimekirja

64
00:02:39,060 --> 00:02:42,600
niikaua kui seal on ruumi kuskil mälus uute tippude.

65
00:02:42,600 --> 00:02:45,370
Seetõttu lingitud nimekirjad on lihtne suurust dünaamiliselt.

66
00:02:45,370 --> 00:02:47,950
Ütle, hiljem programmi on vaja lisada rohkem nodes

67
00:02:47,950 --> 00:02:49,350
meie nimekirjas.

68
00:02:49,350 --> 00:02:51,480
Sõnumisse uue sõlme meie nimekirja lennult,

69
00:02:51,480 --> 00:02:53,740
kõik me peame tegema, on mälu eraldada, et sõlme,

70
00:02:53,740 --> 00:02:55,630
sulpsti andmete väärtust,

71
00:02:55,630 --> 00:02:59,070
ja siis panna see, kui me tahame, reguleerides korral viiteid.

72
00:02:59,070 --> 00:03:02,310
>> Näiteks, kui me tahtsime panna sõlme vahel

73
00:03:02,310 --> 00:03:04,020
2. ja 3. sõlmede loetelu,

74
00:03:04,020 --> 00:03:06,800
 ei oleks meil liikuda 2. või 3. sõlmede üldse.

75
00:03:06,800 --> 00:03:09,190
Ütle me lisada see punane sõlme.

76
00:03:09,190 --> 00:03:12,890
Kõik me tahaks pead tegema, on määrata uus sõlm järgmisel pointer

77
00:03:12,890 --> 00:03:14,870
osutada 3. sõlme

78
00:03:14,870 --> 00:03:18,580
ja siis rewire 2. sõlme järgmisel pointer

79
00:03:18,580 --> 00:03:20,980
juhtida meie uus sõlm.

80
00:03:22,340 --> 00:03:24,370
Nii võime suurust meie nimekirju lennult

81
00:03:24,370 --> 00:03:26,090
kuna meie arvuti ei tugine indekseerimine,

82
00:03:26,090 --> 00:03:28,990
vaid pigem ühendab kasutades viiteid need salvestada.

83
00:03:29,120 --> 00:03:31,600
>> Kuid kahjuks seotud nimekirjad

84
00:03:31,600 --> 00:03:33,370
on see, et erinevalt staatiline massiiv,

85
00:03:33,370 --> 00:03:36,690
arvuti ei saa lihtsalt hüpata keset nimekirja.

86
00:03:38,040 --> 00:03:40,780
Kuna arvuti on külastada iga sõlme seotud nimekirja

87
00:03:40,780 --> 00:03:42,330
saada järgmise juurde,

88
00:03:42,330 --> 00:03:44,770
see läheb kauem aega, et leida eelkõige sõlme

89
00:03:44,770 --> 00:03:46,400
kui see oleks massiivi.

90
00:03:46,400 --> 00:03:48,660
Läbida kogu nimekiri võtab aega proportsionaalne

91
00:03:48,660 --> 00:03:50,580
kuni pikkust nimekirja,

92
00:03:50,580 --> 00:03:54,630
või O (n) asümptootilisest märke.

93
00:03:54,630 --> 00:03:56,510
Keskmiselt jõudes iga sõlme

94
00:03:56,510 --> 00:03:58,800
Samuti võtab aega võrdeline n.

95
00:03:58,800 --> 00:04:00,700
>> Nüüd saab tegelikult kirjutada mõned kood

96
00:04:00,700 --> 00:04:02,000
mis töötab koos seotud nimekirju.

97
00:04:02,000 --> 00:04:04,220
Oletame, et me tahame seotud nimekirja täisarvud.

98
00:04:04,220 --> 00:04:06,140
Me ei esinda sõlme meie nimekirja uuesti

99
00:04:06,140 --> 00:04:08,340
nagu struct 2 valdkondades,

100
00:04:08,340 --> 00:04:10,750
täisarvuni nimega "Val"

101
00:04:10,750 --> 00:04:13,490
ja järgmisel kursor järgmisele sõlme nimekirja.

102
00:04:13,490 --> 00:04:15,660
Noh, tundub lihtne.

103
00:04:15,660 --> 00:04:17,220
>> Oletame, et me tahame kirjutada funktsioon

104
00:04:17,220 --> 00:04:19,329
mis läbib nimekirja ja trükib

105
00:04:19,329 --> 00:04:22,150
väärtus salvestatakse viimase sõlme nimekirja.

106
00:04:22,150 --> 00:04:24,850
Noh, see tähendab, et me peame läbida kõik sõlmed nimekirja

107
00:04:24,850 --> 00:04:27,310
leida viimane, kuid kuna me ei lisades

108
00:04:27,310 --> 00:04:29,250
või midagi kustutama, me ei taha muuta

109
00:04:29,250 --> 00:04:32,210
siseehitus järgmise suunanäitajaks nimekirjas.

110
00:04:32,210 --> 00:04:34,790
>> Niisiis, me vajame osuti spetsiaalselt läbipääsusüsteemid

111
00:04:34,790 --> 00:04:36,940
mis me kutsume "roomik".

112
00:04:36,940 --> 00:04:38,870
See poeb läbi kõik elemendid nimekiri

113
00:04:38,870 --> 00:04:41,190
järgides kett järgmisel lähtekohtadeks.

114
00:04:41,190 --> 00:04:43,750
Kõik me oleme salvestatud on viit 1. sõlme,

115
00:04:43,750 --> 00:04:45,730
või "pea" nimekirja.

116
00:04:45,730 --> 00:04:47,370
Head punktid 1. sõlme.

117
00:04:47,370 --> 00:04:49,120
See on tüüpi pointer-to-sõlme.

118
00:04:49,120 --> 00:04:51,280
>> Et saada tegelik 1. sõlme nimekiri,

119
00:04:51,280 --> 00:04:53,250
meil dereference see pointer,

120
00:04:53,250 --> 00:04:55,100
kuid enne kui saame dereference see, peame kontrollima

121
00:04:55,100 --> 00:04:57,180
Kui osuti on null esimene.

122
00:04:57,180 --> 00:04:59,190
Kui see on null, nimekiri on tühi,

123
00:04:59,190 --> 00:05:01,320
ja me peaks välja printida sõnum, et kuna nimekiri on tühi,

124
00:05:01,320 --> 00:05:03,250
ei ole viimase sõlme.

125
00:05:03,250 --> 00:05:05,190
Aga oletame, et loetelu ei ole tühi.

126
00:05:05,190 --> 00:05:08,340
Kui see ei ole, siis peaksime roomata läbi kogu nimekiri

127
00:05:08,340 --> 00:05:10,440
kuni jõuame viimase sõlme loetelu,

128
00:05:10,440 --> 00:05:13,030
ja kuidas me saame öelda, kui me vaatame viimast sõlme nimekirja?

129
00:05:13,670 --> 00:05:16,660
>> Noh, kui sõlm järgmisel osuti on null,

130
00:05:16,660 --> 00:05:18,320
me teame, et me oleme lõpus

131
00:05:18,320 --> 00:05:22,390
pärast viimast järgmisel osuti ei oleks järgmine sõlme nimekiri osutada.

132
00:05:22,390 --> 00:05:26,590
See on hea tava, et hoiavad viimase sõlme järgmisel osuti käivitub tühjaks

133
00:05:26,590 --> 00:05:30,800
on standardiseeritud vara mis hoiatab meid, kui oleme jõudnud nimekirja.

134
00:05:30,800 --> 00:05:33,510
>> Niisiis, kui roomik → kõrval on null,

135
00:05:34,120 --> 00:05:38,270
meeles pidama, et arrow süntaks on otsetee viite mahavõtmine

136
00:05:38,270 --> 00:05:40,010
kursor struct, siis tutvumise

137
00:05:40,010 --> 00:05:42,510
selle järgmisele väljale samaväärne ebamugav:

138
00:05:42,510 --> 00:05:48,750
(* Roomik). Kõrval.

139
00:05:49,820 --> 00:05:51,260
Kui oleme leidnud viimase sõlme,

140
00:05:51,260 --> 00:05:53,830
me tahame prindi roomik → Val,

141
00:05:53,830 --> 00:05:55,000
väärtus aktiivse sõlme

142
00:05:55,000 --> 00:05:57,130
mis me teame, on viimane.

143
00:05:57,130 --> 00:05:59,740
Vastasel juhul, kui me ei ole veel viimasel sõlme loetelu,

144
00:05:59,740 --> 00:06:02,340
meil liikuda edasi järgmise sõlme nimekiri

145
00:06:02,340 --> 00:06:04,750
ja vaadata, kas see on viimane.

146
00:06:04,750 --> 00:06:07,010
Selleks me lihtsalt paneme meie roomik pointer

147
00:06:07,010 --> 00:06:09,840
osutada praeguse sõlme järgmine väärtus,

148
00:06:09,840 --> 00:06:11,680
see tähendab, et järgmise sõlme nimekirja.

149
00:06:11,680 --> 00:06:13,030
Seda tehakse, seades

150
00:06:13,030 --> 00:06:15,280
roomik = roomik → järgmine.

151
00:06:16,050 --> 00:06:18,960
Siis korrake seda protsessi, mille ahela näiteks

152
00:06:18,960 --> 00:06:20,960
kuni leiame viimase sõlme.

153
00:06:20,960 --> 00:06:23,150
Nii näiteks, kui roomik oli osutades peaga

154
00:06:24,050 --> 00:06:27,710
seadsime roomik osutada roomik → kõrval,

155
00:06:27,710 --> 00:06:30,960
mis on sama järgmise välja 1. sõlme.

156
00:06:30,960 --> 00:06:33,620
Nii, nüüd meie roomik on suunaga 2. sõlme,

157
00:06:33,620 --> 00:06:35,480
ja jällegi, me kordame seda silmus,

158
00:06:37,220 --> 00:06:40,610
kuni oleme leidnud viimase sõlme, mis on

159
00:06:40,610 --> 00:06:43,640
kus sõlm järgmisel osuti osutab tühjaks.

160
00:06:43,640 --> 00:06:45,070
Ja seal on meil siis,

161
00:06:45,070 --> 00:06:47,620
oleme leidnud viimase sõlme loetelu, ja printida oma väärtust,

162
00:06:47,620 --> 00:06:50,800
me lihtsalt kasutada roomik → Val.

163
00:06:50,800 --> 00:06:53,130
>> Liiklevad ei ole nii halb, kuid kuidas lisada?

164
00:06:53,130 --> 00:06:56,290
Lets öelda tahame sisestada täisarv arvesse 4. kohal

165
00:06:56,290 --> 00:06:58,040
aastal täisarv nimekirja.

166
00:06:58,040 --> 00:07:01,280
See on senise 3. ja 4. sõlmed.

167
00:07:01,280 --> 00:07:03,760
Jällegi, meil on läbida nimekirja lihtsalt

168
00:07:03,760 --> 00:07:06,520
saada 3. osa, üks me lisades pärast.

169
00:07:06,520 --> 00:07:09,300
Niisiis, loome roomik osuti uuesti läbida nimekirja,

170
00:07:09,300 --> 00:07:11,400
vaadata, kas meie peas osuti on null,

171
00:07:11,400 --> 00:07:14,810
ja kui see ei ole, suunake oma roomik osuti eesotsas sõlme.

172
00:07:16,880 --> 00:07:18,060
Niisiis, me oleme 1. osa.

173
00:07:18,060 --> 00:07:21,020
Me peame minema edasi veel 2 sätteid enne kui saame sisestada,

174
00:07:21,020 --> 00:07:23,390
nii saame kasutada loop

175
00:07:23,390 --> 00:07:26,430
int i = 1; i <3; i + +

176
00:07:26,430 --> 00:07:28,590
ja iga iteratsiooni silmus,

177
00:07:28,590 --> 00:07:31,540
edendada meie roomik osuti edasi 1 sõlm

178
00:07:31,540 --> 00:07:34,570
kontrollib, kas praegune tipp järgmiseks valdkonnas on null,

179
00:07:34,570 --> 00:07:37,550
ja kui see ei ole, liikuda meie roomik kursor järgmisele sõlme

180
00:07:37,550 --> 00:07:41,810
seades see võrdne praeguse sõlme järgmisel pointer.

181
00:07:41,810 --> 00:07:45,210
Niisiis, kuna meie jaoks silmus ütleb, mida teha, et

182
00:07:45,210 --> 00:07:47,550
kaks korda,

183
00:07:49,610 --> 00:07:51,190
oleme jõudnud 3. sõlme,

184
00:07:51,190 --> 00:07:53,110
ja kui meie roomik osuti on jõudnud sõlme pärast

185
00:07:53,110 --> 00:07:55,270
mida me tahame lisada meie uus täisarv,

186
00:07:55,270 --> 00:07:57,050
kuidas me tegelikult ei sisestamist?

187
00:07:57,050 --> 00:07:59,440
>> Noh, meie uus täisarv tuleb lisada nimekiri

188
00:07:59,440 --> 00:08:01,250
osana oma sõlme struct,

189
00:08:01,250 --> 00:08:03,140
sest see on tõesti jada sõlmed.

190
00:08:03,140 --> 00:08:05,690
Nii, teeme uue kursor sõlme

191
00:08:05,690 --> 00:08:08,910
nn new_node "

192
00:08:08,910 --> 00:08:11,800
ja seadke see viidata mälu, et me nüüd eraldada

193
00:08:11,800 --> 00:08:14,270
edasi hunnik jaoks sõlme ise,

194
00:08:14,270 --> 00:08:16,000
ja kui palju mälu on meil vaja eraldada?

195
00:08:16,000 --> 00:08:18,250
Noh, suurus sõlme,

196
00:08:20,450 --> 00:08:23,410
ja me tahame, et määrata oma val põllult täisarv, et me tahame lisada.

197
00:08:23,410 --> 00:08:25,590
Oletame, 6.

198
00:08:25,590 --> 00:08:27,710
Nüüd, sõlm sisaldab meie täisarvuni.

199
00:08:27,710 --> 00:08:30,650
See on ka hea tava initsialiseerida uus sõlm järgmisele väljale

200
00:08:30,650 --> 00:08:33,690
juhtida null,

201
00:08:33,690 --> 00:08:35,080
aga nüüd?

202
00:08:35,080 --> 00:08:37,179
>> Me peame muutma siseehitus nimekirja

203
00:08:37,179 --> 00:08:40,409
ja järgmine suunanäitajaks loetelus sisalduva olemasoleva

204
00:08:40,409 --> 00:08:42,950
3. ja 4. sõlmed.

205
00:08:42,950 --> 00:08:46,560
Kuna järgmine suunanäitajaks kindlaks nimekirja järjestuse alusel,

206
00:08:46,560 --> 00:08:48,650
ja kuna me lisada meie uus sõlm

207
00:08:48,650 --> 00:08:50,510
otse keset nimekirja,

208
00:08:50,510 --> 00:08:52,010
see võib olla veidi keeruline.

209
00:08:52,010 --> 00:08:54,250
Seda seetõttu, pea meeles, meie arvuti

210
00:08:54,250 --> 00:08:56,250
ainult teab, kus asuvad tippe nimekirja

211
00:08:56,250 --> 00:09:00,400
sest järgmisel lähtekohtadeks salvestatud eelmise sõlmed.

212
00:09:00,400 --> 00:09:03,940
Niisiis, kui me kunagi kaotanud jälgida, et nendes kohtades,

213
00:09:03,940 --> 00:09:06,860
öelda muutes ühe järgmise viiteid meie nimekirja,

214
00:09:06,860 --> 00:09:09,880
Ütleme näiteks, et oleme muutnud

215
00:09:09,880 --> 00:09:12,920
3. sõlme järgmisele väljale

216
00:09:12,920 --> 00:09:15,610
et osutada mõnele sõlme siin.

217
00:09:15,610 --> 00:09:17,920
Me tahaks olla läbi õnne, sest me ei

218
00:09:17,920 --> 00:09:20,940
on aimu, kust leida ülejäänud nimekirja,

219
00:09:20,940 --> 00:09:23,070
ja see on ilmselt tõesti halb.

220
00:09:23,070 --> 00:09:25,080
Niisiis, me peame olema väga ettevaatlikud, et

221
00:09:25,080 --> 00:09:28,360
kus me manipuleerida meie kõrval suunanäitajaks sisestamise ajal.

222
00:09:28,360 --> 00:09:30,540
>> Nii, et lihtsustada käesoleva oletame, et

223
00:09:30,540 --> 00:09:32,220
meie esimene 4 tippu

224
00:09:32,220 --> 00:09:36,200
nimetatakse A-, B-, C-, ja D, nooled esindavad kett viiteid

225
00:09:36,200 --> 00:09:38,070
et ühendada sõlmed.

226
00:09:38,070 --> 00:09:40,050
Niisiis, me peame lisada meie uus sõlm

227
00:09:40,050 --> 00:09:42,070
vahel sõlmed C ja D.

228
00:09:42,070 --> 00:09:45,060
On oluline teha seda õiges järjekorras, ja ma näitan teile, miks.

229
00:09:45,060 --> 00:09:47,500
>> Vaatame vale viis seda teha esimesena.

230
00:09:47,500 --> 00:09:49,490
Hei, me teame, et uus sõlm peab tulema kohe pärast C,

231
00:09:49,490 --> 00:09:51,910
niiet seatud C järgmiseks pointer

232
00:09:51,910 --> 00:09:54,700
osutada new_node.

233
00:09:56,530 --> 00:09:59,180
Olgu, tundub okei, me lihtsalt peame lopeteltiin nüüd poolt

234
00:09:59,180 --> 00:10:01,580
tegemist uue sõlme järgmisel pointer punkt D,

235
00:10:01,580 --> 00:10:03,250
Aga oota, kuidas me seda teeme?

236
00:10:03,250 --> 00:10:05,170
Ainuke asi, mis võiks meile öelda, kus D oli,

237
00:10:05,170 --> 00:10:07,630
aastal järgmise pointer varem salvestatud C,

238
00:10:07,630 --> 00:10:09,870
kuid me lihtsalt rewrote et osuti

239
00:10:09,870 --> 00:10:11,170
osutada uus sõlm,

240
00:10:11,170 --> 00:10:14,230
nii et me ei ole enam aimugi, kus D on mälu,

241
00:10:14,230 --> 00:10:17,020
ja me oleme kaotanud ülejäänud nimekirja.

242
00:10:17,020 --> 00:10:19,000
Mitte üldse hea.

243
00:10:19,000 --> 00:10:21,090
>> Niisiis, kuidas me seda teha eks?

244
00:10:22,360 --> 00:10:25,090
Esimene punkt Uue sõlme järgmisel pointer D.

245
00:10:26,170 --> 00:10:28,990
Nüüd, kui uus sõlm ja C järgmiseks viiteid

246
00:10:28,990 --> 00:10:30,660
osutades sama sõlme, D,

247
00:10:30,660 --> 00:10:32,290
aga sellest pole midagi.

248
00:10:32,290 --> 00:10:35,680
Nüüd saame punkti C järgmiseks viitaja uus sõlm.

249
00:10:37,450 --> 00:10:39,670
Niisiis, oleme teinud seda ilma andmeid kaotamata.

250
00:10:39,670 --> 00:10:42,280
Kood, C on praegune tipp

251
00:10:42,280 --> 00:10:45,540
et läbipääsusüsteemid osuti roomik on suunaga,

252
00:10:45,540 --> 00:10:50,400
ja D on esindatud sõlme poolt esile tõstetud praeguse sõlme järgmisele väljale,

253
00:10:50,400 --> 00:10:52,600
või roomikutel → kõrval.

254
00:10:52,600 --> 00:10:55,460
Niisiis, me kõigepealt kehtestada uus sõlm järgmisel pointer

255
00:10:55,460 --> 00:10:57,370
osutada roomik → kõrval,

256
00:10:57,370 --> 00:11:00,880
Samamoodi me ütlesime new_node järgmiseks osuti peaks

257
00:11:00,880 --> 00:11:02,780
osutada D joonisel.

258
00:11:02,780 --> 00:11:04,540
Siis saame praegune tipp järgmiseks pointer

259
00:11:04,540 --> 00:11:06,330
meie uus sõlm,

260
00:11:06,330 --> 00:11:10,980
nagu pidime ootama punktis C new_node joonisel.

261
00:11:10,980 --> 00:11:12,250
Nüüd kõik on korras, ja me ei kaotanud

262
00:11:12,250 --> 00:11:14,490
jälgida mis tahes andmed, ja me saime lihtsalt

263
00:11:14,490 --> 00:11:16,200
kinni meie uus sõlm keset nimekiri

264
00:11:16,200 --> 00:11:19,330
ilma ümberehitust kogu asja või isegi minnes kõikidest elementidest

265
00:11:19,330 --> 00:11:22,490
kuidas me oleks pidanud koos kindla pikkusega massiiv.

266
00:11:22,490 --> 00:11:26,020
>> Niisiis, lingitud nimekirjad on lihtne, kuid oluline, dünaamiline andmestruktuur

267
00:11:26,020 --> 00:11:29,080
mis on nii plusse ja miinuseid

268
00:11:29,080 --> 00:11:31,260
võrreldes massiivid ja teiste andmestruktuuride

269
00:11:31,260 --> 00:11:33,350
ja nagu sageli juhtub infotehnoloogia,

270
00:11:33,350 --> 00:11:35,640
see on oluline teada, millal kasutada iga vahend,

271
00:11:35,640 --> 00:11:37,960
nii et saate valida õige vahend õige töö.

272
00:11:37,960 --> 00:11:40,060
>> Rohkem praktikas proovida kirjalikult ülesandeid

273
00:11:40,060 --> 00:11:42,080
kustutada sõlmede alates lingitud nimekiri -

274
00:11:42,080 --> 00:11:44,050
meeles olla ettevaatlik, millises järjekorras sa ümber

275
00:11:44,050 --> 00:11:47,430
oma järgmise viiteid, et sa ei kaota tüki oma nimekirja -

276
00:11:47,430 --> 00:11:50,200
või funktsiooni loota tippe seotud nimekirja,

277
00:11:50,200 --> 00:11:53,280
või lõbus, et vastupidises järjekorras kõik sõlmed seotud nimekirja.

278
00:11:53,280 --> 00:11:56,090
>> Minu nimi on Jackson Steinkamp, ​​see on CS50.