[Powered by Google Translate] [Review] [viktorīna 0]
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Jāzeps Ong] [Hārvarda]
>> [Tas ir CS50.] [CS50.TV]
>> Hei, visi.
Laipni uz pārskata sesiju 0 viktorīnā, kas notiek šo trešdien.
Ko mēs darīsim šovakar, es esmu ar 3 citiem TFS,
un kopā mēs gatavojamies iet cauri pārskatu par to, ko mēs esam darījuši gaitā līdz šim.
Tas nav būs 100% pilnīgs, bet tas būtu jums labāku priekšstatu
ko jums jau ir uz leju, un to, kas jums joprojām ir nepieciešams mācīties, pirms trešdien.
Un justies brīvi, lai palielinātu savu roku ar jautājumiem, kā mēs ejam kopā,
bet paturiet prātā, ka mums būs arī mazliet laika beigās-
ja mēs pārdzīvosim ar dažām minūtēm, lai rezerves, lai do vispārīgus jautājumus,
lai saglabātu, ka prātā, un tāpēc mēs esam gatavojas sākt sākumā ar 0 Week.
>> [Viktorīna 0 Review!] [Daļa 0] [Lexi Ross] Taču, pirms mēs, pieņemsim runāt par
loģistiku viktorīnas.
>> [Loģistika] [Viktorīna notiek trešdien 10/10 vietā lekciju]
>> [(Skatīt http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf sīkāku informāciju)] Tas ir par trešdiena 10 oktobris.
>> Tas ir šo trešdien, un, ja jūs iet uz šo URL šeit,
kas ir pieejams arī no CS50.net-tur ir saite uz to,
Jūs varat redzēt informāciju par to, kur doties, pamatojoties uz
Jūsu uzvārds vai skolas piederībai, kā arī
tā stāsta par to, kādi viktorīna segs un par jautājumiem, veidiem, ka jūs gatavojas saņemt.
Paturiet prātā, ka jums ir arī iespēja pārskatīt uz viktorīnu sadaļā,
lai jūsu TFS būtu iet pa dažiem prakses problēmām,
un tas ir vēl viens labs iespēja redzēt, kur jums joprojām ir nepieciešams mācīties izveidota viktorīnas.
Sāksim sākumā ar biti 'n' baitiem.
Atcerieties bits ir tikai 0 vai 1,
un baits ir kolekcija 8 no šiem bitiem.
Apskatīsim šo kolekciju bitiem šeit.
Mums jāspēj izrēķināt, cik bitus tur ir.
Kur mēs paļaujamies tur ir tikai 8 no tiem, astoņas 0 vai 1 vienības.
Un tā kā tur ir 8 biti, kas ir 1 baits,
un pieņemsim pārvērst to heksadecimālo.
Heksadecimālais ir bāze 16, un tas ir diezgan viegli pārveidot
binārā skaits, kas ir tas, kas ir uz vairākiem heksadecimālā.
Viss, kas mums jādara, ir aplūkojam grupām 4,
un mēs pārvērst tos uz atbilstošu heksadecimālo cipara.
Mēs sākam ar labo visvairāk grupā 4, tāpēc 0011.
Tas būs viens 1 un vienu 2, lai kopā, kas padara 3.
Un tad pieņemsim apskatīt citu bloku gada 4.
1101. Tas būs viens 1, viena 4, un viens 8.
Kopā, ka būs 13, kas padara D.
Un mēs atcerēties, ka heksadecimālā mēs ne tikai iet no 0 līdz 9.
Mēs iet no 0 līdz F, lai pēc 9, 10, atbilst,
11 B, uc kur F ir 15.
Šeit 13 ir D,
tāpēc, lai pārvērstu to par decimālu visi mēs darām, ir mēs patiesībā
ārstēt katru pozīciju jauda 2.
Tas ir viens 1, vienu 2, nulle 4s, nulle 8s, viens 16, un tā tālāk,
un tas ir mazliet grūti aprēķināt jūsu galvas, bet, ja mēs ejam uz nākamo slaidu
mēs varam redzēt atbildi uz to.
>> Būtībā mēs ejam pretī tiesības atpakaļ uz kreiso,
un mēs reizinot katra cipara ar attiecīgo jaudu gada 2.
Un atcerieties, lai heksadecimālā mēs apzīmētu šos skaitļus ar 0x sākumā
tāpēc mēs nejauciet to ar decimālskaitlis.
Turpinot par, tas ir ASCII tabulā,
un ko mēs izmantojam ASCII lai ir kartēt no burtiem, lai skaitliskās vērtības.
Atceros kriptogrāfijas PSET mēs plaši izmanto ASCII tabulā
Lai izmantotu dažādas metodes kriptogrāfija,
Cēzars un Vigenère šifra, lai pārvērstu dažādus burtus
virknē Saskaņā ar atslēgu, ko lietotājs.
Apskatīsim mazliet ASCII math.
Aplūkojot "P" + 1, jo raksturs formā, kas būtu Q,
un atcerēties, ka 5 "≠ 5.
Un kā tieši tas mums konvertēt starp šiem 2 veidu?
Tas nav reāli pārāk grūti.
Lai iegūtu 5 mēs atņemt '0 '
jo ir 5 vietas starp šobrīd '0 'un '5. "
Lai iet citu ceļu, mēs vienkārši pievienojiet 0,
tāpēc tas ir sava veida, piemēram regulāri aritmētisko.
Tikai atceraties, ka tad, kad kaut kas ir pēdiņas ap to, tas ir raksturs
un tādējādi atbilst vērtību ASCII tabulu.
Pārcelšanās uz vispārīgākiem datorzinātņu tēmām.
Mēs uzzinājām kāda algoritms ir un kā mēs izmantojam programmēšana
lai īstenotu algoritmiem.
Daži algoritmu piemēri ir kaut kas patiešām vienkāršs, piemēram,
pārbaudīt, vai skaitlis ir pāra vai nepāra.
Par to atceros, mēs mod skaitu ar 2 un pārbaudīt, ja rezultāts ir 0.
Ja tā, tas ir pat. Ja tā nav, tas ir dīvaini.
Un tas ir piemērs patiešām pamata algoritms.
>> Mazliet vairāk iesaistīts viens ir binārs meklēt,
kas mēs iet pār vēlāk pārskatīšanas sesijā.
Un programmēšana ir termins, mēs izmantojam, lai veiktu algoritmu
un pārveidojot to kodu datoru var lasīt.
2 piemēri par plānošanas Scratch,
kas ir tas, ko mēs darījām 0 nedēļa.
Pat ja mums nav reāli tipa no kodu tas veids, kā īstenot
Šis algoritms, kas drukāšanas skaitļi 1-10,
un šeit mēs to pašu C programmēšanas valodu.
Tie ir funkcionāli līdzvērtīgi, vienkārši rakstīts dažādās valodās vai sintakse.
Mēs tad uzzināja par boolean izteiksmes,
un Būla ir vērtība, kas ir vai nu patiess vai nepatiess,
un šeit nereti Būla izteiksmes
iet iekšā nosacījumu, tādēļ, ja (x ≤ 5),
labi, mēs jau noteikti x = 5, tāpēc šis nosacījums ir gatavojas novērtēt taisnība.
Un, ja tā ir taisnība, neatkarīgi kods ir zem nosacījuma
būs jānovērtē ar datoru, lai virkne būs jādrukā
standarta produkciju, un termiņu stāvokli
attiecas uz visu, kas iekšpusē no IF iekavās.
Atcerēties visus uzņēmējus.
Atcerieties, tas ir && un | | kad mēs cenšamies apvienot 2 vai vairāk nosacījumus,
== Nevis = pārbaudīt, vai 2 lietas ir vienādi.
Atcerieties, ka = ir ieskaitīšanai tā == ir Būla operators.
≤, ≥ un tad gala 2 ir pašsaprotami.
Vispārējs pārskats par Būla loģika šeit.
Un Būla izteiksmes ir svarīgi arī cilpas,
kas mēs iet pār tagad.
Mēs mācījāmies par 3 veidu cilpas līdz šim CS50, lai, savukārt, un darīt savukārt.
Un tas ir svarīgi zināt, ka, kamēr vairumam vajadzībām
mēs faktiski var izmantot jebkura veida cilpas kopumā
ir daži veidi, mērķiem vai kopējām tendencēm
programmēšanā, kas īpaši aicinām uz vienu no šiem cilpas
kas padara to par visefektīvāko vai elegants ar kodu tieši tā.
Iesim pa to, ko katrs no šiem cilpas mēdz izmantot visbiežāk.
>> Jo lai cilpa mēs parasti jau zinām, cik reizes mēs vēlamies atkārtot.
Tas, ko mēs ieliekam stāvoklī.
Jo, i = 0, i <10, piemēram.
Mēs jau zinām, ka mēs vēlamies kaut ko darīt 10 reizes.
Tagad, par kamēr cilpa, parasti mēs ne vienmēr
zināt, cik reizes mēs vēlamies cilpa palaist.
Bet mēs zinām kaut kādas nosacījumu, ka mēs gribam, lai
vienmēr būs taisnība, vai vienmēr būt nepatiesa.
Piemēram, lai gan ir noteikts.
Pieņemsim, ka ir Būla mainīgs.
Bet tā ir taisnība, mēs vēlamies kodu novērtēt,
tāpēc mazliet vairāk paplašināmas, nedaudz plašāks nekā uz cilpas,
bet jebkura cilpa var arī pārvērst par kamēr cilpa.
Visbeidzot, darīt, kamēr cilpas, kas var būt visgrūtākais, lai saprastu uzreiz,
bieži lieto, ja mēs gribam, lai novērtētu kodu Pirmkārt
Pirms pirmo reizi mēs pārbaudīt stāvokli.
Kopējā izmantošanas gadījumā darīt, kamēr cilpa
ir, kad jūs vēlaties, lai saņemtu lietotāja ievadi, un jūs zināt, ko vēlaties uzdot lietotājam
par ieguldījumu vismaz vienu reizi, bet, ja tie nav sniegt jums labu ieguldījumu uzreiz
Jūs vēlaties, lai saglabātu lūdzot tos, līdz tie dod jums labu ievadi.
Tas ir visbiežāk izmanto do kamēr cilpa,
un pieņemsim apskatīt faktisko struktūru šo cilpas.
Viņi parasti vienmēr ir tendence sekot šiem modeļiem.
>> Par priekšlikumu cilpa iekšā jums ir 3 sastāvdaļas:
inicializācijas, parasti kaut kā int i = 0, ja i ir skaitītājs,
nosacījumu, ja mēs vēlamies pateikt palaist šo par cilpa, kamēr šis nosacījums joprojām pieder,
Tāpat kā es <10, un tad beidzot, atjauninājumu, kas ir kā mēs pieauguma
skaitītājs mainīgais katrā brīdī cilpa.
Kopīga lieta, lai redzētu, ka ir tikai i + +,
kas nozīmē pieauguma i 1 katru reizi.
Jūs arī varētu darīt kaut kas līdzīgs i + = 2,
kas nozīmē pievieno 2 līdz i katru reizi, kad iet caur cilpu.
Un tad izdarīt tikai attiecas uz jebkuru kodu, kas faktiski darbojas kā daļa no cilpas.
Un, kamēr cilpa, šoreiz mums tiešām ir inicializācijas ārpus cilpas,
tā, piemēram, teiksim, mēs cenšamies darīt to pašu veida cilpas, kā es tikko aprakstīts.
Mēs varētu teikt int i = 0 līdz cilpa sākuma.
Tad mēs varētu teikt, bet es <10 darīt,
tā pati bloku kods kā līdz šim,
un šoreiz atjauninājums daļa no koda, piemēram, i + +,
faktiski iet iekšā no cilpas.
Un visbeidzot, lai darīt, bet, tas ir līdzīgs kamēr cilpa,
bet mums ir jāatceras, ka kods būs novērtēt, kad
pirms stāvoklis tiek pārbaudīts, tāpēc tas padara daudz nozīmē
ja paskatās uz to, lai no augšas uz apakšu.
Jo darīt, kamēr cilpa kodu izvērtē pirms Jūs pat apskatīt kamēr stāvoklī,
tā kā kamēr cilpa, tā pārbauda pirmais.
Paziņojumus un mainīgie.
Ja mēs vēlamies, lai izveidotu jaunu mainīgo mēs vispirms vēlamies, lai sāktu to.
>> Piemēram, int bārs inicializē mainīgo joslu,
bet tas nav arī tā vērtību, lai kāda ir bāra vērtība tagad?
Mēs nezinām.
Tas varētu būt daži atkritumu vērtība, kas bija agrāk glabā atmiņā tur,
un mēs negribam, lai izmantotu šo mainīgo
kamēr mēs patiesībā arī tā vērtību,
tāpēc mēs paziņojam to šeit.
Tad mēs sāktu, lai to tālāk norādīto 42.
Tagad, protams, mēs zinām to var izdarīt vienā rindā, int bārs = 42.
Bet tikai, lai nodzēstu vairākas darbības, kas notiek,
deklarācija un inicializācijas ir notiek atsevišķi šeit.
Tas notiek uz vienu soli, un nākamais, int baz = bar + 1,
Šis apgalvojums zemāk, ka pieaugumu baz, tāpēc beigās šo kodu bloku
ja mēs drukāt vērtību Baz tas bija 44
jo mēs atzīt un sāktu to par 1> bārs,
un tad mēs pieauguma to vēlreiz ar + +.
Mēs devāmies pār šo diezgan īsi, bet tas ir labi, ka vispārējā
izpratne par to, ko diegi un notikumi ir.
Mēs galvenokārt darīja to nulles,
lai jūs varētu domāt par diegiem kā daudzas sekvences kodu
darbojas tajā pašā laikā.
In aktualitāte, tas, iespējams, nedarbojas tajā pašā laikā,
bet veida abstrakti mēs varam domāt par to šādā veidā.
>> Nokasāmajās Piemēram, mums bija vairākas sprites.
Tas varētu būt izpildes citu kodu tajā pašā laikā.
Varētu būt iešana, bet otrs saka kaut
citā daļā no ekrāna.
Notikumi ir vēl viens veids, nošķirot to loģiku
dažādo elementu savu kodu,
un nulles, mēs varējām simulēt notikumus, izmantojot raidījuma
un tas ir patiesībā, kad es saņemšu, nevis tad, kad es dzirdēt,
bet būtībā tas ir veids, lai pārraidītu informāciju
no vienas Sprite uz otru.
Piemēram, jūs varat nosūtīt spēli vairāk,
un kad cits elfa saņem spēli vairāk,
tas reaģē noteiktā veidā.
Tas svarīgi modeli, lai saprastu par programmēšanu.
Tikai iet pār pamata nedēļā 0, ko mēs esam izgājuši vairāk nekā līdz šim,
aplūkosim šo vienkāršo C programmu.
Teksts var būt mazliet maza no šejienes, bet es iešu pār to tiešām ātri.
Mēs esam skaitā 2 header failus augšā, cs50.h un stdio.h.
Mēs tad nosakot konstantu sauc robežu, ir 100.
Mēs esam tam īstenotu mūsu galveno funkciju.
Tā kā mēs neizmantojam komandrindas argumentus šeit mums ir nepieciešams īstenot tukšumu
kā par galveno argumentu.
Mēs redzam int iepriekš galvenais. Tas ir atgriešanās tips, tātad atgriezties 0 apakšā.
Un mēs esam izmantojot CS50 bibliotēkas funkciju iegūt int
pieprasīt no lietotāja ievadi, un mēs saglabājam to šajā mainīgā x,
tāpēc mēs paziņojam x iepriekš, un mēs sāktu to ar x = GetInt.
>> Mēs pēc tam pārbaudiet, ja lietotājs deva mums labu ieguldījumu.
Ja tas ir ≥ LIMIT mēs vēlamies atgriezties kļūdas kodu 1 un izdrukāt kļūdas ziņojumu.
Un, visbeidzot, ja lietotājs ir devis mums labs ieguldījums
mēs ejam uz kvadrātveida numuru un izdrukāt šo rezultātu.
Tikai, lai pārliecinātos, ka tie visi hit mājās
Jūs varat redzēt etiķetes dažādām kodu šeit.
Es teicu konstante, header failus.
Ak, int x. Pārliecinieties atcerēties, ka ir vietējais mainīgs.
Kas kontrastē no globālā mainīgā, ko mēs runājam par
nedaudz vēlāk pārskata sesijā,
un mēs aicinām bibliotēkas funkciju printf,
tāpēc, ja mēs nebūtu iekļauta stdio.h header failu
mēs nevarētu zvanīt printf.
Un es uzskatu, ka bulta, kas ieguva nogrieza šeit ir vērsta uz% d,
kas ir formatēšanas virknes printf.
Tajā teikts izdrukāt šo mainīgo kā numuru,% d.
Un tas ir tas par 0 Week.
Tagad Lucas gatavojas turpināt.
Hei, puiši. Mans vārds ir Lucas.
Es esmu sophomore kas vislabāk māja Campus, Mather,
un es esmu gatavojas runāt mazliet par Nedēļu 1 līdz 2,1.
[Nedēļu 1 un 2.1!] [Lucas Freitas]
Kā Lexi teica, kad mēs sākām tulkojot savu kodu no nulles līdz C
viena no lietām, ko mēs pamanījuši, ka jūs varat ne tikai
rakstīt savu kodu un palaist to, izmantojot zaļo karogu vairs.
Patiesībā, jums ir izmantot dažus pasākumus, lai padarītu jūsu C programmu
kļūt izpildāmo failu.
Būtībā tas, ko jūs darāt, kad jūs esat rakstiski programma ir, ka
Jums tulkot savu ideju valodā ka kompilators var saprast,
tāpēc, ja jūs esat rakstiski programmu C
ko jūs darāt, ir faktiski rakstot kaut kas jūsu kompilators gatavojas saprast,
un tad kompilators gatavojas tulkot šo kodu
kaut ka jūsu dators sapratīs.
>> Un lieta ir, dators ir tiešām ļoti muļķīgi.
Dators var tikai saprast 0s un 1s,
tāpēc faktiski pirmo datoru cilvēki parasti ieprogrammēta
izmantojot 0s un 1s, bet ne vairs, paldies Dievam.
Mums nav nepieciešams iegaumēt secību par 0s un 1s
par cilpa vai par kamēr cilpa un tā tālāk.
Tieši tāpēc mums ir kompilatoru.
Kas kompilators tas ir tas būtībā pārveido C kodu,
mūsu gadījumā, uz valodu, ka jūsu dators sapratīs,
kas ir objekta kodu, un kompilators ka mēs esam izmantojot
sauc šķindoņa, tāpēc tas ir faktiski simbols šķindēt.
Ja jums ir jūsu programma, kas Jums jādara 2 lietas.
Pirmkārt, jums ir apkopot savu programmu, un tad jūs gatavojas palaist savu programmu.
Sastādīt savu programmu jums ir daudz iespējas to darīt.
Pirmais ir jādara šķindēt program.c
kurā programma ir nosaukums jūsu programmā.
Šajā gadījumā jūs varat redzēt, ka viņi vienkārši pasakot "Hei, sastādīt savu programmu."
Tu neesi sakot: "Es vēlos šo nosaukumu manā programmā" vai neko.
>> Otrais variants dod nosaukumu ar savu programmu.
Jūs varat teikt šķindoņa-o un tad vārds, kas jūs vēlaties
izpildāmo failu, kas nosaukts kā un pēc tam program.c.
Un jūs varat arī darīt veikt programmu, un redzēt, kā pirmajās 2 gadījumos
Man C,. Un trešais man ir tikai programmas?
Jā, jūs faktiski nav jākļūst c kad lietojat darīt..
Citādi kompilators ir faktiski gatavojas kliegt pie jums.
Un arī, es nezinu, ja jūs guys atcerēties,
bet daudz reižu mēs arī izmanto-lcs50 vai-LM.
Ka sauc savieno.
Tas tikai stāsta kompilators, ka jūs izmantot šīs bibliotēkas labi tur,
tādēļ, ja jūs vēlaties izmantot cs50.h jūs faktiski ir rakstīt
šķindoņa program.c-lcs50.
Ja jums nav darīt, kompilators nav gatavojas zināt
ka jūs izmantojat šos funkcijas cs50.h.
Un, kad jūs vēlaties, lai palaistu savu programmu, jums ir 2 iespējas.
Ja jūs šķindēt program.c jums nav dot nosaukumu ar savu programmu.
Jums ir palaist to izmantojot. / A.out.
A.out ir standarta vārds, kas šķindēt dod savu programmu, ja jums nav arī tā nosaukumu.
Pretējā gadījumā jūs gatavojas darīt. / Programmu, ja jums deva vārdu ar savu programmu,
un arī tad, ja jūs padarīt programmas nosaukumu, programma ir gatavojas iegūt
jau būs ieprogrammēts tāds pats nosaukums kā C failu.
Tad mēs runājām par datu tipiem un datu.
>> Būtībā datu veidi ir tas pats, kas maz kastes viņi izmanto
uzglabāt vērtības, tāpēc datu tipi ir faktiski tāpat kā Pokémons.
Tās ir visās izmēru un veidu.
Es nezinu, ja tas analoģija ir jēga.
Datu apjoms faktiski ir atkarīga no mašīnas arhitektūru.
Visi dati izmēri, ka es esmu gatavojas parādīs šeit
ir faktiski par 32 bitu mašīna, kas ir gadījums mūsu ierīces,
bet, ja jūs faktiski kodēšanas jūsu Mac vai Windows arī
iespējams, jums nāksies 64 bitu mašīna,
tāpēc atcerieties, ka datu izmēri, ka es esmu gatavojas parādīs šeit
ir par 32-bitu mašīna.
Pirmais, ko mēs redzējām, bija int,
kas ir diezgan vienkārši.
Jūs varat izmantot int uzglabāt skaitlim.
Mēs redzējām arī raksturs, tad char.
Ja jūs vēlaties izmantot burtu vai maz simbolu jūs, iespējams, gatavojas izmantot char.
CHAR ir 1 baits, kas nozīmē 8 bitiem, piemēram, Lexi teica.
Būtībā mums ir ASCII tabula, kas ir 256
iespējamās kombinācijas 0s un 1s,
un tad, kad jūs tipa char tas notiek tulkot
raksturu, kas ieejas jūs skaitlis, kas jums ir ASCII tabulā, tāpat Lexi teica.
Mums ir arī peldēt, ko mēs izmantojam, lai uzglabātu decimāldaļu skaitu.
Ja jūs vēlaties, lai izvēlētos 3,14, piemēram, jūs gatavojas izmantot, apgrozāmos
vai dubultā, kas ir lielāka precizitāte.
Pludiņš ir 4 baiti.
Dubultā ir 8 baiti, tāpēc vienīgā atšķirība ir precizitāte.
Mums ir arī sen, kas tiek izmantots skaitļu,
un jūs varat redzēt uz 32-bitu mašīna int un sen ir vienāda izmēra,
tāpēc nav īsti jēgas lietot ilgi 32-bitu mašīna.
>> Bet, ja jūs izmantojat Mac un 64 bitu mašīna, faktiski sen ir izmērs 8,
tā tas tiešām ir atkarīgs no arhitektūru.
Par 32-bitu mašīna tā nav jēgas lietot ilgi tiešām.
Un tad ilgi ilgi, no otras puses, ir 8 baiti,
tāpēc ir ļoti labi, ja jūs vēlaties, lai ir garāks skaitlim.
Un visbeidzot, mums ir virkne, kas ir faktiski char *,
kas ir rādītājs uz char.
Tas ir ļoti viegli domāt, ka virknes lielums būs līdzīgi
rakstzīmju skaitu, kas jums ir tur,
bet patiesībā char * pati
ir lielums rādītājs uz char, kas ir 4 baiti.
No char * izmērs ir 4 baiti.
Tas nav svarīgi, ja jums ir neliela vārdu vai vēstuli vai neko.
Tas būs 4 baiti.
Mēs arī iemācījušies mazliet par liešana,
lai jūs varētu redzēt, ja jums ir, piemēram, programma, kas saka
int x = 3 un tad printf ("% d" x / 2)
Vai jūs guys zināt, kas tas notiek, lai drukātu uz ekrāna?
>> Kāds >> [Studentiem] 2?.
1. >> 1, jā.
Kad jūs darīt 3/2 tas notiek, lai saņemtu 1,5,
bet kopš mēs esam izmantojot skaitlim tas notiek, lai ignorēt decimālā daļa,
un jūs gatavojas ir 1.
Ja jūs nevēlaties, ka, lai notiktu tas, ko jūs varat darīt, piemēram,
ir atzīt, apgrozāmos y = x.
Tad x, kas kādreiz bija 3 tagad būs 3,000 y.
Un tad jūs varat izdrukāt y / 2.
Patiesībā, es būtu 2. tur.
Tā gatavojas darīt 3.00/2.00,
un jūs gatavojas saņemt 1.5.
Un mums ir šī .2 f vienkārši lūgt 2 zīmes aiz vienību decimālo daļu.
Ja jums ir 0,3 f tas notiek, lai būtu reāli 1,500.
Ja tas ir 2 tas būs 1,50.
Mums arī ir šī lieta šeit.
Ja jūs float x = 3.14, un tad jūs printf x
jūs gatavojas saņemt 3.14.
Un, ja jūs x = int x,
kas nozīmē ārstēt X kā int, un jūs drukāt x tagad
Jums nāksies 3.00.
Vai ir jēga?
Jo jūs pirmo apstrādājot X kā veselums, tāpēc jūs ignorējot decimālā daļa,
un tad jūs drukāšanas x.
Un visbeidzot, jūs varat arī darīt,
int x = 65, un tad jums paziņot CHAR c = x,
un tad, ja jūs drukāt c jūs tiešām gatavojas saņemt
, Tāpēc būtībā, ko jūs šeit darāt
ir tulkojot skaitlim vērā raksturu,
tāpat ASCII tabulā dara.
Mēs arī runājām par math operatoriem.
Lielākā daļa no tām ir diezgan vienkārši, tāpēc +, -, *, /,
un arī mēs runājām par mod, kas ir atlikusī sadalīšanu 2 numuriem.
Ja jums ir 10% 3, piemēram,
tas nozīmē sadalīt 10 ar 3, un kāda ir atlikusī?
Tas būs 1, tāpēc tas ir tiešām ļoti noderīgs par daudz programmu.
Par Vigenère un Cēzara es esmu diezgan pārliecināts, ka visi no jums, puiši izmanto mod.
Par matemātikas operatoriem, jābūt ļoti uzmanīgiem, apvienojot * un /.
>> Piemēram, ja jūs (3/2) * 2, ko jūs gatavojas saņemt?
[Studentiem] 2.
Jā, 2, jo 3/2 būs 1,5,
bet tā kā jūs darāt operācijas starp 2 integers
jūs faktiski tikai gatavojas apsvērt 1,
un tad 1 * 2 būs 2, tāpēc jābūt ļoti, ļoti uzmanīgiem
veicot aritmētiskās ar veseliem skaitļiem, jo
Jūs varētu saņemt, ka 2 = 3, šajā gadījumā.
Un arī jābūt ļoti uzmanīgiem par prioritāti.
Jums vajadzētu parasti izmantot iekavas, lai pārliecinātos, ka jūs zināt, ko jūs darāt.
Daži noderīgi īsceļi, protams, viens ir man + + vai i + = 1
vai izmantojot + =.
Tas ir tas pats, kas dara i = i + 1.
Jūs varat arī man ir - vai man - = 1,
kas ir tas pats, kas i = i -1,
Kaut kas jums guys izmantot daudz uz cilpas, vismaz.
Arī, *, ja jūs izmantojat * = un, ja jūs, piemēram,
i * = 2 ir tas pats, kas sakot i = i * 2,
un pats par sadalīšanu.
Ja jums i / = 2 tas ir tas pats, kas i = i / 2.
>> Tagad par funkcijām.
Jūs puiši uzzināja, ka funkcijas ir ļoti laba stratēģija, lai saglabātu kodu
kamēr jūs programmēšana, tādēļ, ja jūs vēlaties, lai veiktu to pašu uzdevumu
kodā atkal un atkal, iespējams, jūs vēlaties izmantot funkciju
tikai tāpēc jums nav kopēt un ielīmēt kodu atkal un atkal.
Patiesībā, galvenais ir funkcija, un, kad es parādīs formātu funkciju
jūs gatavojas redzēt, ka tas ir diezgan skaidrs.
Mēs arī izmantot funkcijas no dažām bibliotēkām,
Piemēram, printf, getin, kas ir no CS50 bibliotēkas,
un citas funkcijas, piemēram, toupper.
Visas šīs funkcijas ir faktiski īstenoti citās bibliotēkās,
un kad jūs nodot šos piesiet failus sākumā savu programmu
Jūs sakāt, jūs varat lūdzu man kodu šīm funkcijām
tāpēc man nav, lai tos īstenot ar sevi?
Un jūs varat arī rakstīt savas funkcijas, tad, kad jūs sākat plānošanu
tu saproti, ka bibliotēkas nav visas funkcijas, kas jums nepieciešams.
Par pēdējo PSET, piemēram, mēs rakstīja izdarīt, motokross, un lookup,
un tas ir ļoti, ļoti svarīgi, lai varētu rakstīt funkcijas
jo tie ir noderīgi, un mēs tos izmantot visu laiku programmēšanas,
un tas ietaupa daudz kodu.
Par funkcija formāts tas ir viens.
Mums ir atgriešanās veidu sākumā. Kāda ir atgriešanās tips?
Tas ir tikai tad, kad jūsu funkcija ir gatavojas atgriezties.
Ja jums ir funkcija, piemēram, faktoru,
kas notiek, lai aprēķinātu faktoriālu veselam skaitlim,
Iespējams, tas notiek, lai atgrieztos skaitlim arī.
Tad atgriešanās tips būs int.
Printf faktiski ir atgriešanās tipa tukšumu
jo jūs neesat atgriežas neko.
Tu esi vienkārši izdrukāt lietas uz ekrāna
un atmest šo funkciju vēlāk.
Tad jums ir nosaukumu funkciju, ka jūs varat izvēlēties.
Jums vajadzētu būt mazliet saprātīgs, tāpat nav jāizvēlas vārds, piemēram, XYZ
vai līdzīgi x2f.
Mēģiniet veido vārdu, kas ir jēga.
>> Piemēram, ja tas ir faktoru, teiksim faktori.
Ja tas ir funkcija, kas gatavojas izdarīt kaut ko, nosaukt to izdarīt.
Un tad mums ir parametrus, kas ir arī sauc argumenti,
kas ir līdzīgi resursiem ka jūsu funkcija ir
no savu kodu, lai veiktu savu uzdevumu.
Ja jūs vēlaties, lai aprēķinātu skaitļa faktoriālu
iespējams, jums ir nepieciešams, lai ir vairāki aprēķināt faktori.
Viens no argumentiem, kas jums nāksies ir numurs pati.
Un tad tas notiek, lai kaut ko darīt, un jāatgriež vērtība gada beigās
ja vien tas nav spēkā funkcija.
Pieņemsim redzēt piemēru.
Ja es gribu uzrakstīt funkciju, kas summēts visus numurus masīvs integers,
pirmkārt, atgriešanās tips būs int
jo man ir masīvs integers.
Un tad es esmu nāksies funkcijas nosaukumu, piemēram sumArray,
un tad tas notiek, lai masīvs pati, lai int nums,
un tad garums masīva, lai es zinu, cik skaitļu man summa.
Tad man ir inicializēt mainīgo sauc summu, piemēram, uz 0,
un katru reizi, kad es redzu elementu masīvu man vajadzētu pievienot to summu, tāpēc es tomēr par cilpu.
Tāpat kā Lexi teica, jūs int i = 0, i <garumu un i + +.
Un par katru elementu masīvu I did summa + = nums [i],
un tad es atpakaļ summu, tāpēc tas ir ļoti vienkārši, un tas ietaupa daudz kodu
ja jūs izmantojat šī funkcija daudz reižu.
Tad mēs ņēmām apskatīt apstākļos.
Mums ir, ja cits, un cits ja.
Paskatīsimies, kāda ir atšķirība starp tiem.
Veikt apskatīt šiem 2 kodiem. Kāda ir atšķirība starp tiem?
Pirmais ir, būtībā kodi gribu jums pateikt
ja skaitlis ir +, -, 0 vai.
Pirmais saka: ja tas ir> 0, tad tas ir pozitīvi.
Ja tas ir = ar 0, tad tas ir 0, un, ja tas ir <0, tad tas ir negatīvs.
>> Un otrs dara, ja cits, ja cits.
Starp abiem atšķirība ir tā, ka šī ir patiešām gatavojas
pārbaudītu, vai> 0, <0 vai = 0 trīs reizes,
tādēļ, ja jums ir numurs 2, piemēram, tas notiek, lai nāk šeit un teikt
ja (x> 0), un tas notiek, lai teikt, jā, tāpēc es drukāt pozitīvi.
Bet pat ja es zinu, ka tas ir> 0 un tas nav būs 0 0 vai <
Es joprojām gatavojas darīt, ir tas 0, tas ir <0,
tāpēc es esmu tiešām iet iekšā IF ka man nebija
jo es jau zinu, ka tas nav gatavojas, lai apmierinātu kādu no šiem nosacījumiem.
Es varu izmantot, ja cits, ja cits paziņojums.
Tā būtībā saka, ja x = 0 Es izdrukāt pozitīvs.
Ja tā nav, es esmu gatavojas pārbaudīt arī šo.
Ja tas ir 2 ne es esmu gatavojas darīt.
Būtībā, ja man bija x = 2 tu teiktu
ja (x> 0), jā, tā drukāt šo.
Tagad, kad es zinu, ka tas ir> 0 un ka tā atbilst pirmā, ja
Es neesmu pat gatavojas palaist šo kodu.
Kods darbojas ātrāk, patiesībā, 3 reizes ātrāk, ja jūs izmantot šo.
Mēs arī uzzināja par un un vai.
Es neesmu gatavojas iet cauri, jo Lexi jau runāja par viņiem.
Tas ir tikai && un | | operatoru.
>> Vienīgais, ko es saku, ir jābūt uzmanīgiem, kad jums ir 3 nosacījumi.
Izmantot iekavas, jo tas ir ļoti mulsinoši, kad jums ir nosacījums
un vēl viens vai otrs.
Izmantot iekavas tikai, lai pārliecinātos, ka jūsu apstākļi jēgas
jo šajā gadījumā, piemēram, jūs varat iedomāties, ka
tas varētu būt pirmais nosacījums un vienu vai otru
vai 2 nosacījumi apvienoti un
vai trešais, tā vienkārši jābūt uzmanīgiem.
Un visbeidzot, mēs runājām par slēdžiem.
Slēdzis ir ļoti noderīgi, ja jums ir mainīgs.
Pieņemsim, ka jums ir mainīgs, piemēram, n
kas var būt 0, 1, 2 vai, un par katru no šiem gadījumiem
jūs gatavojas veikt uzdevumu.
Jūs varat teikt pārslēgties mainīgais, un tas liecina, ka
vērtība, tad ir kā vērtība1 es esmu gatavojas darīt,
un tad es pauze, kas nozīmē, es neesmu gatavojas apskatīt kādu citu gadījumu
jo mēs jau apmierināti, ka lietu
un tad vērtība2 un tā tālāk, un es arī varētu būt noklusējuma slēdzi.
Tas nozīmē, ja tas neatbilst kādam no gadījumiem, kas man bija
ka es esmu gatavojas darīt kaut ko citu, bet tas ir obligāti.
Tas ir viss, par mani. Tagad pieņemsim ir Tomiju.
Labi, tas būs nedēļa 3-ish.
Šie ir daži no jautājumiem, mēs būsim aptver, Kripto, apjomu, masīvus, uc.
Tikai ātri vārdu par crypto. Mēs nebrauksim, lai āmurs šīs mājas.
>> Mēs to darījām 2 PSET, bet viktorīnas pārliecinieties jūs zināt starpību
starp Cēzara šifra un Vigenère šifrētus,
kā gan no tiem cipariem darbu un to, ko tas ir tāpat kā šifrētu
un atšifrēt tekstu, izmantojot tās 2 šifriem.
Atcerieties, Cēzara šifra vienkārši rotē katru rakstzīmi par tādu pašu summu,
pārliecinoties, ka jums mod ar numuru burtiem alfabēta.
Un Vigenère šifra, no otras puses, rotē katru rakstzīmi
ar citu summu, lai nevis pasakot
Katram varonim pagriezts par 3 Vigenère rotēs katru rakstzīmi
ar citu summu atkarībā no dažiem atslēgvārdiem
kur katrs atslēgvārdu vēstule pārstāv kādu citu summu
lai pagrieztu skaidru tekstu,.
Pieņemsim vispirms runāt par mainīgo jomu.
Ir 2 dažādi veidi mainīgajiem.
Mums ir vietējo mainīgie, un tie būs jānosaka
ārpus galvenās vai ārpus jebkuras funkcijas vai bloku,
un tie būs pieejami jebkur jūsu programmā.
Ja jums ir funkcija un šāds statuss ir, bet cilpa
liels globāls mainīgais ir pieejama visur.
Vietējā mainīga, no otras puses, ir scoped uz vietu, kur tas tiek definēts.
>> Ja jums ir funkcija šeit, piemēram, mums ir šī funkcija g,
un iekšpusē g ir mainīgs šeit sauc y,
un tas nozīmē, ka šis ir vietējais mainīgs.
Pat ja šis mainīgais sauc y
un šis mainīgais sauc y šos 2 funkcijas
nav ne jausmas, ko viens otra vietējās mainīgie.
No otras puses, šeit mēs sakām int x = 5,
un tas ir ārpus jebkuras funkcijas.
Tas ir ārpus galvenā, tāpēc šis ir globāls mainīgais.
Tas nozīmē, ka iekšā no šiem 2 funkcijas, kad es saku x - vai x + +
Es esmu piekļūstot pašu x turklāt šis y un tas y ir dažādi mainīgie.
Tas ir starp pasaules mainīgo un vietējo mainīgajiem starpība.
Ciktāl dizains ir bažas, dažreiz tas ir iespējams, labāka ideja
saglabāt mainīgie vietējiem kad vien iespējams, var
jo ar globālo mainīgo ķekars var iegūt tiešām mulsinoši.
Ja jums ir ķekars funkcijas visu pārveidojot to pašu
jūs varētu aizmirst to, ko tad, ja šī funkcija nejauši izmaina šī globālā,
un tas citas funkcijas nezina par to,
un tas get diezgan mulsinoši, kā jūs iegūtu vairāk kodu.
Turot mainīgie vietējā kad vien iespējams, var
ir tikai labs dizains.
Bloki, atcerieties, ir vienkārši saraksti elementu paša tipa.
Iekšā KI nevar būt sarakstu, piemēram, 1, 2,0, sveiki.
Mēs vienkārši nevaram darīt.
>> Kad mēs deklarēt masīvu C visi elementi jābūt tā paša tipa.
Šeit man ir masīvs 3 integers.
Šeit es esmu garums masīva, bet, ja es esmu tikai deklarējot to šajā sintaksi
kur es jānorāda, kāda visi elementi man nav tehniski nepieciešams šo 3.
Kompilators ir pietiekami gudrs, lai saprastu, cik liels masīvs jābūt.
Tagad, kad es vēlos, lai saņemtu vai noteikt vērtību masīva
Tas ir sintakse, lai to izdarītu.
Tas būs tiešām mainīt otro elementu masīva, jo, atcerieties,
numerācija sākas ar 0, nevis 1.
Ja es gribu, lai lasītu šo vērtību es varu teikt kaut ko līdzīgu int x = array [1].
Vai, ja es gribu, lai noteiktu šo vērtību, piemēram, es esmu šeit darām,
Es varu teikt Array [1] = 4.
Tas laiks piekļuvei elementus ar to indekss
vai viņu stāvokli, vai ja tie ir masīvs,
un ka saraksts sākas ar 0.
Mēs varam būt arī masīvus masīvi,
un to sauc par daudzdimensiju masīvu.
Kad mums ir daudzpusīga masīvs
tas nozīmē, ka mēs varam būt kaut kas līdzīgs rindām un kolonnām,
un tas ir tikai viens veids, kā vizualizēt šīs vai domā par to.
Kad man ir daudzdimensiju masīvu, kas nozīmē, ka es esmu gatavojas sākt nepieciešams
vairāk nekā 1 indeksa, jo, ja man ir režģi
vienkārši sakot ko rinda tu esi mums nedod numuru.
Tas ir tiešām tikai gatavojas sniegt mums sarakstu numuriem.
Pieņemsim, ka man ir šī masīva šeit.
Man ir masīvs sauc režģis, un es saku, tas ir 2 rindas un 3 kolonnas,
un tāpēc tas ir viens veids, kā vizualizēt to.
Kad es saku es gribu, lai iegūtu elementu pie [1] [2]
tas nozīmē, ka, jo tie ir rindas vispirms un tad kolonnas
Es esmu gatavojas lēkt uz rinda 1, jo es teicu 1.
>> Tad es esmu gatavojas nākt nekā šeit uz 2 kolonnu, un es esmu gatavojas saņemt vērtība 6.
Jēga?
Daudzdimensiju masīvus, atceries, ir tehniski tikai masīvs masīvi.
Mēs varam būt masīvus bloki bloki.
Mēs varam glabāt notiek, bet tiešām viens veids, kā domāt par
Kā tas tiek izklāstīts un to, kas notiek, ir vizualizēt
režģī kā šis.
Kad mēs iet masīvus pēc funkcijām, viņi dodas uz uzvesties
mazliet savādāk, nekā tad, kad mēs iet regulāri mainīgie funkcijām
kā iet int vai peldēt.
Kad mēs iet uz int vai char vai kāds no šiem citiem datu tipiem
mēs vienkārši ņēma apskatīt, ja funkcija izmaina
vērtība no mainīgā ka izmaiņas nav gatavojas izplatīt augšu
uz izsaucēja funkcijas.
Ar masīvu, no otras puses, kas notiks.
Ja es iet masīvā uz kādu funkciju un šo funkciju mainās daži no elementiem,
kad es atgriezīšos līdz funkcijai, kas sauc to
mans masīvs tagad būs atšķirīgs, un par to vārdnīca
ir masīvi ir pagājis, atsaucoties, kā mēs redzēsim vēlāk.
Tas ir saistīts ar to, kā palīglīdzekļi darbu, ja šajās pamata datu veidiem,
no otras puses, ir pagājis pēc vērtības.
>> Mēs varam iedomāties, kas kā kopēšana dažu mainīgo un tad iet kopijā.
Tas nav svarīgi, ko mēs darām ar šo mainīgo.
Zvana funkcija nebūs zināms, ka tas tika mainīts.
Masīvi ir tikai nedaudz atšķirīgs šajā sakarā.
Piemēram, kā mēs tikko redzējām, galvenais ir vienkārši funkcija
kas var veikt 2 argumentiem.
Pirmais arguments, lai galvenā funkcija ir argc, vai vairākus argumentus,
un otrais arguments sauc argv,
un tie ir faktiskie vērtības šiem argumentiem.
Pieņemsim, ka man ir programmu, ko sauc this.c,
un es saku padara šo, un es esmu gatavojas palaist šo pie komandrindas.
Tagad iet dažās argumentus manā programmā sauc šo,
Es varētu teikt kaut ko līdzīgu / šis ir cs. 50.
Tas ir tas, ko mēs iedomāties Deivids darīt katru dienu pie termināla.
Bet tagad galvenais uzdevums iekšpusē šīs programmas
ir šīs vērtības, tāpēc argc ir 4.
Tas varētu būt nedaudz mulsinoši, jo tiešām mēs esam tikai brauc, ir cs 50.
Tas ir tikai 3.
Bet atcerieties, ka pirmā no argv elements vai pirmais arguments
ir nosaukums funkcijas pati.
Tātad tas nozīmē, ka mums ir 4 lietas šeit,
un pirmais elements būs. / šis.
Un tas tiks attēlots kā string.
Tad pārējie elementi ir tas, ko mēs drukāti pēc programmas nosaukumu.
Tā tāpat kā malā, kā mēs, iespējams, redzēja 2 PSET,
atcerieties, ka virkne 50 tiek ≠ skaitlim 50.
Tātad mēs nevaram teikt kaut ko līdzīgu, "int x = 3 argv."
>> Tas ir tikai nav gatavojas jēgas, jo tas ir virkne, un tas ir skaitlis.
Tātad, ja jūs vēlaties, lai pārvērstu starp 2, atceries, mēs spēsim
ir šī burvju funkciju sauc atoi.
Kas ņem stīgu un atgriež skaitlim pārstāv iekšpusē šajā virknē.
Tātad tas ir viegli kļūda izteikt uz viktorīnu,
tikai domāju, ka tas tiks automātiski pareizs veids.
Bet tikai zinu, ka tie vienmēr būs stīgas
pat ja virkne satur tikai skaitlim vai rakstzīmi vai peldēt.
Tāpēc tagad parunāsim par braukšanas laiku.
Kad mums ir visi šie algoritmi, kas darīt visas šīs trakas lietas,
tā kļūst patiešām lietderīgi uzdot jautājumu: "Cik ilgi viņi veic?"
Mēs pārstāvam ka ar kaut ko sauc par asimptotiskās notācija.
Tas nozīmē, ka - labi, pieņemsim, ka mēs dodam mūsu algoritms
daži tiešām, tiešām, tiešām liels ieguldījums.
Mēs vēlamies uzdot jautājumu: "Cik ilgi tas ir gatavojas veikt?
Cik soļus paies mūsu algoritmu, lai palaistu
atkarībā no lieluma ieejas? "
Tātad pirmais veids, kā mēs varam aprakstīt palaist laiku ir ar lielu O.
Un tas ir mūsu sliktāko darba laika.
Tātad, ja mēs gribam sakārtot masīvu, un mēs dodam mūsu algoritmu masīvs
tas dilstošā secībā, ja tas būtu augošā secībā,
kas būs sliktākais gadījums.
Šī ir mūsu augšējā robeža ir maksimālais laika mūsu algoritms būs.
No otras puses, šī Ω gatavojas aprakstīt labākajā gadījumā darba laika.
Tātad, ja mēs dodam jau ir sakārtoti masīvs šķirošanas algoritmu,
cik ilgs laiks būs vajadzīgs, lai sakārtotu to?
Un tas, pēc tam, apraksta zemākā darba laika.
Tāpēc šeit ir tikai daži vārdi, kas raksturo dažas kopējas darbības laiku.
Tie ir augošā secībā.
Ātrākais darbības laiks mums ir sauc nemainīgs.
>> Tas nozīmē, ka nav svarīgi, cik daudz elementu mēs dodam mūsu algoritms,
Nav svarīgi, cik liels mūsu masīvs, šķirošanu to
vai darot neatkarīgi mēs darām ar masīvu vienmēr būs tikpat daudz laika.
Tātad, mēs varam apliecināt, ka tikai ar 1, kas ir nemainīgs.
Mēs arī paskatījās logaritmisko palaist laikā.
Tātad kaut kas līdzīgs binārā meklēšana ir logaritmiska,
kur mēs samazināt problēmu ilgāks eliminācijas katru reizi
un tad lietas tikai iegūt augstāku no turienes.
Un, ja jūs esat kādreiz rakstot O jebkura faktoriālo algoritmu,
jūs, iespējams, nevajadzētu uzskatīt to par savu dienas darbu.
Ja mēs salīdzinām skriešanas reizes tas ir svarīgi paturēt prātā šīs lietas.
Tātad, ja man ir algoritms, kas ir O (N), un kāds cits
ir O algoritms (2n) tie ir faktiski asimptotiski līdzvērtīgi.
Tātad, ja mēs iedomājamies n būt liels skaits piemēram miljardi eleventy:
tad, kad mēs esam salīdzinot eleventy miljardus kaut ko līdzīgu miljardiem eleventy +3,
pēkšņi, ka 3 nav īsti liela atšķirība vairs.
Tieši tāpēc mēs esam gatavojas sākt apsvērt šīs lietas ir līdzvērtīgas.
Tātad lietas, piemēram, šīm konstantēm šeit, tur ir 2 x šo, vai pievienojot 3,
šie ir tikai konstantes, un tie gatavojas piliens uz augšu.
Tātad, tāpēc visi šie jaunākas reizes 3 ir tāds pats, kā saka viņi O (N).
Tāpat, ja mums ir 2 citas palaist reizes, teiksim O (n ³ + 2n ²), mēs varam pievienot
+ N, + 7, un tad mums ir cita darbības laiku, kas ir tikai O (n ³).
atkal, tie ir tas pats, jo tie - tie nav vienādi.
Tās ir tās pašas lietas, piedodiet. Tātad tas ir tas pats, jo
this n ³ gatavojas dominēt šajā 2n ².
>> Kas nav tā pati lieta ir, ja mēs esam palaist reizes, piemēram, O (n ³) un O (N ²)
jo tas n ³ ir daudz lielāks nekā šo n ².
Tātad, ja mums ir exponents, pēkšņi tas sāk jautājums,
bet, kad mēs esam tikai nodarbojas ar faktoriem, jo ​​mēs esam šeit,
tad tas nav dodas uz jautājumu, jo tie ir tikai gatavojas pamest.
Pieņemsim to apskatīt dažas no algoritmiem, mēs esam redzējuši līdz šim
un runāt par savu darbības laiku.
Pirmais veids meklē numuru sarakstā, ko mēs redzējām, bija lineāra meklēt.
Un lineārās meklēšanas īstenošana ir super vienkārša.
Mums vienkārši ir saraksts, un mēs ejam apskatīt katru elementu sarakstā
kamēr mēs atrastu numuru mēs meklējam.
Tātad tas nozīmē, ka sliktākajā gadījumā, tas O (N).
Un sliktākais gadījums varētu būt, ja elements ir
pēdējais elements, tad, izmantojot lineāro meklēšanu mums ir jāskatās uz katru elementu
kamēr mēs to pēdējais, lai zinām, ka faktiski tas bija sarakstā.
Mēs nevaram vienkārši atmest pusceļā un saka: "Tas droši vien nav tur."
Ar lineāro meklēšanu mums ir jāskatās uz visu lieta.
Labākajā gadījumā piestrādes laiks, no otras puses, ir nemainīga
jo labākajā gadījumā elements mēs meklējam, ir tikai pirmais sarakstā.
Tātad tas ir gatavojas veikt mums tieši 1 solis, lai cik liels šis saraksts ir
ja mēs meklējam pirmo elementu katru reizi.
>> Tātad, ja jūs meklēt, atcerieties, tas nenozīmē, ka mūsu saraksts tiks sakārtots.
Jo mēs vienkārši dodas meklēt pa katru elementu, un tas nav īsti jautājums
ko lai šie elementi ir iekšā
Vairāk viedo meklēšanas algoritms ir kaut kas līdzīgs bināro meklēšanu.
Atcerieties, ka bināro meklēšanas ieviešana ir, kad jūs gatavojas
glabāt meklējat pie vidū sarakstā.
Un tāpēc mēs meklējam vidū, mēs pieprasām, lai saraksts ir sakārtots
vai arī mēs nezinām, kur pa vidu ir, un mums ir jāskatās pāri
viss saraksts, lai atrastu to, un tad tajā brīdī mēs esam tikai tērēt laiku.
Tātad, ja mums ir sakārtoti sarakstu, un mēs atrast vidū, mēs ejam, lai salīdzinātu vidū
līdz elementam mēs meklējam.
Ja tas ir pārāk augsts, tad mēs varam aizmirst labajā pusē
jo mēs zinām, ka, ja mūsu elements ir jau pārāk liels
un viss pa labi no šā elementa ir vēl lielāks,
tad mums nav nepieciešams meklēt tur vairs.
Kur no otras puses, ja mūsu elements ir pārāk mazs,
mēs zinām viss pa kreisi no šī elementa ir pārāk zems,
tāpēc nav īsti jēgas meklēt tur, vai nu.
Tādā veidā, ar katru soli un katru reizi mēs skatāmies viduspunktā saraksta,
mēs spēsim samazināt mūsu problēmas uz pusi, jo pēkšņi mēs zinām
viss ķekars numuriem, kas var nebūt viens mēs meklējam.
>> Jo pseudocode tas varētu izskatīties kaut kas līdzīgs šim,
un tāpēc mēs esam griešana sarakstu uz pusi katru reizi,
Mūsu sliktākajā gadījumā Run laiks lec no lineārs logaritmiska.
Tik pēkšņi mums ir pieteikšanās posmos, lai atrastu elementu sarakstā.
Labākajā gadījumā piestrādes laiku, lai gan, joprojām ir nemainīgs
jo tagad, pieņemsim tikai teikt, ka elements mēs meklējam, ir
vienmēr precīzs vidū sākotnējā sarakstā.
Tātad mēs varam augt mūsu sarakstā tik lielas kā mēs vēlamies, bet, ja šis elements mēs meklējam, ir pa vidu,
tad tas ir tikai gatavojas veikt mums 1 soli.
Tātad, tāpēc mēs esam O (log n) un Ω (1) vai pastāvīga.
Pieņemsim kursēt bināro meklēšanu šajā sarakstā.
Tāpēc pieņemsim, ka mēs meklējam elementa 164.
Pirmā lieta, mēs gatavojamies darīt, ir atrast viduspunktā šajā sarakstā.
Tas tikai tā notiek, ka viduspunktā gatavojas krist starp šiem 2 numuriem,
tāpēc pieņemsim tikai patvaļīgi teikt, katru reizi, viduspunktā iekrīt starp 2 numuriem,
pieņemsim tikai noapaļot uz augšu.
Mums vienkārši nepieciešams, lai pārliecinātos, ka mēs to izdarīt ik solis ceļu.
Tāpēc mēs esam gatavojas noapaļot uz augšu, un mēs esam gatavojas teikt, ka 161 ir vidū mūsu sarakstā.
So 161 <164, un katrs elements pa kreisi 161
Ir arī <164, lai mēs zinām, ka tas nav dodas, lai palīdzētu mums visiem
lai sāktu meklēt nekā šeit, jo elements mēs meklējam nevar būt tur.
Tātad, ko mēs varam darīt, ir, mēs varam tikai aizmirst par to, ka visa kreisā puse sarakstā,
un tagad tikai apsvērt no tiesībām 161 vēlāk.
>> Tātad vēlreiz, tas ir viduspunktā; pieņemsim tikai noapaļot uz augšu.
Tagad 175 ir pārāk liels.
Tātad mēs zinām, tas nav dodas, lai palīdzētu mums meklē šeit vai šeit,
tāpēc mēs varam tikai mest, ka prom, un galu galā mēs hit 164.
Visus jautājumus par bināro meklēšanu?
Pāriesim no meklējot izmantojot jau sakārtoti sarakstā
faktiski ņemot sarakstu numurus jebkurā secībā
un padarot šo sarakstu augošā secībā.
Pirmais algoritms mēs paskatījās sauca burbulis šķirot.
Un tas būtu vienkāršāka algoritmiem mēs redzējām.
Burbulis šķirot saka, ka tad, kad visi 2 elementi iekšā sarakstā ir nevietā,
nozīmē, ka ir lielāks skaits pa kreisi uz mazāku skaitu,
tad mēs ejam, lai mijmaiņas tiem, jo ​​tas nozīmē, ka saraksts būs
"Vairāk sakārtoti", nekā tas bija pirms tam.
Un mēs esam tikai gatavojas turpināt šo procesu atkal un atkal un atkal
līdz beidzot elementi burbulis to pareizajā vietā, un tam mums ir sakārtoti sarakstu.
>> Norises laiks tas būs O (N ²). Kāpēc?
Nu, jo sliktākajā gadījumā mēs spēsim veikt katru elementu, un
mēs spēsim nonākt salīdzinot to ar jebkuru citu elementu sarakstā.
Bet labākajā gadījumā, mums ir jau sakārtoti sarakstu, burbulis kārtot s
tikai gatavojas iet cauri vienreiz, saka "Nē. Man nebija nekādas mijmaiņa, tāpēc es esmu darīts."
Tātad mums ir labākā lieta darbības laiku Ω (n).
Pieņemsim palaist burbulis šķirot sarakstā.
Vai pirmais, pieņemsim tikai apskatīt dažus pseudocode tiešām ātri.
Mēs vēlamies pateikt, ka mēs vēlamies, lai sekotu, katrā atkārtojuma no cilpas,
izsekot, vai mēs mainīt nekādus elementus.
So iemeslu tas ir, mēs spēsim apturēt, ja mēs esam nav iesaistīts mijmaiņas nekādus elementus.
Darbības sākumā mūsu Loop mēs esam nav iesaistīts mijmaiņas neko, tāpēc mēs sakām, ka ir nepatiesa.
Tagad mēs esam gatavojas iet cauri sarakstam un salīdzināt elements I elements i + 1
un, ja tas ir gadījumā, ka ir lielāks skaits pa kreisi uz mazāku skaitu,
tad mēs esam tikai gatavojas, lai mijmaiņas tiem.
>> Un tad mēs esam gatavojas atcerēties, ka mēs mijmaina elementu.
Tas nozīmē, ka mums ir jāiet cauri sarakstam vismaz vēl 1 reizi
jo stāvoklis, kurā mēs apstājāmies ir tad, kad viss saraksts ir jau sakārtots,
kas nozīmē, mēs esam nav veicis nekādus mijmaiņas darījumus.
Tātad, tāpēc mūsu nosacījums paredz šeit ir ", bet daži elementi ir samainīti."
Tāpēc tagad pieņemsim tikai paskaties darbojas sarakstā.
Man ir saraksts 5,0,1,6,4.
Burbulis kārtot gatavojas sākt visu ceļu pa kreisi, un tas notiek, lai salīdzinātu
Arī I elementiem, tāpēc 0 līdz i + 1, kas ir elements 1.
Tas notiek, lai teikt, labi 5> 0, bet tagad 5 ir pa kreisi,
tāpēc man ir nepieciešams, lai apmainītu 5, 0.
Kad es mijmaiņas tiem, pēkšņi man šis citu sarakstu.
Tagad 5> 1, tāpēc mēs ejam, lai mijmaiņas tiem.
5 nav> 6, tāpēc mums nav nepieciešams neko darīt šeit.
Bet 6> 4, tāpēc mums ir nepieciešams, lai mijmaiņas.
Atkal, mums ir nepieciešams, lai palaistu cauri visam sarakstam beidzot atklāt
ka tie nav pareizā secībā, mēs mijmaiņas tiem,
un šajā brīdī mums ir nepieciešams, lai palaistu cauri sarakstam 1 vairāk laika
lai pārliecinātos, ka viss ir savā kārtībā, un šajā brīdī burbulis veida ir pabeigta.
Atšķirīgs algoritms veikt dažus elementus un šķirošanu, ir izvēle veida.
Aiz atlases veida ideja ir tāda, ka mēs spēsim veidot sakārtoti daļu saraksta
1 elements vienlaikus.
>> Un kā mēs gatavojamies darīt, ir, izveidojot kreiso segmentu sarakstā.
Un būtībā, katrs - par katru soli, mēs spēsim veikt mazāko elementu esam kreisi
kas nav sakārtoti vēl, un mēs ejam, lai pārvietotu to vērā, ka šķiroto segmentā.
Tas nozīmē, ka mums ir nepieciešams, lai pastāvīgi atrast minimālo nešķirotu elements
un tad šo minimālo elementu un mijmaiņas to ar kāda
kreisās visvairāk elements, nav sakārtots.
Palaist laikā šī būs O (n ²), jo sliktākajā gadījumā
Mums nepieciešams, lai salīdzinātu katru elementu katram citu elementu.
Jo mēs esam sakot, ka, ja mēs sāktu kreisajā pusē sarakstā, mums ir nepieciešams
iet cauri visai labo segmentā atrast mazāko elementu.
Un tad atkal, mums ir nepieciešams, lai iet pa visu labo segmentu un
glabāt iet pāri, ka atkal un atkal un atkal.
Kas notiek, lai ar n ². Mēs ejam, lai vajag cilpa iekšpusē citu cilpa
kas liecina n ².
Labākajā gadījumā domu, pieņemsim, ka mēs arī tā jau sakārtoti sarakstu;
mēs faktiski nav darīt jebkurā labāk nekā n ².
Jo izvēle veida ir nekādi nevar zināt, ka
minimālais elements ir tikai viens es gadās būt meklē.
Tā joprojām ir jāpārliecinās, ka tas ir faktiski minimums.
>> Un vienīgais veids, kā pārliecināties, ka tas ir minimālais, izmantojot šo algoritmu,
ir apskatīt katru elementu vēlreiz.
Tik tiešām, ja jūs arī tā - ja jūs sniegtu atlase kārtot jau sakārtoti sarakstu,
tas nav gatavojas darīt jebkurā labāk nekā piešķirot tai sarakstu, kas nav sakārtots vēl.
Starp citu, ja tas notiek, ir gadījums, ka kaut kas ir O (kaut)
un kaut Omega, mēs varam tikai teikt kodolīgāk, ka tas ir θ par kaut ko.
Tātad, ja jūs redzat, ka nākt klajā visur, tas ir tas, ko tas nozīmē tikai to.
>> Ja kaut kas ir Theta n ², tas ir gan liels O (n ²) un Ω (n ²).
Lai vislabāk lietu un sliktākajā gadījumā, tas nav kaut ko mainīt,
algoritms ir gatavojas darīt to pašu katru reizi.
Tātad tas ir tas, ko pseudocode par atlases veida varētu izskatīties.
Mēs būtībā gatavojas teikt, ka es gribu atkārtot pa sarakstu
no kreisās uz labo, un katrā atkārtojuma no cilpas, es esmu gatavojas pārvietot
minimālais elements šajā sakārtoti daļu sarakstu.
Un, kad es pārvietot kaut ko tur, es nekad nepieciešams apskatīt šo elementu vēlreiz.
Jo tiklīdz es swap elements, lai kreisajā segmentā sarakstā, tas ir sakārtoti
jo mēs darām visu, kas ir augošā secībā, izmantojot minimums.
Tāpēc mēs teicām, labi, mēs esam pie stāvoklī man, un mums ir jāskatās uz visu elementu
tiesībām uz i, lai atrastu minimumu.
Tātad tas nozīmē, ka mēs gribam izskatīties no i + 1 līdz saraksta beigām.
Un tagad, ja elements, ka mēs pašlaik meklē ir mazāka nekā mūsu minimumu līdz šim,
kas, atcerieties, mēs sākam minimālo off vienkārši būt
neatkarīgi elements mēs šobrīd, es pieņemu, ka ir minimums.
Ja es atrastu elementu, kas ir mazāks nekā, tad es esmu gatavojas teikt, labi,
labi, man ir atraduši jaunu minimumu.
Es esmu gatavojas atcerēties, kur tas minimums bija.
>> Tāpēc tagad, kad esmu gājusi caur šo labo nešķirotu segmentā,
Es varu teikt, es esmu gatavojas apmainīt minimālo elementu ar elementu, kas ir stāvoklī man.
Kas notiek, lai izveidotu savu sarakstu, mans sakārtoti daļa saraksta, no kreisās uz labo pusi,
un mums nav kādreiz nepieciešams apskatīt elementu atkal reiz tas ir tā daļa.
Tiklīdz mēs esam aizstāja to.
Tāpēc pieņemsim darboties atlases veida šajā sarakstā.
Zils elements šeit būs man, un sarkanā elements būs minimālais elements.
Tāpēc es sāk visu ceļu pa kreisi no saraksta, lai pie 5.
Tagad mums ir nepieciešams, lai atrastu minimālo nešķirotu elementu.
Tātad mēs teiksim 0 <5, tāpēc 0 ir mans jaunais minimums.
>> Bet es nevaru apstāties tur, jo, pat ja mēs varam atzīt, ka 0 ir mazākais,
Mums ir nepieciešams, lai palaistu cauri jebkuru citu elementu sarakstu, lai pārliecinātos.
Lai 1 ir lielāks, 6 ir lielāks, 4 ir lielāks.
Tas nozīmē, ka pēc apskatot visus šos elementus, es esmu nosaka 0 ir mazākais.
Tāpēc es esmu gatavojas swap 5, 0.
Kad man swap, ka es esmu gatavojas saņemt jaunu sarakstu, un es zinu, ka man nekad nav nepieciešams apskatīt 0, kas atkal
jo kad es esmu nomainīju, es esam sakārtoti, un mēs esam darīts.
Tagad tas tikai tā notiek, ka zilā elements ir atkal 5,
un mums ir jāskatās uz 1, 6 un 4 noteikt, ka 1
ir mazākā minimālā elements, tāpēc mēs swap 1 un 5.
Atkal, mums ir jāskatās uz - salīdzināt 5 augstāks 6, 4,
un mēs esam gatavojas swap 4, 5, un, visbeidzot, salīdzināt
šie 2 numuri un mijmaiņas tiem līdz mēs saņemt mūsu sakārtoti sarakstu.
Visus jautājumus par atlases veida?
Labi. Pieņemsim pāriet uz pēdējo tēmu šeit, un tas ir rekursija.
>> Rekursija, atcerieties, tas ir patiešām meta lieta, ja funkcija
atkārtoti aicina sevi.
Tāpēc pie kādā brīdī, bet mūsu fuction ir vairākkārt zvana pats,
tur, jāatrod punkts, kurā mēs pārtraukt zvana sevi.
Jo, ja mēs nedarām, tad mēs esam tikai gatavojas turpināt to darīt mūžīgi,
un mūsu programma ir vienkārši nav gatavojas pārtraukt.
Mēs saucam šo nosacījumu gadījumu.
Un bāzes scenārijs saka, nevis zvana funkciju atkal,
Es esmu tikai gatavojas atgriezties kādu vērtību.
Tātad, kad mēs esam atgriezušies vērtību, esam pārtraukuši zvanot sevi,
un zvaniem mēs esam padarījuši tik tālu atpūtas var arī atgriezties.
Bāzes lietas pretī ir rekursīvs gadījums.
Un tas ir, kad mēs vēlamies veikt citu zvanu funkciju, ka mēs pašlaik iekšā
Un mēs, iespējams, kaut arī ne vienmēr, vēlas izmantot dažādus argumentus.
>> Tātad, ja mums ir funkciju sauc f, un f tikai sauc ņem 1 argumentu,
un mēs tikai glabāt zvanot f (1), f (1), f (1), un tas tikai tā notiek, ka
arguments 1 iekrīt rekursīvo gadījumā mēs vēl nekad gatavojas pārtraukt.
Pat ja mums ir bāzes scenārijs, mums ir nepieciešams, lai pārliecinātos, ka galu galā mēs ejam, lai sasniegtu šo gadījumu.
Mēs ne tikai glabāt uzturas šajā rekursīvs gadījumā.
Parasti, kad mēs saucam sevi, mēs, iespējams, nāksies atšķirīgu argumentu katru reizi.
Te ir ļoti vienkāršs rekursīvas funkcijas.
Tāpēc šī būs compute faktoriālu numuru.
Līdz top šeit mums ir mūsu gadījumu.
Gadījumā, n ≤ 1, mēs nebrauksim, lai izsauktu faktoriāls vēlreiz.
Mēs ejam, lai apturētu, mēs esam tikai gatavojas atgriezties kādu vērtību.
Ja tas tā nav taisnība, tad mēs ejam, lai sasniegtu mūsu rekursīvas lietu.
Ievērojiet, ka mēs esam ne tikai zvanot faktoriāls (n), jo tas nebūtu ļoti noderīga.
Mēs ejam, lai izsauktu faktoriālu kaut kas cits.
>> Un lai jūs varētu redzēt, galu galā, ja mēs iet faktoriālo (5) vai kaut ko,
mēs spēsim zvanīt faktoriāls (4) un tā tālāk, un galu galā mēs esam gatavojas skārusi šo gadījumu.
Tāpēc tas izskatās labi. Paskatīsimies, kas notiek, kad mēs faktiski palaist to.
Šis ir kaudze, un pieņemsim, ka galvenais ir gatavojas nosaukt šo funkciju ar argumentu (4).
Lai vienreiz faktoriālo redz un = 4, faktoru aicinās pati.
Tagad pēkšņi, mums ir faktoriālu (3).
Tāpēc šie funkcijas gatavojas glabāt pieaug līdz beidzot mēs hit mūsu gadījumu.
Šajā brīdī, atgriešanās vērtību šī ir atgriešanās (NX atgriešanās vērtību šo),
atgriešanās vērtību tas ir NX atgriešanās vērtību to.
Galu galā mums ir nepieciešams, lai sasniegtu dažas vairākus.
Augšā šeit, mēs sakām atpakaļ 1.
Tas nozīmē, ka, tiklīdz mēs atgriežamies šo numuru, mēs varam pop šis pie skursteņa.
Tātad šī faktoriāls (1) tiek darīts.
Kad 1 atgriež, šis faktoriālās (1) deklarācijas, šī atgriešanās pret 1.
Atgriešanās vērtību ar to, atceries, bija NX atgriešanās vērtību to.
Tik pēkšņi, tas puisis zina, ka es gribu atgriezties 2.
>> Līdz ar to atcerēties, atgriešanās vērtība tas ir tikai NX atgriešanās vērtība šeit.
Tāpēc tagad mēs varam teikt 3 x 2, un visbeidzot, šeit mēs varam teikt
tas ir tikai būs 4 x 3 x 2.
Un, kad tas atgriežas, mēs nokļūt uz leju, lai vienu skaitlim iekšpusē galvenais.
Kādi jautājumi par recursion?
Labi. Tāpēc tur vairāk laika jautājumiem beigās,
bet tagad Jāzeps būs segtu atlikušās tēmām.
>> [Džozefs Ong] Nu labi. Tāpēc tagad, ka mēs esam runājuši par recursions,
parunāsim mazliet par to, ko apvienot kārtošanas ir.
Sapludināt kārtošanas ir pamatā citu veids šķirošanas sarakstu numuriem.
Un kā tā darbojas, ir, ar sapludināšanas veida jums ir saraksts, un ko mēs darām, ir
mēs sakām, pieņemsim sadalīt šo par 2 daļās.
Mēs vispirms palaist apvienoties kārtot atkal kreisajā pusē,
tad mēs rādīsim apvienot kārtot labajā pusē,
un tas dod mums tagad 2 pusītes, kas ir sakārtoti, un tagad mēs esam gatavojas apvienot šos pusītes kopā.
Tas mazliet grūti redzēt bez Piemēram, tāpēc mēs iet caur priekšlikumus un redzēt, kas notiek.
Tātad jūs sākat ar šo sarakstu, mēs sadalīt to 2 daļās.
Mēs palaist apvienot kārtot uz kreisajā pusē pirmais.
Tātad, tas ir kreisajā pusē, un tagad mēs palaist tos caur šo sarakstu vēlreiz
kas izpaužas nonākt sapludināšanas kārtot, un tad mēs skatāmies, atkal,
kreisajā pusē šī saraksta, un mēs palaist apvienot šķirot par to.
Tagad mēs uz leju, lai sarakstu 2 numuriem,
un tagad kreisā puse ir tikai 1 elements garš, un mēs nevaram
sadalīt sarakstu, kas ir tikai 1 elements uz pusi, tāpēc mēs tikai teikt, kad mums ir 50,
kas ir tikai 1 elements, tas jau ir sakārtoti.
>> Kad mēs esam darīts ar to, ka mēs varam redzēt, ka mēs varam
pāriet uz labo pusi no šā saraksta,
un 3 ir arī sakārtots, un tāpēc tagad, ka abi šīs saraksta pusītes ir sakārtoti
mēs varam pievienoties šos skaitļus atpakaļ kopā.
Lai mēs skatāmies uz 50 līdz 3; 3 ir mazāks par 50, tāpēc tas iet vispirms un tad 50 nāk iekšā
Tagad, kas ir izdarīts, mēs ejam atpakaļ uz augšu uz šo sarakstu un kārtot tas ir labajā pusē.
42 ir tā paša skaits, tāpēc tas jau ir sakārtoti.
Tātad tagad mēs salīdzinām šos 2 un 3 ir mazāks par 42, lai izpaužas likts pirmajā,
šobrīd 42 izpaužas nodot, un 50 izpaužas likts iekšā
Tagad, kas ir sakārtoti, mēs ejam visu ceļu atpakaļ uz augšu, 1337 un 15.
Nu, mēs tagad apskatīt kreisajā pusē šajā sarakstā; 1337 ir pats par sevi, lai tas ir sakārtoti un pats ar 15.
Tātad tagad mēs apvienojam šos 2 numurus sakārtotu šo sākotnējo sarakstu, 15 <1337,
tāpēc tas iet pa priekšu, tad 1337 iet iekšā
Un tagad mēs sakārtoti abas pusītes sākotnējā sarakstā līdz top.
Un viss, kas mums jādara, ir apvienot šos.
Mēs skatāmies uz pirmajām 2 numuriem šajā sarakstā, 3 <15, tāpēc tas nonāk kārtošanas masīva pirmās.
15 <42, tāpēc tas iet iekšā Tagad, 42 <1337, kas iet iekšā
50 <1337, tāpēc tas iet iekšā un paziņo, ka mēs vienkārši bija 2 skaitļus pie šī saraksta.
Tāpēc mēs esam ne tikai pārmaiņus starp 2 sarakstiem.
Mēs esam tikai meklē sākumā, un mēs esam ņemot elements
tas ir mazāks, un tad nodot to mūsu masīvs.
Tagad mēs esam apvienoti visi pusītes, un mēs esam darīts.
>> Kādi jautājumi par apvienoties šķirot? Jā?
[Studentu] Ja tas ir sadalīšana dažādās grupās, kāpēc ne viņi vienkārši sadalīt to vienu reizi
un jums ir 3 un 2 grupā? [Pārējā jautājums nesaprotams]
Iemesls - tāpēc jautājums ir, kāpēc mēs nevaram vienkārši apvienot tos tajā pirmo soli, kad mēs tos?
Iemesls, kāpēc mēs varam darīt, sāciet pie kreisās visvairāk elementiem abās pusēs,
un tad uz mazāku vienu un nodot to, ka mēs zinām, ka šie
individuālie saraksti ir sakārtoti pasūtījumiem.
Tātad, ja es esmu meklē kreisās visvairāk elementiem abās pusēs,
Es zinu, viņi būs mazākais elementi šajos sarakstos.
Lai es varētu nodot tos mazākajiem elementu plankumi šo lielo sarakstu.
No otras puses, ja es paskatos šiem 2 sarakstiem otrā līmeņa tur,
50, 3, 42, 1337 un 15, tie netiek šķiroti.
Tātad, ja es paskatos 50 un 1337, es esmu gatavojas īstenot 50 manā sarakstā pirmais.
Bet tas nav īsti jēgas, jo 3 ir mazākais elements no visiem no tiem.
Tāpēc vienīgais iemesls, kāpēc mēs varam darīt šo apvieno soli ir tāpēc, ka mūsu saraksti jau ir sakārtots.
Kurš ir iemesls, kāpēc mums ir jāķeras visu ceļu uz leju
jo, ja mums ir tikai viens numurs, jūs zināt, ka viens numurs
un pats par sevi jau ir sakārtoti sarakstā.
>> Kādi jautājumi? Nē?
Sarežģītību? Nu, jūs varat redzēt, ka katrā solī tur gala skaitļi,
un mēs varam sadalīt sarakstu puslogaritmiskiem n reizes,
kas ir, ja mēs šo n x log n sarežģītību.
Un jūs redzēsiet labākajā gadījumā uz merge veida ir n log n, un tas tikai tā notiek
ka sliktākajā gadījumā, vai arī tur Ω, ir arī n log n.
Kaut kas jāpatur prātā.
Attīstība, iesim uz kādu super pamata failu I / O.
Ja jūs paskatījās motokross, jūs pamanīsiet mums bija kaut kādas sistēmas
kur jūs varētu rakstīt log failu, ja jūs lasīt, izmantojot kodu.
Let 's redzēt, kā jūs varētu darīt.
Nu, mums ir fprintf, ko jūs varat iedomāties, kā tikai printf,
bet tikai drukāšanas failā, nevis, un līdz ar to f sākumā.
Šāda veida koda šeit, ko tā dara, ir, kā jūs varētu būt redzams motokross,
tā iet caur jūsu 2-dimensiju masīvu izdrukāt rindu pa rindai, ko numuri.
Šajā gadījumā, printf izdrukā jūsu terminālu vai to, ko mēs saucam standarta produkciju sadaļā.
>> Un tagad, šajā gadījumā, viss, kas mums ir jādara, ir aizstāt printf ar fprintf,
pateikt to, ko failu jūs vēlaties drukāt, un šajā gadījumā tā tikai izdrukas to, lai šo failu
vietā izdrukāt to, lai jūsu terminālu.
Nu, tad tas rodas jautājums: Kur mēs iegūt šāda veida failu no, labi?
Mēs nodots pieteikties uz šo fprintf fuction bet mums nebija ne jausmas, no kurienes tas nācis.
Nu, sākumā kodu, kas mums bija bija šī rieciens koda nekā šeit,
kas būtībā saka, ka atvērts fails aicina log.txt.
Ko mēs darām pēc tam ir mums ir jāpārliecinās, ka fails ir faktiski atvērts veiksmīgi.
Tātad tas varētu neizdoties vairāku iemeslu dēļ, jums nav pietiekami daudz vietas uz jūsu datora, piemēram.
Tātad, tas vienmēr ir svarīgi, pirms jūs darīt nekādas darbības ar failu
mēs pārbaudītu, vai šī lieta tika atklāta veiksmīgi.
Tātad, kādi ka, tas ir arguments, fopen, labi, mēs varam atvērt failu daudzos veidos.
Ko mēs varam darīt, ir, mēs varam nodot to w, kas nozīmē ignorēt failu, ja tas izejām jau,
Mēs varam iet A, ko viņi pievienot uz beigām failu, nevis svarīgas to,
vai mēs varam norādīt r, kas nozīmē, pieņemsim atvērt failu kā tikai lasāmu.
Tātad, ja programma mēģina veikt izmaiņas failā,
bļaut pie viņiem, un neļaujiet viņiem to darīt.
Visbeidzot, kad mēs pabeigsim ar failu, beidzis darot operācijas par to,
Mums ir nepieciešams, lai pārliecinātos, ka mēs aizveriet failu.
Un tā beigās savu programmu, jūs gatavojas nodot tos atkal
Šis fails, kuru atklāja, un tikai aizveriet to.
Tātad tas ir kaut kas svarīgs, ka jums ir, lai pārliecinātos, jums.
Līdz ar to atcerēties jūs varat atvērt failu, tad jūs varat rakstīt uz failu,
darīt operācijas failā, bet tad jums ir slēgt lietu beigās.
>> Visus jautājumus par pamata failu I / O? Jā?
[Studentu jautājums, nesaprotami]
Tieši šeit. Jautājums ir, ja tas log.txt fails parādās?
Nu, ja jūs Dāvini log.txt, tas rada to pašā direktorijā, kā izpildāmā.
Tātad, ja jūs esat nokļuvis - >> [Studentu jautājums, nesaprotami]
Jā. Tajā pašā mapē, vai tajā pašā direktorijā, kā jūs to saucat.
Tagad atmiņas, kaudze, un kaudze.
Tātad, kā ir atmiņa, kas veic ar datoru?
Nu, jūs varat iedomāties, atmiņas kā sava veida šajā blokā šeit.
Un atmiņā mums ir ko sauc kaudze iestrēdzis tur, un kaudze, kas ir tur lejā.
Un kaudze aug lejup un kaudze aug uz augšu.
Tā kā Tomijs minēts - ak, labi, un mums ir šie citi 4 segmenti, ko es nopirkšu uz otro -
Kā Tommy teica agrāk, jūs zināt, cik viņa funkcijas sevi sauc un sauc viens otru?
Viņi veidot šāda veida kaudze rāmi.
Nu, ja galvenie zvani foo, foo izpaužas likts uz skursteņa.
Foo aicina, bārs iegūt s likts uz skursteņa, un kas izpaužas likts uz skursteņa pēc.
Un kā viņi atgriezīsies, viņi katrs saņem pacēlies kaudzīti.
Ko katrs no šīm vietām un atmiņas turēt?
Nu, top, kas ir teksta segments, satur pati programma.
Tāpēc mašīnu kodu, kas ir tur, kad jūs sastādīt savu programmu.
Nākamais, kāds inicializēts pasaules mainīgie.
>> Tātad jums ir globālas mainīgos savā programmā, un jūs sakāt, piemēram, a = 5,
kas izpaužas likts šajā segmentā, un tiesības saskaņā ar to,
Jums ir kādi neinicializēts globālu datu, kas ir tikai Int,
bet jums nav teikt, tas ir vienāds ar neko.
Realizēt tie ir globālie mainīgie, lai viņi ārpus galvenā.
Tātad tas nozīmē, kādi pasaules mainīgie, kas ir deklarējušas, bet netiek inicializēts.
Tātad, kas ir kaudzes? Atmiņas piešķirti izmantojot malloc, ko mēs sāksim ar mazliet.
Un visbeidzot, ar kaudze jums ir kādi vietējo mainīgie
un visas funkcijas jūs varētu zvanīt jebkurā no saviem parametriem.
Pēdējā lieta, jums nav īsti ir jāzina, ko vides mainīgie darīt,
bet kad tu palaist programmu, ir saistīts kaut kas, piemēram,
tas ir lietotājvārds personai, kas vadīja programmu.
Un tas būs sava veida apakšā.
Runājot par atmiņas adreses, kas ir heksadecimālo vērtību,
Augšdaļā sākas ar 0 vērtības, un viņi iet visu ceļu uz leju, lai apakšā.
Šajā gadījumā, ja jūs esat par 32 bitu sistēmā,
apakšā adrese būs 0x, kam seko AF, jo tas ir 32 bitu,
kas ir 8 baiti, un šajā gadījumā 8 biti atbilst 8 heksadecimālo cipariem.
Tātad noteikti šeit jūs gatavojas ir, piemēram, 0xffffff, un tur jūs nāksies 0.
Tātad, kādi ir norādes? Daži no jums, iespējams, nav ietverti šajā sadaļā iepriekš.
bet mēs iet pār to lekciju, tāpēc rādītājs ir tikai datu tips
kas veikalos, nevis kaut kādu vērtību, piemēram, 50, tas saglabā adresi kādu vietu atmiņā.
Tāpat kā šīs atmiņas [nesaprotams].
Tātad šajā gadījumā, ko mēs esam, ir, mums ir rādītāju līdz veselam skaitlim vai int *,
un tā satur šo heksadecimālo adresi 0xDEADBEEF.
>> Tātad, kas mums ir, tagad, šis rādītājs norāda uz kādu vietu atmiņā,
un tas ir tikai, vērtība 50 ir šajā atmiņas vietā.
Par dažiem 32-bitu sistēmas, uz visiem 32-bitu sistēmas, norādes aizņem 32 bitus vai 4 baiti.
Bet, piemēram, uz 64-bitu sistēmas, norādes ir 64 biti.
Tā ka ir kaut kas jūs vēlaties paturēt prātā.
Tātad uz gala-bitu sistēmas, rādītājs ir beigas bitus garš.
Norādes ir sava veida grūti sagremot bez papildus lietām,
tāpēc pieņemsim iet caur piemēru par dinamisku atmiņas sadalījumu.
Kas dinamiskā atmiņas sadale tas jums, vai to, ko mēs saucam malloc,
tas ļauj piešķirt kaut kādus datus ārpus komplekta.
Tātad šie dati ir sava veida vairāk pastāvīgo uz programmas darbības laiku.
Jo, kā jūs zināt, ja jūs atzīt x iekšpusē funkciju, un ka funkcija atgriež,
jums vairs nav piekļuves datiem, kas tika glabāti x.
Kas norādes ļaujiet mums darīt, ir tie ļauj mums saglabāt atmiņas vai veikala vērtības
citā segmentā atmiņu, proti, kaudze.
Tagad, kad mēs atgriežamies no funkciju, kamēr mums ir rādītāju
uz šo vietu atmiņā, tad ko mēs varam darīt, ir, mēs varam tikai apskatīt vērtībām tur.
Apskatīsim piemēru: Tas ir mūsu atmiņa izkārtojums atkal.
Un mums ir šī funkcija, galvenais.
Kas tas ir - labi, tik vienkārši, vai ne? - Int x = 5, tas ir tikai mainīgo uz skursteņa, kas galvenais.
>> No otras puses, tagad mēs paziņojam rādītāju, kas izsauc funkciju giveMeThreeInts.
Un tāpēc tagad mēs iedziļināties šīs funkcijas, un mēs izveidot jaunu kaudze rāmi par to.
Tomēr šajā kaudze rāmi, mēs paziņojam int * temp,
kas 3 mallocs integers mums.
Tātad lielums int dos mums cik daudz baitu tas int ir,
un malloc dod mums, ka daudzi baiti vietas uz kaudzes.
Tātad šajā gadījumā, mēs esam radījuši pietiekami daudz vietas uz 3 integers,
un kaudze ir veids tur, kas ir iemesls, kāpēc es esmu sastādīts to augstāk.
Kad mēs esam darīts, mēs atkal šeit, vajag tikai 3 Ints atgriezās,
un tas atgriež adresi, šajā gadījumā vairāk nekā ja šī atmiņa ir.
Un mēs noteikti rādītājs = slēdzi, un tur mums ir tikai viens rādītājs.
Bet ko tas funkcija atgriež ir stacked šeit un pazūd.
Tātad temperatūra pazūd, bet mēs joprojām saglabā adresi, kur
šos 3 integers ir iekšā elektrotīkla.
Tātad šo kopumu, tad norādes ir scoped lokāli uz sakrautas rāmi,
bet atmiņas, uz kuru tie atsaucas, ir kaudzes.
>> Vai ir jēga?
[Studentu] Vai jūs varētu atkārtot, ka? >> [Džozefs] Jā.
Tātad, ja es iet atpakaļ tikai mazliet, jūs redzēsiet, ka temp piešķirti
dažas atmiņas par sakraut tur.
Tātad, ja šī funkcija, giveMeThreeInts nopelnīt, šī kaudze šeit ir izzudīs.
Un līdz ar to kādu no mainīgajiem, kas šajā gadījumā, šis rādītājs, kas tika piešķirti sakrautas rāmī.
Kas notiek, izzudīs, bet kopš mēs atgriezāmies temp
un mēs noteikti rādītāju = temperatūra, rādītājs ir tagad gatavojas atzīmēt pašu atmiņas par atrašanās vietu, kā temp bija.
Tāpēc tagad, lai gan mēs zaudējam temp, ka vietējās rādītājs,
mēs joprojām saglabā atmiņas adresi, ko tā bija vērsta uz iekšpusi šo mainīgo rādītāju.
Jautājumi? Tas var būt sava veida mulsinoši tēmu, ja jums nav aizgājuši pār to sadaļā.
Mēs varam, jūsu TF noteikti iet pār to un, protams, mēs varam atbildēt uz jautājumiem
beigās pārskata sesijā šo.
Bet tas ir sava veida sarežģīts jautājums, un man ir vairāk piemēru, kas gatavojas parādās
kas palīdzēs noskaidrot, ko norādes patiesībā ir.
>> Šajā gadījumā, norādes ir līdzvērtīgi masīvi,
tāpēc es varu tikai izmantot šo rādītāju kā pats kā int masīvu.
Tāpēc es esmu indeksāciju uz 0, un mainot pirmo skaitlim 1,
mainot otro skaitlim līdz 2, un arī 3 skaitlim līdz 3.
Tā vairāk uz norādes. Nu, atgādināt Binky.
Šajā gadījumā mēs esam piešķirts rādītāju, vai mēs paziņoja rādītāju,
bet sākotnēji, kad es tikko paziņoja rādītāju, tas nav norādot uz jebkur atmiņā.
Tas ir tikai atkritumu vērtības iekšpusē no tā.
Tāpēc man nav ne jausmas, kur šis rādītājs ir vērsta uz.
Tā ir adrese, kas ir tikai piepildīta ar 0 un 1, kur tas sākotnēji tika atzīts.
Es nevaru darīt kaut ko ar šo kamēr es aicinu malloc par to
un tad tas dod man maz vietas uz kaudzes, kur es varētu likt vērtības iekšā.
Tad atkal, es nezinu, kas ir iekšā šīs atmiņas.
Tātad pirmā lieta man ir jādara, ir pārbaudīt, vai sistēma bija pietiekami daudz atmiņas
sniegt man atpakaļ 1 skaitlim ir pirmajā vietā, tāpēc es esmu to izdarīt pārbaudi.
Ja rādītājs ir nulle, kas nozīmē, ka tai nav pietiekami daudz vietas, vai kādu citu kļūda,
tāpēc es izietu no manas programmas.
Bet, ja tas izdosies, tagad es varu izmantot šo rādītāju
un ko * rādītājs tas ir tas izriet kur adrese ir
kur šī vērtība ir, un tas nosaka, ka vienāda ar 1.
Tātad vairāk nekā šeit, mēs pārbaudītu, ja tas atmiņa pastāvēja.
>> Tiklīdz jūs zināt, tas ir, jūs varat nodot to
kāda vērtība jūs vēlaties nodot to, šajā gadījumā 1.
Kad mēs esam darīts ar to, jums ir nepieciešams, lai atbrīvotu šo rādītāju
jo mums ir nepieciešams, lai saņemtu atpakaļ uz sistēmu, ka atmiņas, kas jums lūdza pirmajā vietā.
Jo dators nav zināms, kad mēs esam darīts ar to.
Šajā gadījumā mēs skaidri stāsta to, labi, mēs esam darīts ar šo atmiņu.
Ja daži citi procesa vajadzībām tā, kāda cita programma ir vajadzīga, justies brīvi iet uz priekšu un ņemt to.
Ko mēs varam darīt, ir, mēs varam tikai iegūt adresi vietējās mainīgie par komplektu.
Tātad int x ir iekšpusē sakrautas rāmja galvenais.
Un, kad mēs izmantojam šī zīme, šo un operators, ko tas ir
tas aizņem x, un x ir tikai daži dati atmiņā, bet tā ir adrese.
Tas atrodas kaut kur. Tātad, aicinot un x, ko tas dara, ir tas dod mums adresi x.
To darot, mēs nesam rādītājs punktu kur x ir atmiņā.
Tagad mēs vienkārši kaut kas līdzīgs * x, mēs esam gatavojas saņemt 5 atpakaļ.
Zvaigzne sauc dereferencing to.
Jūs sekot adresi un jums par to vērtību uzglabā tur.
>> Kādi jautājumi? Jā?
[Studentu] Ja jums nav darīt to 3-smailo lieta, tas joprojām apkopotu?
Jā. Ja jums nav darīt to 3-rādītāju lieta, tas joprojām gatavojas apkopot,
bet es jums parādīs, kas notiek otrā, un bez to dara,
tas, ko mēs saucam atmiņas noplūde. Tu neesi un sistēma
atpakaļ savu atmiņu, lai pēc kāda laika programma ir gatavojas uzkrāt
Atmiņas ka tas nav, izmantojot, un nekas cits nevar izmantot.
Ja esat kādreiz redzējuši Firefox ar 1,5 miljoniem kilobaitu datorā,
uzdevumu pārvaldnieks, tas, kas notiek.
Jums ir atmiņas noplūde programmā ka viņi nav apstrādes.
Tātad, kā tas rādītājs aritmētika darbojas?
Nu, rādītājs aritmētiskais ir veida, piemēram indeksāciju masīvs.
Šajā gadījumā, man ir rādītāju, un to, ko es daru, ir man darīt rādītāja līdz pirmajam elementam
Šīs masīva 3 integers, ka es esmu piešķirto.
Tātad, tagad to, ko es daru, zvaigzne rādītājs vienkārši maina pirmo elementu sarakstā.
Star rādītājs 1 punktiem vairāk nekā šeit.
Tātad rādītājs ir vairāk nekā šeit, +1 rādītājs ir vairāk nekā šeit, rādītājs +2 ir vairāk nekā šeit.
>> Tik vienkārši pievienojot 1 ir tas pats, kas pārvietojas pa šo masīvu.
Ko mēs darām, ir, kad mēs rādītāju +1, jūs saņemsiet adresi nekā šeit,
un lai iegūtu vērtību šeit, jūs varat ievietot zvaigzne no visas izteiksmes
līdz dereference to.
Tātad, šajā gadījumā, es esmu nosakot pirmo vietu šajā masīvā ar 1,
Otro vietu līdz 2, un trešā vieta līdz 3.
Tad ko es daru vairāk nekā šeit ir es esmu izdrukāt mūsu rādītāju +1,
kas tikai dod man 2.
Tagad es esmu palielināšanai rādītāju, lai rādītājs ir vienāds rādītājs 1,
kas kustas uz priekšu.
Un tāpēc tagad, ja es izdrukāt rādītāju 1, rādītājs 1 tagad ir 3,
kas šajā gadījumā izdrukā 3.
Un, lai atbrīvotu kaut ko, šautriņu ka es arī tā
jābūt norādot sākumā masīva ko es saņēmu atpakaļ no malloc.
Tātad, šajā gadījumā, ja man bija, lai izsauktu 3 tieši šeit, tas nebūtu pareizi,
jo tas ir vidū masīva.
Man ir, lai atņemtu nokļūt uz sākotnējo atrašanās vietu
Sākotnējais pirmā vieta, pirms es varētu atbrīvot to.
Tātad, šeit ir vairāk jāiesaistās piemērs.
Šajā gadījumā, mēs esam piešķirot 7 rakstzīmes rakstzīmju masīvs.
>> Un šajā gadījumā tas, ko mēs darām, ir mēs looping pa pirmo 6 no tiem,
un mēs esam nosakot tos līdz Z.
Tātad, lai int i = 0, i> 6, i + +,
Tātad, rādītājs + es tikai dod mums, šajā gadījumā,
rādītājs, rādītājs +1, rādītājs +2 rādītājs +3, un tā tālāk un tā tālāk ar cilpu.
Ko tā gatavojas darīt, ir tas izpaužas ka adrese, dereferences tā, lai iegūtu vērtību,
un izmaiņas šī vērtība uz Z.
Tad beigās atcerieties, tas ir virkne, labi?
Visi virknes ir, lai izbeigtu ar nulles izbeidz raksturs.
Tātad, ko es daru, ir 6 rādītājs man likt null terminatora raksturs collas
Un tagad ko es esmu būtībā dara nekā šeit īsteno printf uz virkni, labi?
>> Tātad, ja tas printf tagad, kad tas ir sasnieguši virknes?
Kad tas hits null izbeidz raksturs.
Tātad, šajā gadījumā, mana sākotnējā rādītāja norāda uz sākuma šo masīva.
Es izdrukāt pirmo rakstzīmi. Es pārvietot to uz vienu.
Es izdrukāt šo rakstzīmi. Es pārvietot to pa.
Un es glabāt darot kamēr es beigs.
Un tagad beigas * rādītājs būs dereference šo un saņemt null izbeidz raksturs atpakaļ.
Un tāpēc mans kamēr cilpa iet tikai tad, kad šī vērtība nav Null izbeidz raksturs.
Tātad, tagad es izietu no šīs cilpas.
Un tāpēc, ja es atņemtu 6 no šīs rādītājs,
Es iet atpakaļ visu ceļu uz sākumu.
Atcerieties, es esmu to izdarīt, jo man jādodas uz sākumu, lai atbrīvotu to.
>> Tātad, es zinu, ka bija daudz. Vai ir kādi jautājumi?
Lūdzu, jā?
[Studentu jautājums nesaprotams]
Vai varat teikt, ka skaļāk? Žēl.
[Studentu] No pēdējā slaida labi, pirms jūs atbrīvojušies rādītāju,
Kur jūs bijāt tiešām maina vērtību rādītāja?
[Džozefs] Tātad, šeit. >> [Studentu] Ak, labi.
[Džozefs] Tātad, man ir rādītāju mīnus mīnus, labi,
kas pārvietojas lieta atpakaļ vienu, un tad es to atbrīvotu,
jo šis rādītājs ir jānorāda uz sākumu masīva.
[Studentu] Bet tas nav vajadzīgs bija jums apstājās pēc šīs līnijas.
[Džozefs] Tātad, ja man bija apturēta pēc tam, tas būtu uzskatāms atmiņas noplūde,
jo man nav palaist bezmaksas.
[Studentu] Es [nesaprotams] pēc pirmajiem trim līnijām, kur jums bija rādītāju 1 [nesaprotams].
[Džozefs] Uh-Huh. Tātad, kāda ir jautājums tur?
Žēl. Nē, nē. Go, go, lūdzu.
[Studentu] Tātad, jūs ne mainot vērtību norādes.
Jums nebūtu bijis jādara rādītāju mīnus mīnuss.
[Džozefs] Jā, tieši tā.
Tātad, kad man rādītāju +1 un rādītāju +2,
Es nedaru rādītāju vienāds rādītāju +1.
Tātad, rādītājs vienkārši paliek norādot sākumā masīva.
Tas ir tikai tad, kad man plus plus tas, ka tā vērtība atpakaļ iekšā rādītāja,
ka tas faktiski pārceļas šo kopā.
Labi.
Vēl jautājumi?
>> Atkal, ja tas ir sava veida milzīgs, tas tiks iekļauti sesijā.
Uzdod savu mācību kolēģiem par to, un mēs varam atbildēt uz jautājumiem beigās.
Un parasti mums nepatīk to darīt mīnus lieta.
Tas ir prasīt man sekot tam, cik daudz es esmu kompensēt masīvā.
Tātad, kopumā, tas ir tikai, lai izskaidrotu, kā rādītāju aritmētisko darbi.
Bet tas, ko mēs parasti patīk darīt, ir mums patīk izveidot kopiju rādītāja,
un tad mēs izmantot šo kopiju, kad mēs esam pārvietojas virknē.
Tātad, šajos gadījumos jūs izmantojat kopiju drukāt virtenei,
bet mums nav jādara, piemēram, rādītāju mīnus 6 vai sekot līdzi, cik daudz mēs pārcēlās šajā,
tikai tāpēc, ka mēs zinām, ka mūsu sākotnējais punkts ir joprojām norādīja uz saraksta sākumā
un viss, ko mēs mainīts bija šī kopija.
Tātad, kopumā, mainīt kopijas savu sākotnējo rādītāju.
Vai nav mēģināt kārtot līdzīgu - Don 't mainīt oriģinālu kopijas.
Mēģinot mainīt tikai kopijas oriģinālu.
Tātad, jūs ievērosiet, kad mēs iet virkni vērā printf
Jums nav likt zvaigzne priekšā no tā, kā mēs to darījām ar visām citām dereferences, labi?
Tātad, ja jūs izdrukāt visu stīgu% s sagaida ir adrese,
un šajā gadījumā šautriņu vai šajā gadījumā, piemēram masīvu rakstzīmes.
>> Blondīne, char * s, un masīvi ir tas pats.
Rādītājs ir rakstzīmes, un raksturs bloki ir tas pats.
Un tā, viss, kas mums ir jādara, ir caurlaide rādītājs.
Mums nav iet līdzīgi * rādītājs vai kaut kā tā.
Tātad, masīvi un norādes ir pats.
Kad jūs darāt kaut ko līdzīgu x [y] nekā šeit masīva,
ko tas dara ar kapuci, ir tas saka, labi, tas ir raksturs masīvs,
tāpēc tas ir rādītājs.
Un tā x ir tas pats,
un lai ko tas ir tas piebilst y x,
kas ir tas pats, kas virzās uz priekšu, atmiņas, ka daudz.
Un tagad x + y dod mums kaut kādas adreses,
un mēs dereference adresi vai sekot bultiņas
kur tas atmiņā vieta ir, un mēs iegūtu vērtību no šīs vietas atmiņā.
Tātad, tāpēc šie divi ir tieši tas pats.
Tas ir tikai sintaktisko cukura.
Viņi to pašu. Viņi tikai dažādu syntactics par otru.
>> Tātad, ko var noiet greizi ar norādes? Piemēram, partiju. Labi. Tātad, sliktas lietas.
Daži slikti lietas, varat darīt nav pārbaudīt, vai jūsu malloc zvans atgriež null, labi?
Šajā gadījumā, es esmu lūdzot sistēmu, lai dotu man - kas tas ir skaitlis?
Līdzīgi kā 2 miljardu reižu 4, jo veselam skaitlim izmērs ir 4 baiti.
Es esmu lūdzot sniegt, piemēram, 8 miljards baitu.
Protams mans dators nav gatavojas, lai varētu sniegt man, ka daudz atmiņas atpakaļ.
Un mums nav pārbaudīt, vai tas ir nulle, tad, kad mēs cenšamies dereference to vairāk tur -
sekot bultiņas, kur tas notiek, lai - mums nav šo atmiņu.
Tas ir tas, ko mēs saucam dereferencing ar null rādītāju.
Un tas būtībā liek jums segfault.
Tas ir viens no veidiem, kā jūs varat segfault.
Citas sliktas lietas jūs varat darīt - oh labi.
Tas bija dereferencing ar null rādītāju. Labi.
Citas sliktas lietas - labi, noteikt, ka jūs vienkārši ievietot pārbaudi tur
kas pārbauda, ​​vai rādītājs ir nulle
un izietu no programmas, ja tas notiek, ka malloc atgriež null rādītāju.
Tas ir xkcd komiksu. Cilvēki saprot to tagad. Veida.
>> Tātad, atmiņas. Un es devos pār to.
Mēs esam aicinot malloc cilpā, bet katru reizi, kad mēs saucam malloc
mēs zaudēt dziesmu par to, kur šis rādītājs ir vērsta uz,
jo mēs esam clobbering to.
Tātad, sākotnējais aicinājums malloc dod man atmiņā vairāk nekā šeit.
Mani rādītājs norādes uz to.
Tagad, man nav to atbrīvotu, tāpēc tagad es aicinu malloc vēlreiz.
Tagad tas norāda vairāk nekā šeit. Tagad mana atmiņa ir vērsta vairāk nekā šeit.
Norādot vairāk nekā šeit. Norādot vairāk nekā šeit.
Bet es esmu zaudējis dziesmu no visu atmiņu nekā šeit, ka man piešķirta adresēm.
Un tāpēc tagad man nav nekādas atsauces uz tiem vairs.
Tātad, es nevaru bez viņiem ārpus šīs cilpas.
Un tāpēc, lai noteiktu kaut ko tādu,
ja esat aizmirsis, lai atbrīvotu atmiņu, un jūs saņemsiet šo atmiņas noplūde,
Jums ir, lai atbrīvotu atmiņu iekšā šīs cilpas, kad esat pabeidzis ar to.
Nu, tas ir tas, kas notiek. Es zinu daudz no jums ienīstu šo.
Bet tagad - Yay! Jūs saņemsiet kā 44.000 kilobaiti.
Tātad, jūs atbrīvot to beigās cilpa,
un kas notiek, lai tikai atbrīvotu atmiņā katru reizi.
Būtībā, jūsu programma nav atmiņas noplūdi vairs.
>> Un tagad kaut kas cits jūs varat darīt, ir atbrīvotu atmiņu, ka esat lūdza divreiz.
Šajā gadījumā jums malloc kaut, jūs maināt savu vērtību.
Jūs atbrīvot to reizi, jo jūs teicāt, tika darīts ar to.
Bet tad mēs atbrīvojušies to vēlreiz.
Tas ir kaut kas ir diezgan slikti.
Tas nav gatavojas sākotnēji segfault,
bet pēc kāda laika, ko tas ir dubultā atbrīvojot Šis samaitā jūsu kaudze struktūru,
un jūs varēsiet uzzināt nedaudz vairāk par to, ja jūs izvēlaties veikt klases, piemēram CS61.
Bet būtībā pēc kamēr jūsu dators ir gatavojas saņemt sajaukt
par to, ko atmiņas vietas ir, kur un kad tas ir saglabāts -
kur dati tiek glabāti atmiņā.
Un tā atbrīvojot rādītāju divreiz ir slikta lieta, ka jūs nevēlaties to darīt.
>> Citas lietas, kas var noiet greizi neizmanto sizeof.
Tātad, šajā gadījumā jums malloc 8 baiti,
un tas ir pats par diviem veseliem skaitļiem, labi?
Tātad, tas ir pilnīgi droši, bet tas ir?
Nu, kā Lucas runāja par dažādām arhitektūrām,
integers ir dažāda garuma.
Tātad, uz ierīces, kas jūs izmantojat, veseli skaitļi ir aptuveni 4 baiti,
bet uz kādu citu sistēmu tie varētu būt 8 biti vai tie varētu būt 16 baiti.
Tātad, ja es tikai izmantot šo numuru nekā šeit,
Šī programma varētu strādāt uz ierīces,
bet tas nav gatavojas piešķirt pietiekami daudz atmiņas uz kādu citu sistēmu.
Šajā gadījumā, tas ir tas, ko sizeof operators izmanto.
Kad mēs saucam sizeof (int), ko tas dara, ir
tas dod mums lielumu skaitlim par sistēmu, ka programma darbojas.
Tātad, šajā gadījumā, sizeof (int) atgriezīsies 4 par kaut ko līdzīgu ierīci,
un tagad šī griba 4 * 2, kas ir 8,
kas ir tikai daudz vietas nepieciešams divu veselu skaitļu.
Par citu sistēmu, ja int ir kā 16 baiti vai 8 baiti,
tas ir tikai gatavojas atgriezties pietiekami bytes uzglabāt šo summu.
>> Un visbeidzot, structs.
Tātad, ja jūs vēlaties, lai saglabātu sudoku kuģa atmiņā, kā varētu mēs to darām?
Jūs varētu domāt par, piemēram, mainīgais pirmā lieta,
mainīgo par otro lieta, mainīgais Trešā lieta,
mainīgo par ceturto lieta - slikti, vai ne?
Tātad, viens uzlabojums jūs varat veikt uz augšu, ir padarīt 9 x 9 masīvs.
Tas ir labi, bet kas notiks, ja jūs vēlētos saistīt citas lietas ar sudoku kuģa
patīk tas, ko no kuģa grūtības,
vai, piemēram, kādas ir jūsu rezultāts ir, vai cik daudz laika tas ir pieņemts jums atrisināt šo kuģa?
Nu, ko jūs varat darīt, ir iespējams izveidot struct.
Ko es esmu būtībā sakot, ir es esmu definējot šo struktūru nekā šeit,
un es esmu nosakot sudoku valde, kas sastāv no kuģa, kas ir 9 x 9.
>> Un ko tas ir tā norādes uz vārdu līmenī.
Tas arī ir x un y, kas ir koordinātes, kur es esmu šobrīd.
Tas arī ir laiks [nesaprotami], un tas ir kopējais skaits kustas es esmu ievadījis līdz šim.
Un tāpēc šajā gadījumā, es varētu grupēt visu ķekars datu par vienu struktūru
vietā, tā kā peld apkārt līdzīgi dažādiem mainīgajiem
ka es nevaru īsti izsekot.
Un tas ļauj mums būt tikai jauka sintakse veida norādes dažādas lietas iekšpuses šo struct.
Es varu tikai darīt board.board, un man sudoku valde atpakaļ.
Board.level, man, cik grūts tas ir.
Board.x un board.y man koordinātes, kur es varētu būt valdē.
Un tāpēc es esmu piekļuvei, ko mēs saucam lauki struct.
Tas nosaka sudokuBoard, kas ir veids, kas man ir.
Un tagad mēs esam šeit. Man ir mainīgo sauc "valde" tipa sudokuBoard.
Un tāpēc tagad es varētu piekļūt visi lauki, kas veido šo struktūru nekā šeit.
>> Kādi jautājumi par structs? Jā?
[Studentu] Par int x, y, tu paziņoja abi vienā rindā? >> [Džozefs] Uh-Huh.
[Studentu] Tātad, jūs varētu vienkārši darīt ar tiem visiem?
Tāpat kā X, Y komatu reizes kopējais?
[Džozefs] Jā, jūs varētu noteikti darīt, bet iemesls man x un y uz vienas līnijas -
un jautājums ir, kāpēc mēs varam vienkārši izdarīt uz vienas līnijas?
Kāpēc ne mēs tikai visus šos uz vienas līnijas ir
x un y ir saistīti viens ar otru,
un tas ir tikai stilistiski pareizi, kas nozīmē,
jo tas grupējot divas lietas vienā rindā
ka, piemēram, sava veida attiecas uz to pašu.
Un es vienkārši sadalīt šos intervālu. Tas ir tikai stils lieta.
Tā funkcionāli nekādas starpības whatsoever.
Jebkādi citi jautājumi par structs?
Jūs varat definēt Pokédex ar struct.
Pokmon ir vairākas, un tas ir vēstule, īpašnieks, tipa.
Un tad, ja jums ir masīvs Pokemon, jūs varat veido Pokédex, labi?
Labi, atdzesē. Tātad, jautājumi par structs. Tie ir saistīti ar structs.
>> Visbeidzot, GDB. Kāda Gdb jums darīt? Tas ļauj jums atkļūdot savu programmu.
Un, ja jūs neesat izmantojis GDB, es ieteicams skatīties īstermiņa
un tikai iet pār to Gdb ir, kā jūs strādājat ar to, kā jūs varētu to izmantot,
un pārbaudīt to uz programmu.
Un lai ko Gdb ļauj jums jādara, ir tas ļauj pauzes [nesaprotams] Līdz jūsu programmā
un praktisku līniju.
Piemēram, es gribu, lai apturētu izpildi pēc kā mana programmas 3 līniju,
un kamēr es esmu pie 3 līniju es varētu izdrukāt visas vērtības, kas ir tur.
Un tā, ko mēs saucam kā pauzēm rindā
ir mēs saucam liekot pārtraukumpunkts šajā līnijā
un tad mēs varam izdrukāt mainīgie pie valsts programmas šajā laikā.
>> Mēs varam tad no turienes soli pa programmu rindu pa līniju.
Un tad mēs varam apskatīt stāvokli skursteņa laikā.
Un tāpēc, lai izmantotu GDB, ko mēs darām, ir mēs aicinām šķindēt par C failu,
bet mums ir jāiet tā-ggdb karogu.
Un, kad mēs esam darīts ar to mēs vienkārši palaist gdb uz iegūtajā failā.
Un tā jums dažas, piemēram, masu teksta, piemēram, tas,
bet tiešām viss, kas jums jādara, ir rakstīt komandas sākumā.
Break galvenais liek pārtraukumpunkts pie galvenā.
Sarakstā 400 uzskaitīti rindas koda aptuveni 400 līniju.
Un tāpēc šajā gadījumā jūs varat vienkārši paskatīties un teikt, ak,
Es gribu, lai noteikt pārtraukumpunkts pie 397 līniju, kas ir šī pozīcija,
un tad jūsu programma darbojas uz šo soli, un tas notiek, lai izjauktu.
Tas notiek, lai apturētu tur, un jūs varat izdrukāt, piemēram, vērtību zems vai augsts.
Un tāpēc ir komandu, kas jums jāzina ķekars,
un tas slaidrādi iet līdzi mājas lapā,
tādēļ, ja jūs vienkārši vēlaties, lai norādītu tos vai patīk viņus uz jūsu apkrāptu loksnes, justies brīvi.
>> Atdzist. Tas bija viktorīna Review 0, un mēs stick apkārt, ja jums ir kādi jautājumi.
Labi.
>> [Aplausi]
>> [CS50.TV]