[Powered by Google Translate] [Seksyon 6] [Higit pang mga kumportableng]
[Rob Bowden] [Harvard University]
[Ito ay CS50.] [CS50.TV]
>> Maaari naming magtungo sa aming seksyon ng mga tanong.
Naipadala ko ang URL para sa puwang bago.
Ang simula ng seksyon ng tanong sabihin-
tila hindi ako ganap na unsick-ay isang madaling tanong
lamang kung ano ang valgrind?
Ano ang valgrind gawin?
Sinuman na nais upang sabihin kung ano valgrind ginagawa?
[Mag-aaral] tseke memory paglabas.
Oo, valgrind ay isang pangkalahatang memory checker.
Ito, sa dulo, ay nagsasabi sa iyo kung mayroon kang anumang mga paglabas ng memorya,
na halos kung ano ang ginagamit namin ito para sa dahil kung gusto mong
gawin na rin sa hanay ng problema o kung nais mong
sa malaking board, kailangan mong magkaroon ng hindi paglabas ng memory sa anumang,
at kung sakaling mayroon kang isang memory mahayag na hindi mo mahanap,
ring tandaan na tuwing magbubukas ka ng isang file
at kung hindi mo isara ito, na ang isang memory mahayag.
>> Maraming mga tao ay naghahanap para sa ilang mga node na hindi nila pagbabakante
kapag talagang, hindi nila isara ang diksyunaryo sa unang hakbang.
Din ito ay nagsasabi sa iyo kung mayroon kang anumang mga di-wastong bumabasa o nagsusulat,
na nangangahulugan na kung mong subukan at magtakda ng isang halaga
na higit sa dulo ng magbunton at hindi ito mangyayari sa seg fault
ngunit valgrind catches ito, dahil hindi na aktwal mong dapat pagsusulat doon,
at kaya talagang hindi dapat magkaroon ng anumang ng mga alinman.
Paano mo ginagamit ang valgrind?
>> Ito ay isang pangkalahatang tanong ng
uri ng patakbuhin ito at tingnan ang output.
Output ay lumalagpas ng maraming beses.
Mayroon ding masaya error kung saan kung mayroon kang ilang mga bagay na lubha mali
nangyayari sa isang loop, pagkatapos ito ay malaon sabihin, "Way masyadong maraming mga error.
Ako pagpunta sa itigil ang pagbibilang ngayon. "
Ito ay isa lamang tekstuwal output na mayroon ka upang i-parse.
Sa pagtatapos, ito ay sabihin sa iyo ang anumang mga paglabas ng memorya na mayroon kang,
kung gaano karaming mga bloke, na maaaring maging kapaki-pakinabang dahil
kung ito isang bloke unfreed, ito ay karaniwang mas madaling mahanap
sa 1,000 bloke unfreed.
1,000 bloke unfreed marahil ay nangangahulugan na ang hindi ka pagbabakante
iyong naka-link mga listahan sa naaangkop o isang bagay.
Na valgrind.
>> Ngayon ay mayroon kaming ang aming seksyon ng mga tanong,
na hindi mo kailangang i-download.
Maaari kang mag-click sa aking pangalan at hilahin ang mga ito sa puwang.
Ngayon mag-click sa akin.
Rebisyon 1 stack, na ginagawa namin unang.
Rebisyon 2 queue, at Pagbabago 3 ay isa-isa na naka-link na listahan.
Simula off sa aming stack.
Tulad ng sinasabi dito, ang stack ay isa sa mga pinaka-pangunahing,
pangunahing istraktura ng data ng computer science.
Ang prototypical halimbawa ay
ang stack ng mga trays sa dining hall.
Ito ay isa lamang sa tuwing ikaw ay ipinakilala sa isang stack,
isang tao ay pagpunta sa sabihin, "Oh, tulad ng isang stack ng mga trays."
Mong stack ang trays.
Pagkatapos kapag pumunta ka sa hilahin ng tray,
ang unang tray na nagsisimula na nakuha ang huling na ilagay sa stack.
Ang stack din-tulad ng ito sabi dito-
Mayroon namin ang segment ng memory na tinatawag ng stack.
At bakit ito tinatawag ang stack?
>> Dahil tulad ng isang istraktura ng data ng stack,
ito pushes at magpa-pop stack frame sa stack,
kung saan ang stack frame ay tulad ng isang partikular na tawag ng isang function.
At tulad ng isang stack, ikaw ay laging may upang bumalik
mula sa isang function na tawag bago kang makakuha sa mas mababang frame stack muli.
Hindi ka maaaring magkaroon ng mga pangunahing foo tawag tawag bar at bar ng bumalik sa pangunahing direkta.
Palagi itong nakuha upang sundin ang tamang pagtulak ng stack at popping.
Ang dalawang pagpapatakbo, tulad ng sinabi ko, push at mga pop.
Iyon ang unibersal na mga tuntunin.
Na dapat mong malaman sa push at mga pop sa mga tuntunin ng mga stack ng kahit na ano.
Gagamitin namin ang queues uri ng iba't ibang.
Ito ay hindi talagang isang universal na termino, ngunit push at mga pop unibersal para sa stack.
Push ay lamang ilagay sa stack.
Pop off ang stack.
At makita namin dito namin ang aming typedef struct stack,
kaya kami ay may pansamantalang trabaho string **.
Hindi natatakot sa pamamagitan ng anumang **.
Ito ay pagpunta sa isang array ng mga string
o isang hanay ng mga payo sa mga character, kung saan
pointer sa character ay may posibilidad na ang mga string.
Hindi ito na string, ngunit dito, sila ay pagpunta sa maging ang mga string.
>> Mayroon kaming isang array ng mga string.
Mayroon kaming ng laki, na kumakatawan sa kung gaano karaming mga elemento ay kasalukuyang sa stack,
at pagkatapos ay mayroon kaming ang kapasidad, na kung saan ay kung paano maraming mga sangkap na maaari sa stack.
Kapasidad ay dapat magsimula bilang isang bagay na mas malaki kaysa sa 1,
ngunit ang laki upang simulan ang bilang sa 0.
Ngayon, may mga talaga tatlong iba't ibang mga paraan na maaari mong isipin ng isang stack.
Well, may mga marahil higit pa, ngunit sa dalawang pangunahing paraan ay
maaari mong ipatupad ito gamit ang isang array, o maaari mong ipatupad ang mga ito gamit ang isang naka-link na listahan.
Naka-link na listahan ay uri ng trivia gumawa ng mga stack mula sa.
Ito ay lubos na madaling gumawa ng stack gamit ang naka-link na listahan,
kaya dito, kami ay upang gumawa ng stack gamit ang array,
at pagkatapos gamit ang array, mayroong dalawang mga paraan na maaari mong isipin ang tungkol dito.
Bago, kapag ako ay sinabi kami ay may isang kapasidad para sa stack,
upang maaari naming magkasya ang isang elemento sa stack.
>> Ang isang paraan na maaaring mangyari sa lalong madaling habang ikaw ay pindutin ang 10 elemento, tapos ka na.
Maaaring alam mo na may mas mataas na masaklawan ng 10 bagay sa mundo
na hindi ka na kailanman magkaroon ng higit sa 10 mga bagay sa iyong stack,
kung saan maaari kang magkaroon ng isang pang-itaas na nakatali sa laki ng iyong stack.
O maaari kang magkaroon ng iyong stack ay walang hanggan,
ngunit kung gumagawa ka ng isang array, na nangangahulugan na ang bawat solong oras mo pindutin ang 10 elemento,
ka pagpunta sa binabalak na palaguin sa 20 elemento, at kapag pinindot ninyo ang 20 elemento,
ka upang palaguin ang iyong array sa 30 elemento o 40 mga elemento.
Ay pagpunta sa kailangan upang dagdagan ang kapasidad, na kung saan ay kung ano ang kami ay pagpunta sa gawin dito.
Bawat solong oras na maabot namin ang maximum na laki ng aming mga stack,
kapag itulak namin ang iba pa sa, kami ay pagpunta sa kailangan mong taasan ang kapasidad.
Dito, push namin ipinahayag bilang bool push (magpasinda * STR).
Magpasinda * STR ay ang string na kami ay itulak papunta sa stack,
at bool lang sabi kung kami nagtagumpay o Nabigo.
>> Paano namin maaaring mabigo?
Ano ay ang tanging pagkakataon na maaari mong isipin ng
kung saan namin kailangan upang bumalik false?
Oo.
[Mag-aaral] Kung ito ay puno na at ginagamit namin ang isang bounded pagpapatupad.
Oo, kaya paano namin tukuyin-siya sumagot
kung ito ay puno na at ginagamit namin bounded pagpapatupad.
Pagkatapos namin talagang bumalik false.
Sa lalong madaling namin pindutin ang 10 bagay sa array, hindi namin maaaring magkasya 11, kaya bumalik kami maling.
Paano kung ito ay walang hanggan? Oo.
Kung hindi mo maaaring palawakin ang hanay para sa ilang mga kadahilanan.
Oo, kaya memory ay isang limitadong mapagkukunan,
at sa kalaunan, kung panatilihin namin itulak ang mga bagay papunta sa stack nang paulit-ulit,
kami ay pagpunta sa subukan at magtalaga ng isang mas malaking array upang magkasya
ang mas malaking kapasidad, at malloc o anumang ginagamit namin upang bumalik false.
Well, malloc ay magbabalik null.
>> Tandaan, ang bawat solong oras sakaling tumawag malloc, dapat ka check upang makita kung ito
nagbabalik null o tao na ay isang pagbawas sa kawastuhan.
Dahil gusto naming magkaroon ng isang walang hanggan stack,
ang tanging kaso kami ay pagpunta sa bumabalik maling kung susubukan namin
dagdagan ang kapasidad at malloc o anumang nagbabalik maling.
Pagkatapos pop tumatagal walang mga argumento,
at nagbabalik ang string na sa tuktok ng stack.
Anuman ay pinaka kamakailan na hunhon sa stack ay kung ano ang pop ay bumabalik,
at ito rin inaalis ito mula sa stack.
At mapansin na nagbabalik null kung wala sa stack.
Ay laging posible na ang stack ay walang laman.
Sa Java, kung ikaw ay ginagamit upang na, o iba pang mga wika,
sinusubukang i-pop mula sa isang walang laman na stack ay maaaring maging sanhi ng isang pagbubukod o isang bagay.
>> Ngunit sa C, null uri ng maraming ng mga kaso kung paano namin pinangangasiwaan ang mga problemang ito.
Bumabalik na null ay kung paano namin upang magpahiwatig na stack ay walang laman.
Nagbigay kami ng code na subukan ang pag-andar ng iyong stack,
ipatupad ang itulak at pop.
Na ito ay hindi ng maraming ng code.
Ako'y-aktwal na, bago gawin namin iyon, pahiwatig, pahiwatig-
kung hindi mo pa ito nakikita, malloc ay hindi lamang ang function na
na allocates memorya sa magbunton para sa iyo.
May isang pamilya ng mga function ng alloc.
Ang una ay malloc, kung saan ka sanay.
Pagkatapos may calloc, na ipinapakita ang parehong bagay bilang malloc,
ngunit ito ay zero ang lahat para sa iyo.
Kung sakaling mo na gusto upang i-set ang lahat sa null pagkatapos mallocing ng isang bagay
dapat lang na ginamit mo calloc sa unang lugar sa halip ng pagsulat
para sa loop sa zero ang buong block ng memory.
>> Realloc tulad malloc at ay may maraming ng mga espesyal na mga kaso,
ngunit isa lamang kung ano ang realloc ginagawa ay
ito ay tumatagal ng isang pointer na ay nai-inilalaan.
Realloc ay ang function na gusto mong pagbibigay pansin sa dito.
Tumatagal ng pointer na ay na bumalik mula malloc.
Sabihin nating humiling ka mula sa malloc ng pointer ng 10 bytes.
Pagkatapos ay natanto gusto mo ng 20 bytes,
kaya tumawag ka realloc sa na pointer na may 20 bytes,
at realloc ay awtomatikong kopyahin higit sa lahat para sa iyo.
Kung kamakailan mo lamang na tinatawag na malloc muli, tulad ng mayroon akong isang bloke ng 10 bytes.
Ngayon ay kailangan ko ng isang bloke ng 20 bytes,
kaya kung malloc ko 20 bytes, pagkatapos ay mayroon akong upang mano-manong kopyahin sa ibabaw ng 10 bytes mula sa unang bagay
sa ikalawang bagay at pagkatapos ay libre ang unang bagay.
Realloc ay pangasiwaan ang para sa iyo.
>> Mapansin lagda ay walang bisa *,
na lang bumabalik sa isang pointer sa bloke ng memorya,
pagkatapos ay walang bisa * ptr.
Maaari mong isipin na walang bisa * bilang isang generic na pointer.
Sa pangkalahatan, hindi mo kailangang makitungo sa walang bisa *,
ngunit malloc bumabalik ng walang bisa *, at pagkatapos lamang ito ay ginagamit tulad ng
ito ay aktwal na pagpunta sa isang pansamantalang trabaho *.
Ang nakaraang * void na ay ibinalik ng malloc
ngayon ang pagpunta sa maipasa sa realloc, at pagkatapos laki
ang bagong bilang ng mga byte na nais mong maglaan, kaya ang iyong bagong kapasidad.
Bibigyan kita ng ilang minuto, at gawin ang mga ito sa aming espasyo.
Magsimula sa Rebisyon 1.
Ko huminto ka pagkatapos sana tungkol sa sapat na panahon upang ipatupad ang push,
at pagkatapos ay kukunin ko na magbibigay sa iyo ng isa pang break na gawin ang pop.
Ngunit ito ay hindi talaga ang ganoong karaming mga code sa lahat.
Ang pinaka code ay maaaring ang pagpapalawak ng mga bagay-bagay, pagpapalawak ng kapasidad.
Okay, walang presyon ikay,
ngunit hangga't sa tingin mo tulad ng ikaw ay sa tamang landas, na mahusay.
>> Ba ang sinuman anumang code na palagay nila ay kumportable sa akin paghila up?
Oo, ako, ngunit ang sinuman anumang code na maaari kong makuha ang?
Okay, maaari mong magsimula, i-save ito, kahit anong ito ay?
Ko laging kalimutan na hakbang.
Okay, pagtingin sa push,
ang gusto mong ipaliwanag ang iyong code?
[Mag-aaral] Una sa lahat, pinataas na ako ang laki.
Hulaan ko siguro dapat na mayroon ako na-pa rin, pinataas na ako ang laki,
at nakikita ko kung ito ay mas mababa kaysa sa kapasidad.
At kung ito ay mas mababa kaysa sa kapasidad, ako idagdag sa array na namin ay mayroon.
At kung hindi, ako multiply ang kapasidad ng 2,
at reallocate ko ang string array sa isang bagay na may isang mas malaking kapasidad laki ngayon.
At pagkatapos ay kung na nabigo, Sinasabi ko sa user at bumalik ang maling,
at kung ito ang masarap na, pagkatapos kong ilagay ang string sa bagong puwesto.
>> [Rob B.] rin mapapansin na ginamit namin ang isang magaling bitwise operator dito
sa multiply ng 2.
Tandaan, kaliwa shift ay palaging pagpunta sa multiply sa 2.
Kanan shift ay hinati sa pamamagitan ng 2 hangga't tandaan mo na ang ibig sabihin nito
hatiin sa pamamagitan ng 2 sa isang integer na hinati sa pamamagitan ng 2.
Maaaring truncate ng 1 dito o doon.
Ngunit ang shift kaliwa ng 1 ay palaging pagpunta sa multiply sa 2,
maliban kung overflow ang mga hangganan ng integer, at pagkatapos ay hindi ito ay.
Ang isang gilid ng komento.
Gusto ko gawin ito ay hindi baguhin ang coding sa anumang paraan anumang,
ngunit gusto kong gawin ang isang bagay tulad nito.
Aktwal na ito ay upang gawin itong bahagyang na.
Siguro, ito ay hindi ang perpektong kaso upang ipakita ito,
ngunit gusto ko upang i-segment ito sa mga bloke ng-
okay, kung ito kung mangyayari, pagkatapos ako pagpunta sa gawin ang isang bagay,
at pagkatapos ay ang function ay tapos na.
Hindi ko kailangan pagkatapos ay mag-scroll sa aking mga mata ang lahat ng mga paraan pababa sa andar
upang makita kung ano ang mangyayari pagkatapos ng pang tao.
Kung ito kung mangyayari, pagkatapos ko lang ibalik.
Mayroon din ang magaling na idinagdag na pakinabang ng lahat lampas ito
ngayon Paglipat sa kaliwa sabay-sabay.
Hindi ko na kailangan to-kung sakaling malapit ridiculously mahaba ang linya,
pagkatapos 4 bytes na iyon ay maaaring makatulong sa, at din sa mas kaliwa ng isang bagay,
ang hindi gaanong nalulula sa tingin mo kung nais-okay, mayroon akong matandaan
Ako ay kasalukuyang sa isang habang loop sa loob ng isang pang tao sa loob ng isang para sa loop.
Kahit saan maaari mong gawin ito balik agad, ako uri ng tulad ng.
Lubos opsyonal at hindi inaasahan sa anumang paraan.
>> [Mag-aaral] Kung mayroong isang sukat - sa kundisyon ng mabigo?
Ang mabigo kundisyon dito nabigo kaming sa realloc, kaya oo.
Pansinin kung paano sa kundisyon ng mabigo, baka,
maliban kung namin libreng mga bagay-bagay sa ibang pagkakataon, palagi kaming pagpunta sa mabibigo
hindi mahalaga kung gaano karaming beses ang subukan namin upang itulak ang isang bagay.
Kung panatilihin namin pagtulak, panatilihin namin incrementing laki,
kahit na hindi namin paglalagay ng anumang bagay papunta sa stack.
Karaniwan hindi namin dagdagan ang laki hanggang
pagkatapos ng matagumpay na namin na ilagay ang mga ito sa stack.
Nais naming gawin ito, sabihin nating, alinman dito at dito.
At pagkatapos ay sa halip na sinasabi s.size ≤ kapasidad, ito ay mas mababa kaysa sa kapasidad,
lamang dahil namin inilipat kung saan ang lahat ay.
>> At tandaan, ang tanging lugar na maaari kaming posibleng bumalik maling
dito, kung saan realloc ibinalik null,
at kung mangyari mong tandaan ang standard na error,
marahil maaari mong isaalang-alang ang isang kaso kung saan nais mong i-print ang isang karaniwang error,
kaya fprintf stderr sa halip na lamang ang pag-print nang direkta sa pamantayan out.
Muli, na hindi inaasahan, ngunit kung ito ay isang error,
type printf, pagkatapos ay maaari mong upang gawin itong i-print sa standard error sa halip ng karaniwang out.
>> Sinuman ay may anumang bagay upang tandaan? Oo.
[Mag-aaral] Maaari kang pumunta sa ibabaw ng [] hindi marinig?
[Rob B.] Oo, ang aktwal na binariness nito o kung ano ito ay?
[Mag-aaral] Kaya multiply mo ito sa pamamagitan ng 2?
[Rob B.] Oo, talaga.
Sa binary lupa, lagi naming ang aming hanay ng mga digit.
Paglilipat na ito kaliwa ng 1 insert talaga na ito dito sa kanang bahagi.
Bumalik sa mga ito, lamang-alala na ang lahat sa binary
ay isang kapangyarihan ng 2, kaya ito ay kumakatawan 2 sa 0,
ang 2 sa 1, ang 2 sa 2.
Sa pamamagitan ng pagpasok ng 0 sa kanang bahagi sa ngayon, kami lang shift ang lahat.
Ano ang ginamit na 2 sa 0 ngayon ay 2 sa 1, 2 sa 2.
Ang kanang bahagi na namin ipinasok
ay kinakailangang pagpunta sa 0,
na saysay.
Kung sakaling multiply ng bilang ng 2, hindi ito upang tapusin ang kakaiba,
kaya ang 2 sa 0 lugar ay dapat na 0,
at ito ay kung ano ang ko kalahati nagbabala tungkol sa bago ay kung ikaw ay mangyayari sa shift
higit sa bilang ng mga piraso sa isang integer,
1 ito ay pagpunta sa pagpunta off.
Na ang tanging mag-alala kung mangyayari sa pagharap sa talagang malaking capacities.
Ngunit sa puntong iyon, pagkatapos ikaw ay pagharap sa isang array ng mga bilyun-bilyong ng mga bagay,
na maaaring hindi umangkop sa memory pa rin.
>> Ngayon ay maaari naming makakuha ng sa pop, na kung saan ay mas madali.
Maaari mo ito gusto kung mangyari mong mag-pop ang maramihang,
at ngayon ikaw muli sa kalahati kapasidad.
Maaari mong realloc upang paliitin ang halaga ng memorya na mayroon ka,
ngunit hindi mo na kailangang mag-alala tungkol sa na, kaya lamang realloc kaso ay magiging
lumalaking memory, hindi pag-urong memory,
na pop napakadaling.
Ngayon queues, na tulad ng stack,
ngunit ang pagkakasunud-sunod mong gawin ang mga bagay ang reverse.
Ang prototypical halimbawa ng isang queue ay isang linya,
kaya hulaan ko kung ikaw ay Ingles, Gusto ko sinabi
isang prototypical halimbawa ng isang queue queue.
Kaya tulad ng isang linya, kung ikaw ang unang tao sa linya,
inaasahan mong ang unang tao ng linya.
Kung ikaw ang huling tao sa linya, ikaw ay pagpunta sa huling tao serviced.
Tinatawag namin na FIFO pattern, kung saan stack LIFO pattern.
Medyo unibersal ang mga salitang iyon.
>> Tulad ng mga stack at hindi tulad ng array, queues karaniwang hindi payagan ang access sa mga elemento sa gitna.
Dito, stack, mayroon kaming push at mga pop.
Narito, mangyari namin na tinatawag na sa kanila ay enqueue at dequeue.
Narinig ko rin kanila tinatawag shift at unshift.
Narinig ko ang mga tao ay sinasabi push at mga pop sa ring ilapat sa queues.
Narinig ko isingit, alisin,
kaya itulak at pop, kung ikaw ay pakikipag-usap tungkol sa mga stack, ikaw ay pagtulak at popping.
Kung ikaw ay pakikipag-usap tungkol sa mga queues, maaari mong piliin ang mga salita na gusto mong gamitin
para sa pagpapasok ng at pag-alis, at walang pinagkaisahan sa kung ano ang dapat ito ay tinatawag na.
Ngunit dito, mayroon kaming enqueue at dequeue.
Ngayon, ang struct ang hitsura halos kapareho ng struct stack.
Ngunit kami ay upang subaybayan ng ulo.
Hulaan ko sinasabi nito pababa dito, ngunit bakit kailangan namin ang ulo?
Ang mga modelo ay talaga magkakahawig upang itulak at pop.
Maaari mong isipin na ito bilang push at pop.
Ang pagkakaiba lamang ay pop ay bumabalik-halip ng huling, ito bumabalik sa unang.
2, 1, 3, 4, o isang bagay na.
At dito sa simula.
Aming queue ganap na puno na, kaya may apat na mga elemento sa loob nito.
Ang pagtatapos ng aming queue ay kasalukuyang 2,
at ngayon namin pumunta sa magpasok ng iba pa.
>> Kapag gusto naming isingit na may isang bagay sa ibang tao, kung ano ang ginawa namin para sa bersyon ng stack
ang aming pinalawak ng aming bloke ng memorya.
Ano ang problema na ito?
[Mag-aaral] ilipat mo ang 2.
Ano ang sinabi ko bago tungkol sa dulo ng queue,
ito ay hindi magkaroon ng kahulugan na sisimulan namin sa 1,
gusto naming dequeue 1, pagkatapos dequeue 3, pagkatapos dequeue 4,
pagkatapos dequeue 2, pagkatapos dequeue ang isang ito.
Hindi namin maaaring gamitin ang realloc ngayon,
o sa pinakadulo hindi bababa sa, mayroon kang upang gamitin ang realloc sa isang iba't ibang mga paraan.
Ngunit marahil ay hindi dapat gamitin na lamang ang realloc.
Upang mano-manong kopyahin ang iyong memory.
>> Mayroong dalawang mga function upang kopyahin ang memory.
May memcopy at memmove.
Kasalukuyan ako sa pagbasa ng mga tao upang makita kung ano ang ka pagpunta sa nais na gumamit ng.
Okay, memcopy, ang pagkakaiba ay
na memcopy at memmove, isang humahawak tama ang kaso
kung saan ka pagkopya sa isang rehiyon na mangyayari na nago-overlap sa rehiyon
ka pagkopya mula.
Memcopy ay hindi ito pangasiwaan ang. Memmove ginagawa.
Maaari mong isipin na ang problema bilang-
sabihin nating gusto ko upang kopyahin ito tao,
mga apat sa tao na ito sa paglipas ng.
Sa pagtatapos, ano array ay dapat magmukhang
matapos ang kopya ay 2, 1, 2, 1, 3, 4, at ang ilang mga bagay-bagay sa dulo.
Ngunit ito ay nakasalalay sa pagkakasunud-sunod kung saan namin ang aktwal na kopyahin,
dahil kung hindi namin isaalang-alang ang mga katotohanan na rehiyon ng namin ang pagkopya sa
pumapatong sa isa namin ang pagkopya mula sa,
maaari naming gawin tulad ng simula dito, kopyahin ang 2 sa lugar na gusto naming pumunta,
pagkatapos ay ilipat ang aming mga payo pasulong.
>> Ngayon sinusubukan namin dito at dito, at ngayon ay nais namin upang kopyahin
ito tao sa ang tao na ito at ilipat ang aming mga payo pasulong.
Ano kami ay pagpunta upang tapusin ang pagkuha ng 2, 1, 2, 1, 2, 1
sa halip ng naaangkop na 2, 1, 2, 1, 3, 4 dahil
2, 1 overrode ang orihinal 3, 4.
Memmove humahawak na tama.
Sa kasong ito, talaga lang laging gamitin ang memmove
dahil ito humahawak ito nang tama.
Sa pangkalahatan ay hindi magsagawa ng anumang mas masahol pa.
Ang ideya ay sa halip na nagsisimula mula sa simula at pagkopya ng ganitong paraan
tulad lang namin ginawa dito, nagsisimula mula sa dulo at kinokopya sa,
at sa kasong iyon, hindi ka maaaring magkaroon ng problema.
Ang pagganap ng hindi mawawala.
Palaging gamitin ang memmove. Huwag kailanman mag-alala tungkol sa memcopy.
At na kung saan ka pagpunta sa hiwalay memmove
balot-around bahagi ng iyong queue.
Walang alalahanin kung hindi ganap na tapos.
Ito ay mas mahirap kaysa sa stack, push, at pop.
>> Sinuman ay may anumang code kami maaaring gumana sa?
Kahit na ganap na hindi kumpleto?
[Mag-aaral] Oo, ito ay ganap na kumpleto, bagaman.
Ganap na hindi kumpleto pinong hangga't namin na maaari mong i-save ang mga rebisyon?
Nakalimutan ko na bawat solong oras.
Okay, pagbalewala sa kung ano ang mangyayari kapag kailangan namin upang baguhin ang laki ng mga bagay.
Ganap na huwag pansinin ang resize.
Ipaliwanag ang code na ito.
Lalabas na ako muna sa lahat kung ang laki ang ay mas mababa kaysa sa ang unang kopya ng lahat ng
at pagkatapos ay matapos na, ako isingit-ako kukuha ulo + laki,
at gumawa ako bang bumabalot sa buong kapasidad ng array,
at ko bang ipasok ang bagong string sa posisyong iyon.
Pagkatapos ko bang dagdagan ang laki at nagbabalik ng tunay.
>> [Rob B.] na ito ay tiyak ang isa sa mga kasong iyon kung saan ka pagpunta sa nais na gamitin ang mod.
Anumang uri ng kaso kung saan mo wrapping sa paligid, kung sa tingin mo ang pambalot sa paligid,
ang agarang pag-iisip ay dapat mod.
Bilang ng mabilis na pag-optimize / gumawa ng mas maikli ang iyong code isang linya,
napansin mo na linya kaagad na sumusunod ang isang ito
lamang ang laki + +, kaya bumaybay ka na sa line na ito, laki + +.
Ngayon down na dito, mayroon kaming ang kaso
kung saan wala kaming sapat na memorya,
kaya kami ay dagdagan ang aming kapasidad sa pamamagitan ng 2.
Hulaan ko maaari kang magkaroon ng parehong problema dito, ngunit maaari naming huwag pansinin ito ngayon,
kung saan kung nabigong upang taasan ang iyong kapasidad,
ka pagpunta sa nais upang bawasan ang iyong kapasidad ng 2 muli.
Isa pang maikling tala ay tulad lamang ang maaari mong gawin + =,
maaari mo ring gawin << =.
Halos anumang bagay ay maaaring pumunta bago katumbas, + =, | =, & =, << =.
Magpasinda * bagong aming bagong bloke ng memorya.
Oh, sa paglipas dito.
>> Ano ang mga tao na isipin ang tungkol sa mga uri ng aming bagong bloke ng memorya?
[Mag-aaral] dapat magpasinda **.
Iniisip pabalik sa aming struct up dito,
string ay kung ano ang namin ay reallocating.
Nagsasagawa kami ng isang buong bagong dynamic na imbakan para sa mga elemento sa queue.
Ano kami ay pagpunta sa nagtatalaga sa iyong mga string ay kung ano ang namin ang mallocing ngayon,
at kaya bagong pagpunta sa isang pansamantalang trabaho **.
Ito ay pagpunta sa isang array ng mga string.
Pagkatapos kung ano ang kaso sa ilalim kung saan kami ay pagpunta sa bumalik false?
[Mag-aaral] Dapat ba naming paggawa ng pansamantalang trabaho *?
[Rob B.] Oo, magandang tawag.
[Mag-aaral] Ano na?
[Rob B.] Gusto naming gawin ang laki ng magpasinda * dahil hindi na namin
ito ay aktwal na maging isang malaking problema dahil sizeof (pansamantalang trabaho) ay 1.
Sizeof magpasinda * ay pagpunta sa 4,
kaya ng maraming beses kapag ikaw ay pagharap sa ints,
malamang sa iyo upang makakuha ng ang layo dito dahil ang laki ng int at laki ng int *
sa isang 32-bit na sistema ay ang parehong bagay.
Ngunit dito, sizeof (pansamantalang trabaho) at sizeof (pansamantalang trabaho *) na ngayon ang parehong bagay.
>> Ano ang pangyayari na kung saan bumalik kami ng maling?
[Mag-aaral] Bagong null.
Oo, kung ang bagong ay null, bumalik namin maling,
at ako pagpunta sa mahulog dito-
[Mag-aaral] [hindi marinig]
[Rob B.] Oo, ito ay pinong.
Maaari mong alinman sa gawin ng 2 beses kapasidad o kapasidad shift 1 at pagkatapos lamang itakda ito dito o anumang.
Gagawin namin ito bilang nagkaroon kami ito.
Kapasidad >> = 1.
At hindi ka pagpunta sa mag-alala tungkol sa pagkawala ng ng 1 lugar ng
dahil ang natitira ka ng Paglipat ng 1, kaya ang 1 lugar ng ay kinakailangang 0,
kaya kanan paglilipat ng 1, ka pa rin ng pagpunta sa fine.
[Mag-aaral] kailangan mong gawin na bago return?
[Rob B.] Oo, ito ay gumagawa ng ganap na walang kahulugan.
>> Ngayon ay ipinapalagay namin ay pagpunta sa bumabalik totoo sa dulo.
Ang paraan namin ay pagpunta sa gawin ang mga memmoves,
kailangan namin upang maging maingat sa kung paano gawin namin ang mga ito.
Ba ang sinuman magkaroon ng anumang mga mungkahi para sa kung paano gawin namin ang mga ito?
Narito ang aming pagsisimula.
Walang sala, nais naming upang magsimulang muli sa simula
at kopyahin ang mga bagay mula doon, 1, 3, 4, 2.
Paano mo gawin iyon?
Una, mayroon akong tumingin sa pahina ng tao para sa memmove muli.
Memmove, pagkakasunud-sunod ng mga argumento ay laging mahalaga.
Nais namin ang aming destination una, ang pinagmulan segundo, laki ikatlong.
May maraming ng mga function na baligtarin ng pinagmulan at patutunguhan.
Destination, ang pinagmulan ay may kaugaliang upang maging pare-pareho medyo.
Ilipat, kung ano ang bumabalik?
Ito ay nagbabalik ng pointer sa destination, para sa anumang dahilan baka gusto mo na.
Maaari kong larawan basahin ito, ngunit nais naming upang ilipat sa aming destination.
>> Ano ang aming destination pagpunta sa ay?
[Mag-aaral] Bagong.
[Rob B.] Oo, at kung saan kami pagkopya mula?
Ang unang bagay na namin ang pagkopya ito 1, 3, 4.
Ano ang na ito 1, 3, 4.
Ano ang address ng ito 1?
Ano ang address ng na 1?
[Mag-aaral] [hindi marinig]
[Rob B.] Head + ang address ng unang elemento.
Paano kami makakuha ng sa unang elemento sa array?
[Mag-aaral] Queue.
[Rob B.] Oo, q.strings.
Tandaan, dito, ang aming mga ulo ay 1.
Darn ito. Ko lang sa tingin ito ay magically-
Narito, ang aming ulo ay 1. Ako pagpunta upang baguhin ang aking kulay masyadong.
At dito ay string.
Ito, maaari naming alinman magsulat ito bilang namin ginawa sa paglipas dito
may ulo + q.strings.
Isang maraming ng mga tao ring sumulat at q.strings [ulo].
Na ito ay hindi talagang anumang hindi gaanong mahusay.
Maaari mong isipin na ito bilang ikaw ay dereferencing ito at pagkatapos ay pagkuha ng address ng,
ngunit tagatala na i-translate ang mga ito sa kung ano ang namin ay may bago pa rin, q.strings + ulo.
Alinman sa paraan na gusto mong mag-isip nito.
>> At kung gaano karaming mga byte gusto naming kopyahin?
[Mag-aaral] Kapasidad - ulo.
Kapasidad - ulo.
At pagkatapos ay maaari mong palaging isulat ang isang halimbawa
upang malaman kung na tama.
[Mag-aaral] Kailangan itong hinati ng 2 pagkatapos.
Oo, kaya hulaan ko maaari naming gamitin ang laki.
Mayroon pa kaming laki pagiging-
paggamit ng laki, mayroon kaming laki katumbas sa 4.
Sa aming size ay 4. Aming ulo ay 1.
Gusto namin upang kopyahin ang mga ito 3 mga elemento.
Iyon katinuan suriin na laki - ulo ay tama 3.
At babalik dito, tulad ng sinabi namin bago,
kung ginamit namin ang kapasidad, pagkatapos ay nais naming hatiin sa pamamagitan ng 2
dahil kami lumaki ang aming kapasidad, kaya sa halip, kami ay pagpunta sa gamitin ang laki.
Na kopya na bahagi.
Ngayon, kailangan namin upang kopyahin sa iba pang mga bahagi, ang bahagi na naiwan ng simula.
>> Na upang memmove sa kung anong posisyon?
[Mag-aaral] Plus laki - ulo.
Oo, kaya na namin kinopya ang laki - bytes ulo,
at iba pa kung saan nais namin upang kopyahin ang mga natitirang bytes bagong
at pagkatapos laki minus-mabuti, ang bilang ng mga byte na namin ang kinopya.
At pagkatapos ay kung saan kami pagkopya mula?
[Mag-aaral] Q.strings [0].
[Rob B.] Oo, q.strings.
Maaaring alinman sa gawin namin & q.strings [0].
Ito ay makabuluhang mas mababa karaniwan kaysa sa.
Kung lamang ito ng pagpunta sa 0, pagkatapos makikita mo may posibilidad upang makita ang mga q.strings.
Kung saan namin ang pagkopya mula sa.
Gaano karaming mga byte namin ang natitira upang kopyahin? >> [Mag-aaral] 10.
Kanan.
[Mag-aaral] namin multiply 5 - 10 beses laki ng bytes o isang bagay?
Oo, kaya ito ay kung saan-kung ano ang eksaktong ay namin ang pagkopya?
[Mag-aaral] [hindi marinig]
Ano ang uri ng bagay na namin ang pagkopya?
[Mag-aaral] [hindi marinig]
Oo, kaya magpasinda * s na namin ang pagkopya, hindi namin alam kung saan ang mga nagmumula.
Well, kung saan sila ay tumuturo sa, tulad ng mga string, kami magtapos itulak ito papunta sa queue
o enqueuing papunta sa pila.
Kung saan ang mga nagmumula, wala kaming ideya.
Kailangan lang namin upang subaybayan ng magpasinda * s ang kanilang mga sarili.
Hindi namin gusto mong kopyahin ang laki - ulo bytes.
Gusto naming upang kopyahin ang laki - ulo magpasinda * s,
kaya kami ay pagpunta sa multiply ito sa pamamagitan ng sizeof (magpasinda *).
Parehong pababa dito, tumungo * sizeof (magpasinda *).
>> [Mag-aaral] Ano ang tungkol sa [hindi marinig]?
Ito dito mismo?
[Mag-aaral] Hindi, sa ibaba na, ang laki - ulo.
[Rob B.] ito karapatan dito?
Pointer aritmetika.
Paano pointer aritmetika ay pagpunta sa trabaho ay
ito awtomatikong multiply ng laki ng uri na kami ay pagharap sa.
Tulad sa paglipas dito, bagong + (laki - ulo)
eksaktong katumbas sa & bagong [laki - ulo]
hanggang inaasahan namin na upang gumana nang tama,
dahil kung kami ay pagharap sa isang int array, pagkatapos ginagawa namin hindi index sa pamamagitan ng pag-int-
o kung ito ng laki ng 5 at gusto mo ang ika-4 na elemento, pagkatapos namin ang pag-index sa
int array [4].
Kang don't [4] * laki ng int.
Na humahawak sa awtomatikong, at ang kasong ito
literal katumbas, kaya ang syntax ng bracket
ay lamang pagpunta upang ma-convert na ito sa lalong madaling mo makatipon.
Iyon ay isang bagay na kailangan mong mag-ingat ng na
kapag ikaw ay pagdaragdag ng laki - ulo
pagdaragdag ng ikaw ay hindi isang byte.
Nagdadagdag ka ng isang pansamantalang trabaho *, na maaaring maging isang byte o anumang.
>> Iba pang mga tanong?
Okay, dequeue ay magiging madali.
Bibigyan kita ng isang minuto upang ipatupad.
Oh, at hulaan ko ito ay ang parehong sitwasyon kung saan
enqueue kaso, kung kami ay enqueuing null,
baka gusto namin upang mahawakan ang mga ito, maaaring hindi namin.
Hindi namin gawin ito muli dito, ngunit parehong bilang aming stack kaso.
Kung enqueue namin null, maaari naming gusto mong balewalain ang mga ito.
Sinuman ay may ilang mga code maaari kong makuha ang?
[Mag-aaral] ko na lang ay dequeue.
Bersyon 2 ay na-okay.
Gusto mong ipaliwanag?
[Mag-aaral] Una, tiyakin mong may isang bagay sa queue
at sukat na iyon ay pagpunta ng 1.
Kailangan mo bang gawin iyon, at pagkatapos mong ibalik ang ulo
at pagkatapos ay ilipat ang mga ulo up 1.
Okay, sa gayon ay isang sulok kaso kami ay upang isaalang-alang. Oo.
[Mag-aaral] Kung ang iyong ulo ay sa huling elemento,
pagkatapos ay hindi mo nais na pinuno upang tumuro sa labas ng array.
>> Oo, ito sa lalong madaling bilang pinuno ay pinindot niya ang dulo ng aming array,
kapag dequeue namin, ang aming mga ulo ay dapat modded pabalik sa 0.
Sa kasamaang-palad, hindi namin gawin iyon sa isang hakbang.
Hulaan ko ang paraan na gusto ko marahil ayusin ito ay
ito ay pagpunta sa isang pansamantalang trabaho *, kung ano ang kami ay bumabalik,
anumang iyong pangalan ng variable ay nais na maging.
Pagkatapos gusto naming mod ang ulo sa pamamagitan ng aming kapasidad
at pagkatapos ay bumalik magpabasa.
Isang maraming ng mga tao dito ay maaaring nilang gawin
ito ang kaso ng you'll makita tao gawin kung ulo
ay mas mataas kaysa sa kapasidad, gawin ang ulo - kapasidad.
At na nagtatrabaho sa paligid ng kung ano ang mod ay.
Head kapasidad mod = magkano cleaner
ng isang wrapping sa paligid kaysa kung ulo na mas malaki kaysa sa ulo ng kapasidad - kapasidad.
>> Mga tanong?
Okay, ang huling bagay na namin ang natitira sa aming mga naka-link na listahan.
Maaari mong gamitin sa ilang ng mga naka-link na pag-uugali ng listahan kung ginawa mo
naka-link na listahan sa iyong hash na mga talahanayan, kung ginawa mo ng hash table.
Ko Minumungkahi paggawa ng hash table.
Maaaring na nagawa mo na trie ng,
ngunit sinusubukan ng mas mahirap.
Sa teorya, hindi sila asymptotically mas mahusay.
Ngunit lamang tumingin sa malaking board,
at hindi kailanman sinusubukan gawin mas mahusay, at sila up ng higit memory.
Lahat ng tungkol sa sinusubukan nagtatapos up pagiging mas masahol pa para sa pang trabaho.
Kung ano ang David Malan ang solusyon ay palaging
siya laging post kanyang trie solusyon, at sabihin makita kung saan siya kasalukuyang.
Ano siya sa ilalim, David J?
Siya ay # 18, kaya na hindi masyado masama,
at na pagpunta sa isa sa mga pinakamahusay na sinusubukan maaari mong isipin ang
o ang isa sa mga pinakamahusay na sinusubukan ng isang trie.
Hindi ito ay kahit na ang kanyang orihinal na solusyon?
Pakiramdam ko ay tulad ng trie solusyon ay may posibilidad na maging mas sa hanay ng RAM paggamit.
>> Bumaba sa pinakatuktok, at RAM paggamit sa isang digit.
Bumaba patungo sa ibaba, at pagkatapos ay simulan mo nakikita sinusubukan
kung saan makakakuha ka talagang napakalaking paggamit ng RAM,
at sinusubukang ay mas mahirap.
Hindi ganap na nagkakahalaga ito ngunit sa pang-edukasyon na karanasan kung ginawa mo ang isa.
Ang huling bagay ay ang aming naka-link na listahan,
at ang tatlong bagay, stack, queues, at mga naka-link na listahan,
anumang mga bagay na sakaling gawin sa computer science
ay ipagpalagay na mayroon kang lubos na pagkikilala sa mga bagay na ito.
Lang nila kaya pangunahing sa lahat.
>> Naka-link na listahan, at dito namin ng isa-isa naka-link na listahan ay pagpunta sa ang aming pagpapatupad.
Ano ay isa-isa na naka-link ibig sabihin laban sa doble-link? Oo.
[Mag-aaral] lamang nito ang mga punto sa susunod na pointer kaysa sa payo,
tulad ng isa na nauuna sa mga ito at matapos itong.
Oo, kaya sa larawan na format, kung ano ang ko lang gawin?
Mayroon akong dalawang bagay. Mayroon akong larawan at larawan.
Sa larawan na format, ang aming isa-isa naka-link na mga listahan,
karaniwan na, mayroon kaming ilang mga uri ng pointer sa ulo ng aming listahan,
at pagkatapos ay sa loob ng aming listahan, kami na lang ay payo,
at marahil ito puntos sa null.
Ito ay pagpunta sa iyong tipikal na pagguhit ng isa-isa naka-link na listahan.
Isang doble-link sa listahan, maaari kang pumunta paurong.
Kung ako magbibigay sa iyo ng anumang node sa listahan, pagkatapos ay maaari mong kinakailangang makarating sa
anumang iba pang mga node sa listahan kung ito ay doble na naka-link sa listahan.
Ngunit kung nakakuha ako sa ikatlong node sa listahan at ito ng isa-isa na naka-link sa listahan,
walang paraan ka upang makakuha ng sa una at ikalawang node.
At may mga benepisyo at detriments, at isang halata na isa
ay mo tumagal ng hanggang sa karagdagang laki, at mayroon kang subaybayan ng kung saan ang mga bagay na ito ay pagturo ngayon.
Ngunit lamang namin pakialam tungkol sa isa-isa na naka-link.
>> Ang ilang mga bagay na kami ay pagpunta upang ipatupad.
Ang iyong typedef node sa struct, int i: struct node * susunod; node.
Na typedef dapat burn sa iyong isip.
Quiz 1 ay dapat bang bigyan isang typedef ng isang listahan ng mga naka-link node,
at dapat mong agad scribble na pababa
walang kahit na pag-iisip tungkol dito.
Hulaan akong mga tanong ng ilang, bakit namin kailangang struct dito?
Bakit hindi sabihin kami ng node *?
[Mag-aaral] [hindi marinig]
Oo.
Ang tanging bagay na tumutukoy sa isang node bilang isang bagay
ay ang typedef mismo.
Ngunit bilang ng puntong ito, kapag hindi namin ang uri ng pag-parse sa pamamagitan ng kahulugan struct node,
tapos hindi pa namin ang aming typedef pa, kaya dahil ang typedef ay hindi pa tapos,
node ay hindi umiiral.
Ngunit struct node, at ito node in dito,
ito ay maaari ring tinatawag na ano pa man.
Ma-tinatawag n.
Maaari itong tinatawag na naka-link na listahan node.
Maaari itong tinatawag na kahit ano.
Ngunit ito struct node ay nangangailangan ng na tinatawag na ang parehong bagay bilang struct node na ito.
Ano tawagan ka ito ay may rin dito,
at sa gayon ay din sumasagot sa pangalawang punto ng tanong
na ang dahilan kung bakit ng maraming mga beses kapag nakita mo structs at typedefs ng structs,
makikita mo ang hindi nakikilalang structs kung saan makikita mo na lang makita ang typedef struct,
pagpapatupad ng struct, diksyunaryo, o anumang.
>> Bakit dito ang kailangan namin upang sabihin ang node?
Bakit hindi ito ay isang hindi nakikilalang struct?
Ito ay halos ang parehong sagot.
[Mag-aaral] Kailangan mong sumangguni sa ito sa loob ng struct.
Oo, sa loob ng struct, kailangan mong mag-refer sa mismong struct.
Kung hindi mo bigyan ang struct ng pangalan, kung ito ay isang hindi nakikilalang struct, hindi ka maaaring sumangguni sa.
At huling ngunit hindi bababa sa mga dapat lahat ay medyo direkta,
at dapat nilang matulungan kang Napagtanto kung ikaw ay sumusulat ito pababa
na ikaw ay gumagawa ng mali kung ang mga uri ng mga bagay na walang kabuluhan.
Huling ngunit hindi bababa sa, kung bakit ito struct node *?
Bakit hindi ito lamang ay struct node susunod?
[Mag-aaral] pointer sa susunod na struct.
Iyon ay tiyak kung ano ang gusto naming.
Bakit hindi ito ma-struct node susunod?
Bakit ang ito sa struct node * susunod? Oo.
[Mag-aaral] Ito ay tulad ng isang walang-katapusang loop.
Oo.
[Mag-aaral] ay ang lahat ng ito sa isa.
Oo, tingin lang kung paano namin gawin ang laki ng o isang bagay.
Sukat ng isang struct ay isa lamang + o - ang ilang mga pattern dito o doon.
Talaga ito ang kabuuan ng laki ng mga bagay sa struct.
Ito dito mismo, nang hindi binabago ang anumang bagay, laki ang pagpunta sa madaling.
Sukat ng struct node ay pagpunta sa laki ng i + laki ng susunod.
Laki ng i pagpunta sa 4. Laki ng susunod na 4.
Sukat ng struct node ay pagpunta sa 8.
Kung hindi namin *, iniisip ng sizeof
pagkatapos sizeof (i) ay magiging 4.
Sukat ng struct node susunod na pagpunta sa laki ng i + laki ng struct node sa tabi
+ Laki ng i + laki ng struct node susunod.
Ito ay isang walang-katapusang recursion ng node.
Ito ay kung bakit ito ay kung paano ang mga bagay ay may upang maging.
>> Muli, talagang kabisaduhin na,
o hindi bababa sa maunawaan ang mga ito nang sapat na maaari mong ma-
dahilan sa pamamagitan ng kung ano ang dapat ito hitsura.
Ang mga bagay na kami ay pagpunta sa nais na ipapatupad.
Kung ang haba ng listahan-
maaari mong impostor at panatilihin sa paligid ng isang
global haba o isang bagay, ngunit hindi namin upang gawin iyon.
Kami ay pagpunta upang mabilang ang haba ng listahan.
Namin ang naglalaman, kaya na talaga tulad ng paghahanap,
kaya kami ay may naka-link na listahan ng mga integer upang makita kung ang integer na ito sa naka-link na listahan.
Ang Prepend ay pagpunta upang ipasok sa simula ng listahan.
Magkabit ay upang ipasok sa dulo.
Insert_sorted ay upang ipasok sa pinagsunod-sunod na posisyon sa listahan.
Insert_sorted uri ng Ipinagpapalagay na hindi mo ginagamit prepend o ikabit ang nasa masamang paraan.
>> Insert_sorted kapag ikaw ay pagpapatupad insert_sorted-
sabihin nating mayroon kaming ang aming naka-link listahan.
Ito ay kung ano ang kasalukuyang Mukhang, 2, 4, 5.
Gusto kong upang ipasok 3, kaya hangga't sa listahan mismo na pinagsunod-sunod,
madaling hanapin kung saan 3-aari.
Sisimulan ko sa 2.
Okay, 3 ay mas malaki kaysa sa 2, kaya nais kong panatilihin ang pagpunta.
Oh, 4 ay masyadong malaki, kaya alam ko 3 ay pumunta sa pagitan ng 2 at 4,
at mayroon akong upang ayusin ang mga payo at lahat na bagay.
Ngunit kung hindi namin ginawa mahigpit na gamitin insert_sorted,
bang sabihin lamang sinasabi ko prepend 6,
pagkatapos ay ang aking naka-link na listahan ay pagpunta upang maging ito.
Ito ngayon ay hindi gumagawa ng mga kahulugan, kaya para sa insert_sorted, maaari mo lamang ipagpalagay
na listahan ay pinagsunod-sunod, kahit pagpapatakbo umiiral
na maaaring maging sanhi ng hindi ito na pinagsunod-sunod, at na ito.
Maghanap ng isang kapaki-pakinabang na insert-kaya mga ay ang pangunahing bagay ka pagpunta upang ipatupad.
>> Sa ngayon, kumuha nang isang minuto upang gawin ang haba at naglalaman ng,
at mga dapat relatibong mabilis.
Papalapit sa panahon ng pagsasara, kaya't sinuman ay may anumang para sa haba o naglalaman?
Sila ay halos magkakahawig.
[Mag-aaral] Haba.
Natin makita, rebisyon.
Okay.
Gusto mong ipaliwanag?
[Mag-aaral] ko lang lumikha ng isang pointer node at initialize ito sa unang, na ang aming global variable,
at pagkatapos kong suriin upang makita kung null kaya hindi ko makakuha ng seg kasalanan at bumalik ang 0 kung iyon ang kaso.
Kung hindi man, ako loop sa pamamagitan, nang pinapanatili ang track ng loob integer
kung gaano karaming beses ko na access sa susunod na elemento ng listahan
at sa parehong pagpapatakbo ng pagdagdag ring ma-access ang na aktwal na elemento,
at pagkatapos ko patuloy check upang makita kung ito ang null,
at kung null, pagkatapos ito aborts at nagbabalik lamang ang bilang ng mga elemento ko ang access.
>> [Rob B.] ba ang sinuman anumang mga komento sa anumang?
Mukhang fine kawastuhan matalino.
[Mag-aaral] Hindi sa tingin ko kailangan mo ang node == null.
Oo, kaya kung node == null return 0.
Ngunit kung node == null pagkatapos ito-oh, may ay isang isyu sa kawastuhan.
Ito ay ka bumabalik i, pero hindi sa saklaw ngayon.
Kailangan lang int i, kaya i = 0.
Ngunit kung node ay null, pagkatapos pa rin i ay pagpunta sa 0,
at kami ay pagpunta sa bumalik 0, kaya ang kaso na ito ay kapareho.
Isa pang karaniwang bagay ay upang panatilihin ang deklarasyon
ng node sa loob ng para sa loop.
Maaari mong sabihin-oh, hindi.
Natin panatilihin ito bilang ito.
Gusto ko marahil ilagay int i = 0 dito,
pagkatapos node * node = unang in dito.
At ito ay marahil kung paano inaalis ng ito ngayon.
Marahil ito ay kung paano isinulat ko ito.
Maaari mo ring pagtingin sa ito tulad nito.
Ito para sa loop istraktura dito mismo
dapat halos bilang natural na sa iyo para sa int i = 0
i ay mas mababa kaysa sa haba ng array i + +.
Kung iyon ang kung paano mo umulit sa isang array, ito ay kung paano mo umulit sa loob ng isang naka-link na listahan.
>> Ito ay dapat na maging pangalawang kalikasan sa ilang punto.
Gamit na sa isip, ito ay halos ang parehong bagay.
Ay pagpunta sa nais upang gumalaw sa loob ng isang naka-link na listahan.
Kung ang node-ako ay walang ideya kung ano ang halaga ay tinatawag na.
Node i.
Kung ang halaga sa node na = bumalik i totoo, at na ito.
Pansinin na ang tanging paraan namin kailanman bumalik maling
kung umulit namin sa ibabaw ng buong-link na listahan at hindi nagbabalik ng tunay na,
sa gayon ay kung ano ang ginagawa.
Bilang isang bahagi tandaan namin marahil ay hindi makakuha upang isama o prepend.
>> Quick huling tala.
Kung makita mo ang static keyword, kaya sabihin nating static int count = 0,
ginagawa namin ang bilang ng + +, maaari kang talaga tingin ng mga ito bilang isang global na variable,
kahit ko lang sinabi na ito ay hindi kung paano namin pagpunta sa ipatupad ang haba.
Ako ginagawa ito dito, at pagkatapos ay ang bilang ng + +.
Anumang paraan na maaari naming magpasok ng isang node sa aming naka-link na listahan namin ay incrementing aming count.
Ang punto ng ito ay kung ano ang ibig sabihin ng static keyword.
Kung ko lang may int count = 0 na maging isang regular na lumang global variable.
Ano static int count ay nangangahulugan na ito ay isang pandaigdigang variable para sa file na ito.
Ito ay imposible para sa ilang iba pang mga file,
bang tingin ng pset 5, kung mayroon kang makapagsimula.
Mayroon ka ng parehong speller.c, at mayroon kang dictionary.c,
at kung ipinapahayag mo lang ang isang bagay global, pagkatapos anuman sa speller.c
maaaring ma-access sa dictionary.c at vice versa.
Global variable ay naa-access sa pamamagitan ng anumang file na. C,
ngunit static na mga variable ay naa-access lamang mula sa loob ng mismong file,
ito sa loob ng spell checker o sa loob ng dictionary.c,
ito ay uri ng kung paano ipinapahayag ko ang aking variable para sa laki ng aking array
o ang laki ng aking numero ng mga salita sa diksyunaryo.
Dahil hindi ko nais na idedeklara ng isang global variable na sinuman ay access sa,
Ko talagang lamang pakialam tungkol dito para sa aking sariling mga layunin ng.
>> Ang magandang bagay tungkol dito ay din ang mga buong pangalan ng mga bagay-bagay na banggaan.
Kung sinusubukan ng ilang iba pang mga file sa gumamit ng global variable na tinatawag na bilang ng mga bagay pumunta napaka, napaka mali,
kaya ito mabuti mapigil ang safe ang mga bagay, at lamang ang maaari mong i-access ito,
at walang sinuman ang maaari, at kung ang ibang tao declares isang global variable na tinatawag na bilang ng,
hindi ito makagambala sa iyong static na variable na tinatawag na bilang ng.
Ang static ay. Ito ay isang file na global variable.
>> Tanong sa anumang?
Na. Bye.
[CS50.TV]