1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [6. §] [kényelmes]

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

3
00:00:04,000 --> 00:00:09,000
[Ez a CS50.] [CS50.TV]

4
00:00:09,000 --> 00:00:11,000
>> Mi lehet a fejét, hogy mi részén kérdésekre.

5
00:00:11,000 --> 00:00:17,000
Elküldtem az URL-címet a tér előtt.

6
00:00:17,000 --> 00:00:22,000
Az elején a szakasz a kérdések mondja

7
00:00:22,000 --> 00:00:26,000
nyilvánvalóan nem vagyok teljesen unsick-egy nagyon egyszerű kérdés

8
00:00:26,000 --> 00:00:28,000
hogy csak mi Valgrind?

9
00:00:28,000 --> 00:00:30,000
Mit jelent valgrind csinálni?

10
00:00:30,000 --> 00:00:34,000
Bárki, aki azt akarom mondani, hogy mi valgrind csinál?

11
00:00:34,000 --> 00:00:36,000
[Student] Ellenőrzések memóriavesztés.

12
00:00:36,000 --> 00:00:41,000
Ja, Valgrind általános memória ellenőrző.

13
00:00:41,000 --> 00:00:44,000
Azt, hogy a végén, azt mondja, ha bármilyen memóriavesztés,

14
00:00:44,000 --> 00:00:49,000
ami leginkább mi vagyunk használja azt, mert ha azt szeretnénk, hogy

15
00:00:49,000 --> 00:00:54,000
Jól szerepelnek a probléma beállított vagy ha azt szeretné,

16
00:00:54,000 --> 00:00:59,000
kap a nagy fórumon, meg kell, hogy nincs memóriavesztés egyáltalán,

17
00:00:59,000 --> 00:01:01,000
és abban az esetben van egy memóriavesztés, amit nem talál,

18
00:01:01,000 --> 00:01:04,000
is szem előtt tartani, hogy ha megnyit egy fájlt

19
00:01:04,000 --> 00:01:07,000
és ha nem zárja be, ez egy memóriavesztés.

20
00:01:07,000 --> 00:01:10,000
>> Egy csomó ember keres egy csomópont, hogy ők nem szabadít

21
00:01:10,000 --> 00:01:15,000
ha tényleg, nem zárja le a szótárban a legelső lépés.

22
00:01:15,000 --> 00:01:19,000
Azt is megmondja, ha bármilyen helytelen olvas vagy ír,

23
00:01:19,000 --> 00:01:22,000
ami azt jelenti, ha megpróbálod, és állítsa be egy értéket

24
00:01:22,000 --> 00:01:26,000
ez túl vége a halom, és nem történik seg hiba

25
00:01:26,000 --> 00:01:30,000
de valgrind elkapja, ahogyan akkor valójában nem írni ott,

26
00:01:30,000 --> 00:01:33,000
és így biztosan nem kell semmilyen e sem.

27
00:01:33,000 --> 00:01:38,000
Hogyan kell használni Valgrind?

28
00:01:38,000 --> 00:01:42,000
Hogyan kell használni Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Ez egy általános kérdés

30
00:01:45,000 --> 00:01:49,000
fajta futtatni, és nézd meg a kimeneten.

31
00:01:49,000 --> 00:01:51,000
A kimenet elsöprő sokszor.

32
00:01:51,000 --> 00:01:54,000
Van még szórakoztató hibát, ahol ha van valami borzasztóan rossz dolog

33
00:01:54,000 --> 00:01:59,000
történik a hurok, akkor előbb-utóbb azt mondják: "Túl sok hibát.

34
00:01:59,000 --> 00:02:03,000
Fogom megállítani számlálás most. "

35
00:02:03,000 --> 00:02:08,000
Ez alapvetően szöveges kimenetet, hogy meg kell értelmezni.

36
00:02:08,000 --> 00:02:13,000
A végén, azt fogja mondani, hogy minden memóriavesztés, hogy van,

37
00:02:13,000 --> 00:02:16,000
hány blokkok, amelyek hasznosak lehetnek, mivel

38
00:02:16,000 --> 00:02:20,000
ha ez egy blokk unfreed, akkor ez általában könnyebb megtalálni

39
00:02:20,000 --> 00:02:23,000
mint 1.000 blokkok unfreed.

40
00:02:23,000 --> 00:02:26,000
1.000 blokkok unfreed valószínűleg azt jelenti, hogy nem szabadít

41
00:02:26,000 --> 00:02:30,000
a kapcsolt listák megfelelően, vagy ilyesmi.

42
00:02:30,000 --> 00:02:32,000
Ez Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Most már a részén kérdések

44
00:02:35,000 --> 00:02:38,000
ahol nem kell letölteni.

45
00:02:38,000 --> 00:02:41,000
Akkor kattintson a nevem, és húzza őket a térben.

46
00:02:41,000 --> 00:02:44,000
Most kattints rám.

47
00:02:44,000 --> 00:02:46,000
Felülvizsgálat 1 lesz a stack, amit csinálunk 1..

48
00:02:46,000 --> 00:02:55,000
Revision 2 lesz várólista, és a Revision 3 lesz az egyszeresen láncolt lista.

49
00:02:55,000 --> 00:02:58,000
Kezdve le a stack.

50
00:02:58,000 --> 00:03:02,000
Ahogy azt itt, vagy egymástól az egyik alapvető,

51
00:03:02,000 --> 00:03:07,000
alapvető adatstruktúrák a számítógép-tudomány.

52
00:03:07,000 --> 00:03:11,000
A nagyon prototipikus példa

53
00:03:11,000 --> 00:03:13,000
a verem tálcák az étkezőben.

54
00:03:13,000 --> 00:03:16,000
Ez alapvetően, amikor vezetnek be a verem,

55
00:03:16,000 --> 00:03:20,000
valaki fogja mondani, hogy "Ó, mint egy halom tálcák."

56
00:03:20,000 --> 00:03:22,000
Te verem a tálcákat fel.

57
00:03:22,000 --> 00:03:24,000
Aztán ha megy, hogy húzza a tálcát,

58
00:03:24,000 --> 00:03:31,000
az első tálcát, ami egyre húzta az utolsó, amit hozott a köteget.

59
00:03:31,000 --> 00:03:34,000
A kémény is,-mint azt mondja, itt van-

60
00:03:34,000 --> 00:03:37,000
megvan a szegmens a memória az úgynevezett stack.

61
00:03:37,000 --> 00:03:40,000
És miért hívják a stack?

62
00:03:40,000 --> 00:03:42,000
>> Mert, mint egy halom adatszerkezetet,

63
00:03:42,000 --> 00:03:46,000
tolja és durran stack frame a stack,

64
00:03:46,000 --> 00:03:53,000
ahol stack keretek olyan, mint egy különleges hívást egy függvény.

65
00:03:53,000 --> 00:03:57,000
És mint egy halom, akkor mindig vissza kell térnie

66
00:03:57,000 --> 00:04:03,000
Egy függvényhívás előtt juthatsz le a kisebb stack frame újra.

67
00:04:03,000 --> 00:04:08,000
Nem lehet fontosabb hívást foo hívás bár és bár visszatérés a fő közvetlenül.

68
00:04:08,000 --> 00:04:14,000
Ez mindig van, hogy kövesse a helyes stack toló és popping.

69
00:04:14,000 --> 00:04:18,000
A két művelet, mint mondtam, a push és pop.

70
00:04:18,000 --> 00:04:20,000
Ezek egyetemes értelemben.

71
00:04:20,000 --> 00:04:26,000
Tudnia kell, hogy push és pop szempontjából zsetonnal nem számít, mit.

72
00:04:26,000 --> 00:04:28,000
Meglátjuk sorok fajta különböző.

73
00:04:28,000 --> 00:04:32,000
Ez nem igazán egyetemes kifejezést, de push és pop egyetemes a stack.

74
00:04:32,000 --> 00:04:34,000
Push csak tedd a verem.

75
00:04:34,000 --> 00:04:37,000
Pop vedd le a stack.

76
00:04:37,000 --> 00:04:43,000
És azt látjuk, itt már a typedef struct stack,

77
00:04:43,000 --> 00:04:46,000
így már char ** szálakat.

78
00:04:46,000 --> 00:04:51,000
Ne félek semmilyen **.

79
00:04:51,000 --> 00:04:54,000
Ez lesz a végén, hogy egy sor húrok

80
00:04:54,000 --> 00:04:58,000
vagy egy tömb mutatókat karakterek, ahol

81
00:04:58,000 --> 00:05:00,000
mutatókat karakterek általában vonósok.

82
00:05:00,000 --> 00:05:05,000
Nem kell, hogy vonósok, de itt, ők lesznek vonósok.

83
00:05:05,000 --> 00:05:08,000
>> Van egy sor húrok.

84
00:05:08,000 --> 00:05:14,000
Van egy méret, ami az, hogy hány elem jelenleg a stack,

85
00:05:14,000 --> 00:05:19,000
és akkor megvan a kapacitása, ami hány elem lehet a verem.

86
00:05:19,000 --> 00:05:22,000
A kapacitás kell kezdeni, ki, mint valami nagyobb, mint 1,

87
00:05:22,000 --> 00:05:27,000
de a mérete fog indulni, mint 0-ra.

88
00:05:27,000 --> 00:05:36,000
Nos, van alapvetően három különböző módon lehet gondolni egy verem.

89
00:05:36,000 --> 00:05:39,000
Nos, valószínűleg több, de a két fő módja van

90
00:05:39,000 --> 00:05:43,000
akkor végre használatával egy tömb, vagy pedig végrehajtja segítségével láncolt lista.

91
00:05:43,000 --> 00:05:48,000
Csatolt listák ilyen triviális, hogy a stack-től.

92
00:05:48,000 --> 00:05:51,000
Ez nagyon egyszerű, hogy egy köteg használatával linkelt listákat,

93
00:05:51,000 --> 00:05:55,000
így itt, mi megy, hogy egy verem segítségével tömbök,

94
00:05:55,000 --> 00:05:59,000
majd a tömbök, van még két módon lehet gondolni.

95
00:05:59,000 --> 00:06:01,000
Előtt, amikor azt mondtam, hogy van egy kapacitás stack,

96
00:06:01,000 --> 00:06:04,000
így elfér egy elemet a verem.

97
00:06:04,000 --> 00:06:09,000
>> Az egyetlen módja, hogy megtörténhet az, amint elérte a 10 elemet, akkor kész.

98
00:06:09,000 --> 00:06:13,000
Lehet, hogy tudja, hogy van egy felső határa 10 dolog, amit a világban

99
00:06:13,000 --> 00:06:16,000
hogy soha nem lesz több, mint 10 dolgot a stack,

100
00:06:16,000 --> 00:06:20,000
ebben az esetben is van egy felső korlát a mérete a verem.

101
00:06:20,000 --> 00:06:23,000
Vagy lehet, hogy a stack kell korlátos,

102
00:06:23,000 --> 00:06:27,000
de ha csinálsz egy tömböt, ami azt jelenti, hogy minden egyes alkalommal, amikor elérte a 10 elemet,

103
00:06:27,000 --> 00:06:29,000
akkor most kell majd növekedni és 20 elemeket, és ha bejön 20 elemet,

104
00:06:29,000 --> 00:06:33,000
fogsz, hogy növekszik a tömb 30-elemek vagy 40 elemeket.

105
00:06:33,000 --> 00:06:37,000
Fogsz hogy növelni kell a kapacitást, ami mit fogunk csinálni itt.

106
00:06:37,000 --> 00:06:40,000
Minden egyes alkalommal, amikor eléri a maximális méretét a verem,

107
00:06:40,000 --> 00:06:46,000
amikor nyomja valami mást, megyünk, hogy növelni kell a kapacitást.

108
00:06:46,000 --> 00:06:50,000
Itt már toló nyilvánított bool push (char * str).

109
00:06:50,000 --> 00:06:54,000
Char * str a húr, hogy mi nyomja a verembe,

110
00:06:54,000 --> 00:06:58,000
és bool csak azt mondja, hogy sikerült vagy nem sikerült.

111
00:06:58,000 --> 00:07:00,000
>> Hogyan sikerül?

112
00:07:00,000 --> 00:07:04,000
Mi az az egyetlen körülmény, hogy tudsz gondolni

113
00:07:04,000 --> 00:07:07,000
ahol kellene visszatérni hamis?

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

115
00:07:09,000 --> 00:07:12,000
[Student] Ha ez teljes mértékben és mi egy korlátos végrehajtását.

116
00:07:12,000 --> 00:07:17,000
Igen, hogyan határozza meg, azt válaszolta,

117
00:07:17,000 --> 00:07:23,000
ha ez a teljes és mi egy korlátos végrehajtását.

118
00:07:23,000 --> 00:07:26,000
Akkor biztosan visszatér hamis.

119
00:07:26,000 --> 00:07:31,000
Amint elérte a 10 dolog, a tömbben, akkor nem fér 11, úgyhogy vissza hamis.

120
00:07:31,000 --> 00:07:32,000
Mi van, ha ez korlátlan? Igen.

121
00:07:32,000 --> 00:07:38,000
Ha nem tudja bővíteni a tömböt valamilyen okból.

122
00:07:38,000 --> 00:07:43,000
Igen, a memória korlátozott erőforrás,

123
00:07:43,000 --> 00:07:51,000
és végül, ha folyamatosan nyomja a dolgokat a verembe újra és újra,

124
00:07:51,000 --> 00:07:54,000
fogunk próbálni, és lefoglalni egy nagyobb tömböt, hogy illeszkedjen

125
00:07:54,000 --> 00:07:59,000
A nagyobb kapacitású, és a malloc vagy bármilyen általunk használt megy vissza hamis.

126
00:07:59,000 --> 00:08:02,000
Nos, malloc visszatér null.

127
00:08:02,000 --> 00:08:05,000
>> Ne feledje, hogy minden egyes alkalommal, amikor valaha hívja malloc, akkor ellenőrzik, hogy ha ez

128
00:08:05,000 --> 00:08:12,000
visszatér null vagy mást, ami a korrektség levonás.

129
00:08:12,000 --> 00:08:17,000
Mivel azt szeretnénk, hogy egy kötetlen verem,

130
00:08:17,000 --> 00:08:21,000
az egyetlen eset fogunk visszatér hamis, ha megpróbáljuk

131
00:08:21,000 --> 00:08:26,000
kapacitásának növelése és a malloc vagy bármi visszatér hamis.

132
00:08:26,000 --> 00:08:30,000
Aztán pop nincsenek argumentumai,

133
00:08:30,000 --> 00:08:37,000
és visszaadja a karakterlánc van a tetején a verem.

134
00:08:37,000 --> 00:08:41,000
Bármi is volt, legutóbb tolta a veremben, ami pop visszatér,

135
00:08:41,000 --> 00:08:44,000
és ez is eltávolítja a veremből.

136
00:08:44,000 --> 00:08:50,000
És észre, hogy visszatér null, ha nincs a veremben.

137
00:08:50,000 --> 00:08:53,000
Ez mindig lehetséges, hogy a verem üres.

138
00:08:53,000 --> 00:08:55,000
A Java, ha használják, hogy vagy más nyelven,

139
00:08:55,000 --> 00:09:01,000
próbálja pop egy üres verem okozhat kivételt, vagy ilyesmi.

140
00:09:01,000 --> 00:09:09,000
>> De C, null egyfajta tétel az esetek hogyan kezeljük ezeket a problémákat.

141
00:09:09,000 --> 00:09:13,000
Visszatérő null, hogyan fogjuk jelzi, hogy a verem üres volt.

142
00:09:13,000 --> 00:09:16,000
Már feltéve kódot, amely próbára stack funkcionalitását,

143
00:09:16,000 --> 00:09:19,000
végre push és pop.

144
00:09:19,000 --> 00:09:23,000
Ez nem lesz egy csomó kódot.

145
00:09:23,000 --> 00:09:40,000
Úgy lesz, valójában, mielőtt csinálni, tipp, tipp-

146
00:09:40,000 --> 00:09:44,000
ha még nem látta, malloc nem ez az egyetlen funkciója

147
00:09:44,000 --> 00:09:47,000
hogy osztja memóriát a heap az Ön számára.

148
00:09:47,000 --> 00:09:51,000
Van egy család alloc funkciók.

149
00:09:51,000 --> 00:09:53,000
Az első a malloc, amelyen éppen használt.

150
00:09:53,000 --> 00:09:56,000
Aztán ott van calloc, amely nem ugyanaz, mint a malloc,

151
00:09:56,000 --> 00:09:59,000
de ez nullára mindent az Ön számára.

152
00:09:59,000 --> 00:10:04,000
Ha valaha is akartam állítani mindent null után mallocing valamit

153
00:10:04,000 --> 00:10:06,000
akkor éppen használt calloc az első helyen írása helyett

154
00:10:06,000 --> 00:10:09,000
a for ciklus nullára ki az egész blokk memória.

155
00:10:09,000 --> 00:10:15,000
>> Realloc olyan, mint a malloc, és van egy csomó különleges esetekben,

156
00:10:15,000 --> 00:10:19,000
de alapvetően mi realloc csinál,

157
00:10:19,000 --> 00:10:24,000
tart a mutató, már korábban is osztottak.

158
00:10:24,000 --> 00:10:27,000
Realloc a funkció azt szeretné, hogy figyel ide.

159
00:10:27,000 --> 00:10:31,000
Beletelik egy mutatót, amely már visszatért malloc.

160
00:10:31,000 --> 00:10:35,000
Tegyük fel, hogy kér malloc egy mutató a 10 bájt.

161
00:10:35,000 --> 00:10:38,000
Aztán később rájössz akart 20 bájt,

162
00:10:38,000 --> 00:10:42,000
így realloc e mutatót 20 bájt,

163
00:10:42,000 --> 00:10:47,000
és realloc automatikusan átmásolja mindent az Ön számára.

164
00:10:47,000 --> 00:10:51,000
Ha csak hívott malloc megint, mint van egy blokk 10 byte.

165
00:10:51,000 --> 00:10:53,000
Most kell egy blokk 20 byte,

166
00:10:53,000 --> 00:10:58,000
szóval ha malloc 20 bájt, akkor azt kell kézzel másolja át a 10 byte az első dolog, amit

167
00:10:58,000 --> 00:11:01,000
a második dolog, majd szabad az első dolog.

168
00:11:01,000 --> 00:11:04,000
Realloc fogja kezelni, hogy az Ön számára.

169
00:11:04,000 --> 00:11:11,000
>> Figyeljük meg az aláírás lesz void *

170
00:11:11,000 --> 00:11:15,000
ami csak visszatér a mutatót a blokk memória,

171
00:11:15,000 --> 00:11:17,000
akkor void * ptr.

172
00:11:17,000 --> 00:11:22,000
Azt hiszem void *, mint egy általános mutató.

173
00:11:22,000 --> 00:11:27,000
Általában soha nem foglalkozik void *

174
00:11:27,000 --> 00:11:30,000
de a malloc visszatér a void *, aztán ez csak használni, mint

175
00:11:30,000 --> 00:11:34,000
ez valóban lesz egy char *.

176
00:11:34,000 --> 00:11:37,000
Az előző void *, hogy már malloc által visszaadott

177
00:11:37,000 --> 00:11:41,000
most lesz átadni realloc, majd méret

178
00:11:41,000 --> 00:11:49,000
az új bájtok számát szeretnénk lefoglalni, így az új kapacitást.

179
00:11:49,000 --> 00:11:57,000
Adok egy pár percig, és tegye azt a helyet.

180
00:11:57,000 --> 00:12:02,000
Kezdje Felülvizsgálat 1.

181
00:12:16,000 --> 00:12:21,000
Abbahagyom, miután remélhetőleg arról elég időt végre push,

182
00:12:21,000 --> 00:12:24,000
majd adok egy kis szünetet tenni pop.

183
00:12:24,000 --> 00:12:27,000
De ez tényleg nem olyan sok kódot egyáltalán.

184
00:12:27,000 --> 00:12:35,000
A legtöbb kód talán a terjeszkedő cucc, bővül a kapacitás.

185
00:12:35,000 --> 00:12:39,000
Oké, nincs nyomás teljesen meg kell tenni,

186
00:12:39,000 --> 00:12:47,000
de amíg úgy érzed, te vagy a helyes út, ez jó.

187
00:12:47,000 --> 00:12:53,000
>> Van valakinek bármilyen kódot ők jól érzik magukat velem húzza fel?

188
00:12:53,000 --> 00:12:59,000
Igen, lesz, de nem akárki volna semmilyen kódot tudom felhúzni?

189
00:12:59,000 --> 00:13:05,000
Oké, akkor indul, mentse el, bármi legyen is az?

190
00:13:05,000 --> 00:13:09,000
Mindig elfelejtem, hogy a lépést.

191
00:13:09,000 --> 00:13:15,000
Oké, nézett push,

192
00:13:15,000 --> 00:13:18,000
szeretnéd magyarázni a kódot?

193
00:13:18,000 --> 00:13:24,000
[Tanuló] Először is, én emelkedett a méretet.

194
00:13:24,000 --> 00:13:28,000
Azt hiszem, talán kellett volna, hogy az-amúgy, én nagyobb a méret,

195
00:13:28,000 --> 00:13:31,000
és látom, ha ez kevesebb, mint a kapacitás.

196
00:13:31,000 --> 00:13:36,000
És ha ez kevesebb, mint a kapacitás, hozzáteszem, hogy a tömb, hogy már van.

197
00:13:36,000 --> 00:13:42,000
És ha ez nem, szorozza meg a kapacitás 2,

198
00:13:42,000 --> 00:13:50,000
és én átcsoportosítja a húrok tömb valami egy nagyobb kapacitású mérete most.

199
00:13:50,000 --> 00:13:55,000
És ha ez nem sikerül, elmondom a felhasználó és a return false,

200
00:13:55,000 --> 00:14:04,000
és ha ez rendben van, akkor tettem a húr az új helyszínen.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] is észre, hogy használt egy szép bitenkénti operátor itt

202
00:14:07,000 --> 00:14:09,000
sokszorozza 2-vel.

203
00:14:09,000 --> 00:14:11,000
Ne feledje, a bal Shift mindig lesz szorozva 2.

204
00:14:11,000 --> 00:14:15,000
Jobb váltás osztva 2, amíg eszébe jut, hogy ez azt jelenti,

205
00:14:15,000 --> 00:14:18,000
osszuk el 2 mint egy egész osztva 2.

206
00:14:18,000 --> 00:14:20,000
Lehet, hogy csonkolni a 1 itt vagy ott.

207
00:14:20,000 --> 00:14:26,000
De a műszakváltás által hagyott 1 mindig lesz szorozva 2,

208
00:14:26,000 --> 00:14:32,000
ha túlcsordulás határait az egész, és akkor nem lesz.

209
00:14:32,000 --> 00:14:34,000
Mellékes megjegyzés.

210
00:14:34,000 --> 00:14:39,000
Szeretem csinálni, ez nem fogja megváltoztatni a kódolás semmilyen módon,

211
00:14:39,000 --> 00:14:48,000
de én szeretnék csinálni valami ilyesmi.

212
00:14:48,000 --> 00:14:51,000
Valójában megy, hogy egy kicsit hosszabb.

213
00:15:04,000 --> 00:15:08,000
Lehet, hogy nem ez a tökéletes eset mutatja ezt,

214
00:15:08,000 --> 00:15:14,000
de szeretem részes be ezeket a blokkokat of-

215
00:15:14,000 --> 00:15:17,000
oké, ha ez ha bekövetkezik, akkor fogok csinálni valamit,

216
00:15:17,000 --> 00:15:19,000
és akkor a függvény történik.

217
00:15:19,000 --> 00:15:22,000
Azt nem kell majd görgessen a szemem egészen a funkció

218
00:15:22,000 --> 00:15:25,000
hogy mi történik a mást.

219
00:15:25,000 --> 00:15:27,000
Ez, ha ez, ha bekövetkezik, akkor csak vissza.

220
00:15:27,000 --> 00:15:30,000
Azt is a szép előnye mindent ezen túl

221
00:15:30,000 --> 00:15:33,000
most tolódott marad egyszer.

222
00:15:33,000 --> 00:15:40,000
Azt már nem kell, ha valaha is közel nevetségesen hosszú sorokat,

223
00:15:40,000 --> 00:15:45,000
akkor ezek a 4 byte segítségével, valamint a még hátra valami,

224
00:15:45,000 --> 00:15:48,000
A kevésbé túlterheltek magad, ha tetszik, oké, meg kell emlékezni

225
00:15:48,000 --> 00:15:53,000
Én jelenleg egy while ciklus belsejében egy más belsejében egy for ciklus.

226
00:15:53,000 --> 00:15:58,000
Bárhol meg tudod csinálni ezt vissza azonnal, valahogy, mint a.

227
00:15:58,000 --> 00:16:05,000
Ez teljesen opcionális, és nem várható semmilyen módon.

228
00:16:05,000 --> 00:16:12,000
>> [Student] Szükség van a méret - a hibamentes állapotban van?

229
00:16:12,000 --> 00:16:19,000
Az elutasítási feltétel itt nem sikerült realloc, szóval igen.

230
00:16:19,000 --> 00:16:22,000
Figyeljük meg, hogy a fail állapotban, feltehetően

231
00:16:22,000 --> 00:16:26,000
hacsak nem ingyen cucc később, mi mindig lesz sikertelen

232
00:16:26,000 --> 00:16:29,000
nem számít, hányszor próbáljuk nyomni valamit.

233
00:16:29,000 --> 00:16:32,000
Ha folyamatosan nyomva, tartjuk növelésének méret,

234
00:16:32,000 --> 00:16:36,000
bár nem vagyunk helyezzen semmit a verembe.

235
00:16:36,000 --> 00:16:39,000
Általában nem növeljük a méret-ig

236
00:16:39,000 --> 00:16:43,000
miután sikeresen helyezze a köteget.

237
00:16:43,000 --> 00:16:50,000
Szeretnénk csinálni, mondjuk, akár itt és itt.

238
00:16:50,000 --> 00:16:56,000
Aztán ahelyett, hogy s.size ≤ kapacitást, ez kevesebb, mint kapacitás,

239
00:16:56,000 --> 00:17:01,000
Csak azért, mert költözött, ahol minden volt.

240
00:17:01,000 --> 00:17:07,000
>> És ne feledd, az egyetlen hely, hogy esetleg vissza false

241
00:17:07,000 --> 00:17:14,000
van, ahol a realloc vissza null,

242
00:17:14,000 --> 00:17:19,000
és ha történetesen emlékezni standard hiba,

243
00:17:19,000 --> 00:17:22,000
talán érdemes megfontolni ezt az esetet, ha a nyomtatni kívánt standard hiba,

244
00:17:22,000 --> 00:17:26,000
így fprintf stderr helyett csak közvetlen nyomtatás a szabványos ki.

245
00:17:26,000 --> 00:17:31,000
Ismét, ez nem az az elvárás, de ha ez egy hiba,

246
00:17:31,000 --> 00:17:41,000
írja printf, akkor érdemes tenni nyomtatni standard hiba helyett a szabványos ki.

247
00:17:41,000 --> 00:17:44,000
>> Bárki, aki mást megjegyezni? Igen.

248
00:17:44,000 --> 00:17:47,000
[Student] Tud megy át a [hallható]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Igen, a tényleges binariness belőle, vagy csak, mi ez?

250
00:17:55,000 --> 00:17:57,000
[Student] Szóval szorozza meg 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Igen, alapvetően.

252
00:17:59,000 --> 00:18:11,000
A bináris föld, mi mindig a sor számjegy.

253
00:18:11,000 --> 00:18:22,000
Shifting ezt a bal 1-alapvetően betétekkel itt a jobb oldalon.

254
00:18:22,000 --> 00:18:25,000
Vissza az ezt, csak emlékezve arra, hogy mindent, ami bináris

255
00:18:25,000 --> 00:18:28,000
egy 2 hatványa, így ez képezi a 2 a 0,

256
00:18:28,000 --> 00:18:30,000
ez a 2 a 1, ez a 2 a 2.

257
00:18:30,000 --> 00:18:33,000
Helyez a 0 a jobb oldalon most már csak műszak mindent át.

258
00:18:33,000 --> 00:18:38,000
Mi használt mennyiség: 2 a 0 jelentése most 2 a 1, értéke 2, a 2.

259
00:18:38,000 --> 00:18:41,000
A jobb oldalon, hogy ki

260
00:18:41,000 --> 00:18:44,000
szükségszerűen lesz 0,

261
00:18:44,000 --> 00:18:46,000
ami teljesen érthető.

262
00:18:46,000 --> 00:18:49,000
Ha valaha megszorozzuk a szám 2, akkor nem fog a végén furcsa,

263
00:18:49,000 --> 00:18:54,000
így a 2-a 0 helyre legyen 0,

264
00:18:54,000 --> 00:18:59,000
és ez az, amit én 1/2 figyelmeztetett, mielőtt az, ha nem történik váltani

265
00:18:59,000 --> 00:19:01,000
túl a bitek száma egy egész szám,

266
00:19:01,000 --> 00:19:04,000
akkor ez 1 lesz a végén megy ki.

267
00:19:04,000 --> 00:19:10,000
Ez az egyetlen gond, ha történetesen foglalkozik igazán nagy kapacitással.

268
00:19:10,000 --> 00:19:15,000
De ezen a ponton, akkor dolgunk egy sor milliárd dolgok

269
00:19:15,000 --> 00:19:25,000
ami nem fér a memóriába egyébként.

270
00:19:25,000 --> 00:19:31,000
>> Most már lehet kapni a pop, ami még egyszerűbb.

271
00:19:31,000 --> 00:19:36,000
Lehet csinálni, mint ha történetesen, hogy a pop egy csomó,

272
00:19:36,000 --> 00:19:38,000
és most fél kapacitással újra.

273
00:19:38,000 --> 00:19:42,000
Lehet realloc csökken a memória van,

274
00:19:42,000 --> 00:19:47,000
de nem kell aggódni, hogy így csak a realloc ügy lesz

275
00:19:47,000 --> 00:19:50,000
növekvő memória, nem zsugorodó memória,

276
00:19:50,000 --> 00:19:59,000
ami megy, hogy pop szuper könnyű.

277
00:19:59,000 --> 00:20:02,000
Most sorokat, melyek lesznek, mint a halom,

278
00:20:02,000 --> 00:20:06,000
de a sorrend, hogy vegye a dolgokat megfordul.

279
00:20:06,000 --> 00:20:10,000
A prototipikus példa a sorban egy vonal,

280
00:20:10,000 --> 00:20:12,000
így azt hiszem, ha volt angolul, azt mondtam volna

281
00:20:12,000 --> 00:20:17,000
a prototipikus példája a sorban van egy sorban.

282
00:20:17,000 --> 00:20:22,000
Tehát, mint egy vonal, ha te vagy az első ember a sorban,

283
00:20:22,000 --> 00:20:24,000
azt várod, hogy legyen az első, aki kilóg a sorból.

284
00:20:24,000 --> 00:20:31,000
Ha te vagy az utolsó ember a sorban, akkor lesz az utolsó, aki szervizbe.

285
00:20:31,000 --> 00:20:35,000
Úgy hívják, hogy a FIFO motívum, míg a verem LIFO volt a minta.

286
00:20:35,000 --> 00:20:40,000
Ezek a szavak nagyon univerzális.

287
00:20:40,000 --> 00:20:46,000
>> Mint stack és ellentétben tömbök, sorok általában nem engednek hozzáférést elemeket a közepén.

288
00:20:46,000 --> 00:20:50,000
Itt egy halom, már push és pop.

289
00:20:50,000 --> 00:20:54,000
Itt történik, hogy felhívtam őket sorba állítása és dequeue.

290
00:20:54,000 --> 00:20:58,000
Én is hallottam őket nevezik shift és unshift.

291
00:20:58,000 --> 00:21:02,000
Hallottam, azt mondják, push és pop is vonatkoznak sorok.

292
00:21:02,000 --> 00:21:05,000
Hallottam be, távolítsa el,

293
00:21:05,000 --> 00:21:11,000
így push és pop, ha beszélsz stack, akkor nyomja és popping.

294
00:21:11,000 --> 00:21:16,000
Ha beszélsz sorokat, akkor vedd a szavakat használni kívánt

295
00:21:16,000 --> 00:21:23,000
behelyezhető és eltávolítása, és nincs egyetértés, hogy mit kell hívni.

296
00:21:23,000 --> 00:21:27,000
De itt, van sorba állítása és dequeue.

297
00:21:27,000 --> 00:21:37,000
Most, a struct néz ki majdnem teljesen azonos a verem struct.

298
00:21:37,000 --> 00:21:40,000
De meg kell nyomon követni a fejét.

299
00:21:40,000 --> 00:21:44,000
Azt hiszem, azt mondja itt, de miért van szükségünk a feje?

300
00:21:53,000 --> 00:21:57,000
A prototípusok alapvetően megegyezik a push és pop.

301
00:21:57,000 --> 00:21:59,000
Azt hiszem, hogy ez egy push és pop.

302
00:21:59,000 --> 00:22:08,000
Az egyetlen különbség, pop visszatér-helyett az utolsó, ez vissza az első.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, vagy valami.

304
00:22:12,000 --> 00:22:14,000
És itt van a kezdet.

305
00:22:14,000 --> 00:22:17,000
A várólista teljesen tele van, ezért van négy elem benne.

306
00:22:17,000 --> 00:22:21,000
A végén a várólista jelenleg 2,

307
00:22:21,000 --> 00:22:24,000
és most megy be valami mást.

308
00:22:24,000 --> 00:22:29,000
>> Ha szeretnénk beszúrni, hogy valami mást, amit tettünk a verem változat

309
00:22:29,000 --> 00:22:36,000
A kiterjesztettük blokk memória.

310
00:22:36,000 --> 00:22:40,000
Mi a baj ezzel?

311
00:22:40,000 --> 00:22:45,000
[Student] Ön mozgatni a 2.

312
00:22:45,000 --> 00:22:51,000
Azt mondta, mielőtt a vége a sorba,

313
00:22:51,000 --> 00:22:57,000
ennek nincs értelme, hogy kezdjük 1,

314
00:22:57,000 --> 00:23:01,000
akkor szeretnénk dequeue 1, akkor dequeue 3, majd dequeue 4,

315
00:23:01,000 --> 00:23:05,000
akkor dequeue 2, akkor dequeue ezt.

316
00:23:05,000 --> 00:23:08,000
Mi ezért nem használhatja realloc most,

317
00:23:08,000 --> 00:23:11,000
vagy legalábbis, akkor kell használni realloc más módon.

318
00:23:11,000 --> 00:23:15,000
De valószínűleg nem csak használja realloc.

319
00:23:15,000 --> 00:23:18,000
Meg kell majd manuálisan másolja át a memória.

320
00:23:18,000 --> 00:23:21,000
>> Két funkció másolni memória.

321
00:23:21,000 --> 00:23:25,000
Van memcopy és memmove.

322
00:23:25,000 --> 00:23:29,000
Én jelenleg olvasni a man oldalakat, hogy melyiket fogjuk használni kíván.

323
00:23:29,000 --> 00:23:35,000
Oké, memcopy, a különbség

324
00:23:35,000 --> 00:23:38,000
hogy memcopy és memmove egyik kezeli az ügyet helyesen

325
00:23:38,000 --> 00:23:41,000
hová másolni egy régió történik átfedés a régió

326
00:23:41,000 --> 00:23:46,000
te másolást.

327
00:23:46,000 --> 00:23:50,000
Memcopy nem kezelni. Memmove teszi.

328
00:23:50,000 --> 00:23:59,000
Azt hiszem a probléma-

329
00:23:59,000 --> 00:24:09,000
mondjuk akarok másolni ezt a fickót,

330
00:24:09,000 --> 00:24:13,000
E négy ezzel a fickóval vége.

331
00:24:13,000 --> 00:24:16,000
A végén, amit a tömb kell kinéznie

332
00:24:16,000 --> 00:24:26,000
után a másolat 2, 1, 2, 1, 3, 4, és majd pár dolgot a végén.

333
00:24:26,000 --> 00:24:29,000
De ez függ a sorrend, amelyben ténylegesen másolni,

334
00:24:29,000 --> 00:24:32,000
hiszen ha nem veszik figyelembe azt a tényt, hogy a régió vagyunk másolás figyelembe

335
00:24:32,000 --> 00:24:35,000
átfedések az egyik vagyunk másoláshoz,

336
00:24:35,000 --> 00:24:46,000
akkor lehet csinálni, mint a kezdetén van, másolja a 2 arra a helyre akarunk menni,

337
00:24:46,000 --> 00:24:52,000
majd mozgassa a mutatót előre.

338
00:24:52,000 --> 00:24:56,000
>> Most mi lesz itt és itt, és most szeretnénk másolni

339
00:24:56,000 --> 00:25:04,000
ez a srác felett ez a fickó, és mozgassa a mutatót előre.

340
00:25:04,000 --> 00:25:07,000
Mit fogunk a végén kapok 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
helyett a megfelelő 2, 1, 2, 1, 3, 4 mivel

342
00:25:10,000 --> 00:25:15,000
2, 1 nyíltságot felülírhatják az eredeti 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove kezeli, hogy helyesen.

344
00:25:19,000 --> 00:25:23,000
Ebben az esetben, alapvetően csak mindig memmove

345
00:25:23,000 --> 00:25:26,000
mert kezeli megfelelően.

346
00:25:26,000 --> 00:25:29,000
Ez általában nem végez rosszabb.

347
00:25:29,000 --> 00:25:32,000
Az alapötlet az, helyett kezdetétől és másolás így

348
00:25:32,000 --> 00:25:35,000
mint mi most itt volt, akkor indul a végéig, és másolja be,

349
00:25:35,000 --> 00:25:38,000
és ebben az esetben, akkor soha nem jelentett gondot.

350
00:25:38,000 --> 00:25:40,000
Ehhez nincs teljesítmény elveszett.

351
00:25:40,000 --> 00:25:47,000
Mindig memmove. Soha ne aggódj memcopy.

352
00:25:47,000 --> 00:25:51,000
És ez az, ahol fogsz kell külön memmove

353
00:25:51,000 --> 00:26:01,000
a becsomagolt-around részét a sorban.

354
00:26:01,000 --> 00:26:04,000
Ne aggódj, ha nem teljesen kész.

355
00:26:04,000 --> 00:26:10,000
Ez sokkal nehezebb, mint a verem, push és pop.

356
00:26:10,000 --> 00:26:15,000
>> Bárki bármilyen kódot, tudna dolgozni?

357
00:26:15,000 --> 00:26:21,000
Még ha teljesen hiányos?

358
00:26:21,000 --> 00:26:23,000
[Student] Igen, ez teljesen hiányos, mégis.

359
00:26:23,000 --> 00:26:27,000
Teljesen hiányos rendben van, amíg mi, tudod menteni a felülvizsgálat?

360
00:26:27,000 --> 00:26:32,000
Azt felejtsük el, hogy minden egyes alkalommal.

361
00:26:32,000 --> 00:26:39,000
Oké, figyelmen kívül hagyva, hogy mi történik, amikor meg kell átméretezni a dolgokat.

362
00:26:39,000 --> 00:26:42,000
Teljesen figyelmen kívül átméretezés.

363
00:26:42,000 --> 00:26:49,000
Magyarázd ezt a kódot.

364
00:26:49,000 --> 00:26:54,000
Én ellenőrzése először is, ha a mérete kisebb, mint a másolat először is

365
00:26:54,000 --> 00:27:01,000
majd azt követően, hogy én be-veszek head + méret,

366
00:27:01,000 --> 00:27:05,000
és én meg arról, hogy körbe a kapacitás a tömb,

367
00:27:05,000 --> 00:27:08,000
és úgy helyezze be az új húr az adott helyzetben.

368
00:27:08,000 --> 00:27:12,000
Aztán méretének növelése és vissza igaz.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Ez minden bizonnyal az egyik az esetben, ha fogsz szeretné, hogy a mod.

370
00:27:22,000 --> 00:27:25,000
Bármilyen esetben, ha Ön védőcsomagolás körül, ha úgy gondolja, védőcsomagolás körül,

371
00:27:25,000 --> 00:27:29,000
A közvetlen gondolat legyen mod.

372
00:27:29,000 --> 00:27:36,000
Egy gyors optimalizálás / teheti kódját egy sor rövidebb,

373
00:27:36,000 --> 00:27:42,000
azt észleli, hogy a vonal után azonnal ezt

374
00:27:42,000 --> 00:27:53,000
mindössze méret + +, így egyesíteni, hogy bele ezt a sort, méret + +.

375
00:27:53,000 --> 00:27:58,000
Most itt, mi a helyzet

376
00:27:58,000 --> 00:28:01,000
ahol nincs elég memória,

377
00:28:01,000 --> 00:28:05,000
így növekszik a kapacitás 2-vel.

378
00:28:05,000 --> 00:28:09,000
Azt hiszem, akkor is ugyanaz a probléma itt, de tudjuk figyelmen kívül hagyni, hogy most,

379
00:28:09,000 --> 00:28:13,000
ahol, ha nem sikerült növelni a kapacitást,

380
00:28:13,000 --> 00:28:18,000
akkor fogsz szeretné csökkenteni a kapacitást a 2 újra.

381
00:28:18,000 --> 00:28:24,000
További rövid megjegyzés, mint amit tehetünk, + =,

382
00:28:24,000 --> 00:28:30,000
akkor is csinálni << =.

383
00:28:30,000 --> 00:28:43,000
Szinte bármit lehet menni előtt egyenlő, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * új, az új blokk memória.

385
00:28:52,000 --> 00:28:55,000
Oh, itt vagyok.

386
00:28:55,000 --> 00:29:02,000
>> Mit gondolnak az emberek arról, hogy milyen új blokk memória?

387
00:29:02,000 --> 00:29:06,000
[Student] Meg kell char **.

388
00:29:06,000 --> 00:29:12,000
Gondolkodás vissza a struct itt,

389
00:29:12,000 --> 00:29:14,000
húrok, amit mi újraelosztása.

390
00:29:14,000 --> 00:29:21,000
Teszünk egy teljesen új dinamikus tárolás elemek a sorban.

391
00:29:21,000 --> 00:29:25,000
Amit mi leszel hozzárendelése a húrok, amit mi mallocing most,

392
00:29:25,000 --> 00:29:30,000
és így az új lesz a char **.

393
00:29:30,000 --> 00:29:34,000
Ez lesz egy sor húrok.

394
00:29:34,000 --> 00:29:38,000
Akkor mi a helyzet áll fenn, amelyek alapján fogunk visszatérni hamis?

395
00:29:38,000 --> 00:29:41,000
[Student] kéne csinál a char *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Igen, jó hívást.

397
00:29:44,000 --> 00:29:46,000
[Student] Mi volt ez?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] akartunk csinálni mérete char *, mert mi már nem-

399
00:29:49,000 --> 00:29:53,000
ez valóban egy nagyon nagy probléma, mert sizeof (char) lenne 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof char * lesz 4,

401
00:29:55,000 --> 00:29:58,000
így sok idő, amikor dolgunk ints,

402
00:29:58,000 --> 00:30:01,000
Hajlamos megússza, mert mérete int és mérete int *

403
00:30:01,000 --> 00:30:04,000
egy 32-bites rendszer lesz ugyanaz a dolog.

404
00:30:04,000 --> 00:30:09,000
De itt, sizeof (char) és a sizeof (char *) most lesz ugyanaz a dolog.

405
00:30:09,000 --> 00:30:15,000
>> Mi az a körülmény, ha visszatérünk hamis?

406
00:30:15,000 --> 00:30:17,000
[Student] Új null.

407
00:30:17,000 --> 00:30:23,000
Igen, ha az új null, visszatérünk hamis,

408
00:30:23,000 --> 00:30:34,000
és megyek, hogy dobja le a továb-

409
00:30:34,000 --> 00:30:37,000
[Student] [hallható]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Igen, ez rendben van.

411
00:30:39,000 --> 00:30:46,000
Lehet akár 2-szer csinálni befogadóképessége, illetve váltás 1 és akkor is csak állítsa le itt, vagy bármi.

412
00:30:46,000 --> 00:30:52,000
Fogjuk csinálni, mint mi volt ez.

413
00:30:52,000 --> 00:30:56,000
Kapacitás >> = 1.

414
00:30:56,000 --> 00:31:08,000
És te soha nem kell majd aggódnia, hogy elvesznek az 1 helye

415
00:31:08,000 --> 00:31:12,000
mert elmentél tolódott 1, így a 1-es hely szükségképpen 0,

416
00:31:12,000 --> 00:31:16,000
így jobb változó 1, te még mindig rendben lesz.

417
00:31:16,000 --> 00:31:19,000
[Student] Van, amit tennie kell, hogy mielőtt a visszatérés?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Igen, ez teszi semmi értelme.

419
00:31:29,000 --> 00:31:36,000
>> Most tegyük fogunk a végén visszatér igaz a végére.

420
00:31:36,000 --> 00:31:39,000
Ahogy megyünk ezek memmoves,

421
00:31:39,000 --> 00:31:45,000
kell, hogy legyen óvatos, hogy hogyan tesszük őket.

422
00:31:45,000 --> 00:31:50,000
Van valakinek bármilyen javaslata, hogyan csináljunk velük?

423
00:32:17,000 --> 00:32:21,000
Itt a start.

424
00:32:21,000 --> 00:32:28,000
Elkerülhetetlen, szeretnénk kezdeni az elején újra

425
00:32:28,000 --> 00:32:35,000
és másolat dolgokat onnan, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Hogy csinálod ezt?

427
00:32:41,000 --> 00:32:52,000
Először is, meg kell nézni a man oldalt memmove újra.

428
00:32:52,000 --> 00:32:57,000
Memmove, hogy az érvek mindig fontos.

429
00:32:57,000 --> 00:33:01,000
Azt szeretnénk, hogy cél az első, forrás második, méret harmadik.

430
00:33:01,000 --> 00:33:06,000
Van egy csomó funkciók fordított forrás és a cél.

431
00:33:06,000 --> 00:33:11,000
Cél, forrás általában lenniük valamelyest.

432
00:33:17,000 --> 00:33:21,000
Mozgás, mi ez vissza?

433
00:33:21,000 --> 00:33:27,000
Ez visszaad egy pointert a hely, bármilyen okból érdemes ezt.

434
00:33:27,000 --> 00:33:32,000
Tudok képet olvasni, de azt szeretnénk, hogy beköltözik a célpontja.

435
00:33:32,000 --> 00:33:35,000
>> Mi a cél lesz?

436
00:33:35,000 --> 00:33:37,000
[Student] Új.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Igen, és hol vagyunk másol?

438
00:33:39,000 --> 00:33:43,000
Az első dolog, amit másol ez az 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Mi az e-1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Mi a címe ennek a 1?

441
00:33:55,000 --> 00:33:58,000
Mi a címe az 1?

442
00:33:58,000 --> 00:34:01,000
[Student] [hallható]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Fej + a címe az első elemet.

444
00:34:03,000 --> 00:34:05,000
Hogyan jutunk az első elem a tömbben?

445
00:34:05,000 --> 00:34:10,000
[Student] Sor.

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

447
00:34:15,000 --> 00:34:20,000
Ne feledje, hogy itt, a mi fej 1 lehet.

448
00:34:20,000 --> 00:34:24,000
Darn meg. Azt hiszem, hogy ez varázslatos-

449
00:34:24,000 --> 00:34:29,000
Itt a fejünket 1 lehet. Fogom megváltoztatni a színét is.

450
00:34:29,000 --> 00:34:36,000
És itt a szálakat.

451
00:34:36,000 --> 00:34:41,000
Ez akkor sem írni, mint mi ide

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

453
00:34:43,000 --> 00:34:51,000
Egy csomó ember is írni és q.strings [head].

454
00:34:51,000 --> 00:34:55,000
Ez nem igazán kevésbé hatékony.

455
00:34:55,000 --> 00:34:58,000
Azt hihetnénk, hogy rá, mint te dereferencing azt, majd egyre címét,

456
00:34:58,000 --> 00:35:04,000
de a fordító fog lefordítani a mi azelőtt amúgy q.strings + fej.

457
00:35:04,000 --> 00:35:06,000
Akárhogy is szeretnénk gondolni rá.

458
00:35:06,000 --> 00:35:11,000
>> És hány bájtot akarunk másolni?

459
00:35:11,000 --> 00:35:15,000
[Student] Kapacitás - fejét.

460
00:35:15,000 --> 00:35:18,000
Kapacitás - fej.

461
00:35:18,000 --> 00:35:21,000
És akkor is mindig írja ki egy példát

462
00:35:21,000 --> 00:35:23,000
hogy kitaláljuk, ha ez igaz.

463
00:35:23,000 --> 00:35:26,000
[Student] Meg kell osztani 2, akkor.

464
00:35:26,000 --> 00:35:30,000
Igen, azt hiszem, jól jönne méretét.

465
00:35:30,000 --> 00:35:35,000
Még mindig van, hogy méret-

466
00:35:35,000 --> 00:35:39,000
az SW, van méret szerint: 4.

467
00:35:39,000 --> 00:35:42,000
A mérete 4. Fejünk 1 lehet.

468
00:35:42,000 --> 00:35:46,000
Szeretnénk másolni a 3 elem.

469
00:35:46,000 --> 00:35:54,000
Ez a józanság ellenőrizze, hogy a méret - Egymás helyesen 3.

470
00:35:54,000 --> 00:35:58,000
És jön ide vissza, mint azt korábban említettük,

471
00:35:58,000 --> 00:36:00,000
ha használt kapacitás, akkor volna, hogy osszuk el 2

472
00:36:00,000 --> 00:36:04,000
mert mi már nőtt a kapacitás, így ahelyett, fogunk használni méretét.

473
00:36:11,000 --> 00:36:13,000
Ez a másolatok részét.

474
00:36:13,000 --> 00:36:18,000
Most kell másolni a többi része, a része maradt a kezdet.

475
00:36:18,000 --> 00:36:28,000
>> Ez lesz memmove bele milyen pozícióban?

476
00:36:28,000 --> 00:36:32,000
[Student] molett - fejét.

477
00:36:32,000 --> 00:36:38,000
Igen, így már másolható méret - head bájt,

478
00:36:38,000 --> 00:36:43,000
és így, ahol szeretnénk másolni a fennmaradó byte az új

479
00:36:43,000 --> 00:36:48,000
majd mérete mínusz-nos, a byte-ok száma, amit már másolt be

480
00:36:48,000 --> 00:36:52,000
És akkor hol vagyunk másol?

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

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

483
00:36:56,000 --> 00:37:02,000
Tudtuk Vagy csináld & q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Ez lényegesen kevésbé gyakori, mint ezt.

485
00:37:05,000 --> 00:37:14,000
Ha ez csak lesz 0, akkor majd inkább látni q.strings.

486
00:37:14,000 --> 00:37:16,000
Ez az, ahol vagyunk másol.

487
00:37:16,000 --> 00:37:18,000
Hány bytes tudjuk maradt másolni? >> [Student] 10.

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

489
00:37:20,000 --> 00:37:25,000
[Student] Muszáj szorozni 5-10-szer a méret a byte, vagy valami?

490
00:37:25,000 --> 00:37:30,000
Igen, ez az, ahol, mit fogunk másolást?

491
00:37:30,000 --> 00:37:32,000
[Student] [hallható]

492
00:37:32,000 --> 00:37:34,000
Milyen típusú a dolog, mi a másolást?

493
00:37:34,000 --> 00:37:36,000
[Student] [hallható]

494
00:37:36,000 --> 00:37:41,000
Ja, így a char * s, hogy mi másolás, nem tudjuk, ha e érkezik.

495
00:37:41,000 --> 00:37:47,000
Hát, ha ők mutat, mint a húrok, a végén nyomja rá a sor

496
00:37:47,000 --> 00:37:49,000
vagy enqueuing rá a sor.

497
00:37:49,000 --> 00:37:51,000
Amennyiben ezek jönnek, akkor fogalmam sincs.

498
00:37:51,000 --> 00:37:56,000
Csak meg kell nyomon követni a char * s magukat.

499
00:37:56,000 --> 00:38:00,000
Nem akarunk másolni Méret - fej bájt.

500
00:38:00,000 --> 00:38:03,000
Azt akarjuk, hogy másolni méret - Egymás char * s,

501
00:38:03,000 --> 00:38:11,000
így fogunk szorozni ezt sizeof (char *).

502
00:38:11,000 --> 00:38:17,000
Ugyanaz itt lent, egymás * sizeof (char *).

503
00:38:17,000 --> 00:38:24,000
>> [Student] Mi [hallható]?

504
00:38:24,000 --> 00:38:26,000
Ez a jog itt?

505
00:38:26,000 --> 00:38:28,000
[Student] Nem, alatt, hogy a méret - fejét.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Ez itt?

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

508
00:38:32,000 --> 00:38:35,000
Hogyan mutató számtani fog dolgozni az

509
00:38:35,000 --> 00:38:40,000
automatikusan megszorozza a méret a típus, hogy mi dolgunk.

510
00:38:40,000 --> 00:38:46,000
Csakúgy, mint ide, új + (méret - fej)

511
00:38:46,000 --> 00:38:56,000
pontosan egyenértékű és új [size - fej]

512
00:38:56,000 --> 00:39:00,000
amíg azt várjuk, hogy megfelelően működjön,

513
00:39:00,000 --> 00:39:04,000
hiszen ha dolgunk egy int tömböt, akkor mi nem index int-

514
00:39:04,000 --> 00:39:07,000
vagy ha ez a méret az 5 és szeretné, hogy a 4. elemet, majd index a

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

516
00:39:10,000 --> 00:39:14,000
Te ne-[4] * mérete int.

517
00:39:14,000 --> 00:39:21,000
Hogy kezeli automatikusan, és ebben az esetben

518
00:39:21,000 --> 00:39:29,000
szó szerint azonos, így a konzol szintaxis

519
00:39:29,000 --> 00:39:34,000
csak megy át kell alakítani az e amint összeállításához.

520
00:39:34,000 --> 00:39:38,000
Ez valami, amit kell, hogy legyen óvatos, hogy a

521
00:39:38,000 --> 00:39:42,000
ha hozzá méret - head

522
00:39:42,000 --> 00:39:45,000
felveszi, nem egy bájt.

523
00:39:45,000 --> 00:39:53,000
Te hozzáadását char *, mely lehet egy bájt vagy bármi.

524
00:39:53,000 --> 00:39:56,000
>> Egyéb kérdés?

525
00:39:56,000 --> 00:40:04,000
Oké, dequeue lesz könnyebb.

526
00:40:04,000 --> 00:40:11,000
Adok egy percet végrehajtani.

527
00:40:11,000 --> 00:40:18,000
Ja, és azt hiszem, ez ugyanaz a helyzet, amikor

528
00:40:18,000 --> 00:40:21,000
amit a sorba állítása esetben, ha mi enqueuing null,

529
00:40:21,000 --> 00:40:24,000
talán akarjuk kezelni, talán nem.

530
00:40:24,000 --> 00:40:27,000
Mi nem fog még egyszer itt, hanem ugyanaz, mint a stack ügyben.

531
00:40:27,000 --> 00:40:34,000
Ha sorba állításához null, akkor lehet, hogy figyelmen kívül hagyja azt.

532
00:40:34,000 --> 00:40:40,000
Bárki, aki egy kódot tudok felhúzni?

533
00:40:40,000 --> 00:40:45,000
[Student] Én csak azt dequeue.

534
00:40:45,000 --> 00:40:56,000
Version 2, hogy a-rendben.

535
00:40:56,000 --> 00:40:59,000
Akarsz megmagyarázni?

536
00:40:59,000 --> 00:41:01,000
[Student] Először is, győződjön meg arról, hogy van valami a sorban

537
00:41:01,000 --> 00:41:07,000
és hogy a méret lement 1-gyel.

538
00:41:07,000 --> 00:41:11,000
Meg kell csinálni, és akkor vissza a fejét

539
00:41:11,000 --> 00:41:13,000
majd mozgassa a fejét 1.

540
00:41:13,000 --> 00:41:19,000
Oké, szóval van egy sarok esetben figyelembe kell vennünk. Igen.

541
00:41:19,000 --> 00:41:24,000
[Student] Ha a fej az utolsó elem,

542
00:41:24,000 --> 00:41:26,000
akkor nem akar fejet mutatni kívül a tömbben.

543
00:41:26,000 --> 00:41:29,000
>> Igen, amint feje eléri a végén a tömb,

544
00:41:29,000 --> 00:41:35,000
amikor dequeue, fejünk kell modded vissza 0-ra.

545
00:41:35,000 --> 00:41:40,000
Sajnos, nem tudjuk, hogy az egy lépésben.

546
00:41:40,000 --> 00:41:44,000
Azt hiszem, ahogy én valószínűleg erősít meg

547
00:41:44,000 --> 00:41:52,000
ez lesz a char *, amit mi vissza,

548
00:41:52,000 --> 00:41:55,000
amit a változó neve akar lenni.

549
00:41:55,000 --> 00:42:02,000
Aztán szeretnénk mod head által kapacitás

550
00:42:02,000 --> 00:42:10,000
majd vissza ret.

551
00:42:10,000 --> 00:42:14,000
Egy csomó ember van itt tehetnének-

552
00:42:14,000 --> 00:42:19,000
Ebben az esetben a-you'll látni az emberek csinálni, ha fej

553
00:42:19,000 --> 00:42:29,000
nagyobb kapacitás, do fej - kapacitás.

554
00:42:29,000 --> 00:42:36,000
És ez csak a munka körül mi mod.

555
00:42:36,000 --> 00:42:41,000
Fej-mod = kapacitás sokkal tisztább

556
00:42:41,000 --> 00:42:51,000
A csomagolás körül, mint ha a feje nagyobb kapacitás fej - kapacitás.

557
00:42:51,000 --> 00:42:56,000
>> Kérdései vannak?

558
00:42:56,000 --> 00:43:02,000
Oké, az utolsó dolog, mi maradt a mi linkelt lista.

559
00:43:02,000 --> 00:43:07,000
Lehet használni néhány a láncolt lista viselkedést, ha nem

560
00:43:07,000 --> 00:43:11,000
kapcsolt listák a hash táblák, ha nem egy hash táblát.

561
00:43:11,000 --> 00:43:15,000
Azt javasoljuk, csinál egy hash táblát.

562
00:43:15,000 --> 00:43:17,000
Lehet, hogy már megtette a Trie,

563
00:43:17,000 --> 00:43:23,000
de a próbálkozás nehezebb.

564
00:43:23,000 --> 00:43:27,000
Elvileg ők aszimptotikusan jobb.

565
00:43:27,000 --> 00:43:30,000
De nézd meg a nagy táblára,

566
00:43:30,000 --> 00:43:35,000
és megpróbálja soha nem jobb, és nem vesz fel több memóriát.

567
00:43:35,000 --> 00:43:43,000
Minden, ami megpróbálja végül is rosszabb, több munka.

568
00:43:43,000 --> 00:43:49,000
Ez az, amit David Malan megoldása mindig van

569
00:43:49,000 --> 00:43:56,000
ő mindig álláshely a Trie megoldás, és nézzük meg, ahol éppen van.

570
00:43:56,000 --> 00:44:00,000
Mi volt ő alatt, David J?

571
00:44:00,000 --> 00:44:06,000
Ő # 18, úgy, hogy ez nem túl rossz,

572
00:44:06,000 --> 00:44:09,000
és ez lesz az egyik legjobb megpróbálja tudsz gondolni

573
00:44:09,000 --> 00:44:17,000
vagy az egyik a legjobb próbál egy Trie.

574
00:44:17,000 --> 00:44:23,000
Ez még csak nem is az eredeti megoldás?

575
00:44:23,000 --> 00:44:29,000
Úgy érzem, Trie megoldások általában jobban ebben a tartományban a RAM használat.

576
00:44:29,000 --> 00:44:33,000
>> Menj le a csúcsra, és a RAM használat az egységes számjegy.

577
00:44:33,000 --> 00:44:36,000
Menj le alja felé, és akkor látja, megpróbál

578
00:44:36,000 --> 00:44:41,000
ahol kapsz teljesen masszív RAM használat,

579
00:44:41,000 --> 00:44:45,000
és próbál nehezebb.

580
00:44:45,000 --> 00:44:53,000
Nem teljesen megéri, de egy oktatási tapasztalat, ha nem egy.

581
00:44:53,000 --> 00:44:56,000
Az utolsó dolog, a mi linkelt lista,

582
00:44:56,000 --> 00:45:04,000
és ez a három dolog, halom, sorok, és a kapcsolt listák,

583
00:45:04,000 --> 00:45:09,000
bármely jövőbeni dolog, amit valaha is a számítástechnikában

584
00:45:09,000 --> 00:45:12,000
feltételezi, akkor ismeri ezeket a dolgokat.

585
00:45:12,000 --> 00:45:19,000
Ők annyira alapvető mindent.

586
00:45:19,000 --> 00:45:25,000
>> Csatolt listák, és itt már egy egyszeresen láncolt lista lesz a végrehajtás.

587
00:45:25,000 --> 00:45:34,000
Mit jelent egyedül kapcsolódó jelent, szemben a kétszeresen kötött? Igen.

588
00:45:34,000 --> 00:45:37,000
[Student] Csak mutat a következő mutató helyett a mutatók,

589
00:45:37,000 --> 00:45:39,000
, mint például az megelőző és azt az egymás után is.

590
00:45:39,000 --> 00:45:44,000
Igen, így képformátumot, mit tettem most csinálni?

591
00:45:44,000 --> 00:45:48,000
Van két dolgot. Van kép és kép.

592
00:45:48,000 --> 00:45:51,000
A képformátum, mi egyedül kapcsolt listák,

593
00:45:51,000 --> 00:45:57,000
elkerülhetetlenül, van valamilyen mutatót a fejét a listán,

594
00:45:57,000 --> 00:46:02,000
majd a listán, már csak mutató,

595
00:46:02,000 --> 00:46:05,000
és talán ez rámutat arra, hogy null.

596
00:46:05,000 --> 00:46:08,000
Ez lesz a tipikus rajz egy egyszeresen láncolt lista.

597
00:46:08,000 --> 00:46:14,000
A kétszeresen láncolt lista, akkor menj visszafelé.

598
00:46:14,000 --> 00:46:19,000
Ha adok neked bármelyik csomópont szerepel a listán, akkor feltétlenül kap

599
00:46:19,000 --> 00:46:23,000
bármely egyéb csomópont a listában, ha van egy kétszeresen kapcsolt lista.

600
00:46:23,000 --> 00:46:27,000
De ha neked a harmadik csomópontot a listából, és ez egy egyedül láncolt lista,

601
00:46:27,000 --> 00:46:30,000
semmilyen módon nem te valaha is, hogy az első és a második csomópontok.

602
00:46:30,000 --> 00:46:34,000
És ott van előnyöket és hátrányok, és egy nyilvánvaló lett

603
00:46:34,000 --> 00:46:42,000
van az előírtnál több méret, és van, hogy nyomon követheti, ha ezeket a dolgokat mutat most.

604
00:46:42,000 --> 00:46:49,000
De csak érdekel egyszeresen kapcsolódik.

605
00:46:49,000 --> 00:46:53,000
>> Néhány dolgot fogunk végre kell hajtania.

606
00:46:53,000 --> 00:47:00,000
A typedef struct csomópont, int i: struct node * next; csomópont.

607
00:47:00,000 --> 00:47:09,000
Ezt a typedef kell égetni az Ön fejében.

608
00:47:09,000 --> 00:47:14,000
Quiz 1 kell szeretnék adni typedef egy láncolt lista csomópont,

609
00:47:14,000 --> 00:47:18,000
és képesnek kell lennie arra, hogy azonnal irkál azt le

610
00:47:18,000 --> 00:47:22,000
anélkül, hogy gondolkodtam rajta.

611
00:47:22,000 --> 00:47:27,000
Azt hiszem, egy pár kérdést, miért van szükségünk struct itt?

612
00:47:27,000 --> 00:47:32,000
Miért nem mondjuk node *?

613
00:47:32,000 --> 00:47:35,000
[Student] [hallható]

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

615
00:47:38,000 --> 00:47:44,000
Az egyetlen dolog, amely meghatározza a csomópont, mint egy dolog

616
00:47:44,000 --> 00:47:47,000
a typedef maga.

617
00:47:47,000 --> 00:47:55,000
De ezen a ponton, amikor mi vagyunk a fajta elemzés ezen keresztül struct csomóponton meghatározás

618
00:47:55,000 --> 00:48:01,000
még nem fejeztük be a typedef még, igaz, mivel a typedef még nem fejeződött be,

619
00:48:01,000 --> 00:48:05,000
csomópont nem létezik.

620
00:48:05,000 --> 00:48:12,000
De struct csomópont működik, és ez a csomópont itt,

621
00:48:12,000 --> 00:48:14,000
ezt is nevezhetnénk mást.

622
00:48:14,000 --> 00:48:16,000
Ezt nevezhetnénk n.

623
00:48:16,000 --> 00:48:19,000
Ezt nevezhetnénk linkelt lista csomópont.

624
00:48:19,000 --> 00:48:21,000
Ezt nevezhetnénk semmit.

625
00:48:21,000 --> 00:48:26,000
De ez struct csomópontot kell az úgynevezett ugyanaz, mint a struct csomópont.

626
00:48:26,000 --> 00:48:29,000
Mit hívják ezt meg is lehet itt,

627
00:48:29,000 --> 00:48:32,000
és hogy is választ a második pont a kérdés

628
00:48:32,000 --> 00:48:37,000
ezért-sokszor, amikor meglátja Struktúrák és typedefs a struktúrákat,

629
00:48:37,000 --> 00:48:42,000
látni fogja, névtelen struktúrákat, ahol akkor csak látni typedef struct,

630
00:48:42,000 --> 00:48:47,000
végrehajtása struct, szótár, vagy bármi más.

631
00:48:47,000 --> 00:48:51,000
>> Miért van akkor meg kell mondani csomópont?

632
00:48:51,000 --> 00:48:54,000
Miért nem lehet az egy anonim struktúra?

633
00:48:54,000 --> 00:48:56,000
Ez majdnem ugyanaz a válasz.

634
00:48:56,000 --> 00:48:58,000
[Student] Meg kell utalni, hogy a struct.

635
00:48:58,000 --> 00:49:04,000
Igen, a struct, meg kell nézze meg a struct magát.

636
00:49:04,000 --> 00:49:10,000
Ha nem ad a struct egy nevet, ha ez egy névtelen struct, akkor nem hivatkozhat rá.

637
00:49:10,000 --> 00:49:17,000
És végül, de nem utolsó sorban, ezeket mind kissé egyszerű,

638
00:49:17,000 --> 00:49:20,000
és ezeket segít megvalósítani, ha írsz ezt le

639
00:49:20,000 --> 00:49:24,000
hogy te csinálsz valamit rosszul, ha ezek a dolgok nem értelme.

640
00:49:24,000 --> 00:49:28,000
Végül, de nem utolsó sorban, miért ezt kell struct node *?

641
00:49:28,000 --> 00:49:34,000
Miért nem lehet pusztán struct csomópont a következő lépés?

642
00:49:34,000 --> 00:49:37,000
[Student] Pointer a következő struct.

643
00:49:37,000 --> 00:49:39,000
Ez elkerülhetetlenül, amit akarunk.

644
00:49:39,000 --> 00:49:42,000
Miért lehet ez soha nem lehet struct node következő?

645
00:49:42,000 --> 00:49:50,000
Miért kell struct node * a következő lépés? Igen.

646
00:49:50,000 --> 00:49:53,000
[Student] Ez olyan, mint egy végtelen hurok.

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

648
00:49:55,000 --> 00:49:57,000
[Student] lenne mind egyben.

649
00:49:57,000 --> 00:50:02,000
Igen, csak gondolom, hogyan tennénk mérete, vagy ilyesmi.

650
00:50:02,000 --> 00:50:08,000
Mérete a struct alapvetően + vagy - néhány minta itt vagy ott.

651
00:50:08,000 --> 00:50:15,000
Ez alapvetően lesz az összege mérete dolog a struct.

652
00:50:15,000 --> 00:50:18,000
Ez itt megváltoztatása nélkül semmit, a méret lesz könnyű.

653
00:50:18,000 --> 00:50:24,000
Mérete struct csomópont lesz méretének i + méretű következő.

654
00:50:24,000 --> 00:50:27,000
Mérete i lesz 4. Mérete mellett lesz 4.

655
00:50:27,000 --> 00:50:30,000
Mérete struct csomópont lesz 8.

656
00:50:30,000 --> 00:50:34,000
Ha nincs meg a *, gondolva sizeof,

657
00:50:34,000 --> 00:50:37,000
akkor sizeof (i) lesz 4.

658
00:50:37,000 --> 00:50:43,000
Mérete struct csomópont mellett lesz méretének i + méretű struct csomópont mellett

659
00:50:43,000 --> 00:50:46,000
+ Méret i + méretű struct csomópont mellett.

660
00:50:46,000 --> 00:50:55,000
Lenne egy végtelen rekurzió csomópontok.

661
00:50:55,000 --> 00:51:00,000
Ez az, amiért ez a dolgok kell lennie.

662
00:51:00,000 --> 00:51:03,000
>> Ismét határozottan megjegyezni, hogy a

663
00:51:03,000 --> 00:51:06,000
vagy legalább megérteni, elég, hogy lehet, hogy képes legyen

664
00:51:06,000 --> 00:51:12,000
Ezért át, amit meg kell kinéznie.

665
00:51:12,000 --> 00:51:14,000
A dolgok fogunk akar végrehajtani.

666
00:51:14,000 --> 00:51:18,000
Ha hosszú a lista-

667
00:51:18,000 --> 00:51:21,000
akkor csal, és tartsa körül

668
00:51:21,000 --> 00:51:24,000
globális hossz vagy valami, de nem fogunk csinálni.

669
00:51:24,000 --> 00:51:28,000
Megyünk számít a hossza a listán.

670
00:51:28,000 --> 00:51:34,000
Van tartalmaz annak érdekében, hogy ez alapvetően, mint a keresés,

671
00:51:34,000 --> 00:51:41,000
így van egy láncolt lista az egész, hogy ha ez egész szám van a láncolt lista.

672
00:51:41,000 --> 00:51:44,000
Előre betoldott megy be az a lista elején.

673
00:51:44,000 --> 00:51:46,000
Append megy be a végén.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted fog beilleszteni a rendezve pozícióra a listán.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted fajta feltételezi, hogy Ön soha nem használt elé vagy mögé rossz módon.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted amikor végrehajtási insert_sorted-

677
00:52:09,000 --> 00:52:13,000
mondjuk már a láncolt lista.

678
00:52:13,000 --> 00:52:18,000
Ez az, ami úgy néz ki, mint jelenleg, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Szeretnék beszúrni 3, így amíg a lista maga már rendezve,

680
00:52:24,000 --> 00:52:27,000
könnyű megtalálni, ahol 3 tartozik.

681
00:52:27,000 --> 00:52:29,000
Elkezdek a 2.

682
00:52:29,000 --> 00:52:32,000
Oké, 3 nagyobb mint 2, ezért szeretném, hogy folyamatosan megy.

683
00:52:32,000 --> 00:52:35,000
Oh, 4 túl nagy, úgyhogy tudom 3 fog menni a 2 és 4,

684
00:52:35,000 --> 00:52:39,000
és én kijavítani mutatók és minden ilyesmi.

685
00:52:39,000 --> 00:52:43,000
De ha mi nem feltétlenül használja insert_sorted,

686
00:52:43,000 --> 00:52:50,000
mint mondjuk én hozzáfűzése 6,

687
00:52:50,000 --> 00:52:55,000
aztán a linkelt listát fog válni ezt.

688
00:52:55,000 --> 00:53:01,000
Most nincs értelme, így insert_sorted, akkor csak feltételezik,

689
00:53:01,000 --> 00:53:04,000
hogy a sorrend, bár műveletek léteznek

690
00:53:04,000 --> 00:53:09,000
ami okozhat, hogy nem lehet válogatni, és ennyi.

691
00:53:09,000 --> 00:53:20,000
Keressen egy hasznos betét hát ezek a legfontosabb dolgok, amit kell majd végrehajtani.

692
00:53:20,000 --> 00:53:24,000
>> Most, hogy egy percet csinálni hosszúságú és tartalmazza,

693
00:53:24,000 --> 00:53:30,000
és azokat kell viszonylag gyorsan.

694
00:53:41,000 --> 00:53:48,000
Közeledik záróra, így bárki, van valami, hossz, illetve tartalmaz?

695
00:53:48,000 --> 00:53:50,000
Ők lesznek majdnem azonos.

696
00:53:50,000 --> 00:53:57,000
[Student] Hossz.

697
00:53:57,000 --> 00:54:01,000
Lássuk, felülvizsgálatára.

698
00:54:01,000 --> 00:54:04,000
Oké.

699
00:54:12,000 --> 00:54:15,000
Akarsz megmagyarázni?

700
00:54:15,000 --> 00:54:21,000
[Student] Most hozzon létre egy mutatót csomópont és inicializálni azt az első, ami a mi globális változó,

701
00:54:21,000 --> 00:54:27,000
és akkor nézze meg, ha ez nulla, így nem kap egy seg hiba és vissza 0, ha ez a helyzet.

702
00:54:27,000 --> 00:54:34,000
Egyébként, én áthidalás, hogy nyomon követhetőek legyenek a integer

703
00:54:34,000 --> 00:54:38,000
hányszor voltam elérhető a következő eleme a lista

704
00:54:38,000 --> 00:54:43,000
és ugyanabban a növekmény művelet is elérheti, hogy az aktuális elem,

705
00:54:43,000 --> 00:54:47,000
és aztán folyamatosan, hogy a csekket, hogy ha ez null,

706
00:54:47,000 --> 00:54:56,000
és ha ez nulla, akkor megszakítja és csak visszaadja az elemek száma, amit elérni.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Van valakinek észrevételek valamit?

708
00:55:01,000 --> 00:55:06,000
Ez jól néz ki helyességét bölcs.

709
00:55:06,000 --> 00:55:10,000
[Student] Nem hiszem, hogy szükségünk van a node == null.

710
00:55:10,000 --> 00:55:13,000
Igen, ha a csomópont == null return 0.

711
00:55:13,000 --> 00:55:18,000
De ha node == null akkor ez-oh, van egy korrektség kérdése.

712
00:55:18,000 --> 00:55:23,000
Ez csak te vissza én, de ez nem a körét most.

713
00:55:23,000 --> 00:55:30,000
Csak azt kell int i, tehát i = 0.

714
00:55:30,000 --> 00:55:34,000
De ha a csomópont null, akkor én még mindig lesz 0,

715
00:55:34,000 --> 00:55:39,000
és megyünk vissza 0, ezért ebben az esetben azonos.

716
00:55:39,000 --> 00:55:48,000
Egy másik gyakori dolog, hogy a nyilatkozat

717
00:55:48,000 --> 00:55:51,000
A csomópont belsejében a hurok.

718
00:55:51,000 --> 00:55:54,000
Mondhatjuk-oh, nem.

719
00:55:54,000 --> 00:55:56,000
Maradjon is, mint ez.

720
00:55:56,000 --> 00:55:59,000
Én valószínűleg fel int i = 0 itt,

721
00:55:59,000 --> 00:56:05,000
majd node * node = először itt.

722
00:56:05,000 --> 00:56:11,000
És ez valószínűleg how-szerzés eltűnjön ez a most.

723
00:56:11,000 --> 00:56:14,000
Ez valószínűleg hogyan írt volna meg.

724
00:56:14,000 --> 00:56:21,000
Te is, néztem, mint ez.

725
00:56:21,000 --> 00:56:25,000
Ez a hurok struktúra itt

726
00:56:25,000 --> 00:56:30,000
kell szinte természetes, hogy Ön, mint az int i = 0

727
00:56:30,000 --> 00:56:33,000
i kisebb mint hossza tömb i + +.

728
00:56:33,000 --> 00:56:38,000
Ha ez hogyan iterációkhoz egy tömb, ez hogyan iterációkhoz csatolt listát.

729
00:56:38,000 --> 00:56:45,000
>> Ez legyen második természet egy bizonyos ponton.

730
00:56:45,000 --> 00:56:50,000
Ezt szem előtt tartva, ez lesz szinte ugyanaz a dolog.

731
00:56:50,000 --> 00:56:57,000
Fogsz szeretne navigálhat egy láncolt lista.

732
00:56:57,000 --> 00:57:02,000
Ha a csomópont, fogalmam sincs, hogy mi az érték hívják.

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

734
00:57:04,000 --> 00:57:15,000
Ha az érték az adott node = i return true, és ennyi.

735
00:57:15,000 --> 00:57:18,000
Figyelje meg, hogy az egyetlen módja annak, amit valaha return false

736
00:57:18,000 --> 00:57:23,000
, ha már navigálhat az egész láncolt lista, és soha nem tér vissza igaz,

737
00:57:23,000 --> 00:57:29,000
annak érdekében, hogy az, amit ez csinál.

738
00:57:29,000 --> 00:57:36,000
Mint Mellékesen jegyzem meg, hogy valószínűleg nem fog hozzáfűzni vagy hozzáfűzése.

739
00:57:36,000 --> 00:57:39,000
>> Quick utolsó megjegyzés.

740
00:57:39,000 --> 00:57:52,000
Ha látod a statikus kulcsszó, tehát mondjuk static int count = 0,

741
00:57:52,000 --> 00:57:56,000
akkor mi count + +, akkor alapvetően úgy gondolja, hogy ez egy globális változót,

742
00:57:56,000 --> 00:58:00,000
bár én most mondta, hogy ez nem így fogjuk végrehajtani hosszát.

743
00:58:00,000 --> 00:58:06,000
Én ezt itt, majd a count + +.

744
00:58:06,000 --> 00:58:11,000
Bármilyen módon tudjuk meg egy csomópont a mi linkelt lista mi növelésével a gróf.

745
00:58:11,000 --> 00:58:15,000
A lényeg ez az, amit a statikus kulcsszót jelent.

746
00:58:15,000 --> 00:58:20,000
Ha most volt int count = 0 lenne a rendszeres éves globális változót.

747
00:58:20,000 --> 00:58:25,000
Mi static int count azt jelenti, hogy ez egy globális változót ezt a fájlt.

748
00:58:25,000 --> 00:58:28,000
Lehetetlen, hogy egy másik fájl,

749
00:58:28,000 --> 00:58:34,000
tetszik gondolni Pset 5, ha már elindult.

750
00:58:34,000 --> 00:58:39,000
Van két speller.c, és van dictionary.c,

751
00:58:39,000 --> 00:58:42,000
, és ha csak egy dolog nyilvánítja globális, akkor bármit speller.c

752
00:58:42,000 --> 00:58:45,000
lehet hozzáférni dictionary.c és fordítva.

753
00:58:45,000 --> 00:58:48,000
A globális változók elérhetőek bármilyen. C fájlt,

754
00:58:48,000 --> 00:58:54,000
de statikus változók csak elérhető a fájl maga,

755
00:58:54,000 --> 00:59:01,000
így belseje spell checker belül vagy dictionary.c,

756
00:59:01,000 --> 00:59:06,000
ez a fajta mennyire szeretném kijelentem a változó a mérete az én tömb

757
00:59:06,000 --> 00:59:10,000
vagy a méret a számom szavak a szótárban.

758
00:59:10,000 --> 00:59:15,000
Mivel én nem akarok nyilatkozni egy globális változó, hogy bárki hozzáfér,

759
00:59:15,000 --> 00:59:18,000
Én tényleg csak érdekel, hogy a saját célra.

760
00:59:18,000 --> 00:59:21,000
>> A jó dolog is ez a teljes név ütközés cucc.

761
00:59:21,000 --> 00:59:27,000
Ha néhány egyéb fájl megpróbál globális változó nevű gróf dolgok nagyon, nagyon rossz,

762
00:59:27,000 --> 00:59:33,000
így ez a szépen tartja a dolgokat széffel, és csak úgy érheti el,

763
00:59:33,000 --> 00:59:38,000
, és senki más nem tud, és ha valaki kijelenti, egy globális változó nevű gróf,

764
00:59:38,000 --> 00:59:43,000
akkor nem zavarja a statikus változó nevű gróf.

765
00:59:43,000 --> 00:59:47,000
Ez az, amit statikus van. Ez a fájl globális változót.

766
00:59:47,000 --> 00:59:52,000
>> Kérdések a valamit?

767
00:59:52,000 --> 00:59:59,000
All set. Szia.

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