[Powered by Google Translate] [Seksyon 7: Higit pang Maginhawa]
[Rob Bowden] [Harvard University]
[Ito ay CS50] [CS50.TV]
Ayos lang. Kaya tulad ng sinabi ko sa aking email,
ito ay isang binary-puno-intensive na seksyon.
Ngunit may mga hindi na maraming mga katanungan.
Kaya kami ay pagpunta sa subukan at gumuhit ang bawat tanong
at pumunta sa masakit detalye ng lahat ng mga pinakamahusay na paraan ng paggawa ng mga bagay.
Kaya sa simula, pumunta kami sa pamamagitan ng mga guhit sample ng binary na puno at mga bagay-bagay.
Kaya dito, "Tandaan na ang isang binary tree node katulad sa mga naka-link na listahan,
maliban sa halip ng isang pointer dalawa: isa para sa 'bata' sa kaliwa
at isa para sa tamang 'anak'. "
Kaya isang binary puno ay tulad ng isang naka-link na listahan,
maliban sa struct ay pagpunta sa dalawang payo.
Mayroong trinary mga puno, na tatlong payo,
may N-ary puno, na lamang ay may generic na pointer
mong mag-malloc sa malaki sapat na upang magkaroon ng
sapat na payo sa lahat ng posibleng mga bata.
Kaya binary puno ang mangyayari sa isang pare-pareho ang bilang ng dalawang.
Kung gusto mo, maaari kang magbigay ng isang naka-link na listahan bilang isang unary puno,
ngunit hindi sa tingin ko tawag ito ng sinuman na.
"Gumuhit ng isang kahon-at-arrow diagram ng isang binary puno node
naglalaman Nate ng paboritong numero, 7, kung saan ang bawat bata pointer ay null. "
Kaya iPad mode.
>> Ito ay medyo direkta.
Lamang namin ay pagpunta sa magkaroon ng isang node, makikita ko gumuhit ang mga ito bilang isang parisukat.
At makikita kong iguhit ang mga halaga sa dito.
Kaya ang halaga ay pumunta sa dito,
at pagkatapos ay down na dito ipapakita namin sa kaliwang pointer sa kaliwa at sa kanan pointer sa kanan.
At ito ay napaka upang convention na tumawag ito kaliwa at kanang, ang mga pangalan ng pointer.
Pareho sa mga ito ay pagpunta sa maging null.
Na lamang null, at iyon ay null lamang.
Okay. -Back Kaya dito.
"Sa isang naka-link na listahan, lamang namin ay upang mag-imbak ng pointer
sa unang node sa listahan upang matandaan ang buong-link listahan, o ang buong listahan.
Gayundin, na may mga puno, lamang namin upang mag-imbak ng pointer
sa isang solong node upang matandaan ang buong puno.
Node na ito ay Calle ng 'ugat' ng puno.
Bumuo ng sa iyong diagram mula bago o gumuhit ng isang bagong isa
tulad na mayroon ka ng isang kahon-at-arrow paglalarawan ng isang binary puno
na may halaga 7, pagkatapos 3 sa kaliwa,
pagkatapos 9 sa kanan, at pagkatapos ay 6 sa kanan ng 3. "
Natin makita kung ang maaari kong tandaan ang lahat ng na sa aking ulo.
Kaya ito ay na ang aming ugat dito.
Magkakaroon kami ng ilang pointer sa isang lugar, isang bagay na kailangan namin tawagan ang ugat,
at ito na tumuturo sa ito tao.
Ngayon upang gumawa ng isang bagong node,
kung ano ang namin, 3 sa kaliwa?
Kaya ang isang bagong node na may 3, at simula POINTS null.
Kukunin ko na lang ilagay N.
Ngayon nais namin na pumunta sa kaliwa ng 7.
Kaya naming baguhin ang pointer na ito sa ngayon tumuturo sa tao na ito.
At ginagawa namin ang parehong. Gusto naming 9 sa paglipas dito
kung saan simula lang sabi null.
Kami ay pagpunta upang baguhin ang pointer, point sa 9,
at ngayon ay nais naming ilagay 6 sa kanan ng 3.
Kaya pagpunta sa - gumawa ng 6.
At tao na magtuturo doon.
Okay. Kaya na ito ang lahat ng nagtatanong sa amin upang gawin.
>> Ngayon sabihin higit sa ilang mga terminolohiya.
Uusapang namin na tungkol sa kung paano ang ugat ng puno pinakataas na node sa tree.
Ang isa na naglalaman ng 7. Ang mga node sa ilalim ng puno ay tinatawag na ang mga dahon.
Anumang node na lang may null dahil ang mga anak ay isang dahon.
Kaya ito ay posible, kung ang aming puno ng binary ay lamang ng isang solong node,
na ang puno ng dahon, at na ito.
"Ang 'taas' ng puno ay ang bilang ng mga hops na mayroon kang upang gumawa ng
upang makakuha ng mula sa tuktok ng dahon. "
Namin, sa isang segundo, ang pagkakaiba
sa pagitan ng mga balanseng at hindi balanseng puno ng binary,
ngunit sa ngayon, ang kabuuang taas ng puno na ito
Gusto ko sabihin ay 3, kahit na kung ikaw bilangin ang bilang ng mga hops
mayroon kang upang makakuha ng hanggang 9, pagkatapos ito ay talagang lamang ng isang taas ng 2.
Sa ngayon ito ay isang hindi balanseng puno ng binary,
ngunit usapan natin ang tungkol balanseng kapag ito ay nakakakuha ng may-katuturan.
Kaya ngayon maaari naming makipag-usap tungkol sa mga node sa isang puno sa mga tuntunin
may kaugnayan sa iba pang mga node sa tree.
Kaya ngayon mayroon kami ng mga magulang, mga anak, kapatid, ninuno, at kaapu-apuhan.
Ang mga ito ay medyo karaniwang kahulugan, kung ano ang ibig sabihin nila.
Kung hinihiling namin - ito ay mga magulang.
Kaya ano ang magulang ng 3?
[Mag-aaral] 7. >> Oo. Ang magulang ay pagpunta sa kung ano ang mga punto sa iyo.
Pagkatapos ano ang ang mga bata ng 7?
[Mag-aaral] 3 at 9. >> Oo.
Pansinin na ang mga "bata" literal ay nangangahulugan ng mga bata,
kaya 6 hindi angkop, dahil ito ay tulad ng isang apo.
Ngunit kung pumunta kami ng mga kaapu-apuhan, kaya kung ano ang mga kaapu-apuhan ng 7?
[Mag-aaral] 3, 6 at 9. >> Oo.
Ang mga kaapu-apuhan ng root node na ang lahat sa tree,
maliban siguro sa root node mismo, kung hindi mo nais na isaalang-alang na ang isang inapo.
At sa wakas, ninuno, kaya ito ng kabaligtaran direksyon.
Kaya ano ang mga ninuno ng 6?
[Mag-aaral] 3 at 7. >> Oo. 9 ay hindi kasama.
Ito ay direktang likod ng angkan sa root
ay pagpunta sa ang iyong mga ninuno.
>> "Sabihin namin na ang isang binary puno ay 'order' kung para sa bawat node sa tree,
ang lahat ng kanyang mga kaapu-apuhan sa kaliwa ay may mas mababang halaga
at ang lahat ng mga sa kanan may mas malaki halaga.
Halimbawa, ang tree sa itaas ay order ngunit ito ay hindi ang tanging posibleng order arrangement. "
Bago namin na,
isang order na puno ng binary ay kilala rin bilang isang binary puno ng paghahanap.
Narito namin mangyari na pagtawag sa isang order na puno ng binary,
ngunit hindi ko narinig na tinatawag na ito ng isang order na puno ng binary bago,
at sa pagsusulit namin mas malamang na ilagay ang binary paghahanap puno.
Ang mga ito ay isa at sa parehong,
at mahalagang makilala mo ang pagkakaiba sa pagitan ng binary puno at puno ng binary paghahanap.
Isang puno ng binary ay isang puno na ang mga puntos sa dalawang bagay.
Node bawat POINTS sa dalawang bagay.
Walang pagdadahilan tungkol sa mga halaga na punto upang.
Kaya gusto sa paglipas dito, dahil ito ay isang binary puno ng paghahanap,
alam namin na kung pumunta iniwanan namin ng 7,
pagkatapos ang lahat ng halaga na maaari naming posibleng maabot
sa pamamagitan ng pagpunta sa kaliwa ng 7 ay may mas mababa sa 7.
Pansinin na ang lahat ng mga halaga mas mababa kaysa sa 7 3 at 6.
Iyon ang lahat sa kaliwa ng 7.
Kung pumunta kami sa kanan ng 7, ang lahat ay may upang maging mas malaki kaysa sa 7,
kaya 9 sa kanan ng 7, kaya hindi namin magandang.
Ay hindi ito ang kaso para sa isang binary puno,
para sa isang regular na binary puno lang namin 3 sa tuktok, 7 sa kaliwa,
9 sa kaliwa ng 7, walang pag-order ng halaga ng anumang.
Ngayon, hindi aktwal na namin gawin ito dahil ito ay nakakapagod at hindi kinakailangang,
ngunit "subukan upang gumuhit ng maraming mga order na puno bilang maaari mong isipin ng
gamit ang mga numero 7, 3, 9, at 6.
Gaano karaming mga natatanging arrangement doon? Ano ang taas ng bawat isa? "
>> Gagawin namin ang ilang, ngunit ang pangunahing ideya ay,
ito ay hindi sa anumang paraan ng isang natatanging representasyon ng isang binary puno na naglalaman ng mga halagang ito.
Ang kailangan namin ay ilang binary puno na naglalaman ng 7, 3, 6, at 9.
Isa pang posibleng wastong isa ay magiging root ng 3,
pumunta sa kaliwa at 6, pumunta sa kaliwa at 7,
pumunta sa kaliwa at 9.
Iyon ay isang perpektong wastong puno ng binary paghahanap.
Ito ay hindi kapaki-pakinabang, dahil ito ay tulad ng isang naka-link na listahan
at ang lahat ng mga payo lamang null.
Ngunit ito ay isang wastong puno. Oo?
[Mag-aaral] Huwag ang mga halaga na mas malaki sa kanan?
O ay ito -? >> Mga ko nilalayong upang pumunta sa iba pang mga paraan.
Mayroon ding - oo, sabihin lumipat na.
9, 7, 6, 3. Magandang catch.
Ay mayroon pa ring sumunod sa kung ano ang isang puno ng paghahanap ng binary ay dapat gawin.
Kaya lahat sa kaliwa ay may upang maging mas mababa kaysa sa anumang ibinigay na node.
Maaaring ilipat lang namin, sabihin, ito 6 at ilagay ito dito.
Hindi, hindi namin maaari. Bakit ako patuloy na paggawa na?
Natin gawin - dito ay 6, dito ay 7, 6 na puntos sa 3.
Pa rin na ito ay isang may-bisang puno ng binary paghahanap.
Ano ang mali kung ako - sabihin makita kung maaari kong darating up na may-aayos.
Oo, okay. Kaya kung ano ang mali sa puno na ito?
Hulaan ko Ibinigay ko sa iyo ng isang pahiwatig na may sira dito.
Bakit ako patuloy na paggawa na?
Okay. Ito mukhang makatwirang.
Kung titingnan namin sa bawat node, tulad ng 7, pagkatapos sa kaliwa ng 7 ay isang 3.
Kaya mayroon kaming 3, ang mga bagay sa kanan ng 3 6.
At kung titingnan mo sa 6, ang mga bagay sa kanan ng 6 9.
Kaya bakit ito ay hindi isang wastong puno ng binary paghahanap?
[Mag-aaral] 9 pa rin sa kaliwa ng 7. >> Oo.
Dapat ito ay totoo na ang lahat ng mga halaga na maaari mong posibleng maabot sa pamamagitan ng pagpunta sa kaliwa ng 7 ay mas mababa kaysa sa 7.
Kung pumunta kami kaliwa ng 7, namin sa 3 at maaari pa rin namin ng 6 na,
Maaari pa rin namin hanggang 9, ngunit sa pamamagitan ng pag-nawala mas mababa kaysa sa 7,
Hindi namin ay dapat na magagawang upang makakuha ng sa isang numero na mas malaki kaysa sa 7.
Kaya ito ay hindi isang wastong puno ng binary paghahanap.
>> Aking kapatid na lalaki na aktwal na ay nagkaroon ng isang pakikipanayam na tanong
na talaga ito, lamang code up ng isang bagay na upang mapatunayan
kung ang isang puno ay isang binary puno ng paghahanap,
at kaya ang unang bagay na ginawa niya ay lamang suriin upang makita
kung ang kaliwa at kanang ay tama, at pagkatapos ay umulit pababa doon.
Ngunit hindi lamang mo maaaring gawin iyon, mayroon kang upang subaybayan
ng katotohanan na ngayon na nawala ko na kaliwa ng 7,
lahat sa ito subtree ay dapat na mas mababa kaysa sa 7.
Ang tamang algorithm ay kailangang subaybayan
ng hangganan na ang mga halaga ay maaaring posibleng mahulog.
Hindi namin ay pumunta sa pamamagitan ng lahat ng mga ito.
May ay isang magaling na may kaugnayan sa pag-ulit,
bagaman hindi namin nakuha sa mga, o hindi namin makakuha ng sa mga,
pagtukoy kung gaano karaming mga may aktwal ay.
Kaya may mga 14 sa kanila.
Ang ideya ng kung paano mo gawin ito ay mathematically ay tulad,
maaari kang pumili ng anumang solong root node,
at pagkatapos ay kung pumili ako ng 7 root node,
pagkatapos ay may, sabihin nating, ilang numero na maaaring pumunta sa aking kaliwang node,
at may mga ilang numero na maaaring maging ang aking karapatan node,
ngunit kung ako n kabuuang numero, pagkatapos ay ang halaga na maaaring pumunta sa kaliwa
kasama ang halaga na maaaring pumunta sa kanan n - 1.
Kaya ng natitirang mga numero, mayroon silang sa alinman sa kaliwa o kanan.
Mukhang mahirap na, kung ko bang ilagay ang 3 unang pagkatapos ang lahat ay may upang pumunta sa kaliwa,
ngunit kung ko bang ilagay ang 7, ang ilang mga bagay na maaaring pumunta sa kaliwa at ang ilang mga bagay na maaari pumunta sa kanan.
At sa pamamagitan ng '3 unang 'nilalayong ko ang lahat ay maaaring pumunta sa kanan.
Talaga, ikaw lang ay mag-isip tungkol sa ito bilang,
kung gaano karaming mga bagay ay maaaring pumunta sa susunod na antas ng puno.
At ito ay na 14, o maaari kang gumuhit ang lahat ng mga ito,
at pagkatapos ay makakakuha ka ng 14.
>> Pagpunta bumalik dito,
"-Order ng mga binary puno ng mga cool na dahil maaari naming maghanap sa kanila
sa isang katulad na paraan sa paghahanap sa paglipas ng pinagsunod-sunod na array.
Upang gawin ito, kami magsimula sa root at gumana ang aming paraan pababa sa puno
patungo sa mga dahon, pagsuri ng mga halaga sa bawat node laban sa halaga na kami ay naghahanap para sa.
Kung ang halaga ang kasalukuyang node ay mas mababa kaysa sa halaga kaming naghahanap para sa,
pumunta ka sa tabi ng karapatan ang bata node.
Kung hindi man, pumunta ka sa kaliwang bata ang node.
Sa ilang mga punto, makikita mo ang alinman mahanap ang halaga na naghahanap ka ng, o makikita mo tumakbo sa isang null,
nagpapahiwatig ang halaga hindi sa tree. "
Mayroon akong redraw tree nagkaroon kami dati, na kailangan kumuha ng isang segundo.
Ngunit nais naming maghanap kung 6, 10, at 1 sa tree.
Kaya kung ano ito ay, 7, 9, 3, 6. Okay.
Ang mga numero na nais mong upang tumingin up, gusto naming maghanap 6.
Paano ito algorithm trabaho?
Well, kami din ng ilang ugat pointer sa aming puno.
At gusto namin pumunta sa root at sabihin, ay ang halaga na katumbas sa halaga na kami ay naghahanap para sa?
Kaya namin ang hinahanap para sa 6, kaya ito ay hindi katumbas.
Kaya palaging kami makapupunta, at ngayon sinasabi namin, okay, kaya 6 ay mas mababa kaysa sa 7.
Ba na ibig sabihin gusto namin upang pumunta sa kaliwa, o nais namin upang pumunta sa kanan?
[Mag-aaral] Kaliwa. >> Oo.
Ito ay makabuluhang mas madali, lahat ng kailangan mong gawin ay gumuhit ng isang posibleng node ng puno
at pagkatapos mo don't - sa halip na sinusubukan na tingin sa iyong ulo,
okay, kung ito ay mas mababa, ako pumunta sa kaliwa o pumunta sa kanan,
lamang ng pagtingin sa ang larawang ito, napakalinaw na mayroon akong pumunta sa kaliwa
kung ang node na ito ay mas mataas kaysa sa halaga na Naghahanap ako.
Kaya pumunta sa kaliwa, ngayon ako sa 3.
Gusto kong - 3 ay mas mababa kaysa sa halaga Naghahanap ako, na 6.
Kaya pumunta kami sa kanan, at ngayon ko magtapos sa 6,
na ang halaga Naghahanap ako, kaya bumalik ako ng totoo.
Ang susunod na halaga ako pagpunta upang hanapin 10.
Okay. Kaya 10, ngayon, ay pagpunta sa - putol na - pagpunta sa sundin ang mga ugat.
Ngayon, 10 ay pagpunta sa mas malaki kaysa sa 7, kaya gusto kong tumingin sa kanan.
Ako pagpunta sa darating sa paglipas dito, 10 na mas malaki kaysa 9,
kaya ako pagpunta sa gusto upang tumingin sa kanan.
Dumating ako sa paglipas dito, ngunit sa paglipas dito ngayon ako sa null.
Ano ang gagawin ko kung ako pindutin null?
[Mag-aaral] Bumalik maling? >> Oo. Hindi ko mahanap 10.
1 ay isang halos katulad na kaso,
maliban lamang na Binaligtad, sa halip na naghahanap
pababa sa kanang bahagi, ako pagpunta sa tumingin sa kaliwang bahagi.
>> Ngayon ko sa tingin namin aktwal na makakuha ng code.
Narito ang kung saan - buksan ang CS50 appliance at i-navigate ang iyong paraan doon,
ngunit maaari mo ring lamang gawin ito sa espasyo.
Marahil ito ay perpekto upang gawin ito sa espasyo,
dahil maaari naming gumagana sa puwang.
"Una kakailanganin naming ang isang bagong uri ng kahulugan para sa isang binary puno node na naglalaman ng mga int halaga.
Gamit ang boilerplate typedef sa ibaba,
lumikha ng isang bagong kahulugan ng uri para sa isang node sa isang binary puno.
Kung hindi ka makaalis. . . "Blah, blah, blah. Okay.
Kaya sabihin ilagay ang boilerplate dito,
typedef struct node, at node. Oo, okay.
Kaya ano ang mga field na kami ay pagpunta sa gusto sa aming node?
[Mag-aaral] int at pagkatapos ay dalawang payo?
>> Int halaga, dalawang payo? Paano ko isulat ang payo?
[Mag-aaral] Struct. >> Ang dapat kong mag-zoom in Oo, kaya struct node * pakaliwa,
at struct node * kanan.
At tandaan ang talakayan mula sa huling beses,
na ito ay hindi gumagawa ng mga kahulugan, ito ay hindi gumagawa ng mga kahulugan,
ito ay hindi gumagawa ng mga kahulugan.
Kailangan mo ang lahat doon upang tukuyin ito recursive struct.
Okay, sa gayon ay ang kung ano ang aming puno ay pagpunta sa hitsura.
Kung ginawa namin ng trinary puno, pagkatapos node ay maaaring magmukhang B1, B2, struct node * B3,
kung saan b ay isang branch - aktwal na, ko na mas narinig ito pakaliwa, gitna, kanan, ngunit kahit anong.
Lamang namin pakialam tungkol sa binary, kaya karapatan, ang natitira.
"Ngayon ay ipinapahayag ng pandaigdigang node * variable para sa ugat ng puno."
Kaya hindi namin upang gawin iyon.
Upang gumawa ng mga bagay bahagyang mas mahirap at mas pangkalahatan,
hindi namin ay may isang global variable node.
Sa halip, sa pangunahing ay ipinapahayag namin ang lahat ng aming mga node bagay,
at na nangangahulugan na sa ibaba, kapag nagsimula kami tumatakbo
aming naglalaman ng function na at ang aming insert function na,
sa halip ng aming mga naglalaman ng function na lang gamit ang global variable node,
kami ay pagpunta sa tumagal ng isang argumento sa puno na gusto naming i-proseso.
Ang pagkakaroon ang global variable ay dapat upang gumawa ng mga bagay madali.
Kami ay pagpunta upang gumawa ng mga bagay mas mahirap.
Ngayon, kumuha nang isang minuto o higit pa upang gawin ito uri ng bagay,
kung saan sa loob ng pangunahing nais mong upang likhain ang tree, at na ang lahat ng gusto mong gawin.
Subukan at bumuo ng mga ito puno sa iyong pangunahing function na.
>> Okay. Kaya hindi mo kahit na itinayo puno ang buong paraan.
Ngunit sinuman ay may isang bagay na maaari kong makuha ang
upang ipakita kung paano maaaring isa magsimulang bumuo ng tulad ng isang puno?
[Mag-aaral] ng banging May, sinusubukan upang makakuha ng out.
[Bowden] Sinuman ay kumportable sa kanilang puno construction?
[Mag-aaral] Oo naman. Hindi tapos na ito. >> Masarap na ito. Maaari lang namin matapos -
oh, maaari mong i-save ang mga ito? Yehey.
Kaya dito mayroon kaming - oh, bahagyang ako cut off.
Ako naka-zoom in?
Mag-zoom in, mag-scroll. >> Mayroon akong tanong. >> Oo?
[Mag-aaral] Kapag mong tukuyin struct, ang mga bagay tulad ng nasimulan sa anumang bagay?
[Bowden] No. >> Okay. Kaya nais mong simulan ang -
[Bowden] No Kapag mong tukuyin, o kapag ikaw ay ipinapahayag struct,
hindi ito nasimulan sa pamamagitan ng default; lang ito i kung ikaw idedeklara ang isang int.
Ito ay eksakto ang parehong bagay. Ito ay tulad ng bawat isa ng mga indibidwal na mga patlang
ay maaaring magkaroon ng isang halaga ng basura sa loob nito. >> At ay posible upang tukuyin - o idedeklara ng struct
sa isang paraan na ito initialize ang mga ito?
[Bowden] Oo. Kaya, shortcut Pinasimulan syntax
ay pagpunta sa hitsura -
Mayroong dalawang mga paraan na maaari naming gawin ito. Tingin ko dapat namin makatipon ito
upang matiyak na kumalatong din ito.
Ang pagkakasunud-sunod ng mga argument na ay sa struct,
inilagay mo bilang ang pagkakasunud-sunod ng mga argumento sa loob ng mga kulot tirante.
Kaya kung nais mong i-initialize ito sa 9 at ang natitira ay walang bisa at pagkatapos karapatan null,
magiging 9, null, null.
Alternatibo ay, at editor ay hindi gusto ang syntax na ito,
at sa tingin nito ay Gusto ko ng isang bagong bloke,
ngunit alternatibo ay isang bagay tulad ng -
dito, makikita ko bang ilagay ang mga ito sa isang bagong linya.
Maaari mong tahasang sabihin, nakalimutan ko ang eksaktong syntax.
Sa gayon maaari mong tahasang tugunan ang mga ito sa pamamagitan ng pangalan, at sabihin,
C, o. Halaga = 9,. Kaliwang = null.
Ako paghula mga pangangailangan upang maging ng mga kuwit.
. Karapatan = null, upang sa ganitong paraan hindi mo gusto
aktwal na kailangan upang malaman ang pagkakasunod-sunod ng struct,
at kung binabasa mo ito, mas tahasang
tungkol sa kung ano ang halaga ay nasimulan sa.
>> Ito ang mangyayari na ang isa sa mga bagay na -
kaya, para sa pinaka-bahagi, C + + ay isang superset ng C.
Maaari mong gawin ang C code, ilipat ito sa C + +, at dapat itong makatipon.
Ito ay isa ng ang mga bagay na C + + ay hindi sumusuporta, kaya mga tao malamang hindi na gawin ito.
Hindi ko alam kung iyon lamang ang dahilan na mga tao malamang hindi na gawin ito,
ngunit ang kaso kung saan kailangan ko upang gamitin ito na kinakailangan upang gumana sa C + + at kaya hindi ko itong gamitin.
Ang isa pang halimbawa ng isang bagay na ay hindi gumagana sa C + + ay
kung paano ang malloc nagbabalik ng "walang bisa *," technically,
ngunit maaari mong sabihin na ang magpasinda * x = malloc anumang,
at ito ay awtomatikong maging cast sa isang pansamantalang trabaho *.
Na awtomatikong cast ay hindi mangyayari sa C + +.
Na hindi makatipon, at nais mong tahasang kailangang sabihin
magpasinda *, malloc, anumang, upang pinalayas ang mga ito sa isang pansamantalang trabaho *.
May mga hindi maraming bagay na C at C + + hindi sumasang-ayon sa,
ngunit ang mga dalawang.
Kaya kami gamit ang syntax na ito.
Ngunit kahit na hindi namin na syntax,
kung ano ang - ay maaaring maging mali na ito?
[Mag-aaral] hindi ko kailangang dereference ito? >> Oo.
Tandaan na ang arrow sa ay may implicit dereference,
at kaya kapag lamang kami pagharap sa isang struct,
gusto naming gamitin. upang makakuha ng sa isang patlang sa loob ng struct.
At lamang ang oras na ginagamit namin arrow kapag gusto naming gawin -
mahusay, arrow ay katumbas -
na kung ano ito nilalayong kung ginamit ko ang arrow.
Maraming arrow ay nangangahulugan, ang dereference ito, ngayon ako sa isang struct, at maaari ko bang makuha ang patlang.
Alinman makuha ang patlang nang direkta o dereference at makuha ang field -
Hulaan ko ito ay dapat na halaga.
Ngunit dito ako pagharap sa lamang struct, hindi isang pointer sa isang struct,
at kaya hindi ko maaaring gamitin ang mga arrow.
Ngunit ang ganitong uri ng bagay ang maaari naming gawin para sa lahat ng mga node.
Oh aking Diyos.
Ito ay 6, 7, at 3.
Pagkatapos ay maaari naming mag-set up ang mga sangay sa aming puno, maaari kaming magkaroon ng 7 -
maaari naming, ang kanyang kaliwa dapat tumuro sa 3.
Kaya kung paano namin gawin iyon?
[Mag-aaral, hindi maintindihan] >> Oo. Ang address ng node3,
at kung hindi ka magkaroon ng address, pagkatapos ito ay hindi makatipon.
Ngunit tandaan na ang mga payo sa sa susunod na node.
Ang karapatang dapat tumuro 9,
at 3 dapat tumuro sa kanan hanggang 6.
Tingin ko ito ay ang lahat ng set. Anumang mga komento o katanungan?
[Mag-aaral, hindi maintindihan] ugat ay pagpunta sa 7.
Maaari lang namin sabihin node * ptr =
o ugat, = & node7.
>> Para sa aming mga layuning pang-, kami ay pagpunta sa pagharap sa insert,
kaya namin ay pagpunta sa gusto mong magsulat ng isang function na upang ipasok sa ito binary puno
at ipasok ang tiyak na tumawag ng malloc upang lumikha ng isang bagong node para sa puno.
Kaya bagay ay pagpunta upang makakuha ng magulo ang katotohanan na ang ilang mga node
ay kasalukuyang sa stack
at iba pang mga node ay pagpunta upang tapusin up sa magbunton kapag namin isingit ang mga ito.
Ito ay perpektong wasto, ngunit ang tanging dahilan
hindi namin magagawang upang gawin ito sa stack
ay dahil ito ay isang contrived halimbawa na alam namin
puno ay dapat na itinayo bilang 7, 3, 6, 9.
Kung hindi namin ginawa ito, hindi namin ay magkakaroon sa malloc sa unang lugar.
Bilang makita namin ng kaunti mamaya, dapat naming malloc'ing.
Sa ngayon perpektong makatwirang upang ilagay sa stack,
ngunit sabihin baguhin ito sa isang pagpapatupad ng malloc.
Kaya ang bawat isa sa mga ito ay ngayon pagpunta sa isang bagay tulad ng
node * node9 = malloc (sizeof (node)).
At ngayon kami ay pagpunta sa gawin ang aming check.
kung ang (node9 == null) - Hindi ko nais na -
bumalik 1, at pagkatapos ay maaari naming gawin node9-> dahil ngayon ang isang pointer,
halaga = 6, node9-> pakaliwa = null,
node9-> kanan = null,
at kami ay pagpunta upang gawin iyon para sa bawat isa ng mga node.
Sa halip, sabihin ilagay ito sa loob ng isang hiwalay na function na.
Sabihin tumawag ito node * build_node,
at ito ay medyo katulad sa mga API na nagbibigay kami para sa Huffman coding.
Kami magbibigay sa iyo ng initializer function para sa isang puno
at deconstructor "function" para sa mga puno at ang parehong para sa kagubatan.
>> Kaya dito kami ay pagpunta sa magkaroon ng isang function na initializer
upang bumuo ng isang node para sa amin.
At ito upang tumingin medyo mas eksakto tulad nito.
At kahit ako na maging tamad at hindi baguhin ang pangalan ng variable,
kahit node9 ginagawang walang kahulugan na ito.
Oh, hulaan ko node9 ang halaga ay hindi dapat 6.
Ngayon ay maaari naming ibalik ang node9.
At dito dapat namin bumalik null.
Ang bawat tao'y sumasang-ayon sa na build-a-node function na?
Kaya ngayon namin lamang tumawag na upang bumuo ng anumang node sa isang ibinigay na halaga at null pointer.
Ngayon ay maaari naming tumawag na, maaari naming gawin node * node9 = build_node (9).
At sabihin gawin. . .
6, 3, 7, 6, 3, 7.
At ngayon, gusto naming i-set up ang parehong mga payo,
maliban ngayon ang lahat na sa mga tuntunin ng pointer
kaya hindi na kailangan ang address ng.
Okay. Kaya kung ano ang huling bagay na gusto kong gawin?
Mayroong isang error-checking na hindi ako ginagawa.
Ano ang bumuo ng node return?
[Mag-aaral, hindi maintindihan] >> Oo. Kung Nabigo ang malloc, bumalik null.
Kaya ako pagpunta sa lazily ilagay ito dito sa halip ng paggawa ng isang kundisyon para sa bawat.
Kung (node9 == null, o - kahit simple,
ito ay katumbas lamang kung hindi node9.
Kaya kung hindi node9, o hindi node6, o hindi node3, o hindi node7, bumalik 1.
Siguro dapat naming i-print ang malloc Nabigo, o isang bagay na.
[Mag-aaral] Ay maling katumbas null pati na rin?
[Bowden] Anumang zero na halaga ay hindi.
Kaya null ay zero na halaga.
Zero ay isang zero na halaga. Maling ay isang zero na halaga.
Anumang - medyo mas lamang ang 2 zero na halaga null at zero,
hindi totoo ay hash tinukoy bilang zero.
Na nalalapat din kung namin idineklara global variable.
Kung ginawa namin node * ugat dito,
pagkatapos - ang magaling na bagay tungkol sa mga pangkalahatang variable ay na sila ay laging magkaroon ng isang paunang halaga.
Na hindi totoo ng mga function, kung paano sa loob ng dito,
kung kami ay may, tulad ng, node * o node x.
Wala kaming ideya kung ano ang x.value, x.whatever,
o maaari naming i-print ang mga ito at maaari nilang arbitrary.
Iyan ay hindi totoo ng mga pangkalahatang variable.
Kaya node ugat o node x.
Sa pamamagitan ng default, ang lahat ng global, kung hindi tahasang nasimulan sa ilang mga halaga,
ay may zero na halaga bilang halaga nito.
Kaya dito, node * ugat, hindi namin tahasang initialize ito sa anumang bagay,
kaya ang kanyang default na halaga ay null, na ang zero na halaga ng mga payo.
Ang default na halaga ng x ay nangangahulugan na x.value ay zero,
x.left ay null, at ay null ang x.right.
Kaya dahil ito ay isang struct, ang lahat ng mga field ng struct zero na halaga.
Hindi namin kailangang gamitin na dito, bagaman.
[Mag-aaral] Ang mga structs ay naiiba kaysa sa iba pang mga variable, at ang iba pang mga variable ay
basura halaga; ito ay zero?
[Bowden] Iba pang mga halaga. Kaya sa x, x ay zero.
Kung sa pandaigdigang saklaw, ito ay isang paunang halaga. >> Okay.
[Bowden] Alinman ang paunang halaga na ibinigay mo ito o zero.
Tingin ko na tumatagal ng pag-aalaga ng lahat ng ito.
>> Okay. Kaya ang susunod na bahagi ng tanong nagtatanong,
"Ngayon gusto naming magsulat ng isang function na tinatawag na naglalaman ng
na may prototype ng bool naglalaman ng int na halaga. "
Hindi namin gawin bool naglalaman int halaga.
Aming prototype ay pagpunta sa hitsura
bool naglalaman (int halaga.
At pagkatapos din kami upang pumasa ito sa puno
na dapat ito ng pagsuri upang makita kung ito ay may halagang iyon.
Kaya node * puno). Okay.
At pagkatapos ay maaari naming tumawag ang mga ito sa isang bagay tulad ng,
siguro namin nais sa printf o isang bagay.
Naglalaman ng 6, ang aming mga ugat.
Na dapat bumalik, o totoo,
kung saan ay naglalaman ng 5 ugat dapat bumalik false.
Kaya kumuha ng isang segundo upang ipatupad ang.
Maaari mong gawin ito sa alinman iteratively o recursively.
Ang magaling na bagay tungkol sa paraan itinakda namin ang mga bagay-bagay ay na
lends mismo sa aming recursive solusyon mas madali
sa ang global variable na paraan ginawa.
Dahil kung lamang namin naglalaman ng int na halaga, pagkatapos ay mayroon kaming walang paraan ng recursing pababa subtrees.
Gusto naming magkaroon ng isang hiwalay na function ng lingkod na recurses ang ang mga subtrees para sa amin.
Ngunit dahil binago namin ito sa tree bilang isang argument,
na dapat na palaging ito sa unang lugar,
ngayon maaari naming recurse mas madali.
Kaya umuulit o recursive, ipagpapatuloy namin sa paglipas ng parehong,
ngunit gagamitin namin makita na recursive dulo up medyo madali.
Okay. Ba ang sinuman ng isang bagay na maaari naming?
>> [Mag-aaral] Mayroon akong isang umuulit solusyon. >> Lahat ng karapatan, umuulit.
Okay, mukhang mahusay na ito.
Kaya, nais na maglakad sa amin sa pamamagitan nito?
[Mag-aaral] Oo naman. Kaya ba akong magtakda ng Temp variable upang makuha ang unang node ng puno.
At pagkatapos ko lang looped sa pamamagitan habang Temp hindi katumbas null,
kaya habang ay pa rin sa tree, hulaan ko.
At kung ang halaga ay katumbas ng ang halaga na Temp ay tumuturo sa,
pagkatapos ay nagbalik ng halagang iyon.
Kung hindi man, sumusuri kung ito ay sa kanang bahagi o sa kaliwang bahagi.
Kung sakaling makakuha ng isang sitwasyon kung saan mayroong hindi hihigit puno,
ito nagbabalik - labasan loop at nagbabalik ng maling.
[Bowden] Okay. Kaya na mukhang mabuti.
Sinuman ay may anumang mga komento sa anumang?
Mayroon akong walang mga komento sa kawastuhan sa lahat.
Ang isang bagay na maaari naming gawin ay ang tao na ito.
Oh, ito ay pagpunta sa pumunta ng kaunti longish.
Ako maayos na up. Okay.
>> Ang bawat tao'y dapat tandaan kung paano tatluhan gumagana.
Nagkaroon ng tiyak na mga pagsusulit sa nakaraan
na nagbibigay sa iyo ng isang function na may isang tatluhan operator,
at sabihin, isalin ito, gawin ang isang bagay na hindi gumagamit ng tatluhan.
Kaya ito ay isang napaka-karaniwang kaso ng kapag Gusto ko tingin na gamitin ang tatluhan,
kung saan kung ang ilang mga kundisyon na magtakda ng isang variable sa isang bagay,
tao nakatakda na parehong variable sa iba pa.
Iyon ay isang bagay na lubhang madalas maaaring transformed sa ganitong uri ng bagay
kung saan-set na variable na ito - o, mahusay, ay ito tunay? Pagkatapos ito, iba pa ito.
[Mag-aaral] Ang unang isa ay kung totoo, i-right?
[Bowden] Oo. Ang paraan ko laging basahin ito ay, Temp katumbas ng halaga na mas mataas kaysa sa Temp halaga,
pagkatapos ito, iba pa ito. Ito na humihiling ng isang tanong.
Ito mas malaki? Pagkatapos gawin ang unang bagay. Iba Pa gawin ang ikalawang bagay.
Ko halos palaging - tutuldok ang, ko lang - sa aking ulo, basahin ko bilang tao.
>> Ba ang sinuman magkaroon ng isang recursive na solusyon?
Okay. Ito kami ay pagpunta sa - ito na maging mahusay,
ngunit kami ay pagpunta upang gawin itong mas mahusay.
Ito ay medyo magkano ang parehong eksaktong ideya.
Lang, na rin, ang gusto mong ipaliwanag?
[Mag-aaral] Oo naman. Kaya kami ay siguraduhin na ang puno ay hindi null unang,
dahil kung puno ay null ito upang bumalik false dahil hindi pa namin ito natagpuan.
At kung mayroong pa rin puno, kami pumunta sa - muna namin suriin kung ang halaga ay ang kasalukuyang node.
Nagbabalik ng tunay na kung ito ay, at kung hindi namin recurse sa kaliwa o kanan.
Ba ng tunog na naaangkop? >> MM-Hmm. (Kasunduan)
Kaya mapapansin na ito ay halos - structurally na halos kapareho sa umuulit solusyon.
Lang na sa halip na recursing, nagkaroon kami ng isang habang loop.
At ang base kaso dito kung saan puno ay hindi katumbas null
ang kondisyon sa ilalim kung saan namin sinira ng loop habang.
Ang mga ito ay halos katulad na. Ngunit hindi namin ay pagpunta sa isang hakbang karagdagang.
Ngayon, gawin namin ang parehong bagay dito.
Mapansin kami bumabalik ang parehong bagay sa parehong mga linyang ito,
maliban sa isang argument ay naiiba.
Kaya kami upang gawing na sa isang tatluhan.
Pindutin ko ang pagpipilian ng isang bagay, at gumawa ng simbolo. Okay.
Kaya kami upang bumalik ay naglalaman na.
Ito ay pagkuha sa maramihang mga linya, well, naka-zoom in ito ay.
Karaniwan, bilang isang pangkakanyahan bagay, hindi ko sa tingin maraming tao
maglagay ng puwang pagkatapos ng arrow, ngunit hulaan ko kung ikaw ay pare-pareho, fine.
Kung ang halaga ay mas mababa kaysa sa halaga ng puno, gusto naming recurse sa kaliwa ng puno,
tao gusto naming recurse sa puno karapatan.
Kaya na hakbang isa ng hitsura ito mas maliit.
Hakbang dalawa ng hitsura ito mas maliit -
namin paghiwalayin ito sa maramihang mga linya.
Okay. Hakbang dalawang ng paggawa ng tumingin ito mas maliit dito,
kaya ang return halaga ay katumbas ng puno halaga, o naglalaman ng anumang.
>> Ito ay isang mahalagang bagay.
Hindi ako sigurado kung sinabi niya ito tahasang sa klase,
ngunit ito ay tinatawag na maikling-circuit pagsusuri.
Ang ideya dito ay halaga == puno value.
Kung iyon ay totoo, ito ay totoo, at gusto naming 'o' na sa anumang ay sa paglipas dito.
Kaya walang kahit iniisip tungkol sa anumang ay sa paglipas dito,
kung ano ang buong expression ng pagpunta upang bumalik?
[Mag-aaral] True? >> Oo, dahil totoo ng anumang bagay na,
ay kinakailangang totoo or'd - o totoo or'd may anumang.
Ito sa lalong madaling makita namin ang return halaga = puno halaga,
lang kami nagbabalik ng tunay.
Hindi kahit pagpunta sa recurse karagdagang naglalaman ang linya.
Namin sa isang hakbang karagdagang.
Bumalik puno hindi katumbas null at lahat ng ito.
Ginawa ito ng isang linya function na.
Din ito ay isang halimbawa ng maikling-circuit pagsusuri.
Ngunit ngayon ito ay ang parehong ideya -
sa halip na - kaya kung puno hindi katumbas null - o, well,
kung puno ang katumbas null, na ang masamang kaso,
kung puno katumbas null, pagkatapos ang unang kondisyon ay pagpunta sa maling.
Kaya maling anded may anumang ay pagpunta sa kung ano ang?
[Mag-aaral] Maling. >> Oo. Ito ang iba pang kalahati ng maikling-circuit pagsusuri,
kung saan kung ang puno ay hindi katumbas null, pagkatapos hindi namin ay pagpunta sa kahit pumunta -
o kung puno ang katumbas null, pagkatapos hindi namin ay pagpunta sa gawin ang halaga == puno halaga.
Lamang kami upang agad na bumalik ang maling.
Na kung saan ay mahalaga, dahil kung ito ay hindi maikling-circuit suriin,
pagkatapos kung puno ang katumbas null, ang ikalawang kondisyon ay pagpunta sa seg kasalanan,
dahil ang tree-> halaga dereferencing null.
Kaya na na. Ito - shift sabay-sabay sa paglipas.
Ito ay isang napaka-karaniwang bagay din, hindi ito isang linya na ito,
ngunit sa isang karaniwang bagay sa mga kondisyon, maaaring hindi dito mismo,
ngunit kung (puno! = null, at tree-> halaga == halaga), gawin ang anumang.
Ito ay isang napaka-karaniwang mga kondisyon, kung saan sa halip ng pagkakaroon ng
buksan ito sa dalawang ifs, kung saan gusto, tree null?
Okay, hindi null, kaya ngayon tree halaga na katumbas ng halaga? Gawin ito.
Sa halip, ang kondisyon na ito, ito ay hindi kailanman seg fault
dahil ito ay masira kung ito ang mangyayari null.
Well, hulaan ko kung ang iyong puno ay isang ganap na di-wastong pointer, maaari pa rin itong seg kasalanan,
ngunit hindi ito maaaring seg kasalanan kung puno ay null.
Kung ito ay null, masira kung bago ka kailanman dereferenced pointer sa unang lugar.
[Mag-aaral] ba itong tinatawag na tamad na pagsusuri?
>> [Bowden] Lazy pagsusuri ay isang hiwalay na bagay.
Lazy pagsusuri ay higit na katulad ng magtanong para sa isang halaga,
hihilingin sa iyo na kalkulahin ang halaga, uri ng, ngunit hindi mo na kailangan ito agad.
Kaya hanggang sa iyong aktwal na kailangan ito, ito ay hindi sinusuri.
Na ito ay hindi eksakto ang parehong bagay, ngunit sa Huffman pset,
sinasabi nito na namin "lazily" magsulat.
Ang dahilan na gawin namin na dahil aktwal kami buffering ang pagpapawalang -
hindi namin nais na isulat ang mga indibidwal na piraso sa isang pagkakataon,
o mga indibidwal na byte sa isang pagkakataon, gusto namin sa halip upang makakuha ng isang tipak ng mga byte.
Pagkatapos sandaling mayroon kaming isang tipak ng mga byte, pagkatapos magpapadala kami sumulat ito.
Kahit na, hinihiling mo ito upang magsulat - at fwrite at fread gawin ang parehong uri ng bagay.
Sila buffer ang iyong bumabasa at nagsusulat.
Kahit mong hilingin ito sa sumulat kaagad, marahil ito ay hindi.
At hindi ka maaaring maging sigurado na ang mga bagay ay pagpunta sa na nakasulat
hanggang sa tawagan ka hfclose o anumang ito ay,
na pagkatapos sabi, okay, ako isara ang aking file,
na nangangahulugan na Gusto ko mas mahusay na isulat ang lahat ng hindi isinulat ko pa.
Ito ay hindi kailangang isulat ang lahat
hanggang sa ikaw ay isara ang file, at pagkatapos ay kailangang.
Kaya na lang kung ano ang tamad - naghihintay ito hanggang sa ito ay may mangyari.
Ito - tumagal 51 at pupunta ka sa ito nang mas detalyado,
dahil OCaml at lahat sa 51, ang lahat ay recursion.
Walang mga umuulit ang mga solusyon, talaga.
Lahat ay recursion, at tamad na pagsusuri
ay magiging mahalaga para sa maraming mga pangyayari
kung saan, kung hindi mo lazily suriin, na ibig sabihin -
Ang halimbawa sa stream, na walang hanggan mahaba.
Sa teorya, maaari mong isipin ng natural na mga numero bilang isang stream ng 1-2-3-4-5-6-7,
Kaya lazily sinusuri bagay ay pinong.
Kung sabihin ko gusto ko ang ikasampung numero, maaari kong suriin up sa ikasampu numero.
Kung gusto ko ang daan numero, pagkatapos ay maaari kong suriin hanggang sa daan bilang.
Nang walang tamad pagsusuri, pagkatapos ito ay pagpunta sa subukan upang pag-aralan ang lahat ng mga numero agad.
Ka pagsusuri ng walang hanggan maraming mga numero, at ito lamang ay hindi posible.
Kaya may maraming ng mga pangyayari kung saan ang tamad pagsusuri
ay mahalaga sa pagkuha ng mga bagay upang gumana.
>> Ngayon gusto namin na magsulat ng insert kung saan ang insert ay magiging
katulad pagbabago sa kahulugan.
Kaya ngayon bool insert (int value).
Kami ay pagpunta upang baguhin na sa bool insert (int value, node * puno).
Aktwal kami upang baguhin na muli sa isang bit, makikita namin makita kung bakit.
At hayaan ang ilipat ang build_node, para sa ano ba nito,
isingit sa itaas kaya hindi namin upang magsulat ng isang function prototype.
Na isang pahiwatig ka na gamit build_node sa insert.
Okay. Kumuha nang isang minuto para sa.
Tingin ko ko nai-save na ang rebisyon kung gusto mong hilahin mula sa,
o, hindi bababa sa, ginawa ko ngayon.
Gusto ko ang isang bahagyang break na mag-isip tungkol sa logic ng insert,
kung hindi ka makapag-isip nito.
Talaga, ay mo lamang kailanman ay pagpasok sa dahon.
Tulad ng, kung isingit ko 1, pagkatapos hindi maaaring hindi ako pagpunta sa pagpasok 1 -
Ko babaguhin ang itim - I'll-pagpasok ng 1 sa paglipas dito.
O kung isingit ko 4, gusto kong pagpasok 4 sa paglipas dito.
Kaya hindi mahalaga kung ano ang ginagawa mo, ka pagpunta sa pagpasok sa isang dahon.
Ang kailangan mo lang gawin ay umulit pababa sa puno hanggang sa makuha mo sa node
na dapat magulang ang node, magulang ang bagong node,
at pagkatapos ay baguhin ang kaliwa o kanang pointer, depende sa kung
ito ay mas malaki kaysa sa o mas mababa kaysa sa kasalukuyang node.
Baguhin na pointer upang tumuro sa iyong bagong node.
Kaya umulit pababa sa puno, gawin ang mga punto ng dahon sa bagong node.
Din isipin ang tungkol sa kung bakit na forbids ang uri ng mga sitwasyon bago,
kung saan binuo ko ang binary puno kung saan ito ay tama
kung mo lamang tumingin sa isang solong node,
ngunit 9 ay sa kaliwa ng 7 kung iterated mo ang lahat ng mga paraan.
Sa gayon ay imposible sa sitwasyong ito, dahil -
tingin tungkol sa pagpasok 9 o isang bagay, sa unang node,
Ako pagpunta upang makita 7 at ako pagpunta sa pumunta sa kanan.
Kaya hindi mahalaga kung ano ang ginagawa ko, kung ako pagpasok sa pamamagitan ng pagpunta sa isang dahon,
at sa dahon gamit ang naaangkop na algorithm,
ito ay magiging imposible para sa akin upang ipasok ang 9 sa kaliwa ng 7
dahil sa lalong madaling pindutin ko ng 7 ako pagpunta sa pumunta sa kanan.
Ba ang sinuman magkaroon ng isang bagay upang magsimula sa?
[Mag-aaral] ko. >> Oo naman.
[Estudyante, hindi maintindihan]
[Iba pang mga mag-aaral, hindi maintindihan]
[Bowden] Ito ay pinapahalagahan. Okay. Nais upang ipaliwanag?
>> [Mag-aaral] Dahil alam namin na namin ang pagpasok
bagong node sa dulo ng puno,
Looped ko sa pamamagitan ng tree iteratively
hanggang Nakatanggap ako sa isang node na tulis sa null.
At pagkatapos ko nagpasya upang ilagay ito sa kanang bahagi o sa kaliwang bahagi
gamit sa karapatang ito na variable; sinabi ito sa akin kung saan upang ilagay ito.
At pagkatapos, mahalagang, ko lang ginawa na huling -
na punto ng Temp node sa bagong node na ito ay paglikha,
alinman sa kaliwang bahagi o sa kanang bahagi, depende sa kung ano ang halaga ay.
Sa wakas, ako magse-set ang bagong mga halaga ng node sa ang halaga ng mga pagsubok.
[Bowden] Okay, kaya ko bang makita ang isang isyu dito.
Ito ay tulad ng 95% ng paraan doon.
Ang isang isyu na nakikita ko, well, ang sinumang iba pa makita ang isang isyu?
Ano ang pangyayari sa ilalim kung saan masira sila ng loop?
[Mag-aaral] Kung Temp ay null? >> Oo. Kaya kung paano mo baliin ng loop kung Temp ay null.
Ngunit ano ang gagawin ko dito?
Ko dereference Temp, na kung saan ay hindi maaaring hindi null.
Kaya ang iba pang mga bagay na kailangan mong gawin ay hindi lamang subaybayan hanggang sa Temp ay null,
na nais mong subaybayan ng magulang sa lahat ng oras.
Gusto din namin node * magulang, hulaan ko maaari naming panatilihin na sa null sa unang.
Ito ay kakaiba pag-uugali para sa ugat ng puno,
ngunit gagamitin namin iyon.
Kung ang halaga ay mas malaki kaysa sa anumang, pagkatapos Temp = Temp karapatan.
Ngunit bago mo ito gawin namin na, magulang = Temp.
O mga magulang na palaging pagpunta sa pantay na Temp? Ay na ang kaso?
Kung Temp ay hindi null, pagkatapos ay ako pagpunta upang ilipat pababa, kahit na ano,
sa isang node kung saan ang Temp ng magulang.
Kaya magulang ang nangyayari na ang Temp, at pagkatapos ay ilipat ko Temp pababa.
Ngayon Temp ay null, ngunit ang mga magulang ng mga puntos sa ang magulang ng bagay na null.
Kaya down na dito, hindi ko nais upang i-set sa katumbas ng 1.
Kaya ko inilipat sa kanan, kaya kung kanan = 1,
at hulaan ko gusto mo ring gawin -
kung ilipat mo sa kaliwa, nais mong i-set sa katumbas ng 0.
O tao kung sakaling ilipat sa kanan.
Kaya kanan = 0. Kung ito ay tama = 1,
ngayon ay nais namin ang magulang na karapatan pointer newnode,
tao gusto naming magulang kaliwa newnode pointer.
Mga tanong sa na?
Okay. Kaya ito ay ang paraan namin - na rin, aktwal na, sa halip ng paggawa nito,
namin kalahati inaasahan mong gamitin build_node.
At pagkatapos ay kung newnode katumbas null, bumalik false.
Na iyon. Ngayon, ito ay kung ano ang aming inaasahan mong gawin.
>> Ito ay kung ano ang mga kawani solusyon gawin.
Hindi sumasang-ayon ako na ito bilang ang "karapatan" na paraan ng pagpunta tungkol dito
ngunit ito ay perpektong pinong at ito gumagana.
Isang bagay na isang maliit na kakaiba na ngayon ay
kung puno ay nagsisimula off bilang null, kami ay pumasa sa isang null puno.
Hulaan ko ito ay depende sa kung paano mo tukuyin ang pag-uugali ng pagpasa sa isang null puno.
Gusto ko isipin na kung pumasa ka sa isang null puno,
pagkatapos pagpasok ng halaga sa isang null puno
dapat lamang na ibalik ang isang puno kung saan ang tanging halaga ay ang solong node.
Mga tao sumasang-ayon sa na? Maaari mong, kung gusto mo,
kung pumasa ka sa isang null puno
at gusto mong magpasok ng isang halaga sa ito, bumalik false.
Ito ay hanggang sa iyo upang tukuyin iyon.
Upang gawin ang unang bagay na sinabi ko at pagkatapos -
maayos, ikaw ay pagpunta sa may problema sa paggawa na, dahil
magiging mas madali kung nagkaroon kami ng pandaigdigang pointer sa bagay,
ngunit hindi namin, kaya kung puno ay null, mayroong walang maaari naming gawin tungkol na.
Maaari lang namin bumalik false.
Kaya ako pagpunta sa baguhin ang insert.
Namin technically ay maaaring baguhin lamang ito dito mismo,
kung paano ito iterating sa paglipas ng mga bagay,
ngunit ako pagpunta upang baguhin ang insert tumagal ng isang node ** puno.
Double payo.
Ano ang ibig sabihin nito?
Sa halip ng pagharap sa mga payo sa node,
ang bagay na ako pupunta na manipulating ang pointer na ito.
Ako pagpunta sa manipulating ito pointer.
Ako pagpunta sa manipulating payo nang direkta.
Ito ay gumagawa ng kahulugan dahil, isipin ang tungkol pababa -
na rin, ngayon ang puntos na ito sa null.
Kung ano ang nais kong gawin ay manipulahin ang pointer upang ituro na hindi null.
Gusto ko ito upang tumuro sa aking bagong node.
Kung ko lang subaybayan ng mga payo sa aking mga payo,
hindi ko kailangan upang subaybayan ng isang pointer ng magulang.
Maaari ko lang subaybayan upang makita kung ang pointer ay tumuturo sa null,
at kung ang pointer ang ay tumuturo sa null,
baguhin ito upang tumuro sa node na gusto ko.
At maaari ba akong baguhin ito dahil mayroon akong isang pointer sa pointer.
Natin makita sa karapatang ito ngayon.
Maaari mong aktwal na gawin ito recursively medyo madali.
Namin nais upang gawin iyon?
Oo, gawin namin.
>> Natin makita ito recursively.
Una, kung ano ang aming base kaso magiging?
Halos palaging aming base kaso; pero sa totoo, ito uri ng nakakalito.
Unang bagay unang, kung (puno == null)
Hulaan ko lang kami upang bumalik false.
Ito ay naiiba mula sa iyong puno pagiging null.
Ito ang pointer sa iyong root pointer pagiging null
na nangangahulugan na ang iyong root pointer ay hindi umiiral.
Kaya pababa dito, kung gawin ko
node * - sabihin lamang muling gamitin ito.
Node * ugat = null,
at pagkatapos ay ako pagpunta upang tawagan ang insert sa pamamagitan ng paggawa ng isang bagay tulad ng,
isingit ang 4 sa & ugat.
Kaya at ugat, kung ang ugat ay isang node *
at ugat ay pagpunta sa isang node **.
Ito ay wasto. Sa kasong ito, puno, hanggang dito,
puno ay hindi null - o insert.
Dito. Tree ay null Hindi; * puno null, na fine
dahil kung ang * puno ay null, pagkatapos ko manipulahin ito
sa ngayon na tumuturo sa kung ano ang gusto ko ito upang tumuro sa.
Ngunit kung ang puno ay null, ibig sabihin ko lang bumaba dito at sinabi null.
Na hindi magkaroon ng kahulugan. Hindi ko maaaring gawin na iyon.
Kung ang puno ay null, bumalik false.
Kaya ko talaga na sinabi kung ano ang aming real base kaso.
At kung ano ang na magiging?
[Estudyante, hindi maintindihan]
[Bowden] Oo. Kaya kung (* puno == null).
Ito ay nauugnay sa ang kaso sa dito
kung saan kung ang aking pulang pointer ang pointer ako nakatuon sa,
kaya tulad ako nakatutok sa pointer na ito, ngayon ako nakatutok sa pointer na ito.
Ngayon ako nakatutok sa pointer na ito.
Kaya kung ang aking pulang pointer, na ang aking node **,
ay kailanman - kung *, ang aking pulang pointer, kailanman null,
na nangangahulugan na ako sa kaso na kung saan ako tumututok sa isang pointer na mga puntos -
ito ay isang pointer na nabibilang sa isang dahon.
Gusto kong baguhin ang pointer na ito upang tumuro sa aking bagong node.
Bumalik sa paglipas dito.
Aking newnode lamang node * n = build_node (halaga)
pagkatapos n, kung n = null, bumalik ang maling.
Iba Pa nais namin upang baguhin kung ano ang pointer ay kasalukuyang tumuturo sa
sa ngayon na ituro sa aming bagong binuo node.
Maaari naming talagang gawin iyon dito.
Sa halip na sinasabi n, sinasabi namin * puno = kung * puno.
Ang bawat tao'y maunawaan na? Na sa pamamagitan ng pagharap sa mga payo sa payo,
Maaari naming baguhin ang null pointer upang tumuro sa mga bagay na gusto naming ang mga ito upang tumuro sa.
Na aming base kaso.
>> Ngayon ang aming pag-ulit, o sa aming recursion,
ay na halos kapareho sa lahat ng iba pang mga recursions namin ang ginagawa.
Kami ay pagpunta sa nais upang ipasok ang halaga,
at ngayon ako pagpunta sa gamitin ang tatluhan muli, ngunit kung ano ang aming kalagayan upang maging?
Ano ang iyong hinahanap namin upang magpasya kung nais namin upang pumunta kaliwa o kanan?
Natin gawin ito sa hiwalay na mga hakbang.
Kung (halaga <) ano?
[Mag-aaral] Ang halagang puno?
[Bowden] Kaya tandaan na ako ay kasalukuyang -
[Mga mag-aaral, hindi maintindihan]
[Bowden] Oo, kaya dito mismo, sabihin nating na berdeng arrow na ito
ay isang halimbawa ng kung ano ang puno kasalukuyang, ay isang pointer na ito pointer.
Sa gayon ay nangangahulugan na Ako ay isang pointer sa isang pointer sa 3.
Dereference ang nang dalawang beses tunog magandang.
Ano ang gagawin ko - paano ko na?
[Mag-aaral] Dereference isang beses, at pagkatapos ay gawin ang arrow na paraan?
[Bowden] Kaya (* tree) sabay-sabay ang dereference, -> halaga
pagpunta sa ninyo akong bigyan ng halaga ng node na hindi direktang ako na tumuturo sa.
Kaya ko ring sumulat ang mga ito ** tree.value kung gusto mo na.
Alinman sa gumagana.
Kung iyon ang kaso, pagkatapos ay gusto kong tumawag isingit na may halaga.
At kung ano ang aking-update node ** magiging?
Gusto kong pumunta sa kaliwa, kaya ** tree.left pagpunta sa aking kaliwa.
At gusto ko ang pointer sa bagay na iyon
upang kung ang kaliwa ang nagtatapos up null pointer,
Maaari kong baguhin ito upang tumuro sa aking bagong node.
>> At sa iba pang mga kaso ay maaaring maging katulad na katulad.
Natin gumawa ng aktwal na ang aking tatluhan ngayon.
Ipasok ang halaga ng kung halaga <(** tree). Halaga.
Pagkatapos nais naming upang i-update ang aming mga ** sa kaliwa,
tao gusto naming upang i-update ang aming mga ** sa kanan.
[Mag-aaral] ba na makuha ang pointer sa pointer?
[Bowden] Tandaan na - ** ang tree.right ay isang node star.
[Mag-aaral, hindi maintindihan] >> Oo.
** Tree.right tulad nito pointer o isang bagay.
Kaya sa pamamagitan ng pagkuha ng isang pointer iyon, na nagbibigay sa akin kung ano ang gusto kong
ng pointer na tao.
[Mag-aaral] ma kami muli kung bakit kami ay gumagamit ng dalawang mga payo?
[Bowden] Oo. Kaya - walang, maaari mo, at na solusyon bago
ay isang paraan na gawin ito nang hindi ginagawa ng dalawang payo.
Kailangan mo upang maunawaan gamit ang dalawang payo,
at ito ay isang mas malinis na solusyon.
Gayundin, mapapansin na, kung ano ang mangyayari kung ang aking puno -
kung ano ang mangyayari kung ang aking mga ugat ay null? Ano ang mangyayari kung gawin ko ito kaso dito mismo?
Kaya node * ugat = null, ipasok 4 sa & ugat.
Ano ang ugat matapos ang?
[Mag-aaral, hindi maintindihan] >> Oo.
Root halaga na 4.
Root kaliwa null, ugat karapatan ay null.
Sa kaso kung saan hindi namin ay pumasa root ayon sa address,
hindi namin maaaring baguhin ang ugat.
Sa kaso kung saan ang tree - kung saan ugat ay null,
lamang namin ay may upang bumalik false. May walang kami.
Hindi namin maaaring magpasok ng isang node sa isang walang laman na puno.
Ngunit ngayon ng aming makakaya; lang namin gumawa ng isang walang laman na puno sa isang one-node puno.
Na kung saan ay karaniwang inaasahang paraan na ito ay dapat na gumana.
>> Bukod dito, ito ay makabuluhang mas maikli sa
pinapanatili pagsubaybay ng magulang, at kaya umulit ang lahat ng mga paraan.
Ngayon ko ang aking mga magulang, at ko na lang ay ang aking pointer ng karapatan ng magulang sa anumang.
Sa halip, kung ginawa namin ito iteratively, ito ay ang parehong ideya na may isang habang loop.
Ngunit sa halip na humarap sa aking magulang pointer,
sa halip ang aking kasalukuyang pointer ay ang bagay
na direktang ako pagbabago upang tumuro sa aking bagong node.
Hindi ako humarap sa kung ito ay nakaturo sa kaliwa.
Hindi ako humarap sa kung ito ay na nakaturo sa kanan.
Lang anumang pointer na ito, ako pagpunta sa itakda ito upang tumuro sa aking bagong node.
Ang bawat tao'y maunawaan kung paano ito gumagana?
Kung hindi bakit gusto naming gawin ito sa ganitong paraan,
ngunit hindi bababa sa na ito gumagana bilang isang solusyon?
[Mag-aaral] Saan kami nagbabalik ng tunay?
[Bowden] Iyon ay marahil dito mismo.
Kung tama namin ipasok ito, nagbabalik ng tunay.
Iba Pa, pababa dito kami ay pagpunta sa nais upang bumalik anumang mga babalik insert.
>> At kung ano ang mga espesyal na tungkol ito recursive function na?
Buntot recursive, kaya hangga't namin makatipon may ilang optimization,
ito kinikilala mo na at hindi mo na makakuha ng isang stack overflow mula sa,
kahit na kung ang aming puno ay may taas ng 10,000 o 10 milyong.
[Estudyante, hindi maintindihan]
[Bowden] sa tingin ko ito ginagawa ito sa Dash - o kung ano-optimize antas
ay kinakailangan para sa isang buntot recursion na makikilala.
Tingin ko ito kinikilala - GCC at kumalatong
din ng iba't ibang mga kahulugan para sa kanilang mga antas ng pag-optimize.
Gusto kong sabihin ito DashO 2, para sigurado na makilala ang buntot recursion.
Ngunit hindi namin - maaari kang bumuo ng tulad ng isang halimbawa ng Fibonocci o isang bagay.
Hindi madaling subukan na ito, dahil ito ay mahirap upang makabuo
isang binary puno na kaya malaki.
Ngunit oo, tingin ko ito DashO 2, na
kung ikaw makatipon may DashO 2, hanapin buntot recursion
at i-optimize na out.
Natin bumalik sa - magpasok ng literal ang huling bagay na kailangan nito.
Sabihin bumalik sa insert sa paglipas dito
kung saan kami ay pagpunta sa gawin ang parehong ideya.
Pa rin ito ng kasiraan ng hindi ganap na pangasiwaan ang
kapag ang root mismo null, o sa nakalipas na entry ay null,
ngunit sa halip ng pagharap sa isang pointer magulang,
sabihin ilapat ang parehong lohika ng pagpapanatiling pointer sa mga payo.
Kung dito namin panatilihin ang aming node ** kuprum,
at hindi namin kailangan upang subaybayan ang mga ito mismo,
ngunit node ** kuprum = & tree.
At ngayon ang aming habang loop ay na habang ang * kuprum hindi katumbas null.
Huwag kailangang subaybayan ng mga magulang.
Huwag kailangan upang subaybayan ang mga kaliwa at kanang.
At makikita ko tumawag ito Temp, dahil na namin ginagamit Temp.
Okay. Kaya kung (halaga> * Temp),
pagkatapos & (* Temp) -> kanan
tao Temp = & (* Temp) -> pakaliwa.
At ngayon, sa puntong ito, pagkatapos ito loop habang,
Ko lang gawin ito dahil maaaring ito madaling mag-isip tungkol sa iteratively kaysa recursively,
ngunit pagkatapos na ito habang loop,
* Temp ang pointer na gusto naming baguhin.
>> Bago nagkaroon kami ng magulang, at gusto naming baguhin ang alinman sa kaliwa ng magulang o karapatan ng magulang,
ngunit kung gusto naming palitan ang karapatan ng magulang,
* Temp ang karapatan ng magulang, at maaari naming baguhin ang mga ito nang direkta.
Kaya pababa dito, maaari naming gawin * Temp = newnode, at na ito.
Kaya notice, ang lahat ng ginawa namin sa ay kumuha ng linya ng code.
Upang subaybayan ng mga magulang sa lahat na ang karagdagang mga pagsusumikap.
Dito, kung lamang namin subaybayan ng pointer sa pointer,
at kahit na gusto namin upang makakuha ng mapupuksa ng lahat ng mga kulot tirante ngayon,
hitsura nito ay magiging mas maikli.
Ito ngayon ay ang eksaktong parehong solusyon,
ngunit mas kaunting mga linya ng code.
Sa sandaling simulan mo ang pagkilala ito bilang isang wastong solusyon,
ring madali sa dahilan tungkol kaysa tulad, okay,
kung bakit ko ito bandila sa int karapatan?
Ano ang na ibig sabihin nito? Oh, ito signifying na
tuwing pumupunta ako sa kanan, kailangan ko upang i-set ang mga ito,
tao kung pumunta ako sa kaliwa kailangan ko upang i-set ito sa zero.
Dito, hindi ko kailangang dahilan tungkol na, lang madali upang isipin ang tungkol.
Mga tanong?
[Mag-aaral, hindi maintindihan] >> Oo.
Okay, kaya sa huling sandali -
Ako hulaan ang isang mabilis at madaling function na maaari naming gawin ay,
let's - magkasama, hulaan ko, subukan at magsulat ng mga naglalaman ng function na
na hindi pakialam kung ito ay isang binary puno ng paghahanap.
Ito ay naglalaman ng function na ay dapat bumalik totoo
kung saanman sa pangkalahatang puno ng binary ay ang halaga na kaming naghahanap ng mga.
Kaya sabihin muna gawin ito recursively at pagkatapos ay namin gawin ito iteratively.
Maaari naming aktwal lamang gawin ito nang magkasama, dahil ito ay talagang maikling.
>> Ano ang aking base kaso pagpunta na?
[Estudyante, hindi maintindihan]
[Bowden] Kaya kung (puno == null), pagkatapos ay kung ano?
[Mag-aaral] Bumalik maling.
[Bowden] Iba Pa, well, hindi ko kailangan ang pang tao.
Kung aking iba pang mga kaso base.
[Mag-aaral] Tree ng halaga? >> Oo.
Kaya kung (tree-> halaga == halaga.
Mapansin kami pabalik sa node *, hindi node ** s?
Ay naglalaman ng hindi kailanman kailangang gumamit ng node **,
dahil hindi namin ang pagbabago ng mga payo.
Lang kami traversing kanila.
Kung nangyari iyon, gusto naming nagbabalik ng tunay.
Iba Pa nais naming sa pagbagtas sa mga bata.
Kaya hindi namin maaaring dahilan tungkol sa kung ang lahat sa kaliwa ay mas
at lahat sa kanan ay mas malaki.
Kaya ano ang aming kundisyon na dito - o, kung ano ang namin gawin?
[Mag-aaral, hindi maintindihan] >> Oo.
Bumalik naglalaman (halaga, puno-> kaliwa)
o naglalaman ng (halaga, puno-> kanan). At na ito.
At mapansin may ilang maiikling circuit pagsusuri,
kung saan kung mangyari namin upang mahanap ang halaga sa kaliwang puno,
hindi namin kailangan upang tumingin sa kanang puno.
Iyon ang buong function na.
Ngayon sabihin gawin ito iteratively,
na na mas magaling.
Kukunin namin ang karaniwang simula ng node * kuprum = puno.
Habang (kuprum! = Null).
Mabilis na pagpunta upang makita ang isang problema.
Kung kuprum - dito, kung namin kailanman masira ito,
pagkatapos kami maubusan ng mga bagay upang tumingin sa, kaya bumalik false.
Kung (kuprum-> halaga == halaga), nagbabalik ng tunay.
Sa ngayon, hindi namin sa isang lugar -
hindi namin alam kung gusto namin upang pumunta pakaliwa o pakanan.
Sa mang, sabihin pumunta lamang sa kaliwa.
Malinaw naman ako ay tumatakbo sa isang isyu kung saan ganap ko ang inabandunang lahat -
Ako lamang kailanman suriin ang kaliwang bahagi ng isang puno.
Hindi ko lagyan ng anumang bagay na kanang bata ng anumang bagay na.
Paano ko ito aayusin?
[Mag-aaral] Mayroon kang upang subaybayan ang kaliwa at kanang sa isang stack.
[Bowden] Oo. Kaya sabihin gawin itong
struct listahan, node * n, at pagkatapos node ** susunod?
Tingin ko na gumagana fine.
Gusto naming upang pumunta sa kaliwa, o let's - up dito.
Struct listahan = listahan, ito ay simulan
sa struct listahan na ito.
* Listahan = null. Kaya na na ang aming naka-link na listahan
ng mga subtrees na namin nilaktawan sa paglipas ng.
Kami ay pagpunta sa pagbagtas sa kaliwa ngayon,
ngunit dahil hindi maaaring hindi namin kailangan upang bumalik sa kanan,
Kami ay pagpunta upang panatilihin ang kanang bahagi sa loob ng aming mga listahan ng struct.
Pagkatapos ay kakailanganin naming new_list o struct,
struct listahan *, new_list = malloc (sizeof (listahan)).
Pupunta ako upang balewalain ang error-check na, ngunit dapat mong suriin upang makita kung ito ay null.
New_list ang node na ito upang tumuro sa -
oh, na kung bakit gusto ko ito dito. Ito ay upang tumuro sa isang pangalawang listahan ng struct.
Iyon lang kung paano link ang listahan ng trabaho.
Ito ay ang parehong bilang isang int link na listahan
maliban lang kami pinapalitan int node *.
Ito ay eksakto ang parehong.
Kaya new_list, ang halaga ng aming new_list node,
ay na kuprum-> kanan.
Ang halaga ng aming new_list-> susunod na ang aming orihinal na listahan,
at pagkatapos kami ay i-update ang aming listahan upang tumuro sa new_list.
>> Ngayon kailangan namin ng ilang uri ng paraan ng paghila bagay,
tulad namin na traversed ang buong kaliwang subtree.
Ngayon ay kailangan namin upang hilahin ang mga bagay nito,
tulad kuprum null, hindi namin nais na lamang bumalik sa maling.
Gusto naming ngayon hilahin labas sa aming bagong listahan.
Isang maginhawang paraan ng paggawa nito - maayos, aktwal na, may maramihang mga paraan ng paggawa nito.
Sinuman ay isang mungkahi?
Saan ko dapat gawin ito o kung paano dapat kong gawin ito?
Lamang kami ng ilang minuto, ngunit ang anumang mga mungkahi?
Sa halip na - isang paraan, sa halip ng aming kundisyon pagiging habang,
kung ano Kasalukuyan kaming naghahanap sa ay hindi null,
sa halip namin ay pagpunta upang magpatuloy upang pumunta hanggang ang aming listahan mismo ay null.
Kaya kung ang aming listahan ay nagtatapos pagiging null,
pagkatapos namin maubusan ng mga bagay upang tumingin para sa, upang maghanap sa.
Ngunit na ay nangangahulugan na ang unang bagay na sa aming listahan ay lamang ang unang node.
Ang unang bagay ay - hindi na namin kailangan upang makita na.
Kaya listahan-> n ay ang aming puno.
listahan-> susunod ay pagpunta sa maging null.
At ngayon habang listahan ay hindi katumbas null.
Cur ay pagpunta upang hilahin ng isang bagay mula sa aming listahan.
Kaya kuprum ay pagpunta sa pantay na listahan-> n.
At pagkatapos ay listahan ng pagpunta sa pantay na listahan-> n, o listahan-> susunod.
Kaya kung kuprum halaga ay katumbas ng halaga.
Ngayon ay maaari naming magdagdag ng parehong ang aming karapatan pointer at ang aming kaliwa pointer
hangga't hindi null.
Down dito, hulaan ko dapat naming gawin na sa unang lugar.
Kung (na kuprum> karapatan! = Null)
pagkatapos namin ipasok na node sa aming listahan.
Kung (kuprum-> kaliwa), ito ay isang maliit na bit ng dagdag na trabaho, ngunit ito ay pinong.
Kung (kuprum-> kaliwa! = Null),
at kami ay pagpunta upang ipasok ang pakaliwa sa aming listahan ng link,
at na dapat ito.
Namin umulit - hangga't mayroon kaming isang bagay sa aming listahan,
kami ay may isa pang node tingnan.
Kaya tinitingnan namin na node,
advance namin ang aming listahan sa susunod na.
Kung ang node na ay ang halaga na kaming naghahanap ng mga, maaari naming nagbabalik ng tunay.
Iba Pa isingit ang aming parehong kaliwa at kanang subtrees,
hangga't hindi null, sa aming listahan
sa gayon ay hindi maaaring hindi namin pumunta sa ibabaw ng mga ito.
Kaya kung sila ay hindi null,
kung ang aming ugat pointer tulis sa dalawang bagay,
sa unang nakuha namin ang isang bagay kung gayon ang aming listahan ay nagtatapos pagiging null.
At pagkatapos ay inilalagay namin ang dalawang bagay pabalik sa, kaya ngayon ang aming listahan ng laki 2.
Pagkatapos kami ay pagpunta sa loop-back up at lang kami upang hilahin,
sabihin nating, ang kaliwang pointer ng aming mga root node.
At na kailangan lamang panatilihin ang nangyayari, ipapadala namin sa looping sa paglipas ng lahat.
>> Pansinin na ito ay makabuluhang mas komplikado
sa recursive solusyon.
At ako sinabi nang maraming beses
na ang recursive solusyon ay karaniwang may mas sa karaniwan na may solusyon ang umuulit.
Narito ito ay eksakto kung ano ang recursive solusyon ay ginagawa.
Ang tanging pagbabago ay ang sa halip na nang kataon lamang gamit ang stack, ang mga programa ng stack,
bilang iyong paraan ng pagpapanatiling ng track kung ano ang node kailangan mo pa ring bisitahin,
ngayon mayroon kang tahasang gumamit ng isang naka-link na listahan.
Sa parehong mga kaso ikaw ay pinapanatiling subaybayan ang kung ano node pa rin kailangang binisita.
Sa recursive kaso lang madali dahil may isang stack
ay ipinapatupad para sa iyo bilang ng stack ng programa.
Pansinin na ito ay naka-link na listahan, ito ay isang stack.
Anuman lang namin ilagay sa ang stack
ay agad kung ano ang namin ang pagpunta sa mga pull off ang stack upang bisitahin ang susunod.
Humihingi kami ng oras, ngunit ang anumang mga katanungan?
[Estudyante, hindi maintindihan]
[Bowden] Oo. Kaya kung mayroon namin ang aming naka-link listahan,
kasalukuyang upang ituro sa tao na ito,
at ngayon lamang namin ang pagsulong ng aming naka-link na listahan mag-focus sa tao na ito.
Traversing Kami ay sa ibabaw ng naka-link na listahan sa na linya.
At pagkatapos ay hulaan ko dapat magbakante namin ang aming naka-link na listahan at mga bagay-bagay
isang beses bago bumalik true o false, kailangan namin
umulit sa aming listahan ng link at laging down na dito, hulaan ko,
kung namin kuprum ay hindi katumbas ng, idagdag ito, kaya ngayon ay gusto naming magbakante
kuprum dahil, well, ay namin ganap na kalimutan tungkol sa listahan? Oo.
Kaya na kung ano ang gusto naming gawin dito.
Nasaan ang pointer?
Cur ay pagkatapos - gusto namin sa isang listahan ng struct * 10 katumbas ng listahan ng susunod.
Libreng listahan, listahan = Temp.
At sa kaso kung saan bumalik kami totoo, hindi namin kailangan upang umulit
sa ibabaw ng natitira sa aming mga naka-link na listahan pagbabakante bagay.
Ang gandang bagay tungkol sa recursive solusyon pagbabakante bagay
lamang ay nangangahulugan na ang popping factorings off ang stack na mangyari para sa iyo.
Kaya kami nawala mula sa isang bagay na tulad ng 3 linya ng hard-to-tingin-tungkol code
sa isang bagay na makabuluhang maraming iba pang mga hard-sa-tingin-tungkol sa mga linya ng code.
Anumang higit pang mga tanong?
Ayos lang. Humihingi kami ng mabuti. Bye!
[CS50.TV]