[Powered by Google Translate] [Seksyon 6: Mas mababa kumportableng]
[Nate Hardison] [Harvard University]
[Ito ay CS50.] [CS50.TV]
Ayos lang. Maligayang pagdating sa seksyon 6.
Sa linggong ito, kami ay pagpunta sa pakikipag-usap tungkol sa mga data kaayusan sa seksyon,
pangunahing dahil ang problemang ito linggo sa spellr
ang buong bungkos ng ng ibang data paggalugad istraktura.
May grupo ng mga iba't ibang mga paraan maaari kang pumunta sa mga hanay ng problema,
at ang higit pang mga istraktura ng data alam mo, mas cool na bagay na maaari mong gawin.
>> Kaya sabihin makapagsimula. Una namin upang makipag-usap tungkol sa mga stack,
ng stack at queue istraktura ng data na kami ay pagpunta sa makipag-usap tungkol sa.
Stack at queues ay talagang kapaki-pakinabang kapag sinimulan namin ang pinag-uusapan ng mga graph,
kung saan hindi namin ay pagpunta sa gawin ito magkano ng karapatan ngayon.
Ngunit ito ay talagang magandang upang maunawaan ang isa ng malaking pangunahing istraktura ng data ng CS.
Ang paglalarawan sa detalye ng hanay ng problema,
kung hilahin mo ito, ang mga pag-uusap tungkol sa mga stack bilang kamag-anak sa
pile ng mga trays dining na mayroon ka sa cafeteria sa bulwagan kainan
kung saan kapag ang dining kawani ay at Inilalagay ng mga trays dining pagkatapos nilang nalinis ang mga ito,
sila stack ang mga ito isa sa tuktok ng isa.
At pagkatapos ay kapag dumating ang mga bata upang makakuha ng pagkain,
hilahin nila ang mga trays off, unang sa tuktok, ang isa sa ibaba nito, pagkatapos ay ang isa sa ibaba na.
Kaya, sa epekto, ang unang tray na ang dining kawani ilagay down na ang huling isa na ay makakakuha ng kinuha off.
Ang huling isa na ang mga kawani ng dining ilagay sa ay ang unang isa na ay makakakuha ng kinuha off para sa hapunan.
Sa spec set ang problema, kung saan maaari mong i-download kung hindi mo pa nagagawa,
makipag-usap namin tungkol sa pagmomodelo ng isang stack data stucture paggamit ng ganitong uri ng struct.
>> Kaya kung ano ang namin ang nakuha dito, ito ay katulad sa kung ano ang ipinakita sa panayam,
maliban sa panayam nagpakita namin ito sa mga ints bilang kabaligtaran sa magpasinda * s.
Ito ay pagpunta sa isang stack na tindahan kung ano?
Daniel? Ano ang mga namin ang pag-iimbak sa stack?
[Daniel] string? Namin ay >> sa pag-iimbak ng string sa stack, eksakto.
Ang kailangan mo upang lumikha ng isang stack ay isang array
ng isang partikular na kapasidad, na sa kasong ito,
kapasidad ay pagpunta sa lahat ng caps dahil ito ay isang pare-pareho.
At pagkatapos ay sa karagdagan sa array, ang lahat ng kailangan namin upang subaybayan ang kasalukuyang laki ng array.
Isang bagay na dapat tandaan dito na uri ng mga cool na
na namin ang paglikha ng nakasalansan na istraktura ng data sa tuktok ng isa pang istraktura ng data, ang array.
Mayroong iba't ibang mga paraan upang ipatupad ang mga stack.
Hindi namin gawin ito lubos pa, ngunit sana ay pagkatapos ng paggawa sa naka-link na listahan problema,
makikita mo kung paano maaari mong madaling ipatupad ang stack sa itaas ng isang naka-link na listahan pati na rin.
Ngunit sa ngayon, makikita namin dumikit ang array.
Kaya muli, ang lahat ng kailangan namin ay isang array at kailangan lang namin upang subaybayan ang laki ng array.
[Sam] Paumanhin, kung bakit ito na sinabi mo stack sa tuktok ng string?
Sa akin tila tulad ng mga string sa loob ng stack.
[Hardison] Oo. Kami ay ang paglikha, namin ang paglalaan ang aming data ng istraktura ng array -
na isang mahusay na tanong. Kaya tanong ay kung bakit, para sa mga taong nanonood ito online,
kung bakit namin sinasabi na ang stack sa tuktok ng string,
dahil dito ito hitsura tulad ng mga string sa loob ng stack?
Na kung saan ay lubos na ang kaso.
Ano ako ay nagre-refer sa ay na namin ang nakakuha ng isang array ng data ng istraktura.
Mayroon kaming isang array ng magpasinda * s, ito array ng mga string,
at kami ay pagpunta upang idagdag sa na upang lumikha ng ang nakasalansan na istraktura ng data.
>> Kaya stack ay bahagyang mas kumplikado kaysa sa isang array.
Maaari naming gamitin ang isang array upang bumuo ng isang stack.
Kaya na kung saan sinasabi namin na ang stack ay binuo sa tuktok ng isang array.
Gayundin, tulad ng sinabi ko mas maaga, maaari naming bumuo ng isang stack sa itaas ng isang naka-link na listahan.
Sa halip ng paggamit ng isang array upang i-hold ang aming mga elemento,
maaari kaming gumamit ng isang naka-link na listahan upang i-hold ang aming mga elemento at bumuo ng stack sa paligid na.
Natin maglakad sa pamamagitan ng isang pares ng mga halimbawa, pagtingin sa ilang code,
upang makita kung ano ang aktwal na nangyayari dito.
Sa kaliwa, ko na itinapon down kung ano na struct stack ay magmukhang sa memory
kung kapasidad na # tinukoy na apat.
Mayroon namin ang aming apat na elemento magpasinda * array.
Mayroon kaming string [0], string [1], string [2], string [3],
at pagkatapos na huling espasyo para sa aming size integer.
Ba ito magkaroon ng kahulugan? Okay.
Ito ay ano ang mangyayari kung ano ang ginagawa ko sa kanan,
na sa aking code, ay para lamang ipinapahayag ng struct, nakasalansan struct na tinatawag na mga.
Ito ay kung ano ang nakukuha namin. Ito lays down na ito footprint sa memorya.
Ang unang tanong dito ay kung ano ang mga nilalaman ng struct stack na ito?
Sa ngayon ang mga ito ay walang, ngunit hindi lubos na walang.
Hindi nila ito uri ng basura. Wala kaming ideya kung ano ang sa kanila.
Kapag ipinapahayag namin ang mga stack, kami ay ibinabato na sa tuktok ng memory.
Ito ay uri ng tulad ng deklarasyon int i at hindi Sinisimulan ito.
Hindi mo alam kung ano ang doon. Maaari mong basahin kung ano ang doon,
ngunit hindi ito maaaring maging napaka-kapaki-pakinabang na.
Ang isang bagay na gusto mong palaging tandaan na gawin ay simulan ang anumang kailangang nasimulan.
Sa kasong ito, kami ay pagpunta sa initialize ang laki sa zero,
dahil na pagpunta upang i-napakahalaga para sa amin.
Kami maaaring magpatuloy at initialize ang lahat ng mga payo, ang lahat ng mga magpasinda * s,
ilang naiintindihan halaga, marahil null.
Ngunit ito ay hindi lubos na kinakailangan na gawin namin na.
>> Ngayon, ang dalawang pangunahing mga pagpapatakbo sa stack?
Sinuman tandaan mula sa panayam kung ano ang gagawin mo sa stack? Oo?
[Stella] pagtulak at popping? >> Mismong.
Pagtulak at popping ay ang dalawang pangunahing pagpapatakbo sa stack.
At kung ano ang push gawin? >> Ito Inilalagay ng isang bagay papunta sa tuktok
ng stack, at pagkatapos ay popping tumatagal off ito.
[Hardison] Mismong. Kaya pagtulak pushes isang bagay sa tuktok ng stack.
Ito ay tulad ng dining kawani paglalagay ng dining tray sa counter.
At popping nagtatagal dining tray ng stack.
Sabihin maglakad sa pamamagitan ng ilang mga halimbawa ng kung ano ang mangyayari
kapag namin itulak ang mga bagay sa stack.
Kung kami ay upang itulak ang string na 'kumusta' patungo sa daloy ng mga sasakyan sa aming stack,
ito ay kung ano ang aming diagram magiging ganito ang hitsura ngayon.
Tingnan kung ano ang mangyayari?
Namin hunhon sa unang elemento ng aming mga string ng array
at upped namin ang aming laki count na 1.
Kaya't kung tiningnan namin sa pagkakaiba sa pagitan ng dalawang mga slide, dito ay 0, narito ang bago ang push.
Dito ay pagkatapos ng push.
Bago push, pagkatapos ng push.
At ngayon ay mayroon kaming isang elemento sa aming stack.
Ang string "kumusta", at na ito.
Lahat ng iba pa sa array, sa aming mga string ng array, ay pa rin basura.
Hindi pa namin nasimulan ito.
Sabihin nating itulak namin ang isa pang string papunta sa aming stack.
Kami ay pagpunta sa itulak ang "mundo" sa oras na ito.
Sa gayon maaari mong makita ang "mundo" dito napupunta sa tuktok ng "kumusta",
at ang laki ng bilang ng napupunta hanggang sa 2.
Ngayon ay maaari naming itulak ang "CS50", at na kailangan pumunta sa tuktok muli.
Kung pumunta namin pabalik, maaari mong makita kung paano namin pagtulak bagay sa tuktok ng stack.
At ngayon kami makakuha ng mag-pop.
Kapag pop namin ang isang bagay ng stack, kung ano ang nangyari?
Sinuman makita ang pagkakaiba? Medyo banayad.
[Mag-aaral] Ang laki. >> Oo, laki nagbago.
>> Ano pa ang gusto mong inaasahan upang baguhin?
[Mag-aaral] Ang mga string, masyadong. >> Karapatan. Ang masyadong mga string.
Ito ay lumiliko out na kapag ginagawa mo ito sa ganitong paraan,
dahil hindi namin pagkopya ng mga elemento sa aming stack,
hindi namin aktwal gawin, maaari naming gamitin ang laki
subaybayan ng bilang ng mga bagay sa aming array
sa gayon ay kapag pop namin muli, muli lang namin ng pagbawas sa aming size down sa 1.
Walang pangangailangan sa aktwal na pumunta sa at patungan ang anumang.
Uri ng funky.
Ito lumiliko out na ating kadalasang iwan lang bagay nag-iisa dahil ito ay mas trabaho para sa amin upang gawin.
Kung hindi namin upang bumalik at patungan ang isang bagay, at pagkatapos ay kung bakit ito gawin?
Kaya kapag pop namin dalawang beses off ng stack, ang lahat ng ginagawa ng pagbawas sa laki ng ilang beses.
At muli, ito ay lamang dahil hindi namin pagkopya ng mga bagay sa aming stack.
Oo? Sige.
[Mag-aaral, hindi maintindihan] >> At pagkatapos ay kung ano ang mangyayari kapag ikaw itulak ang isang bagay muli?
Kapag itulak mo ang isang bagay na muli, kung saan ito pumunta?
Saan ang pumunta, Basil? >> Sa mga string [1]? >> Karapatan.
Bakit hindi pumunta sa mga string [3]?
[Basil] Dahil nakalimutan na may anuman sa mga string [1] at [2]?
[Hardison] Mismong. Aming stack, mahalagang, "nakalimutan" na ito ay may hawak na sa anumang
sa mga string [1] o string [2], kaya kapag namin itulak ang "woot",
ito lamang Inilalagay ng na sa elemento sa string [1].
Mayroon bang anumang mga katanungan sa kung paano ito gumagana, sa isang pangunahing antas?
[Sam] Kaya ito ay hindi dynamic na sa anumang paraan, sa mga tuntunin ng halaga
o sa mga tuntunin ng laki ng stack?
[Hardison] Mismong. Ito ay - punto ay na ito ay hindi isang dynamic growning stack.
Ito ay isang stack na maaaring magkaroon ng, sa karamihan, apat magpasinda * s, hindi hihigit sa apat na mga bagay.
Kung kami ay upang subukan at itulak ang ikalimang bagay, kung ano ang sa tingin mo dapat mangyari?
[Mga mag-aaral, hindi maintindihan]
[Hardison] Mismong. Mayroong isang bilang ng mga bagay na maaaring mangyari.
Maaaring posibleng seg kasalanan, depende sa kung ano ang namin -
kung paano eksaktong namin ang pagpapatupad ng back-end.
Maaaring patungan. Maaaring na buffer overflow na usapan natin ang tungkol sa klase.
Ano ang gusto ay ang pinaka-halata bagay na maaaring mapatungan
kung sinubukan naming i-push ng dagdag na bagay sa aming stack?
Kaya mo nabanggit buffer overflow.
Ano ang maaaring ang bagay na makapag-nakasulat sa paglipas ng o stomped sa
kung overflowed namin sinasadyang sa pamamagitan ng pagsubok upang itulak ng dagdag na bagay?
[Daniel, hindi maintindihan] >> posibleng.
Ngunit simula, kung ano ang maaaring mangyari? Paano kung sinubukan naming i-itulak 1/4 na bagay?
Maaaring patungan ang laki, hindi bababa sa na may ito memory diagram na nakuha namin na.
>> Sa detalye ng hanay ng problema, na kung ano ang namin ang pagpunta sa pagpapatupad ngayon,
kung ano ang aming nais na gawin ay lamang bumalik sa maling.
Ang aming pamamaraan sa push upang ibalik ang isang boolean na halaga,
at ang boolean na halaga ay totoo kung magtagumpay ang push
at huwad na kung hindi namin maaaring itulak ang anumang mas dahil stack ay puno.
Natin maglakad sa pamamagitan ng kaunting code na ngayon.
Narito ang aming push function na.
Aming push function na para sa isang stack sa string ilalagay sa stack.
Ito ay nagbabalik ng tunay na kung ang string sa Matagumpay na hunhon
sa stack at maling kung hindi man.
Anumang mga mungkahi sa kung ano ang maaaring maging isang magandang unang bagay na gawin dito?
[Sam] Kung laki ay katumbas ng kapasidad pagkatapos ay bumalik sa maling?
[Hardison] Bingo. Nice trabaho.
Kung ang laki ay ang kapasidad, kami ay pagpunta upang bumalik false.
Hindi namin maaaring ilagay ang anumang higit pa sa aming stack.
Kung hindi man, nais naming upang ilagay ang isang bagay sa tuktok ng stack.
Ano ang "sa tuktok ng stack," sa una?
[Daniel] Laki 0? >> Laki 0.
Ano ang tuktok ng stack pagkatapos may isang bagay sa stack? Missy, kilala mo?
[Missy] Isa. >> Sukat ay isa, eksakto. Panatilihin kang pagdaragdag sa laki,
at sa bawat oras na naglalagay ka ng sa bagong elemento sa ang laki ng index sa array.
Maaari naming gawin ito sa na uri ng isang-Liner, kung na saysay.
Kaya namin nakuha ang aming mga string array, kami ay pagpunta upang ma-access ang mga ito sa index ng laki,
at lang kami upang mag-imbak ang aming magpasinda * sa doon.
Pansinin kung paano mayroong walang string pagkopya nangyayari sa dito,
walang dynamic na paglalaan ng memory?
At pagkatapos ay dinala ni Missy kung ano na namin ngayon gawin,
dahil kami na naka-imbak ang string sa naaangkop na lugar sa array,
at sinabi niya na namin ay upang dagdagan ang laki ng isa sa gayon ay handa na kami para sa susunod na push.
Upang maaari naming gawin na may s.size + +.
Sa puntong ito, kami hunhon sa aming array. Ano ang huling bagay na kami ay may sa gawin?
[Mag-aaral] Bumalik totoo. >> Bumalik totoo.
Kaya ito ay medyo simple, ang isang medyo simpleng code. Hindi masyadong maraming.
Sa sandaling na-balot ang iyong ulo sa paligid kung paano gumagana ang stack ang,
ito ay medyo simple na ipapatupad.
>> Ngayon, ang susunod na bahagi ng popping isang string ng stack.
Ako pagpunta upang bigyan ka ng mga guys ilang oras upang gumana sa ito ng kaunti.
Ito ay halos mahalagang reverse ng kung ano ang ginawa namin dito sa push.
Ano tapos ko na na ang aktwal na - oops.
Ko ang booted appliance sa paglipas dito, at sa appliance,
Nakuha ko na ang problema magtakda ng 5 pagtutukoy.
Kung naming mag-zoom in dito, maaari naming makita ako sa cdn.cs50.net/2012/fall/psets/pset5.pdf.
Mo ba ang guys-download ang code na ito na matatagpuan dito, section6.zip?
Ayos lang. Kung hindi ka pa tapos na, gawin na ngayon, talagang mabilis.
Kong gawin ang mga ito sa aking terminal na window.
Aktwal na ginawa ko ito dito. Oo.
Oo, Sam? >> Mayroon akong tanong tungkol sa kung bakit ang sinabi ninyo bracket s.string 'ng laki = STR?
Ano ang STR? Ay na tinukoy sa isang lugar bago, o - oh, sa magpasinda * STR?
[Hardison] Oo, eksakto. Na ang argumento. >> Oh, okay. Sorry.
[Hardison] Kami ay tumutukoy sa string upang itulak.
Ang iba pang mga katanungan na maaaring makabuo na hindi namin ay talagang makipag-usap tungkol dito ay
kinuha namin para sa ipinagkaloob na nagkaroon kami ng variable na ito na tinatawag na mga
na sa saklaw at naa-access sa amin.
Kinuha namin para sa ipinagkaloob na mga stack struct na ito.
Kaya naghahanap pabalik sa push code na ito,
maaari mong makita na ginagawa namin sa mga bagay-bagay sa ang string na ito na Nakakuha ang pumasa sa
ngunit pagkatapos ang lahat ng isang biglaang, hindi namin ina-access s.size, tulad ng, kung saan ay mga darating mula sa?
Sa code na kami ay pagpunta upang tingnan sa archive seksyon
at pagkatapos ay nagtatakda ang mga bagay na kailangan mong ginagawa sa iyong problema,
ginawa namin ang aming stack struct isang pandaigdigang variable
upang maaari naming may access dito sa lahat ng aming iba't ibang mga function
nang hindi na kinakailangang upang mano-manong pumasa ito sa paligid at ipasa ang mga ito sa pamamagitan ng reference,
lahat na uri ng mga bagay-bagay dito.
Lang kami Pandaraya ng kaunti, kung kalooban mo, upang gumawa ng mga bagay nicer.
At na ang isang bagay na ginagawa namin dito dahil ito ay katuwaan, madaling.
Kadalasan, makikita mo ang mga tao gawin ito kung mayroon silang isang malaking istraktura ng data
na pinapatakbo sa loob ng kanilang programa.
>> Natin bumalik sa sa appliance.
Ba lahat matagumpay na makuha ang section6.zip?
Lahat unzip ito gamit ang section6.zip unzip?
Kung pupunta ka sa direktoryo ng seksyon 6 -
aah, sa lahat ng dako ng lugar -
at ilista mo kung ano ang in dito, makikita mo na mayroon kang tatlong magkakaibang. file c.
Mayroon kang queue, sll, na isa-isa-naka-link na listahan, at isang stack.
Kung binuksan mo stack.c,
maaari mong makita na namin Mayroon struct na ito na tinukoy para sa atin,
ang eksaktong struct na lang namin uusapang tungkol sa mga slide.
Mayroon kaming ang aming global variable para sa stack,
Mayroon namin ang aming push function na,
at pagkatapos Mayroon namin ang aming pop function na.
Makikita ko bang ilagay ang code para sa uurong sa slide dito,
ngunit kung ano ang nais kong mo guys na gawin, sa abot ng iyong kakayahan,
pumunta at ipatupad ang pop function na.
Sandaling naipatupad ito, maaari kang makatipon ito na may gumawa ng stack,
at pagkatapos ay patakbuhin ang nagreresultang executable stack,
at na tatakbo sa lahat ng ang code na ito sa pagsubok pababa narito na sa pangunahing.
At pangunahing ay tumatagal ng pag-aalaga ng aktwal na paggawa ng push at pop tawag
at siguraduhin na ang lahat napupunta sa pamamagitan ng lahat ng karapatan.
Mayroon din initializes ng stack laki dito mismo
kaya hindi mo kailangang mag-alala tungkol sa Sinisimulan na.
Maaari mong ipinapalagay na ang maayos na nasimulan
ng oras mong i-access ito sa function na ang pop.
Ba na magkaroon ng kahulugan?
Kaya dito namin pumunta. Ang push code.
Bibigyan kita ng guys 5 o 10 minuto.
At kung mayroon kang anumang mga katanungan sa pansamantala habang ikaw ay coding,
mangyaring hilingin sa kanila nang malakas.
Kaya kung makakakuha ka ng isang punto malagkit, magtanong lamang.
Ipaalam sa akin, ipaalam sa lahat tao alam.
Makipagtulungan sa iyong kapwa.
[Daniel] kami pagpapatupad pop ngayon? >> Lang pop.
Kahit na maaari mong kopyahin ang pagpapatupad ng push kung nais mong
upang ang pagsubok gagana.
Dahil mahirap upang subukan ang mga bagay na pagkuha sa -
o, ito ay mahirap upang subukan ang popping bagay ng isang stack kung may anumang bagay sa stack upang magsimula sa.
>> Ano ang pop dapat na bumabalik? Ang elemento mula sa tuktok ng stack.
Ito ay dapat upang makuha ang mga elemento ng tuktok ng stack
at pagkatapos ng pagbawas sa laki ng stack,
at ngayon nawalan ka elemento sa tuktok.
At pagkatapos mong ibalik ang mga elemento sa itaas.
[Estudyante, hindi maintindihan]
[Hardison] Kaya ano ang mangyayari kung gagawin mo na? [Estudyante, hindi maintindihan]
Ano ang nagtatapos up mangyari ay malamang na ina-access mo ang alinman sa
isang elemento na hindi pa nasimulan, kaya ang iyong pagkalkula
kung saan ang huling elemento ay Naka-off ang.
Kaya dito, kung napansin mo, sa push, hindi namin ina-access string sa s.size elemento
dahil ito ay isang bagong index.
Ang bagong tuktok ng stack.
Sapagkat sa pop, s.size na ang susunod na espasyo,
ang puwang na sa tuktok ng lahat ng mga elemento sa iyong stack.
Kaya ang pinakataas na elemento ay hindi sa s.size,
ngunit sa halip, ito ay sa ilalim nito.
>> Ang iba pang mga bagay na gawin kapag ikaw - sa pop,
ay mo sa pagbawas sa laki.
Kung tandaan mo pabalik sa aming maliit na diagram dito mismo,
talaga, ang tanging bagay na nakita namin ang nangyayari kapag tinatawag namin pop
ay ang laki na ito ay bumaba, una sa 2, pagkatapos ay sa 1.
Pagkatapos kapag hunhon namin ang isang bagong elemento sa, ito pumunta sa sa tamang lugar.
[Basil] Kung s.size ay 2, hindi ito pumunta sa elemento 2,
at pagkatapos ay nais mo nais mag-pop na elemento?
Kaya kung nagpunta kami sa - >> Kaya tingnan natin muli sa.
Kung ito ay ang aming stack sa puntong ito
at tinatawag naming pop,
kung index pinakataas na elemento?
[Basil] Sa 2, ngunit ito ay mag-pop 3. >> Karapatan.
Kaya na kung saan ang aming mga laki ay 3, ngunit nais naming mag-pop ang elemento sa index 2.
Na karaniwang uri ng off sa pamamagitan ng isa na mayroon ka sa ang zero-i-index ng array.
Kaya mo nais mag-pop ang ikatlong elemento, ngunit sa ikatlong elemento ay hindi sa index 3.
At ang dahilan kung bakit hindi namin upang gawin iyon minus 1 kapag kami ay pagtulak
ay dahil ngayon, napansin mo na ang pinakataas na elemento,
kung kami ay upang itulak ang ibang bagay papunta sa stack sa puntong ito,
gusto namin gusto upang itulak ito sa index 3.
At ito lamang kaya ang mangyayari na ang laki at ang mga indeks ng pumila kapag ikaw ay pagtulak.
>> Sino ang nakakuha ng isang gumaganang pagpapatupad stack?
Mayroon kang isang gumaganang stack isa. Mo ba ang pop gumagana pa?
[Daniel] Oo. Tingin ko ito.
>> Program Tumatakbo at hindi seg faulting, pag-print out?
Ba itong i-print "tagumpay" kapag nagpatakbo ka ng ito?
Oo. Gawing stack, patakbuhin ito, kung ito ay mga Kopya "tagumpay" at hindi pumunta boom,
pagkatapos ang lahat ng mabuti.
Ayos lang. Natin pumunta sa appliance na ang talagang mabilis,
at babagtasin namin ito.
Kung titingnan namin sa kung anong nangyayari sa dito sa pop,
Daniel, kung ano ang unang bagay na ginawa mo?
[Daniel] Kung s.size ay mas malaki kaysa sa 0.
[Hardison] Okay. At bakit ginawa mo na?
[Daniel] Upang matiyak na may isang bagay sa loob ng stack.
[Hardison] Kanan. Gusto mong subukan upang matiyak na s.size ay mas malaki kaysa sa 0;
kung hindi man, kung ano ang gusto mong mangyari?
[Daniel] Bumalik null? >> Bumalik null, eksakto.
Kaya kung s.size ay mas malaki kaysa sa 0. Pagkatapos kung ano ang namin gawin?
Ano ang gagawin namin gawin kung ay hindi walang laman ang stack?
[Stella] pagbawas sa laki? >> Mo ng pagbawas sa laki, okay.
Kaya kung paano ginawa mo na? >> S.size--
[Hardison] Mahusay. At pagkatapos ay kung ano ang ginawa mo?
[Stella] At pagkatapos ay sinabi ko ang return s.string [s.size].
[Hardison] Mahusay.
Kung hindi ka bumalik null. Oo, Sam?
[Sam] Bakit ang hindi kailangang maging s.size + 1?
[Hardison] Plus 1? >> Oo. >> Nakuha ko.
[Sam] naisip ko na dahil ka paglalaan 1 out,
ka na bumabalik hindi na tinanong nila para sa.
[Hardison] At ito ay lamang kung ano ang namin ang pakikipag-usap tungkol sa gamit ang buong isyu ng 0 mga indeks.
Kaya kung mag-zoom namin pabalik sa paglipas dito.
Kung titingnan namin sa tao dito mismo, maaari mong makita na kapag pop namin,
popping kami ay ang elemento sa index 2.
>> Kaya naming bawasan ang aming size muna, pagkatapos ay aming size tumutugma sa aming index.
Kung hindi namin unang pagbawas sa laki, at pagkatapos ay mayroon kaming upang gawin ang laki -1 at pagkatapos pagbabawas.
Mahusay. Lahat ng magandang?
Anumang mga tanong na ito?
Mayroong isang bilang ng mga iba't ibang mga paraan upang isulat ang mga ito pati na rin.
Sa katunayan, maaari naming gawin ang isang bagay kahit na - maaari naming gawin ang isa-Liner.
Maaari naming gawin ang isang isang-linya return.
Upang maaari naming aktwal ng pagbawas bago tayo bumalik sa pamamagitan ng paggawa na.
Kaya paglalagay ng - bago ang s.size.
Na ginagawang linya ang talagang siksikan.
Kung saan ang pagkakaiba sa pagitan ng - mga laki at. S.size--
ay na ito postfix - tumawag sila postfix dahil sa - ay pagkatapos ng s.size--
nangangahulugan na s.size ay masuri para sa mga layunin ng paghahanap ng index
dahil ito ay kasalukuyang kapag ang linya na ito ay pinaandar,
at pagkatapos na ito - ang mangyayari pagkatapos linya ay makakakuha pinaandar.
Matapos ang elemento sa index s.size access.
At na hindi kung ano ang gusto namin, dahil gusto naming pagbabawas ang mangyari muna.
Othewise, kami ay pagpunta sa ma-access ang array, epektibo, sa labas ng mga hanggahan.
Kami ay pagpunta sa access sa elemento sa itaas ang isa na aktwal na namin nais na i-access.
Oo, Sam? >> Ba ito nang mas mabilis o gumamit ng mas RAM sa isang linya o hindi?
[Hardison] totoo lang, ito ay talagang dumedepende.
[Sam, hindi maintindihan] >> Oo, depende. Maaari mong gawin ang mga trick tagatala
upang makuha ang tagatala upang makilala na, karaniwang, isipin ko.
>> Kaya namin ang nabanggit nang kaunti tungkol sa mga bagay-optimize tagatala
na maaari mong gawin sa kino-compile,
at na ang uri ng bagay na tagatala maaaring upang malaman kung,
tulad ng oh, hey, maaaring ang maaari kong gawin ito ang lahat ng sa isang operasyon,
kumpara sa paglo-load ng laki variable in mula sa RAM,
decrementing ito, pag-imbak nito ay umurong, at pagkatapos ay naglo-load ang mga ito pabalik sa muli
upang iproseso ang natitirang bahagi ng operasyon na ito.
Ngunit karaniwan, hindi, ito ay hindi ang uri ng bagay
na upang gumawa ng iyong programa makabuluhang mas mabilis.
Anumang higit pang mga katanungan sa stack?
>> Kaya pagtulak at popping. Kung ikaw guys ay nais na subukan ang Hacker edition,
kung ano ang ginawa namin sa edisyon Hacker ay aktwal na nawala
at ginawa stack ito palaguin dynamic.
Ang hamon may pangunahing hanggang dito sa push function na,
upang malaman kung paano gumawa ng array na palaguin
habang patuloy mong itulak ang higit pa at higit pang mga elemento ng stack.
Ito ay aktwal na hindi masyadong maraming karagdagang code.
Isang tawag lamang sa - mayroon kang tandaan upang makakuha ng mga tawag sa malloc sa doon maayos,
at pagkatapos malaman kung kapag ikaw ay tumawag realloc.
Iyon ay isang masaya hamon kung interesado ka.
>> Ngunit para sa oras, sabihin ilipat sa, at sabihin makipag-usap tungkol sa queues.
Mag-scroll sa pamamagitan dito.
Queue ay isang malapit na kapatid ng stack.
Kaya sa stack, bagay na ilalagay sa huling
ay ang unang bagay sa pagkatapos makuha.
Mayroon kaming ito huling sa, una ang, o LIFO, pag-order.
Sapagkat sa queue, bilang gusto mong asahan mula sa kapag ikaw ay nakatayo sa linya,
ang unang tao upang makakuha ng sa linya, ang unang bagay na upang makakuha ng sa queue,
ay ang unang bagay na maipo-nabawi mula sa queue.
Queues din ang mga madalas na ginagamit kapag kami ay pagharap sa graph,
tulad ng usapan natin ang tungkol maikling sa mga stack,
at queues din ang mga madaling-gamiting para sa isang grupo ng iba pang mga bagay.
Ang isang bagay ay madalas ay sinusubukan upang mapanatili, halimbawa,
pinagsunod-sunod na listahan ng mga elemento.
At maaari mong gawin ito na may isang array. Maaari mong mapanatili ang isang pinagsunod-sunod na listahan ng mga bagay sa isang array,
ngunit kung saan na hindi nakakaabala nakakalito pagkatapos palagi kang may upang makahanap ng
ang naaangkop na lugar upang ipasok ang susunod na bagay.
Kaya kung mayroon kang isang hanay ng mga numero, 1 hanggang 10,
at pagkatapos ay nais mong upang palawakin na sa lahat ng mga numero 1 sa pamamagitan ng 100,
at ikaw ay nakakakuha ng mga bilang na ito sa random na pagkakasunod-sunod at sinusubukan upang panatilihin ang lahat
pinagsunod-sunod bilang pumunta ka sa pamamagitan ng, magtapos ka kinakailangang gawin ng maraming ng paglilipat.
Sa ilang mga uri ng mga queues at ilang mga uri ng mga kalakip na kaayusan ng data,
maaari mong aktwal na panatilihin ang mga ito sa medyo simple.
Hindi mo upang magdagdag ng isang bagay at pagkatapos ay magbago ng ayos ang buong bagay sa bawat oras.
Ni mayroon ka na gawin ng maraming ng paglilipat ng panloob na elemento sa paligid.
Kapag tinitingnan namin sa queue, makita na - sa queue.c din sa ang code sa seksyon -
ang struct na binigyan ka namin ng talaga katulad sa struct na ibinigay namin sa iyo para sa isang stack.
>> Mayroong isang pagbubukod na ito, at na ang isang pagbubukod
na mayroon kaming ito ng karagdagang integer na tinatawag na sa ulo,
at ang ulo dito ay para sa pagpapanatili ng track ng ulo ng queue,
o sa unang elemento sa queue.
Sa pamamagitan ng isang stack, nagawa naming upang subaybayan ang mga elemento na kami ay tungkol sa upang mabawi,
o sa tuktok ng stack, gamit lamang ang laki,
kung saan may isang queue, nagkakaroon kami ng humarap sa tapat dulo.
Sinusubukan namin sa tak bagay sa dulo, ngunit pagkatapos ay bumalik ang mga bagay mula sa front.
Kaya epektibo, na may ulo, mayroon kaming index ng simula ng queue,
at laki ay nagbibigay sa amin ang index ng pagtatapos ng queue
upang maaari naming makuha ang mga bagay mula sa ulo at magdagdag ng mga bagay sa buntot.
Sapagkat may sa stack, kami ay lamang sa pagharap sa tuktok ng stack.
Hindi namin ay may upang ma-access sa ilalim ng stack.
Lamang kami ay nagdagdag ng mga bagay sa itaas at kinuha bagay off ng tuktok
kaya hindi namin kailangan na dagdag na patlang sa loob ng aming struct.
Ba na pangkalahatang may kabuluhan?
Ayos lang. Oo, Charlotte? [Charlotte, hindi maintindihan]
[Hardison] Iyon ay isang mahusay na tanong, at iyon ay isa na dumating sa panayam.
Siguro paglalakad sa pamamagitan ng ilang mga halimbawa ay ilarawan kung bakit
hindi namin nais na gumamit ng mga string [0] bilang ang ulo ng queue.
>> Kaya isipin na namin ang aming queue, kami ay pagpunta sa tumawag ito queue.
Sa simula, kapag kami instantiated ito,
kapag namin ang ipinahayag ito, hindi pa namin nasimulan ang anumang.
Ang lahat ng basura. Kaya siyempre gusto namin upang matiyak na namin initialize
parehong laki at ang ulo mga patlang sa 0, isang bagay na makatwirang.
Din namin sige at null ang mga elemento sa aming queue.
At upang gawin ang diagram akma, mapapansin na ngayon ang aming queue ay maaari lamang maghawak ng tatlong elemento;
kung saan ang aming stack maaaring humawak apat, ang aming queue maaari lamang hold ang tatlo.
At ito lamang ay upang gawin ang diagram akma.
Ang unang bagay na mangyayari dito ay namin enqueue ang string "hi".
At tulad lang ginawa namin sa mga stack, walang labis ibang dito,
magtapon namin ang string sa string [0] at dagdagan ang aming laki ng 1.
Enqueue namin "bye", ito ay makakakuha ng ilagay sa.
Kaya ito mukhang isang stack para sa pinaka-bahagi.
Nagsimula off namin dito, ang mga bagong elemento, ang mga bagong elemento, laki mapigil ang pagpunta up.
Ano ang mangyayari sa puntong ito kapag gusto naming dequeue ng isang bagay?
Kapag gusto naming dequeue, na kung saan ay ang sangkap na nais naming dequeue?
[Basil] string [0]. >> Zero. Akmang-akma, Basil.
Gusto naming upang makakuha ng mapupuksa ng unang string, ang isang ito, "hi".
Kaya kung ano ang iba pang mga bagay na ay nagbago?
Mapansin kapag pop namin ang isang bagay ng stack, namin lamang ay nagbago ang laki,
ngunit dito, Mayroon kami ng ilang mga bagay na pagbabago.
Hindi lamang ang ipinapakita ng pagbabago ng laki, ngunit ang mga pagbabago ng ulo.
Ito ay pagpunta pabalik sa punto ng Charlotte ng mas maaga:
bakit namin ito ulo pati na rin?
Ba kabuluhan ngayon, Charlotte? >> Uri ng.
[Hardison] Uri ng? Kaya kung ano ang nangyari kapag kami dequeued?
Ano ang ulo ang gawin na ngayon ay kawili-wili?
[Charlotte] Oh, sapagkat ito ay nagbago - okay. Ganoon pala.
Dahil ang ulo - kung saan ang ulo ay tumuturo sa mga pagbabago sa mga tuntunin ng lokasyon.
Ito ay hindi na laging zero index isa. >> Oo, eksakto.
Ano ang nangyari ay kung dequeueing ang mataas na elemento
ay tapos na at hindi namin ulo field na ito
dahil palagi naming ay pagtawag ang string na ito sa 0 index ang ulo ng aming queue,
nais naming upang ilipat ang iba ng queue.
Gusto namin sa shift ang "bye" mula string [1] sa string [0].
At string [2] pababa sa string [1].
At gusto namin upang gawin ito para sa buong listahan ng mga elemento,
ang buong hanay ng mga elemento.
At kapag ginagawa namin ito sa isang array, na nakakakuha ng talagang mahal.
Sa dito, ito ay hindi sang-ayon. Lang namin ay may tatlong elemento sa aming array.
Ngunit kung nagkaroon kami ng queue ng isang libong mga elemento o isang milyong mga elemento,
at pagkatapos ang lahat ng isang biglaang, sisimulan namin ang paggawa ng grupo ng dequeue tawag lahat sa isang loop,
mga bagay ay talagang na pabagalin bilang nagbabago ang lahat down na patuloy.
Alam mo, shift ng 1, shift ng 1, shift ng 1, shift ng 1.
Sa halip, ginagamit namin ang ulo na ito, tinatawag naming isang "pointer" kahit na ito ay hindi talagang isang pointer
sa mahigpit na kahulugan; ito ay hindi isang uri ng pointer.
Ito ay hindi isang int * o magpasinda * o anumang bagay tulad na.
Ngunit ito pagturo o nagpapahiwatig ang ulo ng aming queue. Oo?
>> [Mag-aaral] Paano malaman ang dequeue lamang pop-off ang anumang sa ulo?
[Hardison] Paano gumagana ang dequeue malaman kung paano mag-pop-off ang kahit anong sa ulo? >> Karapatan, oo.
>> Ano ito tumitingin sa lamang ang anumang field sa ulo ay nakatakda sa.
Kaya sa unang kaso, kung tiningnan namin dito mismo,
0, index 0 ang aming ulo. >> Karapatan.
[Hardison] Kaya sabi lang ito okay, well, ang elemento sa index 0, ang string "hi",
ang elemento sa pinuno ng aming queue.
Kaya kami ay pagpunta sa dequeue na tao.
At na elemento na maipo ibinalik sa tumatawag.
Oo, Saad? >> Kaya ulo talaga nagtatakda ng - kung saan ka pupunta sa index ito?
Na ang simula ng? >> Oo. >> Okay.
[Hardison] Iyon ay maging ang bagong panimula para sa aming mga array.
Kaya kapag dequeue ka ng isang bagay, ang lahat ng kailangan mong gawin ay ma-access ang elemento sa index q.head,
at iyon ay ang sangkap na nais mong dequeue.
Mayroon ka ring pagbawas sa laki.
Susubukan naming makita sa isang bit kung saan ang mga bagay ay makakuha ng isang maliit na nakakalito na ito.
Dequeue namin, at ngayon, kung enqueue namin muli,
kung saan namin enqueue?
Kung saan ay ang susunod na elemento sa aming queue?
Natin na nais naming enqueue ang string na "CS".
Sa kung saan index ay ito pumunta? [Mag-aaral] string [2]. >> Dalawang.
Bakit 2 at hindi 0?
[Basil] Dahil ngayon ulo ay 1, kaya na tulad ng simula ng listahan?
[Hardison] Kanan. At kung ano ang Nagpapahiwatig ang dulo ng listahan?
Ano ang naming gamitin upang tukuyin ang pagtatapos ng aming queue?
Ulo ay ang pinuno ng aming queue, ang simula ng aming queue.
Ano ang dulo ng aming queue? [Mag-aaral] Laki. >> Sukat, eksakto.
Kaya ang aming bagong elemento pumunta sa sa laki, at ang mga elemento na lubos naming off sa ulo.
Kapag enqueue namin sa susunod na elemento, kami ay paglalagay ng ito sa sa laki.
[Mag-aaral] Bago mo ilagay sa bagaman, laki ay 1, i-right?
[Hardison] Kanan. Kaya hindi pa sa laki. + Laki, hindi +1, ngunit ang + ulo.
Dahil Paglipat namin ang lahat sa pamamagitan ng ang halaga ng ulo.
Kaya dito, ngayon kami nakakuha ng queue ng laki 1 na nagsisimula sa index 1.
Buntot ay index 2. Oo?
>> [Mag-aaral] Ano ang mangyayari kapag ka dequeue string [0], at ang mga string 'slot sa memory
lamang makapag-emptied, talaga, o nakalimutan?
[Hardison] Oo. Sa puntong ito, kami ay forgetting kanila.
Kung tayo ay sa pag-iimbak ng mga kopya sa kanila para sa -
maraming data istraktura ay madalas na iimbak ang kanilang sariling mga kopya ng mga elemento
sa gayon na ang mga tao sa pamamahala sa data na istraktura ay hindi mag-alala
tungkol sa kung saan ang lahat ng mga payo ay pagpunta.
Hold ng istraktura ang data sa lahat, pagpipigil sa sa lahat ng mga kopya,
upang tiyakin na ang lahat ay nagpatuloy naaangkop.
Gayunpaman, sa kasong ito, ang mga data kaayusan lamang, simple,
ay hindi gumagawa ng mga kopya ng anumang bagay na namin ang pag-iimbak ng sa kanila.
[Mag-aaral] Kaya ito ay isang tuloy-tuloy na array ng -? >> Oo.
Kung titingnan namin sa kung ano ang kahulugan ng istrakturang ito, ito ay.
Ito ay isang karaniwang array tulad na iyong nakita,
isang array ng magpasinda * s.
Sinusuportahan ba na -? >> Oo, lamang ako ay nagtataka
kung kalaunan maubusan ng memory, sa isang tiyak na lawak,
kung mayroon kang lahat ng mga walang laman na mga spot sa iyong array?
[Hardison] Oo, na isang magandang punto.
>> Kung titingnan namin sa kung ano ang nangyari ngayon sa puntong ito,
namin na puno ang aming queue, mukhang.
Ngunit hindi pa namin talagang puno ang aming queue
dahil mayroon kami ng queue na laki 2, ngunit nagsisimula sa index 1,
dahil na kung saan ang aming ulo pointer.
Tulad mo ay sinasabi, na elemento sa string [0], sa index 0, ay hindi talaga doon.
Hindi ito sa aming queue.
Lang namin ay hindi abala upang pumunta sa at patungan ito kapag dequeued namin ito.
Kaya kahit na mukhang kami maubusan ng memory, hindi namin talagang.
Sa lugar na iyon ay magagamit para sa amin upang gamitin.
Ang naaangkop na pag-uugali, kung kami ay upang subukan at unang dequeue isang bagay
bang "bye", na pop bye off.
Ngayon ang aming queue nagsisimula sa index 2 at ng laki 1.
At ngayon kung namin subukan at enqueue ang isang bagay muli, sabihin ang 50,
50 dapat pumunta sa ang lugar na ito sa index 0
dahil ito ay magagamit pa rin para sa amin. Oo, Saad?
[Saad] ba na mangyari awtomatikong?
[Hardison] Hindi ito mangyayari medyo awtomatikong. Kailangan mong gawin ang matematika
upang gawin itong gumagana, ngunit mahalagang kung ano ang namin ang nagawa lamang namin na nakabalot sa paligid.
[Saad] At ito okay kung ito ay may butas sa gitna nito?
[Hardison] Ito ay kung maaari kaming magsagawa ng matematika sa ehersisyo ang maayos.
>> At lumiliko ito na na aktwal na hindi na mahirap gawin sa mga operator ng mod.
Kaya lang tulad ng ginawa namin sa Caesar at ang crypto bagay,
gamit ang mod, maaari naming makakuha ng mga bagay sa I-wrap sa paligid at panatilihin ang pagpunta
sa paligid at sa paligid at sa paligid sa aming queue,
pinapanatili na ang ulo pointer paglipat sa paligid.
Pansinin na laki ay palaging alang ang numero ng mga elemento na aktwal na sa loob ng queue.
At ang pointer ng ulo na mapigil ang umiikot sa pamamagitan ng.
Kung titingnan namin sa kung ano ang nangyari dito, kung pumunta namin pabalik sa simula,
at ka lamang manood ng kung ano ang mangyayari sa ulo
kapag enqueue kaming isang bagay, walang nangyari sa ulo.
Kapag enqueued namin ang iba pa, walang nangyari sa ulo.
Lalong madaling namin dequeued isang bagay, ang ulo naging up ng isa.
Namin enqueued isang bagay, walang mangyayari sa ulo.
Kapag dequeue kaming isang bagay, ang lahat ng isang biglaang ang ulo ay makakakuha incremented.
Kapag enqueue kaming isang bagay, walang mangyayari sa ulo.
>> Kung ano ang mangyayari sa puntong ito kung hindi kami sa dequeue ang isang bagay muli?
Anumang saloobin? Kung ano ang mangyayari sa ulo?
Ano ang dapat mangyayari sa ulo
kung kami ay upang dequeue iba pa?
Ulo Ang ngayon ay sa index 2,
na nangangahulugan na ang ulo ng queue ay mga string [2].
[Mag-aaral] Aling nagbabalik 0? >> Dapat itong bumalik sa 0. Dapat itong pambalot ng pabalik sa paligid, eksakto.
Sa ngayon, bawat oras na namin tinatawag dequeue, kami ay pagdaragdag ng isa sa ulo,
magdagdag ng isa sa ulo, magdagdag ng isa sa ulo, magdagdag ng isa sa ulo.
Sa lalong madaling panahon na ang ulo pointer ay nakakakuha sa huling index sa aming array,
mayroon kaming sa I-wrap ang mga ito pabalik sa paligid sa simula, bumalik sa 0.
[Charlotte] Ano ang tumutukoy ang kapasidad ng queue sa isang stack?
[Hardison] Sa kasong ito, lamang namin ang ginagamit # tinukoy pare-pareho. >> Okay.
[Hardison] Sa ang aktwal na file na. C, maaari kang pumunta sa at putik sa ilang sandali
at gawin itong bilang malaki o kasing liit ng nais mong.
[Charlotte] Kaya kapag nagsasagawa ka ng ito sa isang queue, kung paano mo computer alam
kung gaano kalaki ang nais mong stack na?
[Hardison] Iyon ay isang mahusay na tanong.
Mayroong ilang mga paraan. Isa ay upang tukuyin lamang ito na front
at sabihin ito ng queue na may 4 na elemento o 50 elemento o 10,000.
Ang iba pang paraan ay upang gawin kung ano ang mga tao sa edisyon ng Hacker ginagawa
at lumikha ng mga function sa iyong queue palaguin ang dynamic ng higit pang mga bagay makapag idinagdag.
>> [Charlotte] Kaya upang pumunta sa ang unang opsyon, kung ano ang syntax mo gamitin
upang sabihin sa programa kung ano ang laki ng queue?
[Hardison] Ah. Kaya sabihin ng ito.
Ako pa rin sa stack.c dito, kaya lang ako pagpunta sa mag-scroll pataas sa tuktok dito.
Maaari mong makita ito dito mismo? Ito ang # tukuyin ang kapasidad 10.
At ito ay halos ang eksaktong parehong syntax na mayroon kami para sa queue.
Maliban sa queue, namin ang nakuha na ang dagdag na field sa struct in dito.
[Charlotte] Oh, naisip ko na kapasidad ang nilalayong ang kapasidad para sa string.
[Hardison] Ah. >> Na ito ay ang maximum na haba ng salita. >> Nakuha ko.
Oo. Ang kapasidad dito - na isang mahusay na punto.
At ito ay isang bagay na nakakalito
dahil kung ano ang namin ang ipinahayag dito ay isang hanay ng magpasinda * s.
Isang array ng mga payo.
Ito ay isang hanay ng mga karakter.
Marahil ito ay kung ano ang nakita mo kapag na deklarasyon ang iyong mga buffers para sa file I / O,
kapag ikaw ay paglikha ng string nang manu-mano sa stack.
Gayunpaman, kung ano ang namin ang nakuha dito ay isang hanay ng magpasinda * s.
Kaya ito ay isang array ng mga payo.
Aktwal na, kung namin mag-zoom out at tinitingnan namin kung anong nangyayari sa dito
sa pagtatanghal, makikita mo na ang aktwal na elemento, ang mga character na data
ay hindi na naka-imbak sa loob ng array mismo.
Ano ang naka-imbak sa loob ng aming array dito pointer sa ang data ng character.
Okay. Kaya nasaksihan namin kung paano ang laki ng queue tulad ng stack,
laki ang palaging Nirerespeto ng numero ng mga elemento kasalukuyang sa queue.
Pagkatapos paggawa ng 2 enqueues, laki ay 2.
Pagkatapos ng paggawa ng isang dequeue laki na ngayon ang 1.
Pagkatapos ng paggawa ng isa pang enqueue ang laki ay bumalik hanggang sa 2.
Kaya ang laki ang talagang nirerespeto ng numero ng mga elemento sa queue,
at pagkatapos ulo lamang mapigil ang cycling.
Napupunta mula sa 0-1-2, 0-1-2, 0-1-2.
At bawat oras na tinatawag naming dequeue, ang ulo ang pointer ay makakakuha incremented sa susunod na index.
At kung ang ulo ay tungkol sa upang pumunta sa paglipas ng, loop bumalik sa paligid upang 0.
Kaya na iyon, maaari naming isulat ang dequeue function na.
At kami ay umalis sa enqueue function na para sa iyo guys ipatupad sa halip.
>> Kapag dequeue namin ang isang elemento ng aming queue,
kung ano ang unang bagay na ginawa ng Daniel kapag nagsimula kaming sumulat sa pop function para sa mga stack?
Hayaan akong marinig mula sa isang tao na hindi binabanggit pa.
Natin makita, Saad, huwag mo matandaan kung ano ang Daniel ay ginawa bilang ang unang bagay na kapag siya sinulat ni pop?
[Saad] May ay, ito ay - >> Siya sinubukan para sa isang bagay.
[Saad] Kung ang laki ay mas malaki kaysa sa 0. >> Mismong.
At kung ano na pagsubok para sa?
[Saad] Iyon ay sa pagsubok upang makita kung mayroong anumang bagay sa loob ng array.
[Hardison] Oo. Eksakto. Kaya hindi mo maaaring pop anumang ng stack kung ito ay walang laman.
Gayundin, hindi mo maaaring dequeue anumang bagay mula sa isang queue kung ito ay walang laman.
Ano ang unang bagay na dapat naming gawin sa aming dequeue function na dito, tingin mo?
[Saad] Kung ang laki ay mas malaki kaysa sa 0? >> Oo.
Sa kasong ito, aktwal ko na lang nasubukan upang makita kung ito ay 0.
Kung ito ay 0, maaari naming ibalik null.
Ngunit eksaktong parehong logic.
At hayaan ang magpatuloy sa ito.
Kung ang laki ay hindi 0, kung saan ay ang mga elemento na gusto naming dequeue?
[Saad] Sa ulo? >> Mismong.
Maaari lang namin hilahin ang unang elemento sa aming queue
sa pamamagitan ng pag-access sa elemento sa ulo.
Walang mabaliw.
Pagkatapos nito, kung ano ang dapat naming gawin? Ano ang mangyari?
Ano ang iba pang mga bagay na usapan natin ang tungkol sa dequeue?
Dalawang bagay ay may mangyari, dahil ang aming queue ay nagbago.
[Daniel] Bawasan ang laki. >> Mayroon kaming upang bawasan ang laki, at dagdagan ang ulo? Eksakto.
Upang dagdagan ang ulo, hindi lang namin nang walang taros taasan ang ulo, tandaan.
Hindi lamang namin maaaring gawin queue.head + +.
Mayroon kaming ring isama ito mod ng kapasidad.
At bakit namin mod ng kapasidad, Stella?
[Stella] Dahil sa I-wrap sa paligid. >> Mismong.
Mod namin sa pamamagitan ng ang kapasidad dahil mayroon itong pambalot ng bumalik sa paligid upang 0.
Kaya ngayon, sa puntong ito, maaari naming gawin kung ano ang Daniel sinabi.
Maaari namin ang pagbawas sa laki.
At pagkatapos ay maaari naming ibalik ang elemento na sa tuktok ng queue.
Ganito ang uri ng pili-pilipit sa unang. Maaaring mayroon ka ng isang katanungan. Paumanhin?
>> [Sam] Bakit ang unang sa tuktok ng queue? Kung saan ay na pumunta?
[Hardison] ay mula sa ika-apat na linya mula sa ibaba.
Pagkatapos naming subukan ang upang matiyak na ang aming queue ay hindi walang laman,
namin hilahin ang magpasinda * una, hindi namin hilahin ang mga elemento na sitting sa index ng ulo
sa aming mga array, ng aming mga string ng >> array, at tawag na unang?
[Hardison] At tinatawag naming muna ito. Oo.
Lang i-follow up sa na, bakit ka sa tingin namin ay upang gawin iyon?
[Sam] bawat unang bumabalik q.strings [q.head]? >> Oo.
>> Dahil ginagawa namin ito nagbabagong ng q.head sa mga katangian ng mod,
at walang paraan upang gawin iyon sa loob ng return line din.
[Hardison] Mismong. Ikaw lugar sa. Sam ay lubos na kawili-sa.
Ang dahilan kung bakit nagkaroon kami upang hilahin ang unang elemento sa aming queue at mag-imbak ang mga ito sa isang variable
ay dahil ang linya na ito kung saan lang namin ay q.head,
ang mod operator doon ay hindi isang bagay na maaari naming gawin
at ito epekto sa ulo walang - sa isang linya.
Kaya namin aktwal upang hilahin ang unang elemento, at pagkatapos ay ayusin ang ulo,
ayusin ang laki, at pagkatapos ay ibalik ang elemento na nakuha namin ang.
At ito ay isang bagay na namin makita ay hanggang sa ibang pagkakataon gamit
naka-link na listahan, tulad ng i-play sa paligid namin sa kanila.
Madalas kapag ikaw ay pagbabakante o disposing ng mga naka-link na listahan
kailangan mong matandaan ang susunod na elemento, ang susunod na pointer ng isang naka-link na listahan
bago disposing ng kasalukuyang.
Dahil kung hindi mo itapon ang impormasyon ng kung ano ang naiwan sa listahan.
Ngayon, kung pumunta ka sa iyong appliance, binuksan mo queue.c--x ng ito.
Kaya kung buksan ko queue.c, hayaan mo akong mag-zoom in dito,
makikita mo na mayroon kang isang file na may katulad na anyo.
Katulad na anyo file sa kung ano ang nagkaroon kami mas maaga may stack.c.
Mayroon kaming ang aming struct para sa queue tinukoy tulad ng nakita natin sa mga slide.
>> Mayroon kaming ang aming enqueue function na kung saan ay para sa iyo na gawin.
At mayroon kaming ang dequeue function na dito.
Ang Ang dequeue function sa file unimplemented,
ngunit ko bang ilagay ito pabalik sa PowerPoint sa gayon ay maaari mong i-type ito sa, kung nais mong.
Kaya para sa susunod na 5 minuto o kaya, guys sa enqueue
na kung saan ay halos sa tapat ng dequeue.
Hindi mo upang ayusin ang ulo kapag ikaw ay enqueueing, ngunit ano ang gagawin upang ayusin?
Laki. Kaya kapag ikaw enqueue, ulo ay mananatiling hindi nagalaw, laki ay makakakuha ng nagbago.
Ngunit ito ay tumagal ng ilang sandali ng - ay mayroon kang upang i-play sa paligid na mod
upang malaman kung eksakto kung ano ang index ang mga bagong elemento ay dapat ipasok sa.
Kaya Bibigyan kita ng guys ng kaunti, ilagay dequeue-back up sa slide,
at ng mga ka guys ay may mga katanungan, shout out ang mga ito sa gayon maaari naming
lahat ng talk tungkol sa mga ito bilang isang grupo.
Gayundin, na may laki don't - kapag mong ayusin ang laki, maaari mong laging lamang -
mo man sa mod ang laki? [Daniel] No. >> Hindi mo na kailangang mod ang laki, sa kanan.
Dahil laki ay palaging, kung you're - ipagpalagay ka sa pamamahala ng mga bagay angkop,
laki ay palaging magiging sa pagitan ng 0 at 3.
Kung saan mayroon kang sa mod kapag ginagawa mo enqueue?
[Mag-aaral] Tanging para sa ulo. >> Tanging para sa ulo, eksakto.
At bakit mayroon kang mod sa lahat sa enqueue?
Kapag ang isang sitwasyon na kung saan kailangan mong i-mod?
[Mag-aaral] Kung mayroon kang mga bagay-bagay sa espasyo, i sa puwang 1 at 2,
at pagkatapos ay kailangan upang magdagdag ng isang bagay sa 0.
[Hardison] Oo, eksakto. Kaya kung ang iyong ulo pointer sa pinakadulo,
o kung ang iyong laki kasama ang iyong ulo ay mas malaki, o sa halip, ay pagpunta sa I-wrap sa paligid ng queue.
>> Kaya sa sitwasyong ito namin Mayroon dito sa slide ngayon,
kung gusto kong enqueue ng isang bagay na ngayon,
gusto naming upang enqueue ang isang bagay sa index 0.
Kaya't kung tiningnan mo sa kung saan ang 50 pupunta, at tumawag ako enqueue 50,
pupunta pababa doon sa ibaba. Napupunta sa index 0.
Pumapalit sa 'hi' na ay na dequeued.
[Daniel] Huwag mong gawin pangangalaga ng na sa dequeue na?
Bakit ang gumawa ng anumang bagay na may ulo sa enqueue?
[Hardison] Oh, kaya hindi ka ng pagbabago sa ulo, paumanhin.
Ngunit mayroon kang gamitin ang operator ng mod kapag ina-access mo
elemento na gusto mong i-enqueue kapag ina-access mo
ang susunod na elemento sa iyong queue.
[Basil] Hindi ko iyon, at Nakatanggap ako ng "tagumpay" sa may.
[Daniel] Oh, Nauunawaan ko kung ano ang iyong sinasabi.
[Hardison] Kaya didn't mo - ginawa mo lang sa q.size?
[Basil] Oo. Ko lang ay nagbago na gilid, hindi ko gawin kasama ang ulo.
[Hardison] hindi mo aktwal na i-reset ang ulo na ang anumang,
ngunit kapag ikaw ay index sa array string,
iyong aktwal na upang magpatuloy at kalkulahin kung saan ang susunod na elemento,
dahil tuod ang stack, ang susunod na sangkap sa iyong stack ay palaging
sa index ng naaayon sa laki.
Kung titingnan namin hanggang sa aming stack push function na,
kami palaging kalabitin ang kuwerdas sa aming bagong elemento karapatan sa laki ng index.
Sapagkat sa pila, hindi namin maaaring gawin iyon
dahil kung hindi kami sa sitwasyong ito,
kung enqueued namin ng 50 aming bagong string ay pumunta karapatan sa string [1]
na hindi namin nais na gawin.
Gusto naming ang bagong string na pumunta sa index 0.
>> Sinusuportahan ba ng sinuman - oo? [Mag-aaral] Mayroon akong tanong ngunit hindi talagang may kaugnayan.
Ano ang ibig sabihin kapag may isang taong nag-tawag lamang ng isang bagay tulad ng pred pointer?
Ano ang pangalan na maikli para sa? Alam ko lang ng pangalan.
[Hardison] Pred pointer? Natin makita. Sa anong konteksto?
[Mag-aaral] Ito ay para sa insert. Maaari kong hilingin mo sa ibang pagkakataon kung gusto mo
dahil hindi ito talagang may kaugnayan, ngunit ko lang -
[Hardison] Mula ipasok ang code David mula sa panayam?
Namin hilahin na up at makipag-usap tungkol sa na.
Susubukan naming makipag-usap tungkol sa na susunod, sa sandaling makuha namin sa naka-link na listahan.
>> Kaya sabihin mabilis talaga tingnan kung ano ang enqueue function na kamukha.
Ano ang unang bagay na ang mga tao sinubukan upang gawin sa iyong enqueue linya? Sa ang queue na ito?
Katulad sa kung ano ang ginawa mo para sa stack pagtulak.
Ano ang ginawa mo, Stella?
[Stella, hindi maintindihan]
[Hardison] Mismong. Kung (q.size == kapasidad) -
Kailangan ko bang ilagay ang aking mga tirante sa tamang lugar - bumalik false.
Mag-zoom sa ilang sandali. Okay.
Ngayon kung ano ang susunod na bagay na nagkaroon kami gawin?
Tulad ng stack, at ipinasok sa tamang lugar.
At kaya kung ano ang tamang lugar upang ipasok na?
Sa stack na ito index laki, na may hindi pa na.
[Daniel] Mayroon akong q.head--o - q.strings >>? >> Oo.
q.strings [q.head + q.size mod kapasidad]?
[Hardison] gusto namin marahil upang ilagay ang mga panaklong sa paligid ng
kaya na namin ang pagkuha ng naaangkop na mangingibabaw at iba pa na cleart sa lahat.
At nakatakda na katumbas? >> Upang STR? >> Upang STR. Mahusay.
At ngayon kung ano ang huling bagay na mayroon kaming gawin?
Lamang tulad ng ginawa namin sa stack. >> Pagdaragdag sa laki? >> Dagdagan ang laki.
Boom. At pagkatapos, dahil ang starter code ibinalik maling sa pamamagitan ng default,
Gusto namin upang baguhin ito sa totoo kung ang lahat ng Dumadaan at lahat ng napupunta na rin.
Ayos lang. Na ang isang maraming impormasyon para sa seksyon.
Humihingi kami ng hindi pa sa paglipas. Gusto naming makipag-usap talagang mabilis tungkol sa mga listahan ng nai-link sa isa-isa.
Makikita ko bang ilagay ito up upang maaari naming bumalik dito sa ibang pagkakataon.
Ngunit hayaan ng bumalik sa aming presentasyon para lamang ng ilang higit pang mga slide.
Kaya enqueue ay TODO, ngayon tapos kami na ito.
>> Ngayon sabihin tumagal ng isang pagtingin sa mga isa-isa-naka-link na listahan.
Usapan natin ang tungkol sa mga ito ng kaunti higit pa sa panayam.
Gaano karaming ng ka guys nakita ang demo kung saan nagkaroon kami ng mga tao
awkwardly na nakaturo sa bawat isa at Holding numero? >> Ako ay sa na.
>> Ano mo guys sa tingin? Ba na, sana demystify mga ilang sandali?
Sa isang listahan, lumiliko out na harapin namin na may ganitong uri na kami ay pagpunta sa tumawag sa isang node.
Sapagkat sa queue at ang stack nagkaroon kami structs na gusto naming tumawag ng queue sa stack,
nagkaroon kami ng mga bagong queue sa mga uri ng stack,
dito ang listahan ay talagang ginawa ng isang bungkos ng mga node.
Sa parehong paraan na ang mga string ay lamang ng grupo ng char ang lahat ng naka-linya sa tabi ng bawat isa.
Isang naka-link na listahan ay lamang node at isa pang node at isa pang node at isa pang node.
At sa halip na mapanira ang lahat ng mga node at pag-imbak ang mga ito contiguously
lahat ng karapatan sa tabi sa bawat isa sa memorya,
pagkakaroon ng susunod na pointer na ito ay nagbibigay-daan sa amin upang iimbak ang mga node saanman, sa random.
At pagkatapos ay ang uri ng wire ang lahat ng mga ito nang magkasama upang tumuro mula sa isa sa susunod na.
>> At kung ano ang malaking kalamangan na ito ay may higit sa isang array?
Sa paglipas ng pag-iimbak ng lahat contiguously lang natigil sa tabi sa bawat isa?
Naaalala? Oo? >> Dynamic na memory paglalaan?
>> Dynamic memory paglalaan sa kung ano ang kahulugan?
[Mag-aaral] Sa na maaari mong patuloy na ginagawa itong mas malaki at hindi mo na kailangang ilipat ang iyong buong array?
[Hardison] Mismong. Kaya may isang array, kapag gusto mong maglagay ng bagong elemento sa gitna ng,
mayroon kang upang ilipat ang lahat upang gumawa ng puwang.
At tulad ng usapan natin ang tungkol sa pila,
na kung bakit namin na panatilihin ang pointer ng ulo,
sa gayon ay hindi namin patuloy na paglilipat ng mga bagay.
Dahil na nakakakuha ng mahal kung mayroon kang isang malaking array
at patuloy na ikaw ay gumagawa ng mga random na pagpapasok.
Sapagkat may isang listahan, ang lahat ng kailangan mong gawin ay magtapon ang mga ito sa isang bagong node,
ayusin ang mga payo, at tapos ka na.
Ano ang sucks tungkol dito?
Bukod sa ang katotohanan na ito ay hindi bilang madaling upang gumana sa bilang isang array? Oo?
[Daniel] Well, hulaan ko ito ay mas mahirap upang ma-access ang isang partikular na elemento sa naka-link na listahan?
[Hardison] hindi lamang ka maaaring lumipat sa isang arbitrary na elemento sa gitna ng iyong listahan ng naka-link.
Paano mo gawin ito sa halip? >> Mayroon kang sa hakbang sa pamamagitan ng buong bagay.
[Hardison] Oo. Mayroon kang pumunta sa pamamagitan ng isa sa isang pagkakataon, isa sa isang pagkakataon.
Ito ay isang malaking - ito ay isang sakit.
Ano ang iba pa - may isa pang nakasira sa.
[Basil] Hindi ka maaaring pumunta pasulong at pabalik? Mayroon kang mag-isa direksyon?
[Hardison] Oo. Kaya kung paano namin malutas na, minsan?
[Basil] doble-naka-link listahan? >> Mismong. May doble na naka-link listahan.
Mayroon ding - paumanhin?
>> [Sam] ba na katulad ng paggamit ng pred bagay na -
Ko lang remembered, ay hindi na kung ano ang pred bagay ay para sa?
Ay hindi na sa pagitan ng doble at isa-isa?
[Hardison] tingnan natin kung ano ang eksaktong siya ay ginagawa.
Kaya dito namin pumunta. Narito ang listahan code.
Narito mayroon namin predptr, in dito. Ba ito kung ano ang pinag-uusapan?
Kaya ito ay - niya pagbabakante isang listahan at siya ay sinusubukan upang mag-imbak ng pointer dito.
Ito ay hindi ang doble, isa-isa naka-link na listahan.
Maaari naming makipag-usap nang higit pa tungkol sa mamaya dahil ito ay pakikipag-usap tungkol sa pagbabakante ang listahan
at gusto kong ipakita ang ilang iba pang mga bagay-bagay sa unang.
ngunit ito lang - alala ito ang halaga ng ptr
[Mag-aaral] Oh, preceeding pointer? >> Oo.
Upang maaari naming pagkatapos ay dagdagan ang ptr sarili bago namin pagkatapos libreng kung ano ang predptr ay.
Dahil hindi namin libreng ptr at pagkatapos ay tumawag ptr = ptr susunod, i-right?
Na masama.
Kaya sabihin makita, ito tao.
>> Ang iba pang masamang bagay tungkol sa listahan ay na kung saan may isang array
lang namin ang lahat ng mga elemento nakasalansan ang kanilang mga sarili sa tabi ng bawat isa,
dito din namin ipinakilala pointer na ito.
Kaya ay may karagdagang tipak ng memorya na kami ay kinakailangang gamitin
para sa bawat elemento na namin ang pag-iimbak sa aming listahan.
Makuha namin ng kakayahang umangkop, ngunit ito ay sa isang gastos.
May cost oras na ito,
at ito ay may ito gastos ng memory.
Oras sa kamalayan na namin ngayon upang pumunta sa pamamagitan ng bawat elemento sa array
upang mahanap ang isa sa index 10, o na maaaring naging index 10 sa isang array.
>> Lamang talagang mabilis, kapag diagram namin ang mga listahang ito,
karaniwang hawak namin sa pinuno ng listahan o unang pointer ng listahan
at tandaan na ito ay isang tunay na pointer.
Ito ay may 4 bytes. Ito ay hindi isang aktwal na node mismo.
Kaya mong makita na ito ay walang int halaga sa ito, walang susunod na pointer sa.
Ito ay literal lamang ang pointer.
Ito ay upang tumuro sa isang bagay na ay isang aktwal na struct node.
[Sam] node na tinatawag na Ang isang pointer? >> Na ito ay - walang. Ito ay isang pointer sa isang bagay ng uri ng node.
Ito ay isang pointer sa isang struct node. >> Oh, okay.
Diagram sa kaliwa, code sa kanan.
Maaari naming itakda ito sa null, kung saan ay isang mahusay na paraan upang simulan ang.
Kapag diagram mo ito, alinman sa sumulat ito bilang null o kang maglagay ng linya sa pamamagitan nito gusto na.
>> Ang isa sa mga pinakamadaling paraan upang gumana sa listahan,
at hinihiling namin mo parehong prepend at ikabit upang makita ang mga pagkakaiba sa pagitan ng dalawang,
ngunit prepending ay talagang madali.
Kapag nag-prepend, ito ay kung saan mo - kapag ikaw prepend (7),
kang pumunta at lumikha ng node struct
at itinakda mo ang unang upang tumuro sa ito, dahil ngayon, dahil prepended namin ito,
ito sa simula ng listahan.
Kung namin prepend (3), na lumilikha ng isa pang node, ngunit ngayon 3 ay bago 7.
Kaya mahalagang namin ang pagtulak ng mga bagay papunta sa aming listahan.
Ngayon, maaari mong makita na prepend, minsan mga tao na tumawag ito itulak,
dahil ka itulak ang isang bagong elemento sa iyong listahan.
Ring madaling tanggalin sa harap ng isang listahan.
Kaya mga tao ay madalas na tumawag na pop.
At sa paraan na iyon, maaari mong tularan ng stack gamit ang isang naka-link na listahan.
Whoops. Paumanhin, ngayon kami ay nakakakuha sa Magkabit. Kaya dito namin prepended (7), na namin ngayon prepend (3).
Kung prepended namin ang iba pa papunta sa listahang ito, kung namin prepended (4),
nais naming 4 at pagkatapos ay 3 at pagkatapos ay 7.
Kaya kami pop at alisin 4, alisin 3, alisin ang 7.
Madalas ang mas magaling na paraan upang isipin ang tungkol sa may Magkabit.
Kaya ko na diagrammed kung ano ang hitsura nito ay magiging tulad ng may ikabit ang dito.
Dito, ikinakabit ang (7) ay hindi tumingin sa anumang ibang
dahil may isa lamang elemento sa listahan.
At appending (3) Inilalagay ng ito sa dulo.
Marahil, maaari mong makita ngayon ang nanlilinlang may Magkabit
ay na dahil lamang namin alam kung saan sa simula ng listahan,
upang isama sa isang listahan na mayroon kang maglakad ang lahat ng mga paraan sa pamamagitan ng listahan
upang makakuha ng sa dulo, itigil, pagkatapos ay bumuo ng iyong node at lahat ng kalabitin ang kuwerdas down na.
Wire ang lahat ng mga bagay-bagay.
Kaya sa prepend, namin lamang natastas sa pamamagitan na ito ay talagang mabilis,
kapag prepend ka sa isang listahan, medyo simple.
>> Gumawa ka ng iyong bagong node, sangkot ilang dynamic na paglalaan ng memorya.
Kaya dito ginagawa namin ng node struct gamit ang malloc.
Kaya malloc ginagamit namin dahil na makikita magtabi memory para sa amin para sa ibang pagkakataon
dahil hindi namin nais na ito - gusto naming memory ito upang magpumilit para sa isang mahabang panahon.
At makakuha kami ng isang pointer sa espasyo sa memory na inilalaan namin lamang.
Ginagamit namin ang laki ng node, hindi namin sabihin sa ilang mga patlang.
Hindi kami mano-manong bumuo ng ang bilang ng mga byte,
sa halip na ginagamit namin sizeof kaya na alam namin na kami ay pagkuha ng naaangkop na bilang ng mga byte.
Sigurado kami upang subukan na nagtagumpay ang aming malloc tawag.
Ito ay isang bagay na gusto mong gawin sa pangkalahatan.
Sa modernong machine, nauubusan ng memory ay hindi isang bagay na madali
maliban kung ikaw ay paglaan ng isang tonelada ng mga bagay-bagay at gumawa ng isang malaking listahan,
ngunit kung ikaw ay pagbuo ng mga bagay-bagay para sa, sabihin nating, tulad ng iPhone o Android,
mo ng limitadong mga mapagkukunan ng memorya, lalo na kung ikaw ay paggawa ng isang bagay matinding.
Kaya ito ay mahusay na upang makakuha ng sa kasanayan.
>> Pansinin na ginamit ko na ng ilang iba't ibang mga function dito
na nakita mo na uri ng mga bagong.
Kaya fprintf tulad printf
maliban nito unang argumento ang stream na kung saan nais mong i-print.
Sa kasong ito, gusto naming i-print sa karaniwang string ng error
na kung saan ay naiiba mula sa karaniwang outstream.
Sa pamamagitan ng default na ito ay nagpapakita sa parehong lugar.
Din ito ng mga Kopya sa terminal, ngunit maaari mong -
paggamit ng mga utos na iyong natutunan tungkol sa, ang mga diskarte sa pag-redirect
natutunan mo tungkol sa Tommy ng video para sa problema set 4, maaari mong idirekta ang mga ito
sa iba't ibang lugar; pagkatapos ay lumabas, dito mismo, mga labasan ng iyong programa.
Ito ay mahalagang tulad ng mga bumabalik na mula sa pangunahing,
maliban gamitin namin exit dahil dito return ay hindi gawin.
Hindi kami sa pangunahing, kaya bumabalik ay hindi lumabas sa programa tulad ng gusto naming.
Kaya gamitin namin sa exit function at bigyan ito ng isang error code.
Pagkatapos dito namin itakda ang halaga ng field sa bagong node, i field nito katumbas ng i, at pagkatapos wire namin ito.
Itinakda namin ang susunod na pointer ang bagong node upang tumuro sa unang,
at pagkatapos ay unang ngayon ituro sa bagong node.
Mga unang linya ng code, aktwal na namin ang pagbuo ng bagong node.
Hindi ang huling dalawang linya ng function na ito ngunit ang unang mga.
Maaari mong aktwal na hilahin sa isang function, sa isang function ng katulong.
Na madalas kung ano ang gagawin ko ay, hilahin ko ito sa isang function,
Tinatawag kong isang bagay tulad ng build node,
at na mapigil ang ang prepend function na medyo maliit, 3 linya lang ang pagkatapos.
Ako makagawa ng isang tawag sa aking build node function na, at pagkatapos ko lahat ng wire up.
>> Ang huling bagay na gusto kong ipakita sa iyo,
at Ipapaalam ko Magkabit ng at ang lahat na sa iyong sariling,
kung paano upang umulit sa isang listahan.
May grupo ng mga iba't ibang mga paraan upang umulit sa isang listahan.
Sa kasong ito, kami ay pagpunta upang mahanap ang haba ng isang listahan.
Kaya sisimulan namin ang haba = 0.
Ito ay lubos na katulad sa pagsusulat strlen para sa isang string.
Ito ay kung ano ang gusto kong ipakita sa iyo, ito para sa loop dito mismo.
Hitsura ay medyo funky, hindi ito ang karaniwang int i = 0, i <anumang, i + +.
Sa halip ito ay Sinisimulan ang aming variable n sa simula ng listahan.
At pagkatapos ay habang ang aming iterator variable ay hindi null, panatilihin namin ang pagpunta.
Ito ay dahil, sa pamamagitan ng convention, ang dulo ng aming listahan null.
At pagkatapos ay upang dagdagan, sa halip kaysa sa paggawa + +,
ang naka-link na katumbas ng listahan ng mga + + n = n-> susunod.
>> Ipapaalam ko sa iyo punan sa gaps dito dahil hindi namin ng oras.
Ngunit panatilihin ito sa isip habang ikaw ay gumagana sa iyong psets spellr.
Naka-link na listahan, kung ikaw ay pagpapatupad ng hash table,
ay tiyak na darating sa napaka madaling gamiting.
At pagkakaroon ito kawikaan para sa looping sa paglipas ng mga bagay ay gumawa ng buhay ng maraming mas madali, sana.
Anumang mga katanungan, mabilis?
[Sam] Ay mong ipadala ang nakumpletong sll at SC?
[Hardison] Oo. Magpapadala ako nakumpleto na slide at nakumpleto sll stack at queue.cs.
[CS50.TV]