1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Apžvalga] [Viktorina 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvardo universiteto]

3
00:00:05,000 --> 00:00:08,000
>> [Tai CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Ei, visi.

5
00:00:10,000 --> 00:00:15,000
Sveiki atvykę į peržiūros sesijos 0 Viktorina, kuri vyksta šį trečiadienį.

6
00:00:15,000 --> 00:00:19,000
Ką mes ketiname tai padaryti šį vakarą, aš su 3 kitų TFS

7
00:00:19,000 --> 00:00:24,000
ir kartu mes ketiname eiti per ką mes padarėme Žinoma, peržiūros.

8
00:00:24,000 --> 00:00:27,000
Jis nesiruošia būti 100% išsamus, tačiau jis turėtų suteikti jums geresnį supratimą

9
00:00:27,000 --> 00:00:31,000
, ką jūs jau turite ir ko jums vis tiek reikia studijuoti iki trečiadienio.

10
00:00:31,000 --> 00:00:34,000
Ir nedvejodami pakelti ranką klausimus, kaip mes einame kartu,

11
00:00:34,000 --> 00:00:38,000
, tačiau reikia nepamiršti, kad mes taip pat turime šiek tiek laiko pabaigoje

12
00:00:38,000 --> 00:00:41,000
jei mes gauti per keletą minučių atsarginių daryti bendro pobūdžio klausimus,

13
00:00:41,000 --> 00:00:47,000
todėl keep that in mind, ir todėl mes ketiname pradėti su 0 savaitės pradžioje.

14
00:00:47,000 --> 00:00:50,000
>> [Viktorina 0 Review!] [0 dalis] [Lexi Ross] Bet kol mes padaryti, kad pakalbėkime apie

15
00:00:50,000 --> 00:00:53,000
Viktorinos logistika.

16
00:00:53,000 --> 00:00:55,000
>> [Logistika] [Viktorina vyksta Trečiadienis 10/10 vietoj paskaitos]

17
00:00:55,000 --> 00:00:57,000
>> [(Žr. Išsamesnės informacijos http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf)] Tai trečiadienis, spalis 10.

18
00:00:57,000 --> 00:01:00,000
>> Štai šį trečiadienį, ir jei jūs einate į šį URL čia,

19
00:01:00,000 --> 00:01:03,000
, kuri yra taip pat prieinama iš CS50.net-ten yra nuoroda į jį,

20
00:01:03,000 --> 00:01:06,000
galite pamatyti informaciją apie tai, kur eiti, remiantis

21
00:01:06,000 --> 00:01:10,000
Jūsų pavardė ar mokyklos priklausomybė taip pat

22
00:01:10,000 --> 00:01:14,000
jis pasakoja apie tai, ką viktorina apims ir klausimų tipai, kad jūs ketinate gauti.

23
00:01:14,000 --> 00:01:19,000
Turėkite omenyje, kad jūs taip pat turėsite galimybę peržiūrėti viktorinoje skyriuje,

24
00:01:19,000 --> 00:01:21,000
todėl jūsų TFS turėtų būti vyksta per šiek tiek praktikos problemas,

25
00:01:21,000 --> 00:01:29,000
ir tai yra dar viena gera proga pamatyti, kur jūs vis dar reikia mokytis viktorinoje.

26
00:01:29,000 --> 00:01:32,000
Pradėkime su bitai 'n' baitų pradžioje.

27
00:01:32,000 --> 00:01:35,000
Atminkite, šiek tiek yra tik 0 arba 1,

28
00:01:35,000 --> 00:01:38,000
ir baitas yra 8 šių bitų kolekcija.

29
00:01:38,000 --> 00:01:42,000
Pažvelkime šiuo bitų surinkimo čia.

30
00:01:42,000 --> 00:01:44,000
Turėtume sugebėti išsiaiškinti, kiek bitų yra.

31
00:01:44,000 --> 00:01:48,000
Kur tikimės, kad tik 8 iš jų 8 0 arba 1 vnt.

32
00:01:48,000 --> 00:01:51,000
Ir kadangi yra 8 bitai, 1 baitas,

33
00:01:51,000 --> 00:01:53,000
ir tegul konvertuoti jį į šešioliktainį.

34
00:01:53,000 --> 00:01:58,000
Šešioliktainis yra pagrindo 16, ir tai gana lengva konvertuoti

35
00:01:58,000 --> 00:02:01,000
dvejetainis skaičius, o tai, kas tai yra, šešioliktainis skaičius.

36
00:02:01,000 --> 00:02:04,000
Visi mes darome, mes pažvelgti grupėmis po 4,

37
00:02:04,000 --> 00:02:07,000
ir mes juos konvertuoti į atitinkamą šešioliktainis skaitmuo.

38
00:02:07,000 --> 00:02:11,000
Mes pradedame su dešiniojoje grupės 4, 0011.

39
00:02:11,000 --> 00:02:16,000
Tai bus vienas 1 ir 2, tai kartu, kad daro 3.

40
00:02:16,000 --> 00:02:19,000
Ir tada pažvelkime kitame bloke 4.

41
00:02:19,000 --> 00:02:24,000
1101. Tų, kurie ketina būti viena 1, 4, ir vienas 8.

42
00:02:24,000 --> 00:02:28,000
Kartu, kad bus 13, todėl D.

43
00:02:28,000 --> 00:02:32,000
Ir mes prisiminti,, kad šešioliktainis mes ne tiesiog eiti nuo 0 iki 9.

44
00:02:32,000 --> 00:02:36,000
Mes einame 0 iki F, kad po 9, 10 atitinka,

45
00:02:36,000 --> 00:02:40,000
11 B, ir tt, kur F yra 15.

46
00:02:40,000 --> 00:02:44,000
Čia 13 yra D,

47
00:02:44,000 --> 00:02:49,000
kad konvertuoti jį į dešimtainį, visi mes darome, mes iš tikrųjų

48
00:02:49,000 --> 00:02:52,000
laikyti kiekvieną poziciją kaip 2 galios.

49
00:02:52,000 --> 00:02:58,000
Štai vienas 1, vienas 2, nulis 4s, nulis 8s, vienas 16 ir tt,

50
00:02:58,000 --> 00:03:03,000
ir tai šiek tiek sunku apskaičiuoti galvą, bet jei mes einame į kitą skaidrę

51
00:03:03,000 --> 00:03:05,000
mes galime matyti, kad atsakymas į šį.

52
00:03:05,000 --> 00:03:09,000
>> Iš esmės mes ketiname per iš dešinės į kairę,

53
00:03:09,000 --> 00:03:14,000
ir mes dauginant kiekvieną skaitmenį pagal atitinkamą galią 2.

54
00:03:14,000 --> 00:03:19,000
Ir atminkite, kad mes Šešioliktainius skaičius žymi šiuos numerius su 0x pradžioje

55
00:03:19,000 --> 00:03:23,000
todėl nereikia supainioti su dešimtainiu skaičiumi.

56
00:03:23,000 --> 00:03:29,000
Tęsiant tai ASCII lentelė,

57
00:03:29,000 --> 00:03:35,000
ir ką mes naudojame ASCII map iš simbolių skaitines reikšmes.

58
00:03:35,000 --> 00:03:39,000
Prisiminti kriptografijos pset plačiai naudoti ASCII lentelėje

59
00:03:39,000 --> 00:03:43,000
siekiant naudoti įvairius metodus, kriptografijos,

60
00:03:43,000 --> 00:03:47,000
Cezaris ir Vigenere šifras skirtingus laiškus, konvertuoti

61
00:03:47,000 --> 00:03:52,000
eilutę pagal vartotojo pateiktas iki rakto.

62
00:03:52,000 --> 00:03:56,000
Pažvelkime šiek tiek ASCII matematikos.

63
00:03:56,000 --> 00:04:02,000
Žiūri "P" + 1, simbolių forma, kuri be Q

64
00:04:02,000 --> 00:04:07,000
ir prisiminti, kad '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
Ir kaip tiksliai tai mes konvertuoti tarp tų 2 formų?

66
00:04:10,000 --> 00:04:13,000
Iš tikrųjų tai ne per sunku.

67
00:04:13,000 --> 00:04:16,000
Siekiant gauti 5 mes atimti '0 '

68
00:04:16,000 --> 00:04:20,000
, nes yra 5 vietos tarp "0" ir "5".

69
00:04:20,000 --> 00:04:23,000
, Siekiant pereiti į kitą pusę, mes tiesiog pridėti 0,

70
00:04:23,000 --> 00:04:25,000
todėl tarsi reguliariai aritmetinis.

71
00:04:25,000 --> 00:04:29,000
Tiesiog neužmirškite, kad kai kažkas turi kabutes pobūdis

72
00:04:29,000 --> 00:04:37,000
ir todėl atitinka ASCII lentelę vertės.

73
00:04:37,000 --> 00:04:40,000
Persikėlimas į bendresnes Kompiuterijos temomis.

74
00:04:40,000 --> 00:04:43,000
Mes sužinojome, kad tai, kas yra algoritmas ir kaip mes ją naudojame programavimo

75
00:04:43,000 --> 00:04:45,000
įgyvendinti algoritmai.

76
00:04:45,000 --> 00:04:48,000
Kai algoritmų pavyzdžiai yra kažkas tikrai paprasta kaip

77
00:04:48,000 --> 00:04:51,000
patikrinti, ar skaičius yra lyginis ar nelyginis.

78
00:04:51,000 --> 00:04:54,000
Už tai atsimenu, mes mod skaičių iš 2 ir patikrinti, ar rezultatas yra 0.

79
00:04:54,000 --> 00:04:57,000
Jei taip, tai dar. Jei ne, tai keista.

80
00:04:57,000 --> 00:04:59,000
Ir tai yra tikrai pagrindinio algoritmo pavyzdys.

81
00:04:59,000 --> 00:05:02,000
>> Šiek tiek daugiau dalyvavo ir dvejetainis paieškos

82
00:05:02,000 --> 00:05:05,000
mes pereiti vėliau sesijos apžvalgos.

83
00:05:05,000 --> 00:05:09,000
Ir programavimas yra terminas, naudojamas algoritmą

84
00:05:09,000 --> 00:05:15,000
ir konvertuoti kodas kompiuterį gali skaityti.

85
00:05:15,000 --> 00:05:20,000
2 programų pavyzdžiai yra nulio,

86
00:05:20,000 --> 00:05:22,000
, kuri yra tai, ką mes padarėme savaitė 0.

87
00:05:22,000 --> 00:05:25,000
Nors mes ne iš tikrųjų įveskite kodą įgyvendinimo būdas

88
00:05:25,000 --> 00:05:29,000
šis algoritmas, kuris spausdina skaičiai 1-10,

89
00:05:29,000 --> 00:05:32,000
ir čia mes darome tą patį C programavimo kalba.

90
00:05:32,000 --> 00:05:41,000
Tai yra funkciškai lygiavertės, tik parašyta įvairiomis kalbomis ar sintaksės.

91
00:05:41,000 --> 00:05:44,000
Mes tada sužinojo apie Būlio išraiškos,

92
00:05:44,000 --> 00:05:48,000
ir loginė reikšmė yra vertė, tai arba true arba false,

93
00:05:48,000 --> 00:05:51,000
ir čia dažnai Būlio išraiškos

94
00:05:51,000 --> 00:05:55,000
vidun sąlygų, todėl, jei (x ≤ 5),

95
00:05:55,000 --> 00:06:00,000
gerai, mes jau x = 5, kad sąlyga ketina įvertinti, tiesa.

96
00:06:00,000 --> 00:06:03,000
Ir jei tai tiesa, bet kodas yra po sąlyga

97
00:06:03,000 --> 00:06:08,000
bus vertinami iš kompiuterio, kad eilutė bus spausdinami

98
00:06:08,000 --> 00:06:12,000
į standartinį išvedimą ir trukmės sąlyga

99
00:06:12,000 --> 00:06:16,000
reiškia viską, kas yra viduje IF skliaustuose.

100
00:06:16,000 --> 00:06:20,000
Prisiminti visiems suinteresuotiems ūkio subjektams.

101
00:06:20,000 --> 00:06:26,000
Atminkite, tai && ir | | kai mes bandome sujungti 2 ar daugiau sąlygų,

102
00:06:26,000 --> 00:06:30,000
== Ne = patikrinti, ar 2 dalykai yra lygūs.

103
00:06:30,000 --> 00:06:36,000
Atminkite, kad = užduotims, o == Būlio operatorius.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ ir tada galutinis 2 yra savaime suprantama.

105
00:06:41,000 --> 00:06:45,000
Bendrosios peržiūros Bulio logika čia.

106
00:06:45,000 --> 00:06:48,000
Ir loginės išraiškos yra taip pat svarbu, kilpomis,

107
00:06:48,000 --> 00:06:50,000
kuriuos mes eiti per dabar.

108
00:06:50,000 --> 00:06:56,000
Mes sužinojome apie 3 rūšių kilpos iki šiol CS50,, o ir padaryti, o.

109
00:06:56,000 --> 00:06:59,000
Ir svarbu žinoti, kad nors dauguma tikslų

110
00:06:59,000 --> 00:07:02,000
mes iš tikrųjų galite naudoti bet kokio tipo kilpa paprastai

111
00:07:02,000 --> 00:07:06,000
yra tam tikrų rūšių tikslais arba bendrų tendencijų

112
00:07:06,000 --> 00:07:09,000
programavimo, kurie konkrečiai reikalauja viena iš šių kilpų

113
00:07:09,000 --> 00:07:13,000
, kad padaryti jį pačios efektyviausios arba elegantiškas kodas ją tokiu būdu.

114
00:07:13,000 --> 00:07:18,000
Eikime per tai, ką kiekvienas iš šių kilpų linkęs būti naudojamas dažniausiai.

115
00:07:18,000 --> 00:07:21,000
>> Į už linijos mes paprastai jau žinote, kiek kartų mes norime pakartoti.

116
00:07:21,000 --> 00:07:24,000
Tai, ką mes įdėti sąlyga.

117
00:07:24,000 --> 00:07:28,000
Nes, i = 0, i <10, pvz.

118
00:07:28,000 --> 00:07:31,000
Mes jau žinome, kad norime padaryti kažką 10 kartų.

119
00:07:31,000 --> 00:07:34,000
Dabar, while cikle, paprastai mes nebūtinai

120
00:07:34,000 --> 00:07:36,000
sužinoti, kiek kartų mes norime linijos paleisti.

121
00:07:36,000 --> 00:07:39,000
Bet mes žinome kažkokią būklės, kad mes norime, kad ji

122
00:07:39,000 --> 00:07:41,000
visada būti teisingi arba visada yra melagingi.

123
00:07:41,000 --> 00:07:44,000
Pavyzdžiui, nors yra nustatytas.

124
00:07:44,000 --> 00:07:46,000
Tarkime, kad Būlio kintamieji.

125
00:07:46,000 --> 00:07:48,000
Nors tai tiesa, mes norime kodas įvertinti,

126
00:07:48,000 --> 00:07:52,000
todėl šiek tiek labiau išplečiama, šiek tiek daugiau nei už linijos,

127
00:07:52,000 --> 00:07:55,000
tačiau bet už linijos taip pat gali būti konvertuojami į while cikle.

128
00:07:55,000 --> 00:08:00,000
Galiausiai nustatyta, ar, o kilpos, kurios gali būti sudėtingiausia suvokti iš karto,

129
00:08:00,000 --> 00:08:04,000
dažnai naudojami, kai norime įvertinti kodą

130
00:08:04,000 --> 00:08:06,000
prieš pirmą kartą mes tikriname šią sąlygą.

131
00:08:06,000 --> 00:08:09,000
Dažnai naudojamas daryti, o kilpa

132
00:08:09,000 --> 00:08:12,000
yra tada, kai norite gauti vartotojo įvesties, ir jūs žinote, jūs norite paprašyti, kad naudotojas

133
00:08:12,000 --> 00:08:15,000
įvesties bent vieną kartą, bet jei jie nesuteikia jums gerą indėlį, iš karto

134
00:08:15,000 --> 00:08:18,000
norite nuolat klausia juos, kol jie jums gerą indėlį.

135
00:08:18,000 --> 00:08:21,000
Štai labiausiai paplitęs while cikle,

136
00:08:21,000 --> 00:08:23,000
ir pažiūrėkime faktiniu šių kilpų struktūros.

137
00:08:23,000 --> 00:08:27,000
Jie paprastai visada linkę laikytis šių modelių.

138
00:08:27,000 --> 00:08:30,000
>> Dėl pasiūlymo kilpa viduje jūs turite 3 dalys:

139
00:08:30,000 --> 00:08:35,000
iniciacijos, paprastai kažkas panašaus int i = 0, kur i yra skaitiklis,

140
00:08:35,000 --> 00:08:40,000
sąlyga, jei mes norime pasakyti, paleisti linijos tol, kol ši sąlyga vis dar turi,

141
00:08:40,000 --> 00:08:44,000
Kaip aš <10, ir galiausiai, atnaujinti, o tai, kaip mes prieaugio

142
00:08:44,000 --> 00:08:47,000
skaitiklis kiekvienos kilpos taške kintamasis.

143
00:08:47,000 --> 00:08:50,000
Dažnas dalykas pamatyti ten yra tik i + +,

144
00:08:50,000 --> 00:08:52,000
o tai reiškia, prieaugio i 1 kiekvieną kartą.

145
00:08:52,000 --> 00:08:55,000
Jūs taip pat galėtų padaryti kažką panašaus i + = 2,

146
00:08:55,000 --> 00:08:58,000
o tai reiškia, I 2 pridėti kiekvieną kartą, kai jūs einate per kilpą.

147
00:08:58,000 --> 00:09:03,000
Ir tada padaryti tai tiesiog reiškia bet kokį kodą, kad iš tikrųjų veikia kaip kilpa.

148
00:09:03,000 --> 00:09:09,000
Ir while cikle, šiuo metu mes iš tikrųjų iniciacijos už kilpos,

149
00:09:09,000 --> 00:09:12,000
taigi, pavyzdžiui, tarkim, mes stengiamės padaryti tos pačios rūšies kilpos, kaip aš ką tik aprašytą.

150
00:09:12,000 --> 00:09:16,000
Mes sakytume, int i = 0 prieš kilpa prasideda.

151
00:09:16,000 --> 00:09:20,000
Tada mes galime pasakyti, o aš <10 tai padaryti,

152
00:09:20,000 --> 00:09:22,000
todėl tą patį kodo blokas, kaip ir anksčiau,

153
00:09:22,000 --> 00:09:26,000
ir šį kartą atnaujinta dalis kodo, pavyzdžiui, aš + +,

154
00:09:26,000 --> 00:09:29,000
iš tikrųjų vyksta viduje kilpos.

155
00:09:29,000 --> 00:09:33,000
Ir, pagaliau, daryti, o, jis panašus į while cikle,

156
00:09:33,000 --> 00:09:36,000
tačiau mes turime prisiminti, kad kodas bus įvertinti, kai

157
00:09:36,000 --> 00:09:40,000
Prieš sąlyga, tikrinama, todėl daro daug daugiau prasmės

158
00:09:40,000 --> 00:09:44,000
jei peržvelgsite tvarka viršaus į apačią.

159
00:09:44,000 --> 00:09:49,000
Do, o kilpa kodas įvertina prieš jus net pažvelgti kartu būklės,

160
00:09:49,000 --> 00:09:55,000
kadangi while cikle, jis pasitikrina pirmas.

161
00:09:55,000 --> 00:09:59,000
Ataskaitos ir kintamieji.

162
00:09:59,000 --> 00:10:04,000
Kai mes norime sukurti naują kintamąjį mes pirmiausia norime ją inicijuoti.

163
00:10:04,000 --> 00:10:07,000
>> Pavyzdžiui, int baras inicijuoja kintama baras,

164
00:10:07,000 --> 00:10:10,000
tačiau jis neturi suteikti jai vertę, tai kas yra baro vertė dabar?

165
00:10:10,000 --> 00:10:12,000
Mes nežinome.

166
00:10:12,000 --> 00:10:14,000
Jis gali būti šiek tiek šiukšlių vertė, kuri anksčiau buvo saugomas atmintyje,

167
00:10:14,000 --> 00:10:16,000
ir mes nenorime naudoti šį kintamąjį

168
00:10:16,000 --> 00:10:19,000
kol mes iš tikrųjų suteikia jai reikšmę,

169
00:10:19,000 --> 00:10:21,000
todėl mes skelbiame jį čia.

170
00:10:21,000 --> 00:10:24,000
Tada mes inicijuoti, kad ji būtų toliau 42.

171
00:10:24,000 --> 00:10:28,000
Dabar, žinoma, mes žinome, tai gali būti padaryta, į vieną eilutę, int bar = 42.

172
00:10:28,000 --> 00:10:30,000
Bet tik reikia išvalyti kelis veiksmus, kurie vyksta,

173
00:10:30,000 --> 00:10:34,000
deklaraciją ir iniciacijos vyksta atskirai.

174
00:10:34,000 --> 00:10:38,000
Taip atsitinka, vienas žingsnis, ir kit ˛ a, int baz = bar + 1,

175
00:10:38,000 --> 00:10:44,000
Toliau šis teiginys, kad padidėjimų Baz, kad šio bloko kodo pabaigoje

176
00:10:44,000 --> 00:10:48,000
jei mes spausdinti bazių vertę, kad būtų 44

177
00:10:48,000 --> 00:10:52,000
nes mes pareiškiame ir inicijuoti, kad ji būtų 1> juosta

178
00:10:52,000 --> 00:10:58,000
ir tada mes prieaugio jį dar kartą su + +.

179
00:10:58,000 --> 00:11:02,000
Mes nuėjome per šį gana trumpai, bet tai gerai, kad bendras

180
00:11:02,000 --> 00:11:04,000
suprasti, ką verpalai ir renginiai.

181
00:11:04,000 --> 00:11:06,000
Mes daugiausia tai padarė nulio,

182
00:11:06,000 --> 00:11:09,000
todėl jūs galite galvoti apie temas kaip daug kodo sekas

183
00:11:09,000 --> 00:11:11,000
veikia tuo pačiu metu.

184
00:11:11,000 --> 00:11:14,000
Be aktualija, tikriausiai jis toks ir yra ne veikia tuo pačiu metu,

185
00:11:14,000 --> 00:11:17,000
bet tarsi abstrakčiai mes galime galvoti apie tai, kad taip.

186
00:11:17,000 --> 00:11:20,000
>> Nulio, pavyzdžiui, mes turėjome kelis animacinius.

187
00:11:20,000 --> 00:11:22,000
Tai galėtų būti tuo pačiu metu vykdyti kitą kodą.

188
00:11:22,000 --> 00:11:26,000
Vienas gali būti vaikščiojimas, o kitas sako kažką

189
00:11:26,000 --> 00:11:29,000
kitoje ekrano dalyje.

190
00:11:29,000 --> 00:11:34,000
Įvykiai yra dar vienas būdas atskirti logiką

191
00:11:34,000 --> 00:11:37,000
tarp skirtingų elementų savo kodą,

192
00:11:37,000 --> 00:11:40,000
ir nulio, mes galėjome, kad būtų imituotos įvykius naudojant transliacija

193
00:11:40,000 --> 00:11:43,000
ir kad iš tikrųjų Kai gausiu, o ne, kai aš girdžiu,

194
00:11:43,000 --> 00:11:47,000
, tačiau iš esmės tai yra būdas perduoti informaciją

195
00:11:47,000 --> 00:11:49,000
iš vienos į kitą Sprite.

196
00:11:49,000 --> 00:11:52,000
Pavyzdžiui, galbūt norėsite perduoti žaidimą per

197
00:11:52,000 --> 00:11:56,000
ir kai gauna kita Sprite žaidimą per

198
00:11:56,000 --> 00:11:58,000
jis reaguoja tam tikru būdu.

199
00:11:58,000 --> 00:12:03,000
Tai svarbi modelis suprasti programavimo.

200
00:12:03,000 --> 00:12:07,000
Tiesiog eiti per pagrindinio savaitę 0, tai, ką mes iki šiol praėjo per

201
00:12:07,000 --> 00:12:10,000
pažvelkime šį paprastą C programos.

202
00:12:10,000 --> 00:12:14,000
Tekstas gali būti šiek tiek mažas, iš čia, bet aš eiti per jį tikrai greitai.

203
00:12:14,000 --> 00:12:20,000
Mes įskaitant 2 header files viršuje, cs50.h ir stdio.h.

204
00:12:20,000 --> 00:12:23,000
Tada mes apibrėžiant pastovų, vadinamą ribą, turi būti 100.

205
00:12:23,000 --> 00:12:26,000
Mes tada įgyvendinti savo pagrindinę funkciją.

206
00:12:26,000 --> 00:12:29,000
Kadangi mes nenaudojame komandinės eilutės argumentai čia mes turime įdėti negaliojančiu

207
00:12:29,000 --> 00:12:32,000
kaip pagrindiniai argumentai.

208
00:12:32,000 --> 00:12:38,000
Mes matome int virš pagrindinis. Štai grįžimo tipo, todėl grįžti 0 apačioje.

209
00:12:38,000 --> 00:12:41,000
Ir mes naudojame CS50 bibliotekos funkcija gauti int

210
00:12:41,000 --> 00:12:45,000
prašyti vartotojo input, ir mes saugome Šis kintamasis x,

211
00:12:45,000 --> 00:12:51,000
todėl mes skelbiame x pirmiau, ir mes jį inicijuoti, kai x = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Mes tada patikrinkite, jei vartotojas davė mums gerą indėlį.

213
00:12:53,000 --> 00:12:59,000
, Jei ji ≥ LIMIT norime grįžti klaidos kodas iš 1 ir spausdinti klaidos pranešimą.

214
00:12:59,000 --> 00:13:02,000
Ir pagaliau, jei vartotojas davė mums geras įnašas

215
00:13:02,000 --> 00:13:08,000
mes ketiname aikštėje ir išspausdinti šį rezultatą.

216
00:13:08,000 --> 00:13:11,000
Tiesiog įsitikinkite, kad tie visi Patekti į

217
00:13:11,000 --> 00:13:17,000
jūs galite pamatyti visas etiketes įvairiose kodą čia.

218
00:13:17,000 --> 00:13:19,000
Minėjau pastovus, antraščių failus.

219
00:13:19,000 --> 00:13:21,000
O, int x. Įsitikinkite, kad prisiminti, kad vietos kintamąjį.

220
00:13:21,000 --> 00:13:24,000
Priešpastato jį pasaulinį kintamąjį, kurį mes kalbame apie

221
00:13:24,000 --> 00:13:27,000
šiek tiek vėliau sesijos apžvalgos,

222
00:13:27,000 --> 00:13:30,000
ir mes kviečiame bibliotekos funkcija printf,

223
00:13:30,000 --> 00:13:34,000
tad jei nebūtume įtraukti stdio.h antraštės failą

224
00:13:34,000 --> 00:13:37,000
nebūtų suteikta galimybė skambinti printf.

225
00:13:37,000 --> 00:13:42,000
Ir aš tikiu, yra nukreipta rodyklė, kad gavo nukirto į% d,

226
00:13:42,000 --> 00:13:45,000
kuris yra formatavimo eilutę printf.

227
00:13:45,000 --> 00:13:52,000
Ji sako, kad atsispausdinti šį kintamąjį kaip skaičius,% d.

228
00:13:52,000 --> 00:13:58,000
Ir kad tai 0 savaitės.

229
00:13:58,000 --> 00:14:06,000
Dabar Lucas ketina tęsti.

230
00:14:06,000 --> 00:14:08,000
Ei, vaikinai. Mano vardas yra Lukas.

231
00:14:08,000 --> 00:14:10,000
Aš tikiu antrakursis geriausiu name miesteliu, Mather,

232
00:14:10,000 --> 00:14:14,000
ir aš norėčiau pakalbėti šiek tiek apie savaitę 1 ir 2,1.

233
00:14:14,000 --> 00:14:16,000
[Savaitė 1 ir 2,1!] [Lucas Freitas]

234
00:14:16,000 --> 00:14:19,000
Kaip Lexi sakiau, kai mes pradėjome versti savo kodą nuo nulio iki C

235
00:14:19,000 --> 00:14:23,000
vienas iš dalykų, kad mes pastebėjome, yra tai, kad jūs galite ne tik

236
00:14:23,000 --> 00:14:26,000
rašyti savo kodą ir paleisti jį naudojant žalią vėliavą nebėra.

237
00:14:26,000 --> 00:14:30,000
Tiesą sakant, jūs turite naudoti tam tikrus veiksmus, kad jūsų C programa

238
00:14:30,000 --> 00:14:33,000
tapti vykdomąjį failą.

239
00:14:33,000 --> 00:14:36,000
Esmės tai, ką jūs darote, kai rašote programą yra tai, kad

240
00:14:36,000 --> 00:14:40,000
jums išversti savo mintis į kalbą, kad kompiliatorius gali suprasti,

241
00:14:40,000 --> 00:14:44,000
todėl, kai jūs rašote programą C

242
00:14:44,000 --> 00:14:47,000
tai, ką jūs darote, yra iš tikrųjų rašyti kažką, kad jūsų kompiliatorių supras,

243
00:14:47,000 --> 00:14:50,000
tai kompiliatorius ketina išversti šį kodą

244
00:14:50,000 --> 00:14:53,000
į kažką, kad jūsų kompiuteris bus suprasti.

245
00:14:53,000 --> 00:14:55,000
>> Ir dalykas, kompiuteris iš tikrųjų yra labai kvailas.

246
00:14:55,000 --> 00:14:57,000
Jūsų kompiuteris gali suprasti tik 0s ir 1s,

247
00:14:57,000 --> 00:15:01,000
faktiškai pirmųjų kompiuterių žmonės paprastai užprogramuotas

248
00:15:01,000 --> 00:15:04,000
0s ir 1s, bet ne daugiau, ačiū Dievui.

249
00:15:04,000 --> 00:15:07,000
Mes neturime įsiminti dėl 0s ir 1s sekas

250
00:15:07,000 --> 00:15:10,000
už linijos arba while cikle ir pan.

251
00:15:10,000 --> 00:15:13,000
Štai kodėl mes turime kompiliatorius.

252
00:15:13,000 --> 00:15:17,000
Kas sudarytojas ar tai iš esmės verčia C kodas,

253
00:15:17,000 --> 00:15:21,000
mūsų atveju, į kalbą, kad jūsų kompiuteris bus suprasti,

254
00:15:21,000 --> 00:15:25,000
, kuri yra objekto kodas, ir kompiliatorius, kad mes naudojame

255
00:15:25,000 --> 00:15:30,000
vadinamas Apsukite metalinis garsas, todėl iš tikrųjų tai yra Apsukite metalinis garsas simbolis.

256
00:15:30,000 --> 00:15:33,000
, Kai jūs turite savo programą, jūs turite daryti 2 dalykų.

257
00:15:33,000 --> 00:15:37,000
Pirma, jūs turite sudaryti savo programą, ir tada jūs ketinate paleisti programą.

258
00:15:37,000 --> 00:15:41,000
Norėdami sudaryti savo programą, jūs turite daug galimybių tai padaryti.

259
00:15:41,000 --> 00:15:44,000
Pirmasis yra padaryti Apsukite metalinis garsas program.c

260
00:15:44,000 --> 00:15:47,000
programa, kurioje yra jūsų programos pavadinimas.

261
00:15:47,000 --> 00:15:51,000
Šiuo atveju jūs galite pamatyti, jie tiesiog sako: "Ei, sudaryti savo programą."

262
00:15:51,000 --> 00:15:56,000
Jūs nesate sakydamas: "Aš noriu šį mano programos pavadinimą" ar ką nors.

263
00:15:56,000 --> 00:15:58,000
>> Antroji galimybė vardą į savo programą.

264
00:15:58,000 --> 00:16:02,000
Apsukite metalinis garsas-galima sakyti, o ir tada vardas, kurį norite

265
00:16:02,000 --> 00:16:06,000
vykdomąjį failą bus pavadintas ir tada program.c.

266
00:16:06,000 --> 00:16:11,000
Ir jūs galite taip pat padarysiu programą, ir pamatyti, kaip per pirmuosius 2 atvejais

267
00:16:11,000 --> 00:16:15,000
Aš įdėti c, o trečiojoje dalyje turiu tik programas?

268
00:16:15,000 --> 00:16:18,000
Taip, jūs iš tikrųjų neturėtų įdėti. C, kai jūs naudojate.

269
00:16:18,000 --> 00:16:22,000
Priešingu atveju kompiliatorius iš tikrųjų vyksta klykauti ne jums.

270
00:16:22,000 --> 00:16:24,000
Ir taip pat, aš ne žinoti, jei jus vaikinai prisiminti,

271
00:16:24,000 --> 00:16:29,000
bet kartais mes taip pat naudojamas lcs50 arba lm daug.

272
00:16:29,000 --> 00:16:31,000
, Kuris yra vadinamas susiejimas.

273
00:16:31,000 --> 00:16:35,000
Jis tiesiog pasakoja kompiliatorių, kad jums naudoti šias bibliotekas teisę ten,

274
00:16:35,000 --> 00:16:39,000
, todėl, jei norite naudoti cs50.h jūs iš tikrųjų turite įvesti

275
00:16:39,000 --> 00:16:43,000
Apsukite metalinis garsas program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Jei jums nereikia daryti, kad sudarytojas nesiruošia žinoti

277
00:16:45,000 --> 00:16:50,000
kad jūs naudojate šias funkcijas cs50.h.

278
00:16:50,000 --> 00:16:52,000
Ir, jei norite paleisti programą, jūs turite 2 galimybes.

279
00:16:52,000 --> 00:16:57,000
Jei tu Apsukite metalinis garsas program.c tu negali suteikti pavadinimą, kad jūsų programa.

280
00:16:57,000 --> 00:17:01,000
Jūs turite paleisti jį naudojant / a.out.

281
00:17:01,000 --> 00:17:06,000
A.out standarto pavadinimas, kad Apsukite metalinis garsas suteikia savo programą, jei jūs neturite suteikti jai pavadinimą.

282
00:17:06,000 --> 00:17:11,000
Kitaip jūs ketinate daryti. / Programa, jei jūsų programa davė pavadinimą,

283
00:17:11,000 --> 00:17:15,000
ir taip pat, jei programos pavadinimą, kad programa yra ketinate gauti

284
00:17:15,000 --> 00:17:23,000
jau galima užprogramuoti tą patį pavadinimą kaip c failas.

285
00:17:23,000 --> 00:17:26,000
Tada mes kalbėjome apie duomenų tipus ir duomenų.

286
00:17:26,000 --> 00:17:31,000
>> Iš esmės duomenų tipai yra tas pats, kaip mažai dėžės, jie naudoja

287
00:17:31,000 --> 00:17:35,000
saugoti vertybes, todėl duomenų tipai yra iš tikrųjų kaip ir pokemons.

288
00:17:35,000 --> 00:17:39,000
Jie ateina visų dydžių ir tipų.

289
00:17:39,000 --> 00:17:43,000
Aš nežinau, jei tai analogija prasminga.

290
00:17:43,000 --> 00:17:46,000
Duomenų dydis iš tikrųjų priklauso nuo mašinų architektūros.

291
00:17:46,000 --> 00:17:49,000
Visi duomenų dydžių, kad aš ketinu parodyti čia

292
00:17:49,000 --> 00:17:53,000
iš tikrųjų yra 32-bitų mašina, kuri yra mūsų prietaiso,

293
00:17:53,000 --> 00:17:56,000
tačiau, jei jūs iš tikrųjų kodavimo savo "Mac" arba "Windows" taip pat

294
00:17:56,000 --> 00:17:59,000
tikriausiai jūs ketinate turėti 64-bitų mašina,

295
00:17:59,000 --> 00:18:03,000
todėl nepamirškite, kad duomenų dydžių, kad aš ruošiuosi parodyti čia

296
00:18:03,000 --> 00:18:06,000
32-bitų mašina.

297
00:18:06,000 --> 00:18:08,000
Pirmasis, kad mes matėme int,

298
00:18:08,000 --> 00:18:10,000
kuri yra gana paprasta.

299
00:18:10,000 --> 00:18:13,000
Galite naudoti int saugoti sveikasis skaičius.

300
00:18:13,000 --> 00:18:16,000
Taip pat matėme charakterį, char.

301
00:18:16,000 --> 00:18:20,000
Jei norite naudoti raštą ar mažai simbolis jūs tikriausiai ketina naudoti char.

302
00:18:20,000 --> 00:18:26,000
Char yra 1 baitas, o tai reiškia, 8 bitai, pavyzdžiui, Lexi sakė.

303
00:18:26,000 --> 00:18:31,000
Iš esmės mes turime ASCII lentelę, kuri turi 256

304
00:18:31,000 --> 00:18:34,000
galimų kombinacijų 0s ir 1s,

305
00:18:34,000 --> 00:18:37,000
ir tada, kai įvesite char ji ketina versti

306
00:18:37,000 --> 00:18:44,000
simbolių, kad žaliavos, jums skaičius, kad jūs turite ASCII lentelę, kaip Lexi sakė.

307
00:18:44,000 --> 00:18:48,000
Mes taip pat turime svyravimas, kurį mes naudojame saugoti dešimtainių skaičių.

308
00:18:48,000 --> 00:18:53,000
Jei norite pasirinkti 3,14, pavyzdžiui, jūs ketinate naudoti plūdę

309
00:18:53,000 --> 00:18:55,000
arba dvigubai daugiau tikslumo.

310
00:18:55,000 --> 00:18:57,000
Plūdė turi 4 baitų.

311
00:18:57,000 --> 00:19:01,000
Dvigubai turi 8 baitų, todėl vienintelis skirtumas yra tikslumas.

312
00:19:01,000 --> 00:19:04,000
Mes taip pat turime ilgai, kad su skaičiais,

313
00:19:04,000 --> 00:19:09,000
ir jūs galite pamatyti 32-bitų mašina, int ir ilgai būti tokio pat dydžio,

314
00:19:09,000 --> 00:19:13,000
, todėl ji nėra tikrai prasminga naudoti 32-bitų mašina.

315
00:19:13,000 --> 00:19:17,000
>> Bet jei jūs naudojate "Mac" ir 64-bit mašina, iš tikrųjų ilgai dydis 8,

316
00:19:17,000 --> 00:19:19,000
taip, tai tikrai priklauso nuo architektūros.

317
00:19:19,000 --> 00:19:22,000
32-bitų mašina nėra prasmės naudoti ilgai tikrai.

318
00:19:22,000 --> 00:19:25,000
Ir tada ilgai ilgai, kita vertus, yra 8 baitai,

319
00:19:25,000 --> 00:19:30,000
todėl jis yra labai gerai, jei norite turėti ilgesnį sveikasis skaičius.

320
00:19:30,000 --> 00:19:34,000
Ir, pagaliau, mes turime eilutę, kuris iš tikrųjų yra char *,

321
00:19:34,000 --> 00:19:37,000
kuris yra rodyklė į char.

322
00:19:37,000 --> 00:19:40,000
Tai labai lengva galvoti, kad eilutės dydis bus kaip

323
00:19:40,000 --> 00:19:42,000
simbolių skaičių, kad jūs turite ten,

324
00:19:42,000 --> 00:19:45,000
bet iš tikrųjų char *

325
00:19:45,000 --> 00:19:49,000
rodyklė į char, kuris yra 4 baitų dydžio.

326
00:19:49,000 --> 00:19:52,000
Char * dydis yra 4 baitų.

327
00:19:52,000 --> 00:19:56,000
Nesvarbu, jei turite mažą žodį arba raidę arba nieko.

328
00:19:56,000 --> 00:19:58,000
Tai bus 4 baitų.

329
00:19:58,000 --> 00:20:01,000
Mes taip pat sužinojome šiek tiek apie liejimą,

330
00:20:01,000 --> 00:20:04,000
, kaip jūs galite pamatyti, jei turite, pavyzdžiui, programa, kuri sako

331
00:20:04,000 --> 00:20:08,000
int x = 3 ir tada printf ("% d", x / 2)

332
00:20:08,000 --> 00:20:12,000
Ar jūs žinote, ką ji ketina atspausdinti ekrane?

333
00:20:12,000 --> 00:20:14,000
>> Kas nors? >> [Studentai] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, yeah.

335
00:20:16,000 --> 00:20:20,000
Kai jūs darote 3/2 ji ketina gauti 1,5

336
00:20:20,000 --> 00:20:24,000
bet kadangi mes naudojame sveikąjį skaičių ji ketina ignoruoti dešimtąją dalį,

337
00:20:24,000 --> 00:20:26,000
ir jūs ketinate turėti 1.

338
00:20:26,000 --> 00:20:29,000
Jei nenorite, kad taip atsitiktų, ką galite padaryti, pavyzdžiui,

339
00:20:29,000 --> 00:20:33,000
paskelbti plūdę y = x.

340
00:20:33,000 --> 00:20:40,000
Tuomet x, kurie būtų 3 dabar bus 3,000 y.

341
00:20:40,000 --> 00:20:44,000
Ir tada jūs galite spausdinti y / 2.

342
00:20:44,000 --> 00:20:50,000
Tiesą sakant, aš turėtų būti 2. ten.

343
00:20:50,000 --> 00:20:55,000
Jis ketina padaryti, 3.00/2.00

344
00:20:55,000 --> 00:20:58,000
ir jūs ketinate gauti 1,5.

345
00:20:58,000 --> 00:21:06,000
Ir mes turime šį .2 f tiesiog paklausti 2 dešimtainių vienetų dešimtąją dalį.

346
00:21:06,000 --> 00:21:12,000
Jei turite .3 f ji ketina iš tikrųjų 1,500.

347
00:21:12,000 --> 00:21:16,000
, Jei tai 2 tai bus 1,50.

348
00:21:16,000 --> 00:21:18,000
Mes taip pat turime šiuo atveju čia.

349
00:21:18,000 --> 00:21:22,000
Jei jūs darote plūdę x = 3,14 ir tada jūs printf x

350
00:21:22,000 --> 00:21:24,000
jūs ketinate gauti 3,14.

351
00:21:24,000 --> 00:21:29,000
Ir jei jūs x = x int

352
00:21:29,000 --> 00:21:34,000
, o tai reiškia, gydyti int x, kaip ir jums spausdinti X Dabar

353
00:21:34,000 --> 00:21:36,000
jūs ketinate turėti 3,00.

354
00:21:36,000 --> 00:21:38,000
Ar tai prasminga?

355
00:21:38,000 --> 00:21:41,000
Nes jūs pirmą kartą gydant x kaip sveikasis skaičius, todėl jūs ignoruojant dešimtainę dalį,

356
00:21:41,000 --> 00:21:45,000
ir tada jūs spausdinate x.

357
00:21:45,000 --> 00:21:47,000
Ir pagaliau, jums taip pat gali tai padaryti,

358
00:21:47,000 --> 00:21:52,000
int x = 65, ir tada jums paskelbti char c = x,

359
00:21:52,000 --> 00:21:56,000
ir tada, jei spausdinti c jūs iš tikrųjų ketinate gauti

360
00:21:56,000 --> 00:21:59,000
, Todėl iš esmės, ką darai čia

361
00:21:59,000 --> 00:22:02,000
versti sveikasis skaičius į simbolį,

362
00:22:02,000 --> 00:22:05,000
taip pat kaip ASCII lentelė.

363
00:22:05,000 --> 00:22:08,000
Mes taip pat kalbėjo apie matematikos operatorių.

364
00:22:08,000 --> 00:22:14,000
Dauguma jų yra gana paprasta, todėl +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
ir mes taip pat kalbėjo apie mod, kuris yra 2 numeriai skyriaus likusi.

366
00:22:20,000 --> 00:22:23,000
Jei turite 10% 3, pavyzdžiui,

367
00:22:23,000 --> 00:22:27,000
tai reiškia, kad 3 10 padalinti, ir kokia yra likusi?

368
00:22:27,000 --> 00:22:30,000
Jis ketina būti 1, todėl jis iš tikrųjų labai naudinga daug programų.

369
00:22:30,000 --> 00:22:38,000
Už Vigenere ir Cezaris, aš esu gana įsitikinęs, kad visi iš jūsų vaikinai naudojami mod.

370
00:22:38,000 --> 00:22:43,000
Apie matematikos operatorių, turi būti labai atsargūs, kai derinant * ir /.

371
00:22:43,000 --> 00:22:48,000
>> Pavyzdžiui, jei jūs (3/2) * 2 ką jūs ketinate įsigyti?

372
00:22:48,000 --> 00:22:50,000
[Studentai] 2.

373
00:22:50,000 --> 00:22:54,000
Taip, 2, nes 3/2 bus 1,5,

374
00:22:54,000 --> 00:22:57,000
bet kadangi jūs darote 2 sveikųjų skaičių operacijas tarp

375
00:22:57,000 --> 00:22:59,000
jūs iš tikrųjų tik ketina apsvarstyti 1

376
00:22:59,000 --> 00:23:03,000
ir tada 1 * 2 bus 2, todėl būkite labai, labai atsargūs,

377
00:23:03,000 --> 00:23:07,000
kai daro aritmetines operacijas su sveikaisiais skaičiais, nes

378
00:23:07,000 --> 00:23:12,000
galite gauti, kad 2 = 3, kad šioje byloje.

379
00:23:12,000 --> 00:23:14,000
, O taip pat būti labai atsargūs apie pirmumo.

380
00:23:14,000 --> 00:23:21,000
Jūs paprastai turėtų naudoti skliaustelius būti tikri, kad žinote, ką jūs darote.

381
00:23:21,000 --> 00:23:27,000
Kai kurios naudingos nuorodos, žinoma, vienas i + + arba i + = 1

382
00:23:27,000 --> 00:23:30,000
arba naudojant + =.

383
00:23:30,000 --> 00:23:34,000
Tai yra tas pats dalykas, kaip daro i = i + 1.

384
00:23:34,000 --> 00:23:39,000
Taip pat galite padaryti i - arba i = 1,

385
00:23:39,000 --> 00:23:42,000
kuris yra tas pats, kaip i = i -1,

386
00:23:42,000 --> 00:23:46,000
tai, ką jūs vaikinai naudoti daug kilpų, bent jau.

387
00:23:46,000 --> 00:23:52,000
Be to, *, jei jūs naudojate * = ir jei jūs, pavyzdžiui,

388
00:23:52,000 --> 00:23:57,000
i * = 2 yra tas pats, kaip sakydamas, i = i * 2

389
00:23:57,000 --> 00:23:59,000
ir tas pats dalykas pasidalijimas.

390
00:23:59,000 --> 00:24:08,000
Jei tai padarysite i / = 2, tai tas pats, kaip i = i / 2.

391
00:24:08,000 --> 00:24:10,000
>> Dabar apie funkcijas.

392
00:24:10,000 --> 00:24:13,000
Jus vaikinai sužinojo, kad funkcijos yra labai gera strategija išsaugoti kodą

393
00:24:13,000 --> 00:24:16,000
o jūs programavimas, todėl, jei norite atlikti tą pačią užduotį

394
00:24:16,000 --> 00:24:20,000
code vėl ir vėl, tikriausiai jūs norite naudoti funkciją

395
00:24:20,000 --> 00:24:25,000
tik tokiu būdu jūs neturite, nukopijuokite ir įklijuokite kodą, vėl ir vėl.

396
00:24:25,000 --> 00:24:28,000
Tiesą sakant, pagrindinė funkcija, ir, kai aš parodyti jums funkcijos formą

397
00:24:28,000 --> 00:24:32,000
jūs ketinate matyti, kad tai yra gana akivaizdus.

398
00:24:32,000 --> 00:24:35,000
Mes taip pat naudojame funkcijas iš kai kuriose bibliotekose,

399
00:24:35,000 --> 00:24:39,000
printf, pavyzdžiui, getin, kuris yra iš CS50 bibliotekoje,

400
00:24:39,000 --> 00:24:43,000
ir kitas funkcijas, pavyzdžiui, toupper.

401
00:24:43,000 --> 00:24:46,000
Visi iš šių funkcijų yra iš tikrųjų įgyvendinamos kitose bibliotekose,

402
00:24:46,000 --> 00:24:49,000
ir kai jūs įtraukėte tas TETHER failus jūsų programos pradžioje

403
00:24:49,000 --> 00:24:53,000
jūs sakote, Ar galite man duoti man tų funkcijų kodą

404
00:24:53,000 --> 00:24:57,000
todėl aš neturiu juos įgyvendinti pats?

405
00:24:57,000 --> 00:25:00,000
Ir taip pat galite rašyti savo funkcijas, todėl, kai jūs pradėti programavimo

406
00:25:00,000 --> 00:25:04,000
jūs suprasite, kad bibliotekos neturi visas funkcijas, kad jums reikia.

407
00:25:04,000 --> 00:25:10,000
Per pastaruosius pset, pavyzdžiui, mes parašėme piešti, scramble, ir peržvalgos,

408
00:25:10,000 --> 00:25:13,000
ir tai labai, labai svarbu, kad būtų galima rašyti funkcijas

409
00:25:13,000 --> 00:25:17,000
nes jie yra naudingi, ir mes naudojame juos visą programavimo laikotarpiui,

410
00:25:17,000 --> 00:25:19,000
ir ji taupo daug kodo.

411
00:25:19,000 --> 00:25:21,000
Funkcijos formatas yra šis.

412
00:25:21,000 --> 00:25:24,000
Mes turime grįžties tipas pradžioje. Kas yra grįžimo tipo?

413
00:25:24,000 --> 00:25:27,000
Tai tik tada, kai jūsų funkcija nesiruošia grįžti.

414
00:25:27,000 --> 00:25:29,000
Jei turite funkciją, pavyzdžiui, faktorinė,

415
00:25:29,000 --> 00:25:31,000
kad ketina apskaičiuoti sveikojo skaičiaus faktorialas,

416
00:25:31,000 --> 00:25:34,000
tikriausiai jis ketina grįžti sveikasis skaičius.

417
00:25:34,000 --> 00:25:37,000
Tada grįžti tipas bus int.

418
00:25:37,000 --> 00:25:41,000
Printf iš tikrųjų turi grįžimo tipo negaliojančiu

419
00:25:41,000 --> 00:25:43,000
, nes jūs nieko negrįžta.

420
00:25:43,000 --> 00:25:45,000
Jūs tiesiog spausdinti ką į ekraną

421
00:25:45,000 --> 00:25:48,000
ir mesti funkciją vėliau.

422
00:25:48,000 --> 00:25:51,000
Tada jūs turite funkcija, galite pasirinkti vardą.

423
00:25:51,000 --> 00:25:55,000
Jūs turite būti šiek tiek protingas, kaip nesirinkite kaip xyz pavadinimas

424
00:25:55,000 --> 00:25:58,000
arba kaip x2f.

425
00:25:58,000 --> 00:26:02,000
Stenkitės, kad pavadinimą, kuris turi prasmę.

426
00:26:02,000 --> 00:26:04,000
>> Pavyzdžiui, jei tai faktorialas, tarkim faktorialas.

427
00:26:04,000 --> 00:26:08,000
Jei tai funkcija, kuri ketina padaryti kažką, pavadinkite jomis pasinaudoti.

428
00:26:08,000 --> 00:26:11,000
Ir tada mes turime parametrus, kurie taip pat vadinamas argumentai,

429
00:26:11,000 --> 00:26:14,000
, kurie yra kaip išteklių, kad jūsų renginys turi

430
00:26:14,000 --> 00:26:17,000
iš savo kodą, atlikti savo užduotį.

431
00:26:17,000 --> 00:26:20,000
Jei norite apskaičiuoti skaičiaus faktorialas

432
00:26:20,000 --> 00:26:23,000
galbūt jums reikia turėti numerį apskaičiuoti faktorialas.

433
00:26:23,000 --> 00:26:27,000
Vienas iš argumentų, kad jūs ketinate turėti abonento numeris.

434
00:26:27,000 --> 00:26:31,000
Ir tada jis ketina kažką daryti ir grąžinti reikšmę pabaigoje

435
00:26:31,000 --> 00:26:35,000
nebent tai negalioja funkcija.

436
00:26:35,000 --> 00:26:37,000
Pažiūrėkime pavyzdį.

437
00:26:37,000 --> 00:26:40,000
Jei aš noriu parašyti funkciją, kad sumos, visus numerius sveikųjų skaičių masyvo,

438
00:26:40,000 --> 00:26:43,000
visų pirma grįžimo tipo bus int

439
00:26:43,000 --> 00:26:46,000
nes turiu sveikųjų skaičių masyvo.

440
00:26:46,000 --> 00:26:51,000
Ir tada aš ruošiuosi funkcijos pavadinimą, pavyzdžiui, sumArray

441
00:26:51,000 --> 00:26:54,000
ir tada ji ketina imtis masyvo pati, int nums,

442
00:26:54,000 --> 00:26:58,000
ir tada taip, aš žinau, kiek numeriai turiu Apibendrinant masyvo ilgis.

443
00:26:58,000 --> 00:27:02,000
Tada aš turiu inicijuoti kintamasis vadinamas sumą, pavyzdžiui, į 0,

444
00:27:02,000 --> 00:27:08,000
ir kiekvieną kartą, kai matau masyvo elementą turėčiau pridėti jį suma, todėl aš už linijos.

445
00:27:08,000 --> 00:27:15,000
Tiesiog kaip Lexi sakė, jūs padaryti int i = 0, i <ilgis ir i + +.

446
00:27:15,000 --> 00:27:20,000
Ir kiekvienas masyvo elementas aš suma + = nums [i],

447
00:27:20,000 --> 00:27:24,000
ir tada grįžau sumą, todėl tai labai paprasta, ir ji taupo daug kodo

448
00:27:24,000 --> 00:27:28,000
jei jūs naudojate šią funkciją, daug kartų.

449
00:27:28,000 --> 00:27:32,000
Tada mes priėmėme tokiomis sąlygomis, atrodo.

450
00:27:32,000 --> 00:27:38,000
Mes turime, jei kitur, ir else if.

451
00:27:38,000 --> 00:27:42,000
Pažiūrėkime, kas yra skirtumas tarp tų.

452
00:27:42,000 --> 00:27:45,000
Paimkite pažvelgti į šiuos 2 kodai. Tai, kas yra tarp jų skirtumas?

453
00:27:45,000 --> 00:27:49,000
Pirmasis iš esmės kodai nori jums pasakyti,

454
00:27:49,000 --> 00:27:51,000
jei skaičius yra +, -, arba 0.

455
00:27:51,000 --> 00:27:55,000
Pirmasis sako, kad, jei jis> 0, tada tai teigiamas.

456
00:27:55,000 --> 00:28:00,000
, Jei tai = "0", tada tai 0, ir jei jis yra <0, tada tai neigiamas.

457
00:28:00,000 --> 00:28:04,000
>> , O kitas daro, jei if, else.

458
00:28:04,000 --> 00:28:07,000
Skirtumas tarp šių dviejų yra tai, kad tai vienas iš tikrųjų ketiname

459
00:28:07,000 --> 00:28:13,000
patikrinti, ar> 0, <0 arba = 0 tris kartus,

460
00:28:13,000 --> 00:28:17,000
todėl, jei turite 2 numeriu, pavyzdžiui, ji ketina ateiti čia ir pasakyti,

461
00:28:17,000 --> 00:28:21,000
if (x> 0), ir jis ketina pasakyti "taip", todėl aš spausdinti teigiamas.

462
00:28:21,000 --> 00:28:25,000
Tačiau, nors aš žinau, kad tai> 0, ir jis nesiruošia būti 0 arba <0

463
00:28:25,000 --> 00:28:29,000
Aš vis dar ketinate daryti, tai 0, tai <0,

464
00:28:29,000 --> 00:28:33,000
todėl aš iš tikrųjų vyksta viduje IF, kad aš neturėjo

465
00:28:33,000 --> 00:28:38,000
nes aš jau žinau, kad jis nesiruošia patenkinti nors iš šių sąlygų.

466
00:28:38,000 --> 00:28:41,000
Aš galiu naudoti, jei if, else.

467
00:28:41,000 --> 00:28:45,000
Tai iš esmės sako, kad jei x = 0 spausdinti teigiamas.

468
00:28:45,000 --> 00:28:48,000
, Jei jis nėra, aš taip pat išbandyti šį.

469
00:28:48,000 --> 00:28:51,000
, Jei tai 2 ne aš ruošiuosi tai padaryti.

470
00:28:51,000 --> 00:28:54,000
Iš esmės, jei aš turėjau x = 2 galėtumėte pasakyti

471
00:28:54,000 --> 00:28:57,000
if (x> 0), taip, kad atsispausdinti šį.

472
00:28:57,000 --> 00:29:00,000
Dabar, kad aš žinau, kad jis> 0, ir kad ji įvykdė pirma, jei

473
00:29:00,000 --> 00:29:02,000
Aš net ketina paleisti šį kodą.

474
00:29:02,000 --> 00:29:09,000
Kodas veikia greičiau, iš tikrųjų, 3 kartus greičiau, jei jūs naudojate šią.

475
00:29:09,000 --> 00:29:11,000
Mes taip pat sužinojome apie ir.

476
00:29:11,000 --> 00:29:15,000
Aš nesiruošia eiti per šią, nes Lexi jau kalbėjome apie juos.

477
00:29:15,000 --> 00:29:17,000
Tai tiesiog && ir | | operatoriaus.

478
00:29:17,000 --> 00:29:21,000
>> Vienintelis dalykas, aš pasakysiu, būkite atsargūs, kai jūs turite 3 sąlygas.

479
00:29:21,000 --> 00:29:24,000
Naudokite skliaustelius, nes tai labai paini, kai sergate liga,

480
00:29:24,000 --> 00:29:27,000
ir vienas, arba dar vienas.

481
00:29:27,000 --> 00:29:30,000
Naudokite skliaustus tiesiog būti tikri, kad jūsų sąlygos prasmės

482
00:29:30,000 --> 00:29:34,000
, nes tokiu atveju, pavyzdžiui, jūs galite įsivaizduoti, kad

483
00:29:34,000 --> 00:29:38,000
tai gali būti pirmoji sąlyga ir vienas ar kitas

484
00:29:38,000 --> 00:29:41,000
arba 2 dalyje nurodytas sąlygas, kartu ir

485
00:29:41,000 --> 00:29:45,000
ir trečio, todėl tiesiog būkite atsargūs.

486
00:29:45,000 --> 00:29:48,000
Ir, pagaliau, mes kalbėjome apie jungikliai.

487
00:29:48,000 --> 00:29:53,000
Jungiklis yra labai naudinga, kai turite kintamąjį.

488
00:29:53,000 --> 00:29:55,000
Tarkime, kad turite kaip n kintamąjį

489
00:29:55,000 --> 00:29:59,000
kad gali būti 0, 1 arba 2, ir kiekvienoje iš šių bylų

490
00:29:59,000 --> 00:30:01,000
jūs ketinate atlikti užduotį.

491
00:30:01,000 --> 00:30:04,000
Galite pasakyti, pereiti kintamąjį, ir tai rodo, kad

492
00:30:04,000 --> 00:30:08,000
vertė tada yra kaip reikšmė1 aš ruošiuosi tai padaryti,

493
00:30:08,000 --> 00:30:12,000
ir tada aš pertrauka, o tai reiškia, aš nesiruošia pažvelgti į bet kitais atvejais

494
00:30:12,000 --> 00:30:15,000
nes mes jau įsitikinusi, kad bylą

495
00:30:15,000 --> 00:30:20,000
ir tada reikšmė2 ir tt, ir aš taip pat gali turėti numatytąjį jungiklį.

496
00:30:20,000 --> 00:30:24,000
Tai reiškia, jei jis neatitinka atvejų, kad turėjau

497
00:30:24,000 --> 00:30:29,000
kad aš ruošiuosi daryti ką nors kita, bet tai neprivaloma.

498
00:30:29,000 --> 00:30:36,000
Štai ir viskas man. Dabar galime Tommy.

499
00:30:36,000 --> 00:30:41,000
Viskas bus gerai, tai bus savaitė 3-ish ".

500
00:30:41,000 --> 00:30:45,000
Tai tik keletas temų, mes, apimančią koduotės, masto, matricos ir tt.

501
00:30:45,000 --> 00:30:49,000
Just a quick žodis kriptografijos. Mes neketiname su plaktuku šį namą.

502
00:30:49,000 --> 00:30:52,000
>> Mes padarėme tai pset 2, bet viktorinoje įsitikinkite, kad jums žinoti skirtumą

503
00:30:52,000 --> 00:30:54,000
tarp Cezario šifravimo ir Vigenere Šifro,

504
00:30:54,000 --> 00:30:57,000
kaip tų šifrai darbą ir tai, ką reiškia užšifruoti

505
00:30:57,000 --> 00:30:59,000
ir iššifruoti tekstą naudodami tuos 2 užkoduota.

506
00:30:59,000 --> 00:31:03,000
Atminkite, kad Cezario šifras tiesiog sukasi kiekvieną simbolį, ta pačia suma,

507
00:31:03,000 --> 00:31:06,000
tikrai mod abėcėlės raidžių skaičius.

508
00:31:06,000 --> 00:31:09,000
Ir Vigenere šifras, kita vertus, sukasi kiekvieną simbolį

509
00:31:09,000 --> 00:31:12,000
skirtingo dydžio, todėl, o ne sako

510
00:31:12,000 --> 00:31:15,000
3 Vigenere Kiekvienas personažas pasukti pasukti kiekvieną simbolį

511
00:31:15,000 --> 00:31:17,000
skirtingos dotacijos sumos, priklausomai nuo to kai kurie raktinių žodžių

512
00:31:17,000 --> 00:31:20,000
, kur kiekvienas raktinį žodį laiškas yra šiek tiek kitokį kiekį

513
00:31:20,000 --> 00:31:26,000
pasukti aiškų tekstą.

514
00:31:26,000 --> 00:31:28,000
Tegul pirmasis kalbėti apie kintamo pobūdžio.

515
00:31:28,000 --> 00:31:30,000
Yra 2 skirtingų tipų kintamaisiais.

516
00:31:30,000 --> 00:31:33,000
Mes turime vietos kintamieji, ir jie bus apibrėžta

517
00:31:33,000 --> 00:31:36,000
už pagrindinė ar ne bet kurią funkciją arba blokuoti,

518
00:31:36,000 --> 00:31:39,000
, ir tai bus prieinama bet kur savo programą.

519
00:31:39,000 --> 00:31:41,000
Jei turite funkciją ir tai veiklai yra while cikle

520
00:31:41,000 --> 00:31:44,000
didelis pasaulio kintamasis yra prieinamas visur.

521
00:31:44,000 --> 00:31:48,000
Vietos kintamąjį, o kita vertus, aprėptis, kad toje vietoje, kur ji yra apibrėžta.

522
00:31:48,000 --> 00:31:53,000
>> Jei turite funkcija čia, pavyzdžiui, mes turime šią funkciją g,

523
00:31:53,000 --> 00:31:56,000
viduje ir g yra kintamasis vadinamas y,

524
00:31:56,000 --> 00:31:58,000
, o tai reiškia, kad tai yra vietos kintamąjį.

525
00:31:58,000 --> 00:32:00,000
Nors šis kintamasis vadinamas y

526
00:32:00,000 --> 00:32:03,000
ir šis kintamasis yra vadinamas y šiuos 2 funkcijas

527
00:32:03,000 --> 00:32:06,000
neįsivaizduoju, ką vieni kitų kintamųjų.

528
00:32:06,000 --> 00:32:10,000
Kita vertus, čia mes sakome, int x = 5,

529
00:32:10,000 --> 00:32:12,000
ir tai ne bet kokią funkciją taikymo sritį.

530
00:32:12,000 --> 00:32:16,000
Tai ne pagrindinis taikymo sritį, kad tai yra pasaulio kintamasis.

531
00:32:16,000 --> 00:32:20,000
Tai reiškia, kad šių 2 funkcijų viduje, kai aš sakau, x arba x + +

532
00:32:20,000 --> 00:32:26,000
Aš prie to paties X,, kuriuo ši y tai y yra skirtingi kintamieji.

533
00:32:26,000 --> 00:32:30,000
Štai skirtumas tarp pasaulinį kintamąjį ir vietos kintamąjį.

534
00:32:30,000 --> 00:32:33,000
Kiek dizainas yra susirūpinęs, kartais tai tikriausiai geriau idėja

535
00:32:33,000 --> 00:32:37,000
išlaikyti vietos kintamieji, kai jūs galbūt galite

536
00:32:37,000 --> 00:32:39,000
nuo globalių kintamųjų krūva gali gauti tikrai paini.

537
00:32:39,000 --> 00:32:42,000
Jei turite krūva funkcijų pakeisti tą patį

538
00:32:42,000 --> 00:32:45,000
galite pamiršti, ką daryti, jei ši funkcija netyčia pakeičia šis pasaulinis,

539
00:32:45,000 --> 00:32:47,000
ir tai kitas funkcijas, nežino, apie tai,

540
00:32:47,000 --> 00:32:50,000
ir ji gauti gana paini, kaip jums daugiau kodą.

541
00:32:50,000 --> 00:32:53,000
Laikydami kintamieji vietos, kai jūs galbūt galite

542
00:32:53,000 --> 00:32:56,000
yra tik geras dizainas.

543
00:32:56,000 --> 00:33:00,000
Matricos, atminkite, kad yra tiesiog to paties tipo elementų sąrašus.

544
00:33:00,000 --> 00:33:04,000
Viduje CI negali turėti kaip 1, 2,0, sąrašą, sveiki.

545
00:33:04,000 --> 00:33:06,000
Mes tiesiog negali padaryti.

546
00:33:06,000 --> 00:33:11,000
>> Kai mes skelbiame masyvą C visi elementai turi būti to paties tipo.

547
00:33:11,000 --> 00:33:14,000
Čia aš turiu 3 sveikųjų skaičių masyvą.

548
00:33:14,000 --> 00:33:18,000
Čia aš turiu masyvo ilgis, bet jei aš tiesiog nedeklaravę šia sintakse

549
00:33:18,000 --> 00:33:21,000
kur galiu nurodyti, ką visi elementai yra ne techniškai reikia šį 3.

550
00:33:21,000 --> 00:33:25,000
Kompiliatorius yra pakankamai protingas, kad išsiaiškinti, kaip didelis masyvas turi būti.

551
00:33:25,000 --> 00:33:28,000
Dabar, kai aš noriu gauti ar nustatyti masyvo vertę

552
00:33:28,000 --> 00:33:30,000
tai yra sintaksė, kaip tai padaryti.

553
00:33:30,000 --> 00:33:33,000
Tai iš tikrųjų pakeisti antrą elementą iš masyvo, nes prisiminti,

554
00:33:33,000 --> 00:33:36,000
numeracija prasideda nuo 0, o ne 1.

555
00:33:36,000 --> 00:33:42,000
Jei aš noriu skaityti tą vertę aš galiu pasakyti kažką panašaus į int x = array [1].

556
00:33:42,000 --> 00:33:44,000
Arba, jei aš noriu nustatyti tą vertę, kaip aš darau čia,

557
00:33:44,000 --> 00:33:47,000
Galiu pasakyti, masyvas [1] = 4.

558
00:33:47,000 --> 00:33:50,000
Prieigą prie elementus savo indeksą, kad laikas

559
00:33:50,000 --> 00:33:52,000
arba jų padėtį arba kai jie yra masyve,

560
00:33:52,000 --> 00:33:57,000
ir kad sąrašas prasideda 0.

561
00:33:57,000 --> 00:34:00,000
Mes taip pat galime turėti masyvų masyvai,

562
00:34:00,000 --> 00:34:03,000
ir tai vadinama multi-dimensional masyvo.

563
00:34:03,000 --> 00:34:05,000
Kai mes turime multi-dimensional masyvo

564
00:34:05,000 --> 00:34:07,000
tai reiškia, kad mes galime turėti kažką panašaus į eilučių ir stulpelių,

565
00:34:07,000 --> 00:34:11,000
ir tai yra tik vienas būdas vizualizuoti tai ar galvoti apie tai.

566
00:34:11,000 --> 00:34:14,000
Kai turiu multi-dimensional masyvas, tai reiškia, kad aš ruošiuosi pradėti kuriems

567
00:34:14,000 --> 00:34:17,000
daugiau kaip 1 puslapis, nes jei aš turėti tinklelį

568
00:34:17,000 --> 00:34:19,000
tiesiog pasakyti, ką eilutė esate nesuteikia mums numerį.

569
00:34:19,000 --> 00:34:22,000
Tai tikrai tiesiog ketina duoti mums numerių sąrašą.

570
00:34:22,000 --> 00:34:25,000
Tarkime, turiu šio masyvo.

571
00:34:25,000 --> 00:34:30,000
Turiu masyve tinklelis, ir aš sakydamas, kad tai 2 eilučių ir 3 stulpelių,

572
00:34:30,000 --> 00:34:32,000
ir todėl tai yra vienas būdas vizualizuoti.

573
00:34:32,000 --> 00:34:37,000
Kai aš sakau, aš noriu gauti elementas [1] [2]

574
00:34:37,000 --> 00:34:41,000
tai reiškia, kad, nes jie yra eilutės ir tada stulpeliai

575
00:34:41,000 --> 00:34:44,000
Aš einu, kad pereitumėte prie 1 eilutėje, nes aš sakiau 1.

576
00:34:44,000 --> 00:34:49,000
>> Tada aš ruošiuosi atvažiuoti čia 2 skiltyje, ir aš ruošiuosi gauti vertė Vertė 6.

577
00:34:49,000 --> 00:34:51,000
Prasminga?

578
00:34:51,000 --> 00:34:55,000
Multi-vienmačių masyvų atminkite, kad yra techniškai tik masyvų masyvas.

579
00:34:55,000 --> 00:34:57,000
Mes galime turėti masyvų masyvų masyvai.

580
00:34:57,000 --> 00:35:00,000
Mes galime nesustoti, bet tikrai vienas būdas galvoti apie

581
00:35:00,000 --> 00:35:03,000
kaip tai buvo nustatyta ir tai, kas vyksta, vizualizuoti

582
00:35:03,000 --> 00:35:09,000
kaip šis tinklelis.

583
00:35:09,000 --> 00:35:12,000
Jei mes pro masyvų į funkcijas, jie ketina elgtis

584
00:35:12,000 --> 00:35:16,000
šiek tiek kitaip, nei tada, kai mes pereiname reguliariai kintamuosius, funkcijas

585
00:35:16,000 --> 00:35:18,000
kaip int ar float išlaikius.

586
00:35:18,000 --> 00:35:21,000
Kai mes pereiname int arba char arba bet kurį iš šių kitų duomenų tipų

587
00:35:21,000 --> 00:35:24,000
mes tiesiog paėmė, jei ši funkcija keičia išvaizdą

588
00:35:24,000 --> 00:35:28,000
šio kintamojo vertė, kad pokyčiai vyksta ne propaguoti

589
00:35:28,000 --> 00:35:32,000
Kviečiančiojo funkcijoms.

590
00:35:32,000 --> 00:35:35,000
Masyvo, kita vertus, kad taip atsitiks.

591
00:35:35,000 --> 00:35:39,000
Jei galiu perduoti masyvo tam tikrą funkciją, ir kad funkcijos pokyčiai, tam tikrus elementus,

592
00:35:39,000 --> 00:35:43,000
kai aš atėjau atgal į viršų funkciją, pavadino jį

593
00:35:43,000 --> 00:35:47,000
mano masyvas bus kitokie, ir kad žodynas

594
00:35:47,000 --> 00:35:50,000
yra matricos yra priimtas atsižvelgiant, kaip matysime vėliau.

595
00:35:50,000 --> 00:35:53,000
Tai susiję su kaip indikatoriniai darbą, kai šių pagrindinių duomenų tipai,

596
00:35:53,000 --> 00:35:55,000
kita vertus, yra perduodama pagal vertę.

597
00:35:55,000 --> 00:35:59,000
>> Mes galime galvoti, kad kai kurių kintamojo kopiją ir po to einančios kopijos.

598
00:35:59,000 --> 00:36:01,000
Nesvarbu, ką mes darome su tuo kintamuoju.

599
00:36:01,000 --> 00:36:06,000
Iš kurio skambinama, funkcija nebus žinoti, kad jis buvo pakeistas.

600
00:36:06,000 --> 00:36:10,000
Matricos yra tik šiek tiek skiriasi šiuo klausimu.

601
00:36:10,000 --> 00:36:13,000
Pavyzdžiui, kaip mes ką tik matė, pagrindinis yra tiesiog funkcija

602
00:36:13,000 --> 00:36:15,000
kad gali imtis 2 argumentų.

603
00:36:15,000 --> 00:36:20,000
Pirmasis argumentas, kad pagrindinė funkcija yra argc, ar daug argumentų,

604
00:36:20,000 --> 00:36:23,000
o antrasis argumentas yra vadinamas argv

605
00:36:23,000 --> 00:36:27,000
ir jie yra tikrieji šių argumentų reikšmės.

606
00:36:27,000 --> 00:36:30,000
Tarkime, aš turiu programą, pavadintą this.c,

607
00:36:30,000 --> 00:36:34,000
ir aš sakau, kad tai, ir aš ruošiuosi į komandų eilutę paleisti šią.

608
00:36:34,000 --> 00:36:38,000
Dabar kai kuriais argumentais, į savo programą pavadino tai,

609
00:36:38,000 --> 00:36:42,000
Galėčiau pasakyti kažką panašaus. / Tai yra CS 50.

610
00:36:42,000 --> 00:36:45,000
Tai, ką mes įsivaizduoti Davidas daryti kiekvieną dieną į terminalą.

611
00:36:45,000 --> 00:36:48,000
Bet dabar pagrindinė funkcija viduje tos programos

612
00:36:48,000 --> 00:36:52,000
šias vertybes, todėl argc yra 4.

613
00:36:52,000 --> 00:36:56,000
Tai gali būti šiek tiek painu, nes tikrai mes tik epizodiškai, CS 50.

614
00:36:56,000 --> 00:36:58,000
Tai tik 3.

615
00:36:58,000 --> 00:37:02,000
Bet atsiminkite, kad pirmasis elementas argv arba pirmasis argumentas

616
00:37:02,000 --> 00:37:05,000
yra pačios funkcijos pavadinimas.

617
00:37:05,000 --> 00:37:07,190
Taigi, tai reiškia, kad mes turime 4 dalykų čia,

618
00:37:07,190 --> 00:37:10,530
ir bus. / tai pirmasis elementas.

619
00:37:10,530 --> 00:37:12,970
, Ir tai bus atstovaujama eilutę.

620
00:37:12,970 --> 00:37:18,590
Tada likę elementai yra tai, ką mes įvedėte po programos pavadinimu.

621
00:37:18,590 --> 00:37:22,720
Taigi lygiai taip pat žemę, nes mes tikriausiai matė pset 2,

622
00:37:22,720 --> 00:37:28,780
prisiminti, kad 50 eilutė ≠ sveikuoju skaičiumi 50.

623
00:37:28,780 --> 00:37:32,520
Taigi mes negalime pasakyti kažką panašaus, "int x = argv 3."

624
00:37:32,520 --> 00:37:36,470
>> Kad tiesiog nėra prasmės, nes tai yra eilutė, ir tai yra sveikasis skaičius.

625
00:37:36,470 --> 00:37:38,510
Taigi, jei norite konvertuoti tarp 2, atminkite, kad mes einame į

626
00:37:38,510 --> 00:37:40,810
ši stebuklinga funkcija vadinama atoi.

627
00:37:40,810 --> 00:37:46,270
Kad mano eilutę ir grąžina sveikąjį skaičių, atstovaujama tos eilutės viduje.

628
00:37:46,270 --> 00:37:48,360
Taip, kad lengvai klaidą padaryti viktorina,

629
00:37:48,360 --> 00:37:51,590
tiesiog galvoju, kad tai bus automatiškai tinkamo tipo.

630
00:37:51,590 --> 00:37:53,860
Bet tiesiog žinau, kad jie visada bus stygos

631
00:37:53,860 --> 00:38:00,920
net jei eilutė yra tik sveikąjį skaičių ar simbolį ar apyvartinės lėšos.

632
00:38:00,920 --> 00:38:03,380
Taigi, dabar pakalbėkime apie važiavimo laikas.

633
00:38:03,380 --> 00:38:06,700
Kai mes turime visus šiuos algoritmus, kad padaryti visus šiuos crazy dalykų,

634
00:38:06,700 --> 00:38:11,580
jis tampa tikrai naudinga užduoti klausimą: "Kaip ilgai jie?"

635
00:38:11,580 --> 00:38:15,500
Mes atstovaujame, kad kažką vadinama asimptotinė notacijos.

636
00:38:15,500 --> 00:38:18,430
Taigi, tai reiškia, kad - gerai, tarkime, mes suteikiame mūsų algoritmus

637
00:38:18,430 --> 00:38:20,840
kai kurie tikrai, tikrai, tikrai didelis indėlis.

638
00:38:20,840 --> 00:38:23,840
Mes norime užduoti klausimą, "Kaip ilgai jis ketina imtis?

639
00:38:23,840 --> 00:38:26,370
Kiek žingsnių ji imsis mūsų algoritmas paleisti

640
00:38:26,370 --> 00:38:29,980
įėjimo dydžio funkcija? "

641
00:38:29,980 --> 00:38:33,080
Taigi pirmas būdas, kuriuo mes galime aprašyti vykdymo metu su dideliu O.

642
00:38:33,080 --> 00:38:35,380
Ir tai yra mūsų blogiausio atvejo veikimo laikas.

643
00:38:35,380 --> 00:38:38,590
Taigi, jei norime rūšiuoti masyvo, ir mes suteikiame mūsų algoritmas masyvą

644
00:38:38,590 --> 00:38:41,000
tai mažėjančia tvarka, kai ji turėtų būti didėjančia tvarka,

645
00:38:41,000 --> 00:38:43,130
kad bus blogiausiu atveju.

646
00:38:43,130 --> 00:38:49,800
Tai mūsų viršutinė riba ilgiausią laiką, mūsų algoritmas.

647
00:38:49,800 --> 00:38:54,740
Kita vertus, tai Ω apibūdinti geriausią "veikimo laiką.

648
00:38:54,740 --> 00:38:58,210
Taigi, jei mes suteikiame jau surūšiuoti masyvo rūšiavimo algoritmą,

649
00:38:58,210 --> 00:39:00,940
Kiek tai užtruks rūšiuoti ją?

650
00:39:00,940 --> 00:39:06,610
Ir tai, tada, aprašoma apatinė veikia laiko.

651
00:39:06,610 --> 00:39:10,980
Taigi čia yra tik keli žodžiai, kurie apibūdina tam tikrų bendrų rodymo laikus.

652
00:39:10,980 --> 00:39:13,120
Tai yra didėjančia tvarka.

653
00:39:13,120 --> 00:39:16,060
Greičiausias važiavimo laikas, mes turime vadinama konstanta.

654
00:39:16,060 --> 00:39:19,800
>> Tai reiškia, kad nesvarbu, kiek elementų mes suteikiame mūsų algoritmus,

655
00:39:19,800 --> 00:39:22,280
nesvarbu, kaip didelis mūsų masyvas yra, rūšiavimas

656
00:39:22,280 --> 00:39:26,510
arba daryti tai, ką mes darome, į masyvą visada tą pačią sumą laiko.

657
00:39:26,510 --> 00:39:30,270
Taigi, mes galime atstovauti tik su 1, kuris yra pastovus.

658
00:39:30,270 --> 00:39:32,410
Mes taip pat pažvelgė logaritminis vykdymo metu.

659
00:39:32,410 --> 00:39:34,800
Kad kažkas kaip dvejetainis paieškos yra logaritminė,

660
00:39:34,800 --> 00:39:37,140
kur mes supjaustyti per pusę, kiekvieną kartą problemą

661
00:39:37,140 --> 00:39:40,970
ir tada viskas tiesiog gauti daugiau iš ten.

662
00:39:40,970 --> 00:39:43,580
Ir jei jūs kada nors rašyti O bet kokio Faktorialaus algoritmas,

663
00:39:43,580 --> 00:39:47,850
jūs tikriausiai turėtų apsvarstyti tai, kaip savo darbo dieną.

664
00:39:47,850 --> 00:39:53,910
Kai mes lyginti rodymo laikus svarbu nepamiršti, šiuos dalykus.

665
00:39:53,910 --> 00:39:57,760
Taigi, jei aš turiu algoritmą, kad O (n), ir kažkas

666
00:39:57,760 --> 00:40:03,590
buvo O algoritmas (2n) iš tiesų, tai yra asimptotiškai ekvivalentas.

667
00:40:03,590 --> 00:40:06,590
Taigi, jei įsivaizduosime n būti didelis kaip eleventy skaičius mlrd

668
00:40:06,590 --> 00:40:13,090
todėl, kai mes palyginti kažką panašaus eleventy mlrd + 3 mlrd eleventy

669
00:40:13,090 --> 00:40:17,640
staiga, kad 3 nėra tikrai padaryti didelį skirtumą nebėra.

670
00:40:17,640 --> 00:40:20,980
Štai kodėl mes ketiname pradėti galvoti apie šiuos dalykus, būtų lygiavertė.

671
00:40:20,980 --> 00:40:24,220
Taigi dalykų, pavyzdžiui, šių konstantų čia, 2 x tai, arba pridedant 3,

672
00:40:24,220 --> 00:40:27,180
tai yra tik konstantos, ir jie ketina mesti.

673
00:40:27,180 --> 00:40:32,480
Štai kodėl visi iš šių 3 veikimo laikais yra tas pats, kaip pasakyti, kad jie yra O (n).

674
00:40:32,480 --> 00:40:37,490
Be to, jei mes turime 2 kitas paleisti kartus, tarkim, O (n ³ + 2n ²), mes gali pridėti

675
00:40:37,490 --> 00:40:42,070
+ N + 7, tada mes turime kitą veikimo laiką, kad tik O (n ³).

676
00:40:42,070 --> 00:40:46,290
Vėlgi, tai yra tas pats, nes jie - tai ne tas pats.

677
00:40:46,290 --> 00:40:49,840
Tai yra tie patys dalykai, atsiprašau. Taigi tai yra tas pats, nes

678
00:40:49,840 --> 00:40:53,090
tai n ³ ketina dominuoti šį 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Kas yra ne tas pats, jei mes paleisti kartus kaip O (n ³) ir O (n ²)

680
00:40:59,130 --> 00:41:02,820
, nes tai n ³ yra daug didesnis nei, n ².

681
00:41:02,820 --> 00:41:05,470
Taigi, jei mes turime eksponatų, staiga pradeda, kad nesvarbu,

682
00:41:05,470 --> 00:41:08,280
bet kai mes tik susijusius su faktoriais, kaip mes esame čia,

683
00:41:08,280 --> 00:41:12,810
tada jis nesiruošia reikšmės, nes jie tik ketina mesti.

684
00:41:12,810 --> 00:41:16,760
Leiskite pažvelgti į kai kuriuos algoritmus, mes matėme iki šiol atrodo

685
00:41:16,760 --> 00:41:19,260
ir kalbėti apie jų vykdymo metu.

686
00:41:19,260 --> 00:41:23,850
Pirmasis būdas ieško sąrašą, kad mes matėme, buvo linijinis paieška.

687
00:41:23,850 --> 00:41:26,950
Ir linijinio paieška įgyvendinimas yra super paprasta.

688
00:41:26,950 --> 00:41:30,490
Mes tiesiog turime sąrašą, ir mes ketiname pažvelgti į kiekvieno elemento sąraše

689
00:41:30,490 --> 00:41:34,260
kol mes rasti numerį mes ieškome.

690
00:41:34,260 --> 00:41:38,370
Taigi, tai reiškia, kad blogiausiu atveju, tai O (n).

691
00:41:38,370 --> 00:41:40,860
Ir blogiausiu atveju čia galėtų būti, jei elementas yra

692
00:41:40,860 --> 00:41:45,710
paskutinis elementas, tada tiesinio paiešką, mes turime pažvelgti į kiekvieno elemento

693
00:41:45,710 --> 00:41:50,180
kol mes iki paskutinės tam, kad žinoti, kad jis iš tikrųjų buvo sąraše.

694
00:41:50,180 --> 00:41:52,910
Mes negalime tiesiog atsisakyti pusės ir sako, "Tai tikriausiai nėra".

695
00:41:52,910 --> 00:41:55,980
Su tiesiniu paieška turime pažvelgti į visa tai.

696
00:41:55,980 --> 00:41:59,090
Geriausiu atveju veikimo laikas, kita vertus, yra pastovus

697
00:41:59,090 --> 00:42:04,200
nes geriausiu atveju mes ieškome elementas yra tik pirmasis sąraše.

698
00:42:04,200 --> 00:42:08,930
Todėl ji ketina imtis mums lygiai 1 lygio, nesvarbu, kaip didelis sąrašas

699
00:42:08,930 --> 00:42:12,140
jei mes ieškome pirmojo elemento kiekvieną kartą.

700
00:42:12,140 --> 00:42:15,390
>> Taigi, kai jums ieškoti, atminkite, kad ji nereikalauja, kad mūsų sąrašas būti rūšiuojami.

701
00:42:15,390 --> 00:42:19,430
Nes mes tiesiog vyksta ieškoti per kiekvieno elemento, ir tai tikrai ne klausimas,

702
00:42:19,430 --> 00:42:23,560
kas, kad šios sudedamosios dalys yra.

703
00:42:23,560 --> 00:42:28,110
Daugiau pažangių paieškos algoritmas kažką panašaus dvejetainis paieškos.

704
00:42:28,110 --> 00:42:31,500
Atminkite, kad įgyvendinimas yra dvejetainis paieškos, kai jūs ketinate

705
00:42:31,500 --> 00:42:34,320
nuolat ieško sąrašo viduryje.

706
00:42:34,320 --> 00:42:38,000
Ir todėl, kad mes ieškome ne viduryje, mes reikalaujame, kad sąrašas surūšiuotas

707
00:42:38,000 --> 00:42:40,580
kitaip mes ne žinoti, kur viduryje yra, ir mes turime pažvelgti per

708
00:42:40,580 --> 00:42:44,480
Visą sąrašą, jį rasti, ir tada tuo momentu mes tiesiog eikvoti laiko.

709
00:42:44,480 --> 00:42:48,480
Taigi, jei mes turime surūšiuoti sąrašą, ir mes manome viduryje, mes ketiname palyginti viduryje

710
00:42:48,480 --> 00:42:51,590
prie elemento, kurį mes ieškome.

711
00:42:51,590 --> 00:42:54,640
Jei jis per didelis, tada mes galime pamiršti, dešinėje pusėje

712
00:42:54,640 --> 00:42:57,810
nes žinome, kad, jei mūsų elementas jau yra per didelis

713
00:42:57,810 --> 00:43:01,080
ir viskas, dešinėje šio elemento pusėje yra dar didesnis,

714
00:43:01,080 --> 00:43:02,760
tada mums nereikia ieškoti ten nebėra.

715
00:43:02,760 --> 00:43:05,430
Jei, kita vertus, jei mūsų elementas yra per mažas,

716
00:43:05,430 --> 00:43:08,700
mes žinome viską, kad šio elemento kairėje yra pernelyg žemas,

717
00:43:08,700 --> 00:43:11,390
, todėl ji nėra tikrai prasmės ieškoti ten, arba.

718
00:43:11,390 --> 00:43:15,760
Tokiu būdu, kiekviename žingsnyje ir kiekvieną kartą, kai mes žiūrime į sąrašo Mediana,

719
00:43:15,760 --> 00:43:19,060
mes ketiname sumažinti mūsų problemą per pusę, nes staiga mes žinome,

720
00:43:19,060 --> 00:43:23,040
visa krūva skaičių, kuris negali būti vienas, mes ieškome.

721
00:43:23,040 --> 00:43:26,950
>> Į pseudocode tai atrodytų kažką panašaus į tai,

722
00:43:26,950 --> 00:43:30,990
ir todėl, kad mes per pusę kiekvieną kartą, pjovimo sąrašą

723
00:43:30,990 --> 00:43:34,920
mūsų blogiausiu atveju skaičiuoti laiką šokinėja nuo linijinių logaritmas.

724
00:43:34,920 --> 00:43:39,260
Taip staiga mes turime prisijungimo etapų nustatymu siekiant rasti sąrašo elementą.

725
00:43:39,260 --> 00:43:42,460
Geriausiu atveju veikimo laikas, nors tai, nekintančiomis

726
00:43:42,460 --> 00:43:45,180
nes dabar, tegul tiesiog pasakyti, kad mes ieškome elementas

727
00:43:45,180 --> 00:43:48,380
visada tiksli viduryje į pirmąjį sąrašą.

728
00:43:48,380 --> 00:43:52,080
Taigi, mes galime augti mūsų sąrašą kaip dideli, kaip mes norime, tačiau, jei elementas, mes ieškome yra viduryje,

729
00:43:52,080 --> 00:43:54,910
vienintelė 1 žingsnis

730
00:43:54,910 --> 00:44:00,920
Štai kodėl mes O (log n), o Ω (1) arba nuolatinis.

731
00:44:00,920 --> 00:44:04,510
Leiskite paleisti dvejetainis paiešką šiame sąraše.

732
00:44:04,510 --> 00:44:08,020
Taigi, tarkime, kad mes ieškome elemento 164.

733
00:44:08,020 --> 00:44:11,650
Pirmas dalykas, kurį mes ketiname padaryti yra rasti šiame sąraše įpusėjo.

734
00:44:11,650 --> 00:44:15,060
Jis tiesiog taip atsitinka, kad viduryje ketina patenka tarp šių 2 numeriai,

735
00:44:15,060 --> 00:44:18,960
todėl galime tik savavališkai, kiekvieną kartą, viduryje yra tarp 2 numeriai,

736
00:44:18,960 --> 00:44:21,150
tegul tik suapvalinti.

737
00:44:21,150 --> 00:44:24,330
Mes tiesiog reikia įsitikinti, kad mes tai darome kiekvieną žingsnį kelyje.

738
00:44:24,330 --> 00:44:29,040
Taigi, mes ketiname suapvalinti, ir mes ketiname pasakyti, kad 161 yra mūsų sąraše viduryje.

739
00:44:29,040 --> 00:44:34,640
Taigi 161 <164, ir kiekvienas elementas su 161 kairėje

740
00:44:34,640 --> 00:44:39,120
taip pat yra <164, todėl mes žinome, kad ji nesiruošia padėti mums ne visi

741
00:44:39,120 --> 00:44:42,690
pradėti ieškoti čia, nes elementas mes ieškome negali būti ten.

742
00:44:42,690 --> 00:44:47,060
Taigi, ką mes galime padaryti, mes galime tiesiog pamiršti apie tą visą kairę pusę sąrašo,

743
00:44:47,060 --> 00:44:51,700
ir dabar tik atsižvelgti į dešinę iš 161 tolyn.

744
00:44:51,700 --> 00:44:54,050
>> Taigi dar kartą, tai viduryje, galime tik suapvalinti.

745
00:44:54,050 --> 00:44:56,260
Dabar 175 yra per didelis.

746
00:44:56,260 --> 00:44:59,180
Taigi mes žinome, jis nesiruošia padėti mums čia arba čia,

747
00:44:59,180 --> 00:45:06,610
todėl mes galime tiesiog mesti, kad toli, ir, galiausiai, mes nukentėjo 164.

748
00:45:06,610 --> 00:45:10,560
Klausimų apie dvejetainis paieškos?

749
00:45:10,560 --> 00:45:14,180
Pereikime ieškoti per jau rūšiuotų sąrašą

750
00:45:14,180 --> 00:45:17,660
iš tikrųjų numerių sąrašą, bet kokia tvarka

751
00:45:17,660 --> 00:45:20,960
ir šį sąrašą didėjančia tvarka.

752
00:45:20,960 --> 00:45:24,060
Pirmas algoritmas, mes pažvelgė buvo vadinamas burbulas rūšiuoti.

753
00:45:24,060 --> 00:45:27,300
Ir tai būtų paprastesnis algoritmų, mes matėme.

754
00:45:27,300 --> 00:45:32,970
Burbulas tarsi sako, kad kai bet viduje sąraše yra 2 elementai iš vietos,

755
00:45:32,970 --> 00:45:36,500
yra didesnis skaičius mažesniu skaičiumi kairėje,

756
00:45:36,500 --> 00:45:40,190
tada mes ketiname apsikeitimo juos, nes tai reiškia, kad sąrašas bus

757
00:45:40,190 --> 00:45:42,860
"Daugiau surūšiuoti", nei jis buvo anksčiau.

758
00:45:42,860 --> 00:45:45,180
Ir mes tik ketina tęsti šį procesą vėl ir vėl ir vėl

759
00:45:45,180 --> 00:45:52,100
kol galiausiai burbulas į teisingą jų vietą elementai natūra ir mes turime surūšiuoti sąrašą.

760
00:45:52,100 --> 00:45:57,230
>> Vykdymo metu tai bus O (n ²). Kodėl?

761
00:45:57,230 --> 00:46:00,370
Gerai, nes blogiausiu atveju, mes ketiname imtis kiekvienas elementas, ir

762
00:46:00,370 --> 00:46:04,570
mes ketiname baigti, lyginant jį su kiekvieno kito elemento sąraše.

763
00:46:04,570 --> 00:46:08,030
Tačiau geriausiu atveju, mes turime jau surūšiuoti sąrašą, burbulas rūšiuoti

764
00:46:08,030 --> 00:46:12,230
tiesiog eiti per vieną kartą pasakyti "Ne aš nepadarė jokių apsikeitimo sandorius, todėl aš padariau".

765
00:46:12,230 --> 00:46:17,410
Taigi, mes turime geriausiu atveju veikimo laiką Ω (n).

766
00:46:17,410 --> 00:46:20,680
Leiskite paleisti burbulas rūšiuoti sąrašą.

767
00:46:20,680 --> 00:46:23,560
Arba pirmiausia, galime tiesiog pažvelgti į kai pseudocode tikrai greitai.

768
00:46:23,560 --> 00:46:28,160
Mes norime pasakyti, kad mes norime sekti kiekvieną kilpa iteracijos,

769
00:46:28,160 --> 00:46:32,190
sekti, ar mes pakeitėme jokių elementų.

770
00:46:32,190 --> 00:46:37,610
Taigi priežasties, kad yra, mes ketiname sustoti, kai mes ne pavertė jokių elementų.

771
00:46:37,610 --> 00:46:41,980
Taigi mūsų kilpos pradžios mes ne pavertė nieko, todėl mes pasakyti, kad klaidinga.

772
00:46:41,980 --> 00:46:47,170
Dabar mes ketiname eiti per sąrašą ir palyginkite i, kad elementas i + 1 elementas

773
00:46:47,170 --> 00:46:50,310
ir jei jis yra, kad yra didesnis skaičius į kairę mažesnio skaičiaus,

774
00:46:50,310 --> 00:46:52,310
tada mes tik ketina apsikeitimo juos.

775
00:46:52,310 --> 00:46:54,490
>> Ir tada mes ketiname prisiminti, kad mes pavertė elementas.

776
00:46:54,490 --> 00:46:58,900
Tai reiškia, kad turime eiti per sąrašą bent 1 kartą

777
00:46:58,900 --> 00:47:02,160
nes būklė, kai mes sustojome, kai visa sąrašas jau yra surūšiuoti,

778
00:47:02,160 --> 00:47:04,890
tai reiškia, mes neatliekame jokių apsikeitimo sandorius.

779
00:47:04,890 --> 00:47:09,960
Štai kodėl mūsų sąlyga žemyn čia yra ", o kai kurie elementai buvo pavertė".

780
00:47:09,960 --> 00:47:13,720
Taigi, dabar galime tik pažvelgti į tai veikia sąrašo.

781
00:47:13,720 --> 00:47:16,640
Turiu sąrašą 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Burbulas rūšiuoti ketina pradėti visą kelią kairėje, ir tai vyksta palyginti

783
00:47:19,850 --> 00:47:24,700
i elementai, kad nuo 0 iki i + 1, kuris yra elementas 1.

784
00:47:24,700 --> 00:47:29,020
Jis ketina pasakyti, bei 5> 0, bet dabar 5 yra kairėje,

785
00:47:29,020 --> 00:47:32,500
todėl man reikia sukeisti 5 ir 0.

786
00:47:32,500 --> 00:47:35,470
Kai aš apsikeitimo juos, staiga gauti šią kitą sąrašą.

787
00:47:35,470 --> 00:47:38,260
Dabar 5> 1, tai mes ketiname apsikeitimo juos.

788
00:47:38,260 --> 00:47:42,160
5 nėra> 6, todėl mums nereikia nieko daryti, čia.

789
00:47:42,160 --> 00:47:46,690
Bet 6> 4, todėl mums reikia sukeisti.

790
00:47:46,690 --> 00:47:49,740
Vėlgi, mes turime paleisti per visą sąrašą, kad galų gale atrasti

791
00:47:49,740 --> 00:47:52,330
, kad tai yra ne iš eilės, mes apsikeitimo juos,

792
00:47:52,330 --> 00:47:57,120
, ir šiuo metu mes turime paleisti per sąrašą 1 daugiau laiko

793
00:47:57,120 --> 00:48:05,390
įsitikinti, kad viskas savo nutartyje, ir šiuo metu burbulas rūšiuoti baigė.

794
00:48:05,390 --> 00:48:10,720
Kitą algoritmą, atsižvelgiant į kai kuriuos elementus ir rūšiavimas jų atranka yra rūšiuoti.

795
00:48:10,720 --> 00:48:15,740
Už atrankos rūšiuoti idėja yra ta, kad mes ketiname sukurti surūšiuoti sąrašo dalį

796
00:48:15,740 --> 00:48:18,150
1 elementas vienu metu.

797
00:48:18,150 --> 00:48:23,170
>> Ir tai, kaip mes ketiname daryti, kad kuriant kairįjį sąrašo segmentą.

798
00:48:23,170 --> 00:48:27,510
Ir iš esmės, kiekvienas kiekvieną žingsnį, mes ketiname imtis mažiausią elementą, mes palikome

799
00:48:27,510 --> 00:48:32,310
, kurie nebuvo surūšiuoti dar ir mes ketiname perkelti jį į tą rūšiuotų segmento.

800
00:48:32,310 --> 00:48:35,850
Tai reiškia, kad mes turime nuolat rasti mažiausią nerūšiuotų elementas

801
00:48:35,850 --> 00:48:40,720
ir tada imtis, kad minimalų elementą ir apsikeitimo jį su bet kokia

802
00:48:40,720 --> 00:48:45,090
kairės labiausiai elementas, kuris yra surūšiuoti.

803
00:48:45,090 --> 00:48:50,890
Paleisti laikas bus O (n ²), nes blogiausiu atveju

804
00:48:50,890 --> 00:48:55,070
reikia palyginti Kiekvienas elementas kiekvieno kito elemento.

805
00:48:55,070 --> 00:48:59,250
Nes mes sakydamas, kad jei mes pradėsime kairėje sąrašo pusėje, mes turime

806
00:48:59,250 --> 00:49:02,970
eiti per visą dešiniajame segmente rasti mažiausią elementą.

807
00:49:02,970 --> 00:49:05,430
Ir tada vėl, mes turime eiti per visą tinkamą segmente ir

808
00:49:05,430 --> 00:49:08,210
nuolat vyksta per daugiau ir daugiau ir daugiau vėl.

809
00:49:08,210 --> 00:49:11,350
Tai bus n ². Mes ketiname reikia kilpa viduje kitos kilpos

810
00:49:11,350 --> 00:49:13,350
kuris rodo, n ².

811
00:49:13,350 --> 00:49:16,530
Geriausiu atveju minties, tarkim, mes suteikiame jai jau surūšiuoti sąrašą;

812
00:49:16,530 --> 00:49:19,270
mes iš tikrųjų nereikia daryti, bet geriau nei n ².

813
00:49:19,270 --> 00:49:21,730
Kadangi pasirinkimas rūšiuoti neturi žinoti, kad

814
00:49:21,730 --> 00:49:25,540
minimalus elementas yra tik vienas aš atsitiktų būti ieškote.

815
00:49:25,540 --> 00:49:28,970
Tačiau vis dar reikia įsitikinti,, kad iš tikrųjų tai yra minimalus.

816
00:49:28,970 --> 00:49:31,670
>> Ir vienintelis būdas įsitikinti, kad ji yra minimali, naudojant šį algoritmą,

817
00:49:31,670 --> 00:49:34,640
dar kartą pažvelgti į kiekvieno elemento.

818
00:49:34,640 --> 00:49:38,420
Ir tikrai, jei jūs suteikiate jai - jei jūs suteikiate ATRANKA rūšiavimas jau surūšiuoti sąrašą,

819
00:49:38,420 --> 00:49:42,720
ji nesiruošia padaryti, bet geriau nei suteikiant jai sąrašą, kuris dar nėra rūšiuojamos.

820
00:49:42,720 --> 00:49:46,320
Beje, jei tai atsitinka būti, kad kažkas yra O (kažkas)

821
00:49:46,320 --> 00:49:50,640
ir omega apie kažką, mes galime tik pasakyti, daugiau glaustai, kad tai θ apie kažką.

822
00:49:50,640 --> 00:49:52,760
Taigi, jei matote, kad sugalvoti bet kur, kad tai, ką, kad tik reiškia.

823
00:49:52,760 --> 00:49:57,580
>> Jei kažkas yra teta n ², tai yra tiek didelis O (n ²) ir Ω (n ²).

824
00:49:57,580 --> 00:49:59,790
Taigi geriausiu atveju ir blogiausiu atveju, tai nereiškia, kad skirtumas,

825
00:49:59,790 --> 00:50:04,400
algoritmas ketinate daryti tą patį kiekvieną kartą.

826
00:50:04,400 --> 00:50:06,610
Taigi tai yra kokio Pseudocode atrankos rūšiuoti galėtų atrodyti.

827
00:50:06,610 --> 00:50:10,630
Mes iš esmės ketinate pasakyti, kad aš noriu, kad keistumėte sąrašą

828
00:50:10,630 --> 00:50:15,180
iš kairės į dešinę, ir kiekvieną kilpa iteracijos, aš ketina perkelti

829
00:50:15,180 --> 00:50:19,780
minimalus elementas į šį rūšiuotų sąrašo dalį.

830
00:50:19,780 --> 00:50:23,260
Ir kai aš perkelti kažkas ten, aš niekada reikia iš naujo pažvelgti į šio elemento.

831
00:50:23,260 --> 00:50:28,600
Nes kaip tik aš apsikeitimo elementas, į kairę sąrašo segmente, tai rūšiuojamos

832
00:50:28,600 --> 00:50:32,600
nes mes darome viską, didėjančia tvarka naudojant minimum.

833
00:50:32,600 --> 00:50:38,740
Taigi, mes sakėme, gerai, mes i padėtyje, ir mes turime pažvelgti į visus elementus,

834
00:50:38,740 --> 00:50:42,260
i teise produktais tam kad rasti minimumą.

835
00:50:42,260 --> 00:50:46,150
Taigi, tai reiškia, kad mes norime pažvelgti i + 1 į sąrašo pabaigoje.

836
00:50:46,150 --> 00:50:51,610
Ir dabar, jei elementas, kad mes šiuo metu ieško yra mažesnis nei minimalus iki šiol,

837
00:50:51,610 --> 00:50:54,190
atminkite, kad mes pradėti minimalią off tiesiog būti

838
00:50:54,190 --> 00:50:57,020
kokia elementas mes šiuo metu, aš manyti, kad yra minimali.

839
00:50:57,020 --> 00:51:00,270
Jei aš rasti elementą, kad mažesnis nei, tada aš ketina pasakyti, gerai,

840
00:51:00,270 --> 00:51:02,700
gerai, aš rasiu naują minimumą.

841
00:51:02,700 --> 00:51:06,080
Aš ruošiuosi prisiminti, kur ši minimali riba buvo.

842
00:51:06,080 --> 00:51:09,560
>> Taigi dabar, kai aš atvyko per tą dešinėje nerūšiuotų segmente,

843
00:51:09,560 --> 00:51:16,690
Galiu pasakyti, kad aš ruošiuosi apsikeitimo minimalų elementą su elementu, kuris yra i padėtyje.

844
00:51:16,690 --> 00:51:21,100
Kad ketina sukurti savo sąrašą, mano surūšiuoti dalis sąrašo iš kairės į dešinę,

845
00:51:21,100 --> 00:51:25,190
ir mes neturime kada nors reikės ieškoti elemento dar kartą, kai jis yra tos dalies.

846
00:51:25,190 --> 00:51:27,930
Kai mes pavertė jį.

847
00:51:27,930 --> 00:51:30,260
Todėl galime paleisti atrankos rūšiuoti į šį sąrašą.

848
00:51:30,260 --> 00:51:38,220
Mėlyna elementas čia bus i ir raudona elementas bus minimalus elementas.

849
00:51:38,220 --> 00:51:41,570
Taigi, aš prasideda visą kelią sąrašo kairėje, todėl 5.

850
00:51:41,570 --> 00:51:44,610
Dabar mums reikia rasti mažiausią nerūšiuotų elementas.

851
00:51:44,610 --> 00:51:49,480
Taigi, mes galime pasakyti, kad 0 <5 0 yra mano naujas minimalus.

852
00:51:49,480 --> 00:51:53,820
>> Bet aš negaliu sustoti, nes nors mes galime pripažinti, kad 0 yra mažiausias,

853
00:51:53,820 --> 00:51:59,390
mes turime paleisti per sąrašą ir įsitikinkite, kiekvieno kito elemento.

854
00:51:59,390 --> 00:52:01,760
So 1 yra didesnis, 6 yra didesnis, 4 dalis, yra didesnis.

855
00:52:01,760 --> 00:52:05,850
Tai reiškia, kad po to, kai žiūri į visus šiuos elementus, aš pasiryžęs 0 yra mažiausias.

856
00:52:05,850 --> 00:52:09,800
Taigi, aš ruošiuosi sukeisti 5 ir 0.

857
00:52:09,800 --> 00:52:15,480
Kai aš apsikeitimo sandorius, kurie, aš ruošiuosi gauti naują sąrašą, ir aš žinau, kad niekada nereikia vėl pažvelgti kad 0

858
00:52:15,480 --> 00:52:19,380
nes kai aš pavertė jį aš surūšiuoti jį ir baigsime.

859
00:52:19,380 --> 00:52:22,730
Dabar jis tiesiog taip atsitinka, kad mėlyna elementas vėl 5,

860
00:52:22,730 --> 00:52:26,030
ir mes turime pažvelgti į 1, 6 ir 4 nustatyti, kad: 1

861
00:52:26,030 --> 00:52:31,520
yra mažiausias minimalus elementas, todėl mes apsikeitimo 1 ir 5.

862
00:52:31,520 --> 00:52:36,890
Vėlgi, mes turime pažvelgti į - palyginti 5 6 ir 4,

863
00:52:36,890 --> 00:52:39,830
ir mes ketiname apsikeitimo 4 ir 5, ir, pagaliau, palyginti

864
00:52:39,830 --> 00:52:45,740
tie 2 numeriai ir apsikeitimo juos, kol mes gauti mūsų surūšiuoti sąrašą.

865
00:52:45,740 --> 00:52:49,730
Klausimų dėl atrankos Rūšiuoti?

866
00:52:49,730 --> 00:52:56,420
Gerai. Pereikime iki paskutinės tema čia, ir tai yra rekursija.

867
00:52:56,420 --> 00:52:59,810
>> Rekursija atminkite, kad tai tikrai meta dalykas, kai funkcija

868
00:52:59,810 --> 00:53:02,740
keletą kartų raginama pati.

869
00:53:02,740 --> 00:53:05,620
Taigi, tam tikru momentu, o mūsų fuction pakartotinai ragina save,

870
00:53:05,620 --> 00:53:10,100
ten turi būti tam tikra vieta, kurioje mes sustabdyti skambinate save.

871
00:53:10,100 --> 00:53:13,670
Nes jei mes nedarome, kad, tada mes tik ketina toliau tai daryti amžinai,

872
00:53:13,670 --> 00:53:16,660
ir mūsų programa yra tik nesiruošia nutraukti.

873
00:53:16,660 --> 00:53:19,200
Mes vadiname atveju ši sąlyga bazė.

874
00:53:19,200 --> 00:53:22,570
Ir bazinį scenarijų, sako, o ne dar kartą paskambinus funkciją,

875
00:53:22,570 --> 00:53:25,330
Aš tik ketina grįžti tam tikrą vertę.

876
00:53:25,330 --> 00:53:28,080
Taigi, kai mes grįžo vertę, mes sustabdysime paskambinus save,

877
00:53:28,080 --> 00:53:32,550
ir mes iki šiol buvo skambučius poilsio taip pat gali grįžti.

878
00:53:32,550 --> 00:53:36,050
Priešingas bazine rekursinis atveju.

879
00:53:36,050 --> 00:53:39,050
Ir tai yra, kai mes norime, kad kitą skambutį funkciją, kurią mes šiuo metu in

880
00:53:39,050 --> 00:53:44,690
Ir tikriausiai, nors ne visada, nori naudoti skirtingus argumentus.

881
00:53:44,690 --> 00:53:48,940
>> Taigi, jei mes turime funkcija vadinama f ir f tiesiog vadinamas 1 argumentą,

882
00:53:48,940 --> 00:53:52,010
ir mes tiesiog paskambinę F (1), F (1), F (1), ir jis tiesiog taip atsitinka, kad

883
00:53:52,010 --> 00:53:56,510
argumentas, 1 patenka į rekursinis atveju, mes dar niekada nesiruošia sustoti.

884
00:53:56,510 --> 00:54:01,620
Net jei mes turime bazinę atveju, mes turime padaryti tikri, kad ilgainiui mes einame, kad pasiektų šį bazinį scenarijų.

885
00:54:01,620 --> 00:54:04,250
Mes ne tik nuolat lankantis šioje grįžtamojo atveju.

886
00:54:04,250 --> 00:54:09,870
Paprastai, kai mes vadiname save, mes tikriausiai bus turėti skirtingą argumentas kiekvieną kartą.

887
00:54:09,870 --> 00:54:12,700
Rekursinis funkcija yra tikrai paprasta.

888
00:54:12,700 --> 00:54:15,090
Todėl tai bus apskaičiuoti skaičiaus faktorialas.

889
00:54:15,090 --> 00:54:17,790
Iki viršaus čia mes turime bazinį scenarijų.

890
00:54:17,790 --> 00:54:22,330
Tuo atveju, kad n ≤ 1, mes nesiruošia skambinti faktorialas vėl.

891
00:54:22,330 --> 00:54:26,490
Mes ketiname sustabdyti, mes tiesiog ketina grįžti tam tikrą vertę.

892
00:54:26,490 --> 00:54:30,170
Jei tai nėra tiesa, tada mes ketiname smūgį rekursinis bylą.

893
00:54:30,170 --> 00:54:33,550
Pastebėsite čia, kad mes ne tik paskambinus faktorialas (n), nes tai nebūtų labai naudinga.

894
00:54:33,550 --> 00:54:36,810
Mes ketiname skambinti faktorialas apie ką nors kita.

895
00:54:36,810 --> 00:54:40,850
>> Ir todėl jūs galite pamatyti, galų gale, jei mes pereiname Factorial (5) ar kažką,

896
00:54:40,850 --> 00:54:45,900
mes ketiname skambinti faktorialas (4) ir tt, ir galiausiai mes ketiname pataikyti į šį bazinį scenarijų.

897
00:54:45,900 --> 00:54:51,730
Taigi tai gerai atrodo. Pažiūrėkime, kas atsitinka, kai mes iš tikrųjų paleisti.

898
00:54:51,730 --> 00:54:57,840
Tai kamino, ir tarkime, kad pagrindinis ketina iškviesti šią funkciją su argumentais (4).

899
00:54:57,840 --> 00:55:02,200
Taigi, kai faktorialas mato ir = 4, faktorialas kreipsis.

900
00:55:02,200 --> 00:55:05,010
, Staiga, dabar mes turime faktorialas (3).

901
00:55:05,010 --> 00:55:10,780
Taigi šios funkcijos yra nuolat auga, kol galiausiai mes Hit mūsų bazės bylą.

902
00:55:10,780 --> 00:55:17,830
Gražinama reikšmė yra šiuo metu, grąža (nx gražinama reikšmė),

903
00:55:17,830 --> 00:55:21,290
grąžina vertė yra tai nx gražinama reikšmė.

904
00:55:21,290 --> 00:55:23,290
Galiausiai mums reikia, kad pasiektų tam tikrą skaičių.

905
00:55:23,290 --> 00:55:26,560
Viršuje čia, mes sakome, return 1.

906
00:55:26,560 --> 00:55:30,650
Tai reiškia, kad, kai mes grįžtame šį skaičių, mes galime pop prie kamino.

907
00:55:30,650 --> 00:55:36,570
Taigi tai faktorialas (1) daroma.

908
00:55:36,570 --> 00:55:41,190
Kai 1 deklaracijos, tai factorial (1) deklaracijos, šią deklaraciją iki 1.

909
00:55:41,190 --> 00:55:46,910
Gražinama reikšmė to, atminkite, kad nx gražinama reikšmė.

910
00:55:46,910 --> 00:55:50,720
Taip staiga, šis vaikinas žino, kad aš noriu grįžti 2.

911
00:55:50,720 --> 00:55:55,910
>> Taigi prisiminti, grįžti, vertė yra tai, tik nx gražinama reikšmė čia.

912
00:55:55,910 --> 00:56:01,160
Taigi dabar mes galime pasakyti 3 x 2, ir, pagaliau, čia galime sakyti,

913
00:56:01,160 --> 00:56:04,010
tai tiesiog bus 4 x 3 x 2.

914
00:56:04,010 --> 00:56:09,570
Ir vieną kartą Tai grąžina, mes gauname vieną sveikojo skaičiaus viduje pagrindinis.

915
00:56:09,570 --> 00:56:15,460
Bet kokie klausimai dėl rekursijos?

916
00:56:15,460 --> 00:56:17,090
Gerai. Taigi čia daugiau laiko klausimus pabaigoje,

917
00:56:17,090 --> 00:56:23,360
bet dabar Juozapas apims likusius temų.

918
00:56:23,360 --> 00:56:25,590
>> [Džozefas Ong] Gerai. Taigi dabar, kad mes kalbėjome apie recursions

919
00:56:25,590 --> 00:56:27,840
pakalbėkime šiek tiek apie tai, ką sujungti rūšiuoti.

920
00:56:27,840 --> 00:56:31,740
Sujungti tarsi iš esmės kita numerių sąrašą rūšiavimo būdas.

921
00:56:31,740 --> 00:56:36,430
Ir kaip ji veikia, sujungti rūšiuoti turite sąrašą, ir tai, ką mes darome, yra

922
00:56:36,430 --> 00:56:39,120
mes sakome, Maksāsim tai į 2 dalis.

923
00:56:39,120 --> 00:56:42,750
Mes pirmą kartą paleidus sujungti rūšiuoti vėl į kairę pusę,

924
00:56:42,750 --> 00:56:45,040
tada mes paleisti sujungti rūšiuoti dešinėje pusėje,

925
00:56:45,040 --> 00:56:50,240
ir tai suteikia mums dabar 2 puses, kurie yra surūšiuoti, ir dabar mes kartu sujungti šias puses.

926
00:56:50,240 --> 00:56:55,010
Tai šiek tiek sunku įsivaizduoti, be Pavyzdžiui, kad mes pereiti per judesius ir pamatyti, kas atsitiks.

927
00:56:55,010 --> 00:56:59,590
Taigi, pradėdami šį sąrašą, mes padalinti į 2 dalis.

928
00:56:59,590 --> 00:57:02,300
Mes valdome Merge sort kairę pusę.

929
00:57:02,300 --> 00:57:06,660
Taip, kad kairėje pusėje, ir dabar mes vėl paleisti juos per šį sąrašą

930
00:57:06,660 --> 00:57:09,800
kuri pasireiškia patenka į Merge sort ir tada mums atrodo, vėl,

931
00:57:09,800 --> 00:57:13,270
kairėje pusėje šio sąrašo ir mes paleisti sujungti rūšiuoti.

932
00:57:13,270 --> 00:57:15,880
Dabar mes kibti į sąrašą 2 numeriai,

933
00:57:15,880 --> 00:57:19,010
ir dabar yra kairėje pusėje yra tik 1 elementas ilgai, ir mes negalime

934
00:57:19,010 --> 00:57:23,380
padalinti sąrašą, kad tik 1 elementas į pusę, todėl mes tiesiog pasakyti, kai mes turime 50,

935
00:57:23,380 --> 00:57:26,400
kuri yra tik 1 elementas, tai jau surūšiuoti.

936
00:57:26,400 --> 00:57:29,860
>> Kai baigsime su tuo, mes galime pamatyti, kad mes galime

937
00:57:29,860 --> 00:57:32,230
pereiti prie šio sąrašo dešinėje pusėje,

938
00:57:32,230 --> 00:57:36,480
ir 3 dalis, taip pat rūšiuojamos, ir kad dabar abi pusės yra šio sąrašo surūšiuoti

939
00:57:36,480 --> 00:57:39,080
mes galime prisijungti prie šių numerių atgal kartu.

940
00:57:39,080 --> 00:57:45,320
Taigi, mes pažvelgti į 50 ir 3, 3 yra mažesnis nei 50, todėl jis eina pirmas ir 50 Įgijusi

941
00:57:45,320 --> 00:57:49,340
Dabar tai padaryta, mes einame atgal į tą sąrašą ir rūšiuoti Dešinė pusė.

942
00:57:49,340 --> 00:57:52,440
42 yra jo paties, todėl jis jau rūšiuojamos.

943
00:57:52,440 --> 00:57:57,850
Taigi dabar mes palyginti šių 2 ir 3 dalis, yra mažesnis nei 42, todėl, kad gauna įdėti į pirmąjį,

944
00:57:57,850 --> 00:58:02,340
dabar 42 bus įdėti, ir 50 bus įdėti in

945
00:58:02,340 --> 00:58:07,220
Dabar, kad rūšiuojamos, mes pereiti visą kelią atgal į viršų, 1337 ir 15.

946
00:58:07,220 --> 00:58:14,560
Na, dabar mes pažvelgti į kairę pusę šio sąrašo; 1337 yra pats todėl rūšiuojami ir tas pats su 15.

947
00:58:14,560 --> 00:58:19,020
Taigi dabar mes sujungti šias 2 numerius, rūšiuoti, kad pradiniam sąrašui, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
todėl jis eina pirmasis, tada 1337 eina.

949
00:58:23,060 --> 00:58:26,640
Ir dabar mes rūšiuojamos abi puses, į pirmąjį sąrašą iki viršaus.

950
00:58:26,640 --> 00:58:30,440
Ir visi mes turime padaryti, yra sujungti šias.

951
00:58:30,440 --> 00:58:36,890
Mes pažvelgti į pirmus 2 numerius šiame sąraše, 3 mažiau nei 15, todėl jis patenka į rūšiavimo masyvo.

952
00:58:36,890 --> 00:58:44,460
15 <42, tai jis eina in Dabar, 42 <1337, kad eina.

953
00:58:44,460 --> 00:58:51,010
50 <1337, todėl jis eina. Pastebėti, kad mes tiesiog paėmė 2 numeriai šio sąrašo.

954
00:58:51,010 --> 00:58:53,640
Taigi mes ne tik pakaitomis tarp 2 sąrašų.

955
00:58:53,640 --> 00:58:56,050
Mes paprasčiausiai ieškome pradžioje, ir mes elementas

956
00:58:56,050 --> 00:59:00,270
tai mažesni ir tada pradėti jį į mūsų masyvas.

957
00:59:00,270 --> 00:59:04,080
Dabar mes susijungė visas puses ir baigsime.

958
00:59:04,080 --> 00:59:07,780
>> Kokių nors klausimų apie sujungti rūšiuoti? Taip?

959
00:59:07,780 --> 00:59:14,190
[Studentų] Jei tai suskaidymas į skirtingas grupes, tai kodėl ne jie tiesiog padalinti vieną kartą

960
00:59:14,190 --> 00:59:19,970
ir jūs turite 3 ir 2 su grupe? [Kitos klausimas nesuprantamas]

961
00:59:19,970 --> 00:59:24,940
Priežastis - todėl kyla klausimas, kodėl mes negalime tiesiog jas sujungti, kad pirmas žingsnis, po to, kai mes juos?

962
00:59:24,940 --> 00:59:29,530
Priežastis, mes galime tai padaryti, pradėkite nuo kairiojo daugeliu elementų iš abiejų pusių,

963
00:59:29,530 --> 00:59:33,040
ir tada imtis mažesnių, ir įdėti jį į tai, kad mes žinome, kad tai

964
00:59:33,040 --> 00:59:35,290
atskiri sąrašai surūšiuoti užsakymus.

965
00:59:35,290 --> 00:59:37,290
Taigi, jei aš žiūriu kairiojo abiejų per pusę elementų,

966
00:59:37,290 --> 00:59:40,490
Aš žinau, jie ketina būti smulkiausi elementai iš šių sąrašų.

967
00:59:40,490 --> 00:59:43,930
Taigi aš galiu įdėti į mažiausias elementas dėmės šio didelio sąrašo.

968
00:59:43,930 --> 00:59:47,810
Kita vertus, jei aš pažvelgti į šių 2 sąrašus ten antro lygio

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 ir 15, tie kiekiai nebuvo išrūšiuoti.

970
00:59:51,640 --> 00:59:55,770
Taigi, jei aš pažvelgti į 50 ir 1337, aš ketina pateikti 50 į savo sąrašą.

971
00:59:55,770 --> 01:00:00,130
Bet tai nereiškia, tikrai prasminga, nes 3 yra mažiausias elementas, iš visų tų.

972
01:00:00,130 --> 01:00:04,390
Taigi, vienintelė priežastis, mes galime tai padaryti derinant žingsnis, nes mūsų sąrašuose jau išrūšiuoti.

973
01:00:04,390 --> 01:00:07,010
Kuris yra, kodėl mes turime gauti visą kelią į apačią

974
01:00:07,010 --> 01:00:09,800
nes kai mes turime tik vieną numerį, žinote, kad vieną numerį

975
01:00:09,800 --> 01:00:14,120
ir pati jau surūšiuoti sąrašas.

976
01:00:14,120 --> 01:00:19,360
>> Turite klausimų? Ar ne?

977
01:00:19,360 --> 01:00:24,260
Sudėtingumas? Na, jūs galite pamatyti, kad kiekviename etape galutiniai skaičiai,

978
01:00:24,260 --> 01:00:27,590
ir mes galime padalinti sąrašą pusei log n kartų,

979
01:00:27,590 --> 01:00:31,700
kuris yra, kai mes gauname šią n x log n sudėtingumą.

980
01:00:31,700 --> 01:00:34,940
Ir pamatysite, sujungti rūšiuoti geriausiu atveju yra n log n, ir jis tiesiog taip atsitinka

981
01:00:34,940 --> 01:00:39,340
, kad blogiausiu atveju, ar ten Ω, taip pat n log n.

982
01:00:39,340 --> 01:00:42,480
Kažkas nepamiršti,.

983
01:00:42,480 --> 01:00:45,750
Permainos, eikime keletas super pagrindinio failo I / O.

984
01:00:45,750 --> 01:00:48,830
Jei jūs žiūrite scramble, jūs pastebėsite, mes turėjo kažkokią sistemos

985
01:00:48,830 --> 01:00:51,270
kur galima rašyti į failą, jei jūs perskaitėte visą kodą.

986
01:00:51,270 --> 01:00:53,730
Pažiūrėkime, kaip tai galite padaryti.

987
01:00:53,730 --> 01:00:57,450
Na, mes turime fprintf, jūs galite galvoti kaip tik printf,

988
01:00:57,450 --> 01:01:01,720
bet tiesiog spausdinti į failą, o ne, ir todėl pradžioje f.

989
01:01:01,720 --> 01:01:07,570
Šis kodas čia rūšiuoti, ką ji daro, kaip jūs galėjote matyti scramble,

990
01:01:07,570 --> 01:01:12,310
jis eina per savo 2-dimensional array spausdinimo eilės, kas numeriai iš eilės.

991
01:01:12,310 --> 01:01:17,850
Šiuo atveju, printf spausdina savo terminalą arba, ką mes vadiname standartinį išvedimo skyriaus.

992
01:01:17,850 --> 01:01:22,170
>> Ir dabar, šiuo atveju, viskas, ką turite padaryti, pakeisti printf su fprintf,

993
01:01:22,170 --> 01:01:26,770
pasakyti, kokį failą, kurį norite spausdinti, ir šiuo atveju tai tiesiog spausdina jį į šį failą

994
01:01:26,770 --> 01:01:32,230
, o ne spausdinant jį į savo terminalą.

995
01:01:32,230 --> 01:01:36,500
Na, tada, kad kyla klausimas: Kur mes gauname šį failą rūšiuoti, tiesa?

996
01:01:36,500 --> 01:01:39,840
Mes vyko prisijungti prie šio fprintf fuction, bet mes neturėjome supratimo, iš kur jis atėjo.

997
01:01:39,840 --> 01:01:43,980
Na, anksti kodą, tai, ką mes buvo Šią dalį kodo čia,

998
01:01:43,980 --> 01:01:48,340
, kuri iš esmės sako, kad atidaryti failo ragina log.txt.

999
01:01:48,340 --> 01:01:53,220
Ką mes darome, Po to, kai mes turime padaryti, kad failas yra iš tikrųjų pradėjo sėkmingai.

1000
01:01:53,220 --> 01:01:57,070
, Todėl gali nepavykti dėl kelių priežasčių, jūs neturite pakankamai vietos ant jūsų kompiuterio, pavyzdžiui.

1001
01:01:57,070 --> 01:01:59,790
Taigi, tai visada svarbu, prieš jums padaryti jokių operacijų su failu

1002
01:01:59,790 --> 01:02:03,300
kad mes patikrinti, ar, kad failas buvo atidarytas sėkmingai.

1003
01:02:03,300 --> 01:02:09,330
Taigi, kas, kad, tai argumentas fopen, gerai, mes galime atidaryti failą įvairiais būdais.

1004
01:02:09,330 --> 01:02:13,510
Ką mes galime padaryti, tai mes galime perduoti jį w, o tai reiškia nepaisyti failą jei išeinant jau

1005
01:02:13,510 --> 01:02:18,070
Mes galime perduoti A, kurioje jie pridėti į failo pabaigą, o ne nuslopinti,

1006
01:02:18,070 --> 01:02:22,730
ar mes galime nurodyti r, o tai reiškia, galime atidaryti failą tik skaityti.

1007
01:02:22,730 --> 01:02:24,890
Taigi, jei programa bando atlikti bet kokius pakeitimus į failą,

1008
01:02:24,890 --> 01:02:30,140
klykauti ne jų ir neleiskite jiems tai padaryti.

1009
01:02:30,140 --> 01:02:33,320
Galiausiai, kai mes su failu, baigsite daryti operacijas,

1010
01:02:33,320 --> 01:02:35,860
mes turime padaryti, kad mes uždarykite failą.

1011
01:02:35,860 --> 01:02:38,830
Ir taip jūsų programos pabaigoje, jūs ketinate dar kartą perduoti juos

1012
01:02:38,830 --> 01:02:42,120
šį failą, kad jūs atidarėte, o tiesiog uždarykite ją.

1013
01:02:42,120 --> 01:02:44,650
Taigi tai yra kažkas, svarbu, kad jūs turite įsitikinti, kad jūs.

1014
01:02:44,650 --> 01:02:47,180
Taigi atminkite, jūs galite atidaryti failą, tada jūs galite rašyti į failą,

1015
01:02:47,180 --> 01:02:51,270
daryti operacijas bylos medžiaga, tačiau tada jūs turite nutraukti bylą pabaigoje.

1016
01:02:51,270 --> 01:02:53,270
>> Klausimų nuo pagrindinio failą I / O? Taip?

1017
01:02:53,270 --> 01:02:58,050
[Studento klausimas, nesuprantamas]

1018
01:02:58,050 --> 01:03:02,480
Čia. Kyla klausimas, kur iš tiesų ši log.txt failas atrodo?

1019
01:03:02,480 --> 01:03:07,890
Na, jei jūs tiesiog suteikti jai log.txt, ji sukuria jį į tą patį katalogą kaip vykdomąjį.

1020
01:03:07,890 --> 01:03:10,500
Taigi, jei! Galite - >> [Studento klausimas, nesuprantamas]

1021
01:03:10,500 --> 01:03:18,830
Taip. Tame pačiame aplanke, arba tame pačiame kataloge, kaip jūs ją vadina.

1022
01:03:18,830 --> 01:03:21,400
Dabar atmintis, kamino, o krūva.

1023
01:03:21,400 --> 01:03:23,400
Taigi, kaip tai išdėstyti kompiuterio atminties?

1024
01:03:23,400 --> 01:03:26,270
Na, galite įsivaizduoti, kaip rūšiuoti atminties šio bloko čia.

1025
01:03:26,270 --> 01:03:30,260
Ir atmintyje mes turime tai, kas vadinama krūvą įstrigo ten, ir kamino, kad ten.

1026
01:03:30,260 --> 01:03:34,480
Ir krūvos auga žemyn ir kamino auga į viršų.

1027
01:03:34,480 --> 01:03:38,620
Taigi, kaip Tommy paminėti - oh, na, ir mes turime šiuos ir kitus 4 segmentai, kurie aš gausiu per sekundę -

1028
01:03:38,620 --> 01:03:42,890
Kaip Tommy sakė anksčiau, jūs žinote, kaip jo funkcijas vadina save ir skambinti vieni kitiems?

1029
01:03:42,890 --> 01:03:44,930
Jie sukurti šią kamino rėmo rūšiuoti.

1030
01:03:44,930 --> 01:03:47,360
Na, jeigu pagrindinis ragina foo foo gauna įdėti ant kamino.

1031
01:03:47,360 --> 01:03:52,430
Foo ragina, baras įdėti kamino ir kad gauna įdėti į steką, po

1032
01:03:52,430 --> 01:03:57,040
Ir kaip jie grįžta, jie visi gauti nurašomas kamino.

1033
01:03:57,040 --> 01:04:00,140
Ką kiekvienas iš šių vietų ir atminties laikyti?

1034
01:04:00,140 --> 01:04:03,110
Na, į viršų, kuri yra teksto segmentas, yra pačią programą.

1035
01:04:03,110 --> 01:04:06,390
Taigi mašininiu kodu, tai ten, kai jūs sudaryti savo programą.

1036
01:04:06,390 --> 01:04:08,520
Be to, bet koks inicializuoti globalių kintamųjų.

1037
01:04:08,520 --> 01:04:12,660
>> Taigi jūs turite globalių kintamųjų jūsų programoje, ir jūs sakote, pavyzdžiui, A = 5,

1038
01:04:12,660 --> 01:04:15,260
kad gauna įdėti šiame segmente, ir iš karto po, kad,

1039
01:04:15,260 --> 01:04:18,990
turite niezainicjowanymi pasaulinius duomenis, kurie tiesiog LC,

1040
01:04:18,990 --> 01:04:20,990
, bet jūs neturite pasakyti, kad lygus nieko.

1041
01:04:20,990 --> 01:04:23,870
Suprantu, tai yra visuotiniai kintamieji, todėl jie už pagrindinis.

1042
01:04:23,870 --> 01:04:28,560
Taigi, tai reiškia, kad jokių globalių kintamųjų, kad būtų deklaruojami, bet ne inicijuoti.

1043
01:04:28,560 --> 01:04:32,310
Taigi, kas yra krūvos? Atminties skiriama naudojant malloc, kurį mes gauti šiek tiek.

1044
01:04:32,310 --> 01:04:35,990
Ir, pagaliau, kamino turite vietos kintamieji

1045
01:04:35,990 --> 01:04:39,950
ir funkcijos, kurias galima vadinti bet jų parametrų.

1046
01:04:39,950 --> 01:04:43,720
Paskutinis dalykas, jūs tikrai ne turi žinoti, ką aplinkos kintamieji,

1047
01:04:43,720 --> 01:04:46,700
kai paleidžiate programą, ten yra kažkas, susijęs, pavyzdžiui,

1048
01:04:46,700 --> 01:04:49,550
tai yra asmens vartotojo vardas, kuris vyko programą.

1049
01:04:49,550 --> 01:04:51,550
Ir tai bus tarsi apačioje.

1050
01:04:51,550 --> 01:04:54,540
Atminties adresai, kurie Šešioliktainis reikšmės,

1051
01:04:54,540 --> 01:04:58,170
vertės pusėje viršuje prasideda nuo 0, ir jie išeina visą kelią žemyn į apačią.

1052
01:04:58,170 --> 01:05:00,440
Šiuo atveju, jei jūs esate ant 32-bit sistemos

1053
01:05:00,440 --> 01:05:05,390
apačioje adresas bus 0x, AF, nes tai yra 32 bitų,

1054
01:05:05,390 --> 01:05:10,890
, o tai yra 8 baitų, ir šiuo atveju 8 baitai atitinka 8 šešioliktainių skaitmenų.

1055
01:05:10,890 --> 01:05:20,110
Tiek žemyn čia jūs ketinate turėti, kaip, 0xffffff, ir ten jūs ketinate turi 0.

1056
01:05:20,110 --> 01:05:23,660
Taigi, kas yra patarimų? Kai kurie iš jūsų negali apėmė tai skyriuje anksčiau.

1057
01:05:23,660 --> 01:05:26,660
bet mes eiti per jį paskaitą, kad žymeklis yra tik duomenų tipas

1058
01:05:26,660 --> 01:05:34,030
kuri saugo, o ne kažkoks vertės, pavyzdžiui, 50, ji saugo vieta tam tikru atminties adresą.

1059
01:05:34,030 --> 01:05:36,020
Patinka, kad atmintis [nesuprantamas].

1060
01:05:36,020 --> 01:05:41,120
Taigi, šiuo atveju, ką turime, yra mes turime žymiklį į sveikasis skaičius arba int *

1061
01:05:41,120 --> 01:05:46,210
ir jame yra 0xDEADBEEF šį šešioliktainį adresą.

1062
01:05:46,210 --> 01:05:50,880
>> Taigi, ką mes turime, yra dabar, tai rodyklės nurodo tam tikru atminties vietą,

1063
01:05:50,880 --> 01:05:56,020
ir tai tik, vertė 50 yra šią atminties vietoje.

1064
01:05:56,020 --> 01:06:01,810
Dėl kai kurių 32-bitų sistemų, visų 32-bitų sistemų, patarimų imtis 32 bitų arba 4 baitų.

1065
01:06:01,810 --> 01:06:06,020
Bet, pavyzdžiui, 64-bitų sistema, rodykles 64 bitų.

1066
01:06:06,020 --> 01:06:08,040
Todėl tai, ką jūs norite turėti omenyje,.

1067
01:06:08,040 --> 01:06:12,310
Taigi galutinio bitų sistemos, rodyklė yra galutiniai bitų ilgio.

1068
01:06:12,310 --> 01:06:17,320
Pointeriai yra tarsi sunkiai virškinami, be papildomų dalykų,

1069
01:06:17,320 --> 01:06:20,300
todėl eikime per dinaminės atminties paskirstymo pavyzdys.

1070
01:06:20,300 --> 01:06:25,130
Kas dinaminės atminties paskirstymo daro už jus, ar tai, ką mes vadiname malloc

1071
01:06:25,130 --> 01:06:29,280
ji leidžia paskirstyti kažkokią ne rinkinio duomenų.

1072
01:06:29,280 --> 01:06:31,830
Taigi šie duomenys yra tarsi visam laikui programos trukmę.

1073
01:06:31,830 --> 01:06:36,430
Nes, kaip žinote, jei jūs deklaruoti x viduje funkcijos, ir kad funkcija grąžina,

1074
01:06:36,430 --> 01:06:40,910
jums nebereikia turėti prieigą prie duomenų, saugomų x.

1075
01:06:40,910 --> 01:06:44,420
Patarimų darykime jie mums saugoti atmintyje arba parduotuvė reikšmes

1076
01:06:44,420 --> 01:06:46,840
į kitą atminties segmento, ty krūvos.

1077
01:06:46,840 --> 01:06:49,340
Dabar, kai mes grįžtame funkcijos, kaip ilgai, kaip mes turime rodyklę

1078
01:06:49,340 --> 01:06:54,960
tą atminties vietą, tada tai, ką mes galime padaryti, mes galime tiesiog pažvelgti ten vertybių.

1079
01:06:54,960 --> 01:06:58,020
Pažvelkime į pavyzdį: Tai yra mūsų atmintis išdėstymas vėl.

1080
01:06:58,020 --> 01:07:00,050
Ir mes turime šią funkciją, pagrindinis.

1081
01:07:00,050 --> 01:07:06,870
Kas tai yra - gerai, taip paprasta, tiesa? Int x = 5, tai tik kamino kintamasis pagrindinė.

1082
01:07:06,870 --> 01:07:12,450
>> Kita vertus, dabar mes paskelbti žymeklį, kuriame raginama funkcijos giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
Ir todėl dabar mes einame į šią funkciją ir mes sukurti naują kamino rėmus.

1084
01:07:16,800 --> 01:07:20,440
Tačiau šioje kamino rėmo, mes skelbiame int * temp,

1085
01:07:20,440 --> 01:07:23,210
kuris už mus mallocs 3 sveikieji skaičiai.

1086
01:07:23,210 --> 01:07:25,880
Taigi, int dydis duos mums, kiek baitų int yra,

1087
01:07:25,880 --> 01:07:29,620
ir malloc suteikia mums, kad daug erdvės baitų krūvos.

1088
01:07:29,620 --> 01:07:32,890
Taigi šiuo atveju, mes sukūrėme pakankamai vietos 3 sveikieji skaičiai,

1089
01:07:32,890 --> 01:07:36,830
ir krūvos ten yra būdas, kuris yra, kodėl aš sudarytas aukščiau.

1090
01:07:36,830 --> 01:07:42,900
Kai baigsite, mes vėl čia, jums reikia tik 3 int grįžo,

1091
01:07:42,900 --> 01:07:47,000
ir ji grąžina adresą, šiuo atveju daugiau kaip, kur, kad atmintis yra.

1092
01:07:47,000 --> 01:07:51,250
Ir mes rodyklė = jungiklį, ir ten mes turime tik dar vienas žymeklį.

1093
01:07:51,250 --> 01:07:54,550
Bet kas, kad funkcija grąžina yra sukrauti čia ir dingsta.

1094
01:07:54,550 --> 01:07:59,250
Taigi temp dingsta, bet mes vis dar išlaikyti adresą, kur

1095
01:07:59,250 --> 01:08:01,850
tie 3 sveikieji skaičiai yra viduje elektros tinklo.

1096
01:08:01,850 --> 01:08:06,180
Taigi šis rinkinys patarimų aprėptis vietoje sukrauti rėmo,

1097
01:08:06,180 --> 01:08:09,860
bet atminties, su kuriais jie susiję, yra krūvos.

1098
01:08:09,860 --> 01:08:12,190
>> Ar tai prasminga?

1099
01:08:12,190 --> 01:08:14,960
[Studentų] Gal galėtumėte pakartoti? >> [Juozapas] Taip.

1100
01:08:14,960 --> 01:08:20,270
Taigi, jei aš einu atgal, pamatysite, kad tik šiek tiek temp skiriama

1101
01:08:20,270 --> 01:08:23,500
kai kurie iki ten krūvos atminties.

1102
01:08:23,500 --> 01:08:28,680
Taigi, kai ši funkcija, giveMeThreeInts grąžina, tai kamino čia išnyks.

1103
01:08:28,680 --> 01:08:35,819
Ir su bet kintamuosius, šiuo atveju, tai rodyklė, kuri buvo skirta sukrauti rėmo.

1104
01:08:35,819 --> 01:08:39,649
Kad išnyks, bet kadangi mes grįžo temperatūra

1105
01:08:39,649 --> 01:08:46,330
ir mes nustatyti žymeklį = temp, rodyklė dabar ketina tą pačią atminties vietą, kaip temperatūra buvo.

1106
01:08:46,330 --> 01:08:50,370
Taigi dabar, nors mes prarasti temp, kad vietos rodyklę,

1107
01:08:50,370 --> 01:08:59,109
mes vis dar išlaiko atminties adresą, ką ji buvo nukreipta šio kintamojo rodyklė viduje.

1108
01:08:59,109 --> 01:09:03,740
Turite klausimų? Tai gali būti natūra paini tema, jei tu dar nesi per jį skyriuje.

1109
01:09:03,740 --> 01:09:09,240
Mes galime jūsų TF tikrai eiti per jį ir, žinoma, gali atsakyti į klausimus

1110
01:09:09,240 --> 01:09:11,500
peržiūros sesijos pabaigos.

1111
01:09:11,500 --> 01:09:14,220
Bet tai yra tarsi sudėtinga tema, ir aš turiu daugiau pavyzdžių, kurie ketina pasirodyti

1112
01:09:14,220 --> 01:09:18,790
, kuris padės išsiaiškinti, kas patarimų iš tikrųjų yra.

1113
01:09:18,790 --> 01:09:22,500
>> Šiuo atveju, patarimų yra lygiavertis masyvai,

1114
01:09:22,500 --> 01:09:25,229
todėl galiu tiesiog naudoti šį žymeklį kaip tą patį dalyką, kaip int masyvas.

1115
01:09:25,229 --> 01:09:29,840
Taigi, aš indeksavimo į 0, ir pakeisti pirmą sveikasis skaičius 1,

1116
01:09:29,840 --> 01:09:39,689
keisti antrąjį sveikasis skaičius 2, ir 3-iasis sveikasis skaičius 3.

1117
01:09:39,689 --> 01:09:44,210
Taigi daugiau rodykles. Na, prisiminti Binky.

1118
01:09:44,210 --> 01:09:48,319
Šiuo atveju mes skiriama rodyklę, ar mes paskelbta žymeklį,

1119
01:09:48,319 --> 01:09:52,760
bet iš pradžių, kai aš ką tik paskelbė rodyklę, tai ne nurodydama bet atmintyje.

1120
01:09:52,760 --> 01:09:54,930
Tai tik šiukšlių viduje vertybės.

1121
01:09:54,930 --> 01:09:56,470
Taigi, aš neįsivaizduoju, kur tai rodyklė būtų nukreipta.

1122
01:09:56,470 --> 01:10:01,630
Ji turi adresą, kuris yra tiesiog alsuoja 0 ir 1, kur jis iš pradžių buvo paskelbta.

1123
01:10:01,630 --> 01:10:04,810
Aš negaliu nieko daryti, kol aš vadinu jį malloc

1124
01:10:04,810 --> 01:10:08,390
ir tada jis man duoda mažai vietos ant krūvos, kur galiu įdėti viduje vertybes.

1125
01:10:08,390 --> 01:10:11,980
Tada vėl, aš nežinau, kas viduje šios atminties.

1126
01:10:11,980 --> 01:10:16,780
Taigi pirmas dalykas, ką turite padaryti, tai patikrinti, ar sistema turėjo pakankamai atminties

1127
01:10:16,780 --> 01:10:20,850
suteikti man atgal 1 pirmąją vietą sveikąjį skaičių, kuris yra, kodėl aš darau tai patikrinti.

1128
01:10:20,850 --> 01:10:25,020
Jei rodyklė yra niekinis, tai reiškia, kad ji neturėjo pakankamai vietos ar kokios nors kitos įvyko klaida,

1129
01:10:25,020 --> 01:10:26,320
todėl aš išeiti iš mano programos.

1130
01:10:26,320 --> 01:10:29,400
 Bet jei jis pavyko, o dabar galiu naudoti, kad žymiklį

1131
01:10:29,400 --> 01:10:35,020
ir ką * rodyklė daro tai kur adresas

1132
01:10:35,020 --> 01:10:38,480
, kai ši vertė yra, ir tai išskiria jį lygus 1.

1133
01:10:38,480 --> 01:10:41,850
Taigi čia, mes patikrinti, jei tai atmintis.

1134
01:10:41,850 --> 01:10:45,380
>> , Kai jūs žinote, jis egzistuoja, galite įdėti į ją

1135
01:10:45,380 --> 01:10:50,460
kokią vertę jūs norite įdėti į ją; šiuo atveju 1.

1136
01:10:50,460 --> 01:10:53,060
Kai baigsime su juo, jums reikia nemokamai, kad žymeklį

1137
01:10:53,060 --> 01:10:57,160
nes mes turime grįžti prie sistemos, kad atminties, kad jūs paprašė į pirmąją vietą.

1138
01:10:57,160 --> 01:10:59,690
Nes kompiuteris nežino, kai baigsite su juo.

1139
01:10:59,690 --> 01:11:02,510
Šiuo atveju mes aiškiai nurodant, kad jį, gerai, mes su tos atminties.

1140
01:11:02,510 --> 01:11:10,780
Jeigu kai kurios kitos procesas turi kita programa reikia, nedvejodami eiti į priekį ir priimti jį.

1141
01:11:10,780 --> 01:11:15,110
Tai, ką mes taip pat galime tai padaryti, mes galime tik lokalūs kintamieji rinkinio adresą.

1142
01:11:15,110 --> 01:11:19,080
Taigi, int x viduje sukrauti rėmo Maino.

1143
01:11:19,080 --> 01:11:23,060
Ir kai mes naudojame šią ampersendo, tai ir operatorius, ką ji daro

1144
01:11:23,060 --> 01:11:27,310
ji mano, x, ir x yra tik keletas atminties duomenys, tačiau jis turi adresą.

1145
01:11:27,310 --> 01:11:33,790
Tai kažkur. Taigi, pašaukimas & x, Kas tai yra ji suteikia mums x adresą.

1146
01:11:33,790 --> 01:11:38,430
Tai darydami, mes darome rodyklė tašką, kur x yra atmintyje.

1147
01:11:38,430 --> 01:11:41,710
Dabar mes tiesiog kažkas panašaus * x, mes ketiname gauti 5 atgal.

1148
01:11:41,710 --> 01:11:43,820
Žvaigždė vadinama dereferencing jį.

1149
01:11:43,820 --> 01:11:46,640
Jums sekti adresą, ir jūs gaunate jį ten laikomi vertę.

1150
01:11:51,000 --> 01:11:53,310
>> Turite klausimų? Taip?

1151
01:11:53,310 --> 01:11:56,500
[Studentų] Jei jums nereikia daryti 3-smailiu dalykas, ar ji vis dar kaupia?

1152
01:11:56,500 --> 01:11:59,490
Taip. Jei jums nereikia daryti 3-jų rodyklė dalykas, jis vis dar ketina kaupti,

1153
01:11:59,490 --> 01:12:02,720
bet aš parodyti jums, kas atsitinka per sekundę, ir be daryti, kad,

1154
01:12:02,720 --> 01:12:04,860
kad tai, ką mes vadiname Atminties nutekėjimas. Jūs nesate sistemai suteikiamas

1155
01:12:04,860 --> 01:12:07,850
atsarginę savo atmintį, kad po kurio laiko programa kaupti

1156
01:12:07,850 --> 01:12:10,940
atminties, kad ji nenaudoja, ir nieko daugiau galite naudoti ją.

1157
01:12:10,940 --> 01:12:15,750
Jei jūs kada nors matė "Firefox" su 1,5 mln. Kilobaitų jūsų kompiuteryje,

1158
01:12:15,750 --> 01:12:17,840
Task Manager, kad tai, kas vyksta.

1159
01:12:17,840 --> 01:12:20,760
Turite Atminties nutekėjimas, kad jie ne tvarkymo programoje.

1160
01:12:23,080 --> 01:12:26,240
Taigi, kaip rodyklė aritmetinis darbas?

1161
01:12:26,240 --> 01:12:29,480
Na, rodyklė aritmetinis rūšiuoti panašaus indeksavimo į masyvą.

1162
01:12:29,480 --> 01:12:36,370
Šiuo atveju, turiu rodyklę, ir tai, ką darau, žymiklį nukreipkite žymiklį į pirmąjį elementą

1163
01:12:36,370 --> 01:12:42,100
šiame 3 sveikieji skaičiai, kad aš skiriamų masyvo.

1164
01:12:42,100 --> 01:12:46,670
Taigi dabar ką man daryti, žvaigždė žymeklis tiesiog pakeičia pirmasis elementas sąraše.

1165
01:12:46,670 --> 01:12:49,140
Žymiklis žvaigždutėmis 1 taškų čia.

1166
01:12:49,140 --> 01:12:53,140
Taigi žymeklis yra čia, rodyklė +1 yra čia, rodyklė 2 yra čia.

1167
01:12:53,140 --> 01:12:56,610
>> Taigi tiesiog pridėjus 1 yra tas pats, kaip juda išilgai šio masyvo.

1168
01:12:56,610 --> 01:12:59,880
, Ką mes darome, kai mes darome 1 žymeklį gausite adresą čia,

1169
01:12:59,880 --> 01:13:04,180
ir siekiant gauti čia vertė, galite įdėti žvaigždę iš visos išraiškos

1170
01:13:04,180 --> 01:13:05,990
į dereference jį.

1171
01:13:05,990 --> 01:13:09,940
Taigi, šiuo atveju, aš nustatyti pirmąją vietą šiame masyve 1,

1172
01:13:09,940 --> 01:13:13,970
antroji vieta 2, o trečioji vieta 3.

1173
01:13:13,970 --> 01:13:18,180
Tada, ką aš darau čia aš spausdinti mūsų žymeklį 1,

1174
01:13:18,180 --> 01:13:19,970
, kurie tik suteikia man 2.

1175
01:13:19,970 --> 01:13:23,650
Dabar aš incrementing žymiklį, kad žymiklis lygus žymeklį 1,

1176
01:13:23,650 --> 01:13:26,780
, kuri juda į priekį.

1177
01:13:26,780 --> 01:13:30,810
Ir todėl dabar, jei aš atsispausdinti žymeklį 1, rodyklė +1 dabar 3,

1178
01:13:30,810 --> 01:13:33,990
, kuris šiuo atveju spausdina 3.

1179
01:13:33,990 --> 01:13:36,560
Ir siekiant į laisvą kažkas, rodyklių, kad aš tau jį

1180
01:13:36,560 --> 01:13:40,540
turi būti nukreipta į masyvo, kurią aš gavau atgal iš malloc pradžioje.

1181
01:13:40,540 --> 01:13:43,430
Taigi, šiuo atveju, jei aš būčiau skambinti 3 čia, tai negali būti teisus,

1182
01:13:43,430 --> 01:13:45,070
, nes jis yra iš masyvo viduryje.

1183
01:13:45,070 --> 01:13:48,820
Turiu atimti patekti į pradinę vietą

1184
01:13:48,820 --> 01:13:50,420
pirmasis pradinis vietoje, kol aš galiu jį išlaisvinti.

1185
01:13:56,300 --> 01:13:58,450
Taigi, štai aktyviau dalyvauti pavyzdys.

1186
01:13:58,450 --> 01:14:03,360
Šiuo atveju, mes skirti 7 simbolių simbolių masyvas.

1187
01:14:03,360 --> 01:14:06,480
>> Ir šiuo atveju tai, ką mes darome, yra mes kilpų per pirmuosius 6 iš jų,

1188
01:14:06,480 --> 01:14:09,900
ir mes jas iki Z.

1189
01:14:09,900 --> 01:14:13,350
Taigi, int i = 0, i> 6, i + +,

1190
01:14:13,350 --> 01:14:16,220
Taigi, rodyklė + i tiesiog duoti mums, šiuo atveju,

1191
01:14:16,220 --> 01:14:20,860
rodyklė, rodyklė +1, +2, rodyklė rodyklė 3, ir tt, ir tt į kilpą.

1192
01:14:20,860 --> 01:14:24,040
Tai, ką jis ketina daryti tai pasireiškia tuo IP adresu, dereferences gauti vertę,

1193
01:14:24,040 --> 01:14:27,440
ir pokyčių, kurie vertė iki Z.

1194
01:14:27,440 --> 01:14:30,350
Tada pabaigoje prisiminti, tai yra eilutė, tiesa?

1195
01:14:30,350 --> 01:14:33,560
Visos eilutės turi baigtis null pabaigos simbolis.

1196
01:14:33,560 --> 01:14:38,620
Taigi, ką aš padaryti, tai 6 rodyklė aš įdėti null Terminatorius pobūdžio in

1197
01:14:38,620 --> 01:14:43,980
Ir dabar, ką aš iš esmės daro čia įgyvendina printf eilutę, tiesa?

1198
01:14:43,980 --> 01:14:46,190
>> Taigi, kai printf dabar, kai jis pasiekė eilutės pabaigą?

1199
01:14:46,190 --> 01:14:48,230
Kai tik ji pasieks nulinę pabaigos simbolis.

1200
01:14:48,230 --> 01:14:52,030
Taigi, šiuo atveju, mano originalus žymeklis nurodo, kad šio masyvo pradžioje.

1201
01:14:52,030 --> 01:14:56,410
Galiu atspausdinti pirmąją raidę. Aš jį perkelti per vieną.

1202
01:14:56,410 --> 01:14:58,420
Galiu atsispausdinti tą simbolį. Galiu perkelti jį per.

1203
01:14:58,420 --> 01:15:02,180
Ir aš nuolat tai daryti, kol aš pasiekti pabaigos.

1204
01:15:02,180 --> 01:15:07,750
Ir dabar galutinis * žymeklis bus dereference ir gauti null pabaigos simbolis.

1205
01:15:07,750 --> 01:15:11,780
Ir todėl mano, o kilpa veikia tik tada, kai ta vertė nėra null pabaigos simbolis.

1206
01:15:11,780 --> 01:15:13,770
Taigi, dabar aš išeiti iš šio ciklo.

1207
01:15:18,780 --> 01:15:21,180
Ir todėl, jei aš atimti 6 iš šio rodyklė

1208
01:15:21,180 --> 01:15:22,860
Aš einu atgal visą kelią į pradžią.

1209
01:15:22,860 --> 01:15:27,880
Atminkite, kad darau tai, nes aš turiu eiti į pradžią, siekiant atlaisvinti.

1210
01:15:27,880 --> 01:15:30,270
>> Taigi, aš žinau, kad buvo daug. Ar yra kokių nors klausimų?

1211
01:15:30,270 --> 01:15:31,870
Prašome, taip?

1212
01:15:31,870 --> 01:15:36,610
[Studento klausimas nesuprantamas]

1213
01:15:36,610 --> 01:15:38,190
Ar galite pasakyti, kad garsiau? Atsiprašau.

1214
01:15:38,190 --> 01:15:44,140
[Studentų] tiesiai prieš jus išlaisvintų žymiklį paskutinės skaidrės,

1215
01:15:44,140 --> 01:15:47,300
Kur tu buvai, iš tikrųjų keičiasi, kad rodyklė vertę?

1216
01:15:47,300 --> 01:15:50,370
[Juozapas] Taigi, čia. >> [Studentų] O, gerai.

1217
01:15:50,370 --> 01:15:51,890
[Juozapas] Taigi, turiu rodyklę minuso minuso, teisė,

1218
01:15:51,890 --> 01:15:54,140
kurie juda dalykas atgal vienu, ir tada aš atlaisvinti jį,

1219
01:15:54,140 --> 01:15:57,000
nes tai rodyklė turi būti nukreiptas į masyvo pradžioje.

1220
01:15:57,000 --> 01:16:00,420
[Studentų] Bet, kad nebūtų būti reikalinga, jei būtumėte sustojo po šios eilutės.

1221
01:16:00,420 --> 01:16:03,130
[Juozapas] Taigi, jei aš buvo sustabdytas po to, tai būtų laikoma Atminties nutekėjimas,

1222
01:16:03,130 --> 01:16:04,810
nes aš ne paleisti nemokamai.

1223
01:16:04,810 --> 01:16:11,290
[Studentų] [nesuprantamas] po pirmųjų trijų eilučių, kur jums teko žymeklį 1 [nesuprantamas].

1224
01:16:11,290 --> 01:16:13,140
[Juozapas] Aha. Taigi, kas ten klausimas?

1225
01:16:13,140 --> 01:16:14,780
Atsiprašau. Ne, ne. Eik, eik, prašau.

1226
01:16:14,780 --> 01:16:16,870
[Studentų] Taigi, jūs ne keisti rodykles vertę.

1227
01:16:16,870 --> 01:16:19,130
Nebūtų reikėję padaryti žymeklį minus minuso.

1228
01:16:19,130 --> 01:16:19,730
[Juozapas] Taip, būtent.

1229
01:16:19,730 --> 01:16:21,890
Taigi, kai aš padaryti žymeklį 1 ir 2 rodyklę,

1230
01:16:21,890 --> 01:16:24,410
Aš ne daryti žymeklį lygus žymeklį 1.

1231
01:16:24,410 --> 01:16:27,260
Taigi, rodyklė tiesiog lieka nukreipta į masyvo pradžioje.

1232
01:16:27,260 --> 01:16:31,460
Tai tik kai aš plius plius, kad ji nustato vertę atgal viduje rodyklė,

1233
01:16:31,460 --> 01:16:33,550
, kad ji iš tikrųjų juda kartu.

1234
01:16:36,860 --> 01:16:37,780
Gerai.

1235
01:16:40,550 --> 01:16:42,030
Daugiau klausimų?

1236
01:16:44,680 --> 01:16:47,790
>> Vėlgi, jei tai yra tarsi didžioji, tai bus įtraukti į sesijos.

1237
01:16:47,790 --> 01:16:50,710
Paklausti jūsų mokymo kolegos apie tai, ir mes galime atsakyti į klausimus pabaigoje.

1238
01:16:53,510 --> 01:16:56,600
Ir paprastai, kad mums nepatinka tai padaryti minuso dalykas.

1239
01:16:56,600 --> 01:16:59,760
Tai turi reikalauti, kad mane sekti, kiek aš kompensuoti masyve.

1240
01:16:59,760 --> 01:17:04,520
Taigi, apskritai, tai yra tik paaiškinti, kaip rodyklė aritmetines darbus.

1241
01:17:04,520 --> 01:17:07,970
Bet ką mes paprastai patinka daryti, mes norėtume sukurti rodyklė kopiją,

1242
01:17:07,970 --> 01:17:11,640
ir tada mes naudoti šią kopiją, kai mes judėti į eilutę.

1243
01:17:11,640 --> 01:17:14,660
Taigi, šių atveju jūs naudojate kopiją spausdinti visą eilutę,

1244
01:17:14,660 --> 01:17:19,040
tačiau mes negalime padaryti, kaip žymeklis minus 6 arba sekti, kiek mes persikėlė,

1245
01:17:19,040 --> 01:17:22,700
tik todėl, kad mes žinome, kad mūsų pradinis taškas dar atkreipė dėmesį į sąrašo pradžioje

1246
01:17:22,700 --> 01:17:25,340
ir visi, kad mes pakeisti ši kopija.

1247
01:17:25,340 --> 01:17:28,250
Taigi, apskritai, pakeisti savo originalaus rodyklė kopijas.

1248
01:17:28,250 --> 01:17:32,350
Nebandykite rūšiuoti kaip NeraŠykiTe pakeisti originalus.

1249
01:17:32,350 --> 01:17:35,290
Bandymas pakeisti tik kopijas jūsų originalus.

1250
01:17:41,540 --> 01:17:44,870
Taigi, jūs pastebėsite, kai mes pereiname eilutę į printf

1251
01:17:44,870 --> 01:17:48,990
jūs neturite įdėti žvaigždę priešais jį, kaip mes padarėme su visais kitais dereferences, tiesa?

1252
01:17:48,990 --> 01:17:54,180
Taigi, jei jums atspausdinti visą eilutę% s tikisi, adresas,

1253
01:17:54,180 --> 01:17:57,610
ir šiuo atveju rodyklių arba šiuo atveju, kaip simbolių masyvas.

1254
01:17:57,610 --> 01:18:00,330
>> Simbolių, char * s, ir masyvai yra tas pats dalykas.

1255
01:18:00,330 --> 01:18:03,690
Žymeklis yra simbolių ir simbolių matricos yra tas pats dalykas.

1256
01:18:03,690 --> 01:18:05,720
Ir taip, visi mes turime padaryti, tai perduoti rodyklė.

1257
01:18:05,720 --> 01:18:08,150
Mes neturime perduoti kaip ir * pointer ar ko nors panašaus.

1258
01:18:13,110 --> 01:18:14,930
Taigi, matricas ir rodyklės yra tas pats dalykas.

1259
01:18:14,930 --> 01:18:19,160
Kai jūs darote kažką panašaus x [Y] per čia masyvo,

1260
01:18:19,160 --> 01:18:21,960
ką jis daro po gaubtu, tai sako, gerai, tai skaitmenu rinkinys,

1261
01:18:21,960 --> 01:18:23,690
todėl rodyklė.

1262
01:18:23,690 --> 01:18:26,510
Ir taip x yra tas pats,

1263
01:18:26,510 --> 01:18:28,650
ir taip, ką ji daro, ji priduria, y x,

1264
01:18:28,650 --> 01:18:31,820
kuris yra tas pats, kaip juda į priekį, atminties, kad daug.

1265
01:18:31,820 --> 01:18:34,930
Ir dabar x + y suteikia mums tam tikrą adresą, rūšiuoti,

1266
01:18:34,930 --> 01:18:37,570
ir mes dereference adresą arba sekite rodyklę

1267
01:18:37,570 --> 01:18:41,640
, kur, kad atminties vieta, ir mes gauti naudą iš tos atminties vietą.

1268
01:18:41,640 --> 01:18:43,720
Taip, kad šie du dalykai yra lygiai tas pats.

1269
01:18:43,720 --> 01:18:45,840
Tai tik sintaksinė cukrus.

1270
01:18:45,840 --> 01:18:48,090
Jie padaryti tą patį. Jie tik skirtingi syntactics vienas kitą.

1271
01:18:51,500 --> 01:18:57,590
>> Taigi, ką gali suklysti su rodyklės? , Pavyzdžiui, daug. Gerai. Taigi, blogų dalykų.

1272
01:18:57,590 --> 01:19:02,410
Blogų dalykų, kuriuos galite padaryti, yra ne patikrinti,, jei jūsų malloc skambutis vėl nulis, tiesa?

1273
01:19:02,410 --> 01:19:06,560
Šiuo atveju, aš klausia sistemą duoti man - kas yra šis skaičius?

1274
01:19:06,560 --> 01:19:11,200
Kaip ir 2 milijardus kartų 4, nes sveikasis skaičius dydis 4 baitai.

1275
01:19:11,200 --> 01:19:13,810
Aš prašau jį kaip 8 milijardas baitų.

1276
01:19:13,810 --> 01:19:17,270
, Žinoma, mano kompiuteris yra nesiruošia būti gali duoti man, kad daug atminties atgal.

1277
01:19:17,270 --> 01:19:20,960
Ir mes ne patikrinti, ar tai yra niekinis, todėl, kai mes bandome dereference jį per ten

1278
01:19:20,960 --> 01:19:24,270
sekti rodyklę, kur jis ketina mes neturime, kad atmintis.

1279
01:19:24,270 --> 01:19:27,150
Tai, ką mes vadiname dereferencing NULL pointeris.

1280
01:19:27,150 --> 01:19:29,710
Ir tai iš esmės sukelia jums segfault.

1281
01:19:29,710 --> 01:19:31,790
Tai yra vienas iš būdų, kaip galite segfault.

1282
01:19:34,090 --> 01:19:38,090
Kitų blogų dalykų, kuriuos galite padaryti, - Oh well.

1283
01:19:38,090 --> 01:19:40,650
, Kuris buvo dereferencing NULL pointeris. Gerai.

1284
01:19:40,650 --> 01:19:45,160
Kitų blogų dalykų - taip pat, siekiant nustatyti, kad jūs tiesiog įdėti ten patikrinti

1285
01:19:45,160 --> 01:19:46,980
kuri patikrina, ar žymeklis yra niekinis

1286
01:19:46,980 --> 01:19:51,000
ir išeiti iš programos, jei tai atsitinka, kad malloc grąžina null žymeklį.

1287
01:19:55,110 --> 01:19:59,850
Tai xkcd komiška. Žmonėms jį suprasti dabar. Rūšiuoti.

1288
01:20:06,120 --> 01:20:09,350
>> Taigi, atmintis. Ir aš per šį.

1289
01:20:09,350 --> 01:20:12,000
Mes ragina malloc į kilpą, bet kiekvieną kartą, kai mes vadiname malloc

1290
01:20:12,000 --> 01:20:14,370
mes prarasti sekti, iš kur ši rodyklė yra nukreipta į

1291
01:20:14,370 --> 01:20:15,750
nes mes clobbering.

1292
01:20:15,750 --> 01:20:18,410
Taigi, pradinis kvietimas į malloc suteikia man atminties čia.

1293
01:20:18,410 --> 01:20:19,990
Mano žymeklis rodykles į tai.

1294
01:20:19,990 --> 01:20:23,020
Dabar aš neatleidžia, todėl dabar aš vadinu malloc dar kartą.

1295
01:20:23,020 --> 01:20:26,070
Dabar ji primena čia. Dabar mano atmintis yra nukreipta čia.

1296
01:20:26,070 --> 01:20:27,640
Nukreipta čia. Nukreipta čia.

1297
01:20:27,640 --> 01:20:31,820
Bet aš prarado stebėti visų per čia, kad aš skirta atminties adresus.

1298
01:20:31,820 --> 01:20:35,100
Ir todėl dabar aš neturiu jokios nuorodos į jų nebėra.

1299
01:20:35,100 --> 01:20:37,230
Taigi, galiu neatleidžia juos ne iš šio ciklo.

1300
01:20:37,230 --> 01:20:39,390
Ir todėl, siekiant nustatyti kažką panašaus į tai,

1301
01:20:39,390 --> 01:20:42,250
, jei pamiršite, kad atlaisvintumėte atminties, ir jūs gaunate šią atminties nutekėjimas,

1302
01:20:42,250 --> 01:20:45,810
Turite atlaisvinti atminties viduje šio ciklo, kai jūs baigsite su juo.

1303
01:20:45,810 --> 01:20:51,400
Na, tai, kas vyksta. Aš žinau, kad daug iš jūsų nekenčiu.

1304
01:20:51,400 --> 01:20:55,270
O dabar - yay! Jūs gaunate kaip 44.000 kilobaitų.

1305
01:20:55,270 --> 01:20:57,110
Taigi, jūs nemokamai ji kilpos pabaigoje,

1306
01:20:57,110 --> 01:20:59,770
ir tai vyksta tiesiog atlaisvinti atmintį kiekvieną kartą.

1307
01:20:59,770 --> 01:21:03,620
Iš esmės, jūsų programa neturi atminties nutekėjimas nebėra.

1308
01:21:03,620 --> 01:21:08,150
>> Ir dabar kažkas galite padaryti, tai atlaisvinti atminties, kad jūs paprašė du kartus.

1309
01:21:08,150 --> 01:21:11,060
Šiuo atveju, jūs malloc kažkas, galite pakeisti savo vertę.

1310
01:21:11,060 --> 01:21:13,140
Jums nemokamai ją vieną kartą, nes jūs sakėte, buvo padaryti su juo.

1311
01:21:13,140 --> 01:21:14,940
Bet tada mes išlaisvino jį iš naujo.

1312
01:21:14,940 --> 01:21:16,730
Tai yra kažkas, kad gana neblogai.

1313
01:21:16,730 --> 01:21:18,820
Jis nesiruošia iš pradžių segfault

1314
01:21:18,820 --> 01:21:23,350
tačiau po kurio laiko Kas tai yra dvigubai išlaisvinant ŠĮ gadina savo krūvos struktūrą,

1315
01:21:23,350 --> 01:21:27,200
ir jums sužinoti šiek tiek daugiau apie tai, jei jūs nuspręsite imtis klasės, kaip CS61.

1316
01:21:27,200 --> 01:21:30,000
Bet iš esmės po kurio laiko jūsų kompiuteris yra susipainioti

1317
01:21:30,000 --> 01:21:33,010
apie tai, kas atminties vietos yra, kur ir kur saugoma

1318
01:21:33,010 --> 01:21:34,800
kai duomenys yra saugomi atmintyje.

1319
01:21:34,800 --> 01:21:38,080
Ir taip atlaisvinti žymeklį du kartus yra blogas dalykas, kad jūs nenorite daryti.

1320
01:21:38,080 --> 01:21:41,600
>> Kitų dalykų, kurie gali suklysti nenaudoja sizeof.

1321
01:21:41,600 --> 01:21:44,460
Taigi, šiuo atveju jums malloc 8 baitai,

1322
01:21:44,460 --> 01:21:46,700
ir tai yra tas pats, kaip du sveikieji skaičiai, tiesa?

1323
01:21:46,700 --> 01:21:49,580
Taigi, tai visiškai saugus, tačiau tai?

1324
01:21:49,580 --> 01:21:52,160
Na, kaip Lukas kalbėjo apie skirtingų architektūrų,

1325
01:21:52,160 --> 01:21:54,220
sveikieji skaičiai yra skirtingų ilgių.

1326
01:21:54,220 --> 01:21:57,970
Taigi, ant prietaiso, kad jūs naudojate, sveikieji skaičiai yra apie 4 baitai,

1327
01:21:57,970 --> 01:22:02,370
tačiau dėl kokios nors kitos sistemos, jie gali būti 8 baitai, arba jie gali būti 16 baitų.

1328
01:22:02,370 --> 01:22:05,680
Taigi, jei aš tiesiog naudoti šį numerį čia,

1329
01:22:05,680 --> 01:22:07,310
ši programa gali dirbti ant prietaiso,

1330
01:22:07,310 --> 01:22:10,360
bet jis nesiruošia skirti pakankamai atminties kokios nors kitos sistemos.

1331
01:22:10,360 --> 01:22:14,020
Šiuo atveju, tai ką sizeof operatorius yra naudojamas.

1332
01:22:14,020 --> 01:22:16,880
Kai mes vadiname sizeof (int), Kas tai yra

1333
01:22:16,880 --> 01:22:21,910
 ji suteikia mums sistemą, kad programa veikia sveikojo skaičiaus dydį.

1334
01:22:21,910 --> 01:22:25,490
Taigi, šiuo atveju, sizeof (int) grįš 4 kažką panašaus prietaiso,

1335
01:22:25,490 --> 01:22:29,980
Dabar tai 4 * 2, kuris yra 8,

1336
01:22:29,980 --> 01:22:32,330
kuri yra tik vietos reikia dviem sveikaisiais skaičiais suma.

1337
01:22:32,330 --> 01:22:36,710
Kitą sistemą, jei int kaip 16 baitų ar 8 baitų,

1338
01:22:36,710 --> 01:22:39,380
tai tik nesiruošia grįžti pakankamai baitų laikyti tą sumą.

1339
01:22:41,830 --> 01:22:45,310
>> Ir, pagaliau, structs.

1340
01:22:45,310 --> 01:22:48,340
Taigi, jei jūs norėjote saugoti sudoku lenta atmintyje, kaip galėtume tai padaryti?

1341
01:22:48,340 --> 01:22:51,570
Jūs manote, kaip kintamojo pirmas dalykas,

1342
01:22:51,570 --> 01:22:53,820
Antras dalykas, kintamasis, Trečias dalykas kintamasis,

1343
01:22:53,820 --> 01:22:56,420
blogai, tiesa - jau ketvirtą dalykas rodiklis?

1344
01:22:56,420 --> 01:23:00,750
Taigi, vienas pagerėjimas, kurį jūs galite padaryti ant to padaryti 9 x 9 masyvo.

1345
01:23:00,750 --> 01:23:04,480
Tai gerai, bet ką daryti, jei norėjo susieti kitų dalykų, su sudoku valdybos

1346
01:23:04,480 --> 01:23:06,490
patinka tai, ką valdybos sunku,

1347
01:23:06,490 --> 01:23:11,740
arba, pavyzdžiui, kaip jūsų rezultatas, ir kiek laiko ji ėmėsi, jums išspręsti šią lenta?

1348
01:23:11,740 --> 01:23:14,970
Na, ką galite padaryti, tai galite sukurti struct.

1349
01:23:14,970 --> 01:23:18,910
Ką aš iš esmės sakydamas, aš apibrėžti šią struktūrą čia,

1350
01:23:18,910 --> 01:23:23,230
ir aš Sudoku taryba, kurią sudaro valdyba, kuri yra 9 x 9.

1351
01:23:23,230 --> 01:23:26,650
>> Ir ką ji turi, ji turi patarimų lygio pavadinimą.

1352
01:23:26,650 --> 01:23:30,730
Ji taip pat turi X ir Y, kurie yra iš ten, kur aš esu dabar koordinatės.

1353
01:23:30,730 --> 01:23:35,980
Ji taip pat turi laikas, praleistas [nesuprantamas], ir ji turi iš viso juda, aš užregistruotų iki šiol.

1354
01:23:35,980 --> 01:23:40,010
Ir todėl šiuo atveju, aš gali grupuoti visa krūva duomenų į tik vieną struktūrą

1355
01:23:40,010 --> 01:23:42,790
vietoj to, kad, pavyzdžiui, plaukioja aplink kaip įvairių kintamųjų

1356
01:23:42,790 --> 01:23:44,540
kad aš negaliu tikrai sekti.

1357
01:23:44,540 --> 01:23:49,720
Ir tai leidžia mums turėti tik gražus sintaksė rūšies nuorodos skirtingus dalykus viduje šio struct.

1358
01:23:49,720 --> 01:23:53,430
Aš galiu tik padaryti board.board ir gaunu sudoku lenta.

1359
01:23:53,430 --> 01:23:56,320
Board.level, man, kaip sunku yra.

1360
01:23:56,320 --> 01:24:00,540
Board.x ir board.y duoti man, kur aš galiu būti valdybos koordinates.

1361
01:24:00,540 --> 01:24:04,730
Ir todėl aš prieigą prie,, ką mes vadiname struct laukai.

1362
01:24:04,730 --> 01:24:08,840
Tai apibrėžia sudokuBoard, kuris yra tipo, kad aš turiu.

1363
01:24:08,840 --> 01:24:14,800
Ir dabar mes čia. Turiu kintamasis vadinamas "lenta" tipo sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
Ir todėl dabar aš galiu gauti prieigą visus laukus, kurie sudaro šią struktūrą čia.

1365
01:24:20,830 --> 01:24:22,450
>> Bet apie structs klausimai? Taip?

1366
01:24:22,450 --> 01:24:25,890
[Studentų] int x, y, jūs pareiškė, tiek vienoje eilutėje? >> [Juozapas] Aha.

1367
01:24:25,890 --> 01:24:27,400
[Studentų] Taigi, gal jūs tiesiog padaryti, kad su visais iš jų?

1368
01:24:27,400 --> 01:24:31,200
Kaip ir x, y kableliais kartus, kad iš viso?

1369
01:24:31,200 --> 01:24:34,460
[Juozapas] Taip, galite tikrai padaryti, kad bet priežastis, kodėl aš toje pačioje eilutėje X ir Y -

1370
01:24:34,460 --> 01:24:36,330
ir kyla klausimas, kodėl mes galime tik tai padaryti toje pačioje eilutėje?

1371
01:24:36,330 --> 01:24:38,600
Kodėl ne mes tiesiog įdėti visi jie toje pačioje eilutėje yra

1372
01:24:38,600 --> 01:24:42,090
X ir Y yra susiję vieni su kitais,

1373
01:24:42,090 --> 01:24:44,780
ir tai tik stilistiškai teisinga, tam tikra prasme,

1374
01:24:44,780 --> 01:24:46,600
, nes jis du dalykus grupavimas toje pačioje eilutėje

1375
01:24:46,600 --> 01:24:49,340
, kad kaip ir tarsi į tą patį.

1376
01:24:49,340 --> 01:24:51,440
Ir aš tiesiog padalinti tai atskirai. Tai tik stiliaus dalykas.

1377
01:24:51,440 --> 01:24:53,720
Tai funkciškai, neturi reikšmės.

1378
01:24:58,150 --> 01:24:59,270
Visus kitus klausimus dėl structs?

1379
01:25:03,030 --> 01:25:06,620
Galite nustatyti Pokédex su struct.

1380
01:25:06,620 --> 01:25:11,720
Pokemon numerį ir jis turi laišką, savininkas, tipo.

1381
01:25:11,720 --> 01:25:16,990
Ir tada, jei turite Pokemon masyvo, galite sudaryti Pokédex, tiesa?

1382
01:25:16,990 --> 01:25:20,810
Gerai, kietas. Taigi, klausimai ant structs. Tie, kurie susiję su structs.

1383
01:25:20,810 --> 01:25:25,270
>> Galiausiai, GDB. Ką GDB jums tai padaryti? Jis leidžia jums derinti savo programą.

1384
01:25:25,270 --> 01:25:27,650
Ir, jei turite nenaudojama GDB, aš norėčiau rekomenduojama žiūrėti trumpas

1385
01:25:27,650 --> 01:25:31,250
tiesiog vyksta per ką GDB, kaip jūs su juo dirbti, kaip jūs galite naudoti ją,

1386
01:25:31,250 --> 01:25:32,900
ir išbandyti jį dėl programos.

1387
01:25:32,900 --> 01:25:37,400
Ir kas iš to GDB leidžia jums padaryti tai leidžia laikinai sustabdyti [nesuprantamas] Iki savo programą

1388
01:25:37,400 --> 01:25:38,920
ir praktinis linija.

1389
01:25:38,920 --> 01:25:42,600
Pavyzdžiui, aš noriu, kaip mano programa 3 eilutėje, norėdami laikinai sustabdyti vykdymo,

1390
01:25:42,600 --> 01:25:46,010
ir, o aš 3 eilutėje galiu atspausdinti visas vertes, kurios yra ten.

1391
01:25:46,010 --> 01:25:49,710
Ir taip, ką mes vadiname kaip pristabdžius linija

1392
01:25:49,710 --> 01:25:52,350
mes vadiname tai atskaitos tašką tos linijos

1393
01:25:52,350 --> 01:25:55,920
ir tada mes galime spausdinti kintamuosius programos būklę tuo metu.

1394
01:25:55,920 --> 01:25:58,990
>> Mes galime iš ten žingsnis per programą, eilutė po eilutės.

1395
01:25:58,990 --> 01:26:03,200
Ir tada mes galime pažvelgti į kamino būklę tuo metu.

1396
01:26:03,200 --> 01:26:08,600
Ir todėl, siekiant naudoti gdb, ką mes darome, mes vadiname Apsukite metalinis garsas C failą,

1397
01:26:08,600 --> 01:26:11,290
bet turime priimti-ggdb vėliava.

1398
01:26:11,290 --> 01:26:15,850
Ir vieną kartą baigsime su tuo mes tiesiog paleisti gdb gautame išvesties failo.

1399
01:26:15,850 --> 01:26:18,810
Ir tokiu būdu jūs gaunate, kaip šis, kai, pavyzdžiui, teksto masę

1400
01:26:18,810 --> 01:26:21,990
bet tikrai ne visi, ką jums reikia padaryti, tai tipo komandų pradžioje.

1401
01:26:21,990 --> 01:26:24,250
Break pagrindinis nurodo atskaitos tašką pagrindinis.

1402
01:26:24,250 --> 01:26:28,470
Sąrašas 400 išvardyti kodo linijomis aplink linija 400.

1403
01:26:28,470 --> 01:26:31,410
Ir todėl šiuo atveju galite tiesiog apsižvalgyti ir pasakyti, Oh,

1404
01:26:31,410 --> 01:26:34,360
Noriu nustatyti atskaitos tašką, 397 eilutėje, kurioje yra ši eilutė,

1405
01:26:34,360 --> 01:26:37,170
ir tada jūsų programa veikia į šio žingsnio ir ji ketina nutraukti.

1406
01:26:37,170 --> 01:26:41,120
Ji ketina pristabdyti ten ir galite atsispausdinti, pavyzdžiui, vertė maža, ar didelė.

1407
01:26:41,120 --> 01:26:46,410
Ir todėl yra komandų krūva, jums reikia žinoti,

1408
01:26:46,410 --> 01:26:48,660
ir tai skaidrių peržiūrą bus eiti į svetainę,

1409
01:26:48,660 --> 01:26:54,000
todėl, jei jūs tiesiog norite tai nuoroda ar kaip įdėti juos į savo Ruošinukai, jaustis laisvai.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Tai buvo Viktorina apžvalga 0, ir mes klijuoti aplink, jei turite kokių nors klausimų.

1411
01:27:00,650 --> 01:27:03,850
Gerai.

1412
01:27:03,850 --> 01:27:09,030
>>  [Plojimai]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]