1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] A programozás, gyakran kell, hogy képviselje Értéklistákon,

2
00:00:10,050 --> 00:00:12,840
mint például a nevek a diákok egy része

3
00:00:12,840 --> 00:00:15,100
vagy az eredmények a legújabb kvíz.

4
00:00:15,100 --> 00:00:17,430
>> A C nyelven bejelentett tömböket lehet használni

5
00:00:17,430 --> 00:00:19,160
tárolására listákat.

6
00:00:19,160 --> 00:00:21,200
Ez könnyű felsorolni elemeit lista

7
00:00:21,200 --> 00:00:23,390
tömb tárolja, és ha kell elérni

8
00:00:23,390 --> 00:00:25,050
vagy módosítsa az i-edik lista elem

9
00:00:25,050 --> 00:00:27,570
néhány önkényes index I,

10
00:00:27,570 --> 00:00:29,910
hogy lehet tenni állandó időben,

11
00:00:29,910 --> 00:00:31,660
de tömbök vannak hátrányai is.

12
00:00:31,660 --> 00:00:33,850
>> Amikor állapítsa meg őket, mi kell mondani

13
00:00:33,850 --> 00:00:35,900
elöl mekkora vannak,

14
00:00:35,900 --> 00:00:38,160
azaz, hogy hány elemet tudnak tárolni

15
00:00:38,160 --> 00:00:40,780
és mekkorák ezek az elemek, amelyek meghatározott típusát.

16
00:00:40,780 --> 00:00:45,450
Például, int arr (10)

17
00:00:45,450 --> 00:00:48,220
tud tárolni 10 darab

18
00:00:48,220 --> 00:00:50,200
, amelyek a mérete int.

19
00:00:50,200 --> 00:00:52,590
>> Nem tudjuk megváltoztatni egy tömb méretét után nyilatkozatot.

20
00:00:52,590 --> 00:00:55,290
Van, hogy egy új tömb, ha meg akarjuk tárolni több elemet.

21
00:00:55,290 --> 00:00:57,410
Az ok, ez a korlátozás létezik, hogy a mi

22
00:00:57,410 --> 00:00:59,040
program tárolja az egész tömböt

23
00:00:59,040 --> 00:01:02,310
mint a szomszédos darab memória.

24
00:01:02,310 --> 00:01:04,500
Mondja ez a puffer, ahol tárolják a tömbben.

25
00:01:04,500 --> 00:01:06,910
Lehet, hogy más változók

26
00:01:06,910 --> 00:01:08,310
közvetlen közelében található a tömbben

27
00:01:08,310 --> 00:01:10,060
a memóriában, így nem

28
00:01:10,060 --> 00:01:12,060
csak, hogy a tömb nagyobb.

29
00:01:12,060 --> 00:01:15,700
>> Néha szeretnénk kereskedni a tömb gyors adathozzáférés sebességét

30
00:01:15,700 --> 00:01:17,650
egy kicsit rugalmasabb.

31
00:01:17,650 --> 00:01:20,380
Adja meg a láncolt lista, a másik alapvető adatstruktúra

32
00:01:20,380 --> 00:01:22,360
lehet, hogy nem lesz olyan ismerős.

33
00:01:22,360 --> 00:01:24,200
Magas szinten,

34
00:01:24,200 --> 00:01:26,840
A láncolt lista tárolja az adatokat egy sorozat csomópontok

35
00:01:26,840 --> 00:01:29,280
, amelyek kapcsolódnak egymáshoz linkek,

36
00:01:29,280 --> 00:01:31,760
ezért neve: 'láncolt lista. "

37
00:01:31,760 --> 00:01:33,840
Mint látni fogjuk, ez a különbség a tervezési

38
00:01:33,840 --> 00:01:35,500
vezet különböző előnyei és hátrányai

39
00:01:35,500 --> 00:01:37,000
mint egy tömb.

40
00:01:37,000 --> 00:01:39,840
>> Íme néhány C kód egy nagyon egyszerű láncolt lista egészek.

41
00:01:39,840 --> 00:01:42,190
Láthatjuk, hogy az általunk képviselt minden csomópont

42
00:01:42,190 --> 00:01:45,520
a listán, mint a struct amely 2 dolog,

43
00:01:45,520 --> 00:01:47,280
egy egész tárolására úgynevezett "val"

44
00:01:47,280 --> 00:01:50,460
és egy linket a következő csomópont a listán

45
00:01:50,460 --> 00:01:52,990
amit képviselnek, mint a mutató úgynevezett "next".

46
00:01:54,120 --> 00:01:56,780
Így tudjuk követni a teljes lista

47
00:01:56,780 --> 00:01:58,790
mindössze egy mutatót az 1. csomópont,

48
00:01:58,790 --> 00:02:01,270
és akkor kövesse a következő mutatók

49
00:02:01,270 --> 00:02:03,130
a 2. csomópont,

50
00:02:03,130 --> 00:02:05,280
a 3. csomópont,

51
00:02:05,280 --> 00:02:07,000
a 4. csomópont,

52
00:02:07,000 --> 00:02:09,889
és így tovább, amíg eljutunk az a lista végére.

53
00:02:10,520 --> 00:02:12,210
>> Lehet, hogy képes látni 1 előnye ennek

54
00:02:12,210 --> 00:02:14,490
át a statikus tömb szerkezet - a láncolt lista,

55
00:02:14,490 --> 00:02:16,450
nem kell egy nagy darab memória összesen.

56
00:02:17,400 --> 00:02:20,530
Az 1. csomópont a lista élhetnénk ezen a helyen a memóriában,

57
00:02:20,530 --> 00:02:23,160
és a 2. csomópont lehet egészen át ide.

58
00:02:23,160 --> 00:02:25,780
Mi lehet eljutni az összes csomópont nem számít, hol a memóriában vannak,

59
00:02:25,780 --> 00:02:28,890
mert kezdődik az 1. csomópont, minden csomópont next mutató

60
00:02:28,890 --> 00:02:31,700
azt mondja, hogy pontosan hová menjen legközelebb.

61
00:02:31,700 --> 00:02:33,670
>> Továbbá, nem kell, hogy mondjam elöl

62
00:02:33,670 --> 00:02:36,740
mekkora a láncolt lista lesz, mint mi statikus tömbök,

63
00:02:36,740 --> 00:02:39,060
hiszen tudjuk tartani hozzá csomópontok listáját

64
00:02:39,060 --> 00:02:42,600
amíg van hely valahol a memóriában, az új csomópont.

65
00:02:42,600 --> 00:02:45,370
Ezért a linkelt listák könnyen átméretezni dinamikusan.

66
00:02:45,370 --> 00:02:47,950
Mondja el, később a program kell, hogy adjunk több csomópont

67
00:02:47,950 --> 00:02:49,350
a mi listáját.

68
00:02:49,350 --> 00:02:51,480
Ha új csomópontot A lista on the fly,

69
00:02:51,480 --> 00:02:53,740
minden, amit meg kell tennie, hogy a memóriát az adott csomópont,

70
00:02:53,740 --> 00:02:55,630
puff az adatok értékét,

71
00:02:55,630 --> 00:02:59,070
majd helyezze, hogy hová szeretnénk beállításával a megfelelő mutatókat.

72
00:02:59,070 --> 00:03:02,310
>> Például, ha azt akartuk helyeznie egy csomópont között

73
00:03:02,310 --> 00:03:04,020
a 2. és 3. csomópontok a lista,

74
00:03:04,020 --> 00:03:06,800
 akkor nem kell mozgatni a 2. vagy 3. csomópontok egyáltalán.

75
00:03:06,800 --> 00:03:09,190
Mondja el, mi behelyezése a piros csomópont.

76
00:03:09,190 --> 00:03:12,890
Minden mi volna tennie, hogy megadja az új csomópont next mutató

77
00:03:12,890 --> 00:03:14,870
pont a 3. csomópont

78
00:03:14,870 --> 00:03:18,580
majd újból felhasználni a 2. csomópont next mutató

79
00:03:18,580 --> 00:03:20,980
arra utalnak, hogy az új csomópont.

80
00:03:22,340 --> 00:03:24,370
Szóval, mi lehet átméretezni a listákat on the fly

81
00:03:24,370 --> 00:03:26,090
hiszen a számítógép nem hivatkozhat indexálás,

82
00:03:26,090 --> 00:03:28,990
hanem össze a mutató tárolja.

83
00:03:29,120 --> 00:03:31,600
>> Azonban az a hátránya, láncolt listák

84
00:03:31,600 --> 00:03:33,370
az, hogy ellentétben a statikus tömb,

85
00:03:33,370 --> 00:03:36,690
a számítógép nem csak ugrik a közepén a listán.

86
00:03:38,040 --> 00:03:40,780
Mivel a számítógép, hogy látogassa meg minden csomópont a láncolt lista

87
00:03:40,780 --> 00:03:42,330
hogy a következő egy,

88
00:03:42,330 --> 00:03:44,770
ez fog hosszabb időt vesz igénybe, hogy megtalálja egy adott csomóponton

89
00:03:44,770 --> 00:03:46,400
, mint lenne egy tömbben.

90
00:03:46,400 --> 00:03:48,660
Ahhoz, hogy keresztezik a teljes lista időt vesz igénybe, arányos

91
00:03:48,660 --> 00:03:50,580
a hossza a jegyzék,

92
00:03:50,580 --> 00:03:54,630
vagy O (n) aszimptotikus jelöléssel.

93
00:03:54,630 --> 00:03:56,510
Átlagban, elérve minden csomópont

94
00:03:56,510 --> 00:03:58,800
is időt vesz igénybe, arányos n.

95
00:03:58,800 --> 00:04:00,700
>> Nos, hadd valójában írni egy kódot

96
00:04:00,700 --> 00:04:02,000
amely együttműködik a kapcsolódó listákat.

97
00:04:02,000 --> 00:04:04,220
Tegyük fel, hogy szeretnénk egy láncolt lista egészek.

98
00:04:04,220 --> 00:04:06,140
Tudunk jelentenek csomópont listánkon újra

99
00:04:06,140 --> 00:04:08,340
mint egy struct, 2 területen,

100
00:04:08,340 --> 00:04:10,750
Egy egész érték úgynevezett "ertek"

101
00:04:10,750 --> 00:04:13,490
és a következő mutató a következő csomópont a listán.

102
00:04:13,490 --> 00:04:15,660
Nos, úgy tűnik, elég egyszerű.

103
00:04:15,660 --> 00:04:17,220
>> Tegyük fel, hogy szeretnénk írni egy függvényt

104
00:04:17,220 --> 00:04:19,329
amely bejárja a listát, és kiírja a

105
00:04:19,329 --> 00:04:22,150
tárolt érték az utolsó csomópont a lista.

106
00:04:22,150 --> 00:04:24,850
Nos, ez azt jelenti, hogy kell majd áthalad az összes csomópont a lista

107
00:04:24,850 --> 00:04:27,310
hogy megtalálja az utolsó, de mivel nem vagyunk hozzá

108
00:04:27,310 --> 00:04:29,250
vagy törlése semmit, nem akar változtatni

109
00:04:29,250 --> 00:04:32,210
a belső szerkezete a következő mutatók a listában.

110
00:04:32,210 --> 00:04:34,790
>> Szóval, szükségünk lesz egy mutató kifejezetten bejárás

111
00:04:34,790 --> 00:04:36,940
amely hívjuk "bejáró".

112
00:04:36,940 --> 00:04:38,870
Ez feltérképezni az összes elemét a lista

113
00:04:38,870 --> 00:04:41,190
követve a lánc a következő mutatók.

114
00:04:41,190 --> 00:04:43,750
Minden általunk tárolt egy mutató az 1. csomópont,

115
00:04:43,750 --> 00:04:45,730
vagy "feje" a listán.

116
00:04:45,730 --> 00:04:47,370
Head rámutat az 1. csomóponton.

117
00:04:47,370 --> 00:04:49,120
Ez a típusú pointer-to-node.

118
00:04:49,120 --> 00:04:51,280
>> Ahhoz, hogy a tényleges 1. csomópont szerepel a listán,

119
00:04:51,280 --> 00:04:53,250
meg kell dereference ez a mutató,

120
00:04:53,250 --> 00:04:55,100
de mielőtt tudjuk feloldani, mi kell, hogy ellenőrizze

121
00:04:55,100 --> 00:04:57,180
ha a mutató null először.

122
00:04:57,180 --> 00:04:59,190
Ha ez nulla, a lista üres,

123
00:04:59,190 --> 00:05:01,320
és meg kell nyomtassa ki egy üzenetet, hogy mivel a lista üres,

124
00:05:01,320 --> 00:05:03,250
nincs utolsó csomópont.

125
00:05:03,250 --> 00:05:05,190
De mondjuk a lista nem üres.

126
00:05:05,190 --> 00:05:08,340
Ha ez nem, akkor meg kell feltérképezni a teljes lista

127
00:05:08,340 --> 00:05:10,440
addig, amíg eljutunk az utolsó csomópont a lista

128
00:05:10,440 --> 00:05:13,030
és hogyan lehet mondani, ha keresünk az utolsó csomópont a listán?

129
00:05:13,670 --> 00:05:16,660
>> Nos, ha a csomópont melletti mutató null,

130
00:05:16,660 --> 00:05:18,320
tudjuk, hogy mi vagyunk a végén

131
00:05:18,320 --> 00:05:22,390
mivel az utolsó következő mutató nem lenne következő csomópontot a listában mutasson.

132
00:05:22,390 --> 00:05:26,590
Ez jó gyakorlat, hogy mindig az utolsó csomópont melletti mutató inicializálni null

133
00:05:26,590 --> 00:05:30,800
hogy egy szabványos tulajdonság, amely figyelmeztet bennünket, ha elértük a lista végét.

134
00:05:30,800 --> 00:05:33,510
>> Tehát, ha a bejáró → következő null,

135
00:05:34,120 --> 00:05:38,270
ne feledjük, hogy a nyíl szintaxis egy parancsikont dereferencing

136
00:05:38,270 --> 00:05:40,010
a mutató egy struct, akkor hozzáférés

137
00:05:40,010 --> 00:05:42,510
a következő mező megegyezik a kínos:

138
00:05:42,510 --> 00:05:48,750
(* Bejáró). Következő.

139
00:05:49,820 --> 00:05:51,260
Amint megtaláltuk az utolsó csomópont,

140
00:05:51,260 --> 00:05:53,830
szeretnénk nyomtatni bejáró → val,

141
00:05:53,830 --> 00:05:55,000
az értéket a jelenlegi csomópont

142
00:05:55,000 --> 00:05:57,130
amiről tudjuk, hogy az utolsó.

143
00:05:57,130 --> 00:05:59,740
Ellenkező esetben, ha nem vagyunk még az utolsó csomópont a listán,

144
00:05:59,740 --> 00:06:02,340
meg kell mozgatni, hogy a következő csomópont a listán

145
00:06:02,340 --> 00:06:04,750
és ellenőrizze, hogy ez az utolsó.

146
00:06:04,750 --> 00:06:07,010
Ehhez már csak meg robotunk pointer

147
00:06:07,010 --> 00:06:09,840
pont a jelenlegi csomópont következő értéket,

148
00:06:09,840 --> 00:06:11,680
vagyis, a következő csomópont a listában.

149
00:06:11,680 --> 00:06:13,030
Ez úgy történik, beállításával

150
00:06:13,030 --> 00:06:15,280
bejáró = bejáró → következő.

151
00:06:16,050 --> 00:06:18,960
Akkor megismételjük ezt a folyamatot, és egy hurok például,

152
00:06:18,960 --> 00:06:20,960
amíg meg nem találjuk az utolsó csomópontot.

153
00:06:20,960 --> 00:06:23,150
Így például, ha a bejáró mutatott a fejét,

154
00:06:24,050 --> 00:06:27,710
elindultunk bejáró mutasson bejáró → következő,

155
00:06:27,710 --> 00:06:30,960
amely ugyanaz, mint a következő mező az 1. csomópont.

156
00:06:30,960 --> 00:06:33,620
Szóval, most a bejáró mutat a 2. csomópont,

157
00:06:33,620 --> 00:06:35,480
és újra, hogy ismételje meg a hurok,

158
00:06:37,220 --> 00:06:40,610
amíg meg nem találtuk az utolsó csomópont, azaz

159
00:06:40,610 --> 00:06:43,640
amennyiben a csomópont melletti mutató mutat null.

160
00:06:43,640 --> 00:06:45,070
És ott van ez,

161
00:06:45,070 --> 00:06:47,620
találtunk az utolsó csomópont a listáról, és nyomtatni annak értékét,

162
00:06:47,620 --> 00:06:50,800
mi csak használni bejáró → val.

163
00:06:50,800 --> 00:06:53,130
>> Mozgás nem olyan rossz, de mi van beszúrásával?

164
00:06:53,130 --> 00:06:56,290
Mondjuk szeretnénk beszúrni egy egész a 4. pozíció

165
00:06:56,290 --> 00:06:58,040
egy egész listát.

166
00:06:58,040 --> 00:07:01,280
Vagyis a jelenlegi 3. és 4. csomópontok.

167
00:07:01,280 --> 00:07:03,760
Ismét meg kell mozogni a lista csak a

168
00:07:03,760 --> 00:07:06,520
kap a 3. elem, az egyik mi behelyezése után.

169
00:07:06,520 --> 00:07:09,300
Tehát, hozzon létre egy bejáró mutató ismét áthalad a listán,

170
00:07:09,300 --> 00:07:11,400
ellenőrizze, hogy a fejünk mutató nulla,

171
00:07:11,400 --> 00:07:14,810
és ha ez nem, mutasson robotunk mutató élén csomópontot.

172
00:07:16,880 --> 00:07:18,060
Szóval, mi vagyunk az 1. elem.

173
00:07:18,060 --> 00:07:21,020
Meg kell, hogy menjen előre 2 további elem, mielőtt mi is be,

174
00:07:21,020 --> 00:07:23,390
így tudjuk használni a for ciklus

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

176
00:07:26,430 --> 00:07:28,590
és minden iteráció a hurok,

177
00:07:28,590 --> 00:07:31,540
előre robotunk előre mutató 1-csomópont

178
00:07:31,540 --> 00:07:34,570
ellenőrzi, ha a jelenlegi csomópont melletti mező null,

179
00:07:34,570 --> 00:07:37,550
és ha ez nem, helyezze robotunk mutatót a következő csomópont

180
00:07:37,550 --> 00:07:41,810
azáltal, hogy egyenlő a jelenlegi csomópont next mutató.

181
00:07:41,810 --> 00:07:45,210
Szóval, hiszen a for ciklus azt mondja erre

182
00:07:45,210 --> 00:07:47,550
kétszer,

183
00:07:49,610 --> 00:07:51,190
elértük a 3. csomópont,

184
00:07:51,190 --> 00:07:53,110
és egyszer robotunk mutató elérte a csomópont után

185
00:07:53,110 --> 00:07:55,270
amelyhez be szeretné szúrni az új egész,

186
00:07:55,270 --> 00:07:57,050
hogyan tudjuk valójában nem az behelyezése?

187
00:07:57,050 --> 00:07:59,440
>> Nos, a mi új egész szám kell illeszteni a lista

188
00:07:59,440 --> 00:08:01,250
részeként a saját node struct,

189
00:08:01,250 --> 00:08:03,140
mivel ez valóban sorozata csomópontok.

190
00:08:03,140 --> 00:08:05,690
Szóval, most egy új mutatót csomópont

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

192
00:08:08,910 --> 00:08:11,800
és állítsa pont a memóriában, hogy most osztják

193
00:08:11,800 --> 00:08:14,270
A halom a csomópont is,

194
00:08:14,270 --> 00:08:16,000
és mennyi memória van szükségünk, hogy fordítsanak?

195
00:08:16,000 --> 00:08:18,250
Nos, akkora, mint egy csomópont,

196
00:08:20,450 --> 00:08:23,410
és azt akarjuk állítani, hogy val mezőt az egész, hogy szeretnénk beszúrni.

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

198
00:08:25,590 --> 00:08:27,710
Most, a csomópont tartalmazza a egész szám.

199
00:08:27,710 --> 00:08:30,650
Ez is jó gyakorlat inicializálni az új csomópont következő mezőre

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

201
00:08:33,690 --> 00:08:35,080
de most mi lesz?

202
00:08:35,080 --> 00:08:37,179
>> Meg kell változtatni a belső szerkezete a lista

203
00:08:37,179 --> 00:08:40,409
és a következő mutatók listában szereplő meglévő

204
00:08:40,409 --> 00:08:42,950
3. és 4. csomópontok.

205
00:08:42,950 --> 00:08:46,560
Mivel a következő mutatók határozzák meg sorrendben a lista

206
00:08:46,560 --> 00:08:48,650
és mivel mi beilleszteni az új csomópont

207
00:08:48,650 --> 00:08:50,510
egyenesen a közepén a lista

208
00:08:50,510 --> 00:08:52,010
ez lehet egy kicsit trükkös.

209
00:08:52,010 --> 00:08:54,250
Ennek az az oka, emlékszem, a számítógépes

210
00:08:54,250 --> 00:08:56,250
tudja a helyét a csomópontok a lista

211
00:08:56,250 --> 00:09:00,400
mert a következő mutatók tárolt előző csomópontok.

212
00:09:00,400 --> 00:09:03,940
Tehát, ha valaha vereség pálya bármely ezeken a helyeken,

213
00:09:03,940 --> 00:09:06,860
mondjuk megváltoztatásával egyik következő mutatók a listán,

214
00:09:06,860 --> 00:09:09,880
Például, mondjuk mi változott

215
00:09:09,880 --> 00:09:12,920
a 3. csomópont következő mezőre

216
00:09:12,920 --> 00:09:15,610
arra utalnak, hogy egyes node ide.

217
00:09:15,610 --> 00:09:17,920
Mi lenne a szerencse, mert nem

218
00:09:17,920 --> 00:09:20,940
Van valami ötlete, hogy hol találja a többi lista

219
00:09:20,940 --> 00:09:23,070
és ez nyilvánvalóan nagyon rossz.

220
00:09:23,070 --> 00:09:25,080
Szóval, van, hogy nagyon óvatos a megrendeléshez

221
00:09:25,080 --> 00:09:28,360
melyben manipulálják a következő mutatók behelyezés során.

222
00:09:28,360 --> 00:09:30,540
>> Tehát, egyszerűsítése, mondjuk, hogy

223
00:09:30,540 --> 00:09:32,220
az első 4 csomópont

224
00:09:32,220 --> 00:09:36,200
nevezzük A, B, C, és D, a nyilakkal képviselő a lánc mutatókat

225
00:09:36,200 --> 00:09:38,070
hogy csatlakoztassa a csomópontokat.

226
00:09:38,070 --> 00:09:40,050
Szóval, kell helyezni az új csomópont

227
00:09:40,050 --> 00:09:42,070
között csomópontok C és D

228
00:09:42,070 --> 00:09:45,060
Ez a kritikus csinálni a megfelelő sorrendben, és megmutatom, miért.

229
00:09:45,060 --> 00:09:47,500
>> Nézzük meg a rossz irányba kell csinálni az első.

230
00:09:47,500 --> 00:09:49,490
Hé, tudjuk, hogy az új csomópont jön rögtön C,

231
00:09:49,490 --> 00:09:51,910
úgyhogy meghatározott C soron következő mutató

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

233
00:09:56,530 --> 00:09:59,180
Rendben, úgy tűnik, rendben van, csak be kell fejeznem most a

234
00:09:59,180 --> 00:10:01,580
hogy az új csomópont mellett pointer mutasson a D,

235
00:10:01,580 --> 00:10:03,250
De várjunk csak, hogyan lehet csinálni?

236
00:10:03,250 --> 00:10:05,170
Az egyetlen dolog, ami elmondja, hol D volt,

237
00:10:05,170 --> 00:10:07,630
volt a következő mutató korábban tárolt C,

238
00:10:07,630 --> 00:10:09,870
de mi csak átírta, hogy pointer

239
00:10:09,870 --> 00:10:11,170
mutatni, hogy az új csomópont,

240
00:10:11,170 --> 00:10:14,230
így már nincs semmi nyom, ahol a D a memóriában,

241
00:10:14,230 --> 00:10:17,020
és mi elvesztettük a többi listán.

242
00:10:17,020 --> 00:10:19,000
Nem jó egyáltalán.

243
00:10:19,000 --> 00:10:21,090
>> Szóval, hogyan csináljuk ezt a jogot?

244
00:10:22,360 --> 00:10:25,090
Először is, pont az új csomópont melletti mutató a D.

245
00:10:26,170 --> 00:10:28,990
Most mind az új csomópont és a C soron következő mutatók

246
00:10:28,990 --> 00:10:30,660
mutatnak, hogy ugyanazon a csomóponton, D,

247
00:10:30,660 --> 00:10:32,290
de ez rendben van.

248
00:10:32,290 --> 00:10:35,680
Most C. pontja a következő mutató az új csomópontot.

249
00:10:37,450 --> 00:10:39,670
Szóval, csináltam ezt adatvesztés nélkül.

250
00:10:39,670 --> 00:10:42,280
A kód, C jelenlegi csomópont

251
00:10:42,280 --> 00:10:45,540
hogy a bejárás mutató bejáró mutat az,

252
00:10:45,540 --> 00:10:50,400
és D képviseli a csomópont által mutatott a jelenlegi csomópont melletti területen,

253
00:10:50,400 --> 00:10:52,600
vagy lánctalpas → következő.

254
00:10:52,600 --> 00:10:55,460
Tehát először az új csomópont next mutató

255
00:10:55,460 --> 00:10:57,370
mutasson bejáró → következő,

256
00:10:57,370 --> 00:11:00,880
ugyanúgy mondtuk new_node soron következő pointer kell

257
00:11:00,880 --> 00:11:02,780
mutatnak D az ábra mutatja.

258
00:11:02,780 --> 00:11:04,540
Akkor tudjuk meg az aktuális csomópont next mutató

259
00:11:04,540 --> 00:11:06,330
az új csomópont,

260
00:11:06,330 --> 00:11:10,980
mint ahogy meg kellett várni, hogy pont C new_node a rajzban.

261
00:11:10,980 --> 00:11:12,250
Most minden van rendben, és mi nem vesztett

262
00:11:12,250 --> 00:11:14,490
követni minden olyan adatot, és tudtuk, hogy csak

263
00:11:14,490 --> 00:11:16,200
kibír az új csomópont közepén a lista

264
00:11:16,200 --> 00:11:19,330
anélkül, újjáépítése az egész dolog, vagy akár változó olyan elemeket

265
00:11:19,330 --> 00:11:22,490
hogy hogyan kellett volna egy fix hosszúságú tömbben.

266
00:11:22,490 --> 00:11:26,020
>> Tehát linkelt listák az alap, de fontos, dinamikus adatszerkezet

267
00:11:26,020 --> 00:11:29,080
amelyek előnyei és hátrányai

268
00:11:29,080 --> 00:11:31,260
összehasonlítva tömbök és más adatszerkezetek,

269
00:11:31,260 --> 00:11:33,350
és ahogy az gyakran előfordul a számítógép-tudomány,

270
00:11:33,350 --> 00:11:35,640
ezért fontos, hogy tudja, mikor kell használni az egyes eszközöket,

271
00:11:35,640 --> 00:11:37,960
így akkor vedd a megfelelő eszközt a megfelelő munkát.

272
00:11:37,960 --> 00:11:40,060
>> További gyakorlat, próbálja írás funkciók

273
00:11:40,060 --> 00:11:42,080
törölni csomópontok egy láncolt lista -

274
00:11:42,080 --> 00:11:44,050
emlékszem, hogy legyen óvatos a sorrend, amelyben átrendezéséhez

275
00:11:44,050 --> 00:11:47,430
a következő mutatókat annak érdekében, hogy ne veszítse el a darab a lista -

276
00:11:47,430 --> 00:11:50,200
vagy funkció számolni a csomópontok egy láncolt lista,

277
00:11:50,200 --> 00:11:53,280
vagy szórakoztató egy, fordított sorrendben az összes csomópont egy láncolt lista.

278
00:11:53,280 --> 00:11:56,090
>> A nevem Jackson Steinkamp, ​​ez CS50.