>> [MUSIC nagpe-play]
>> Rob BOWDEN: Hi.
Ako Rob.
At sabihin na solusyon na ito out.
Kaya dito kami ay pagpunta sa ipatupad isang pangkalahatang table.
Nakita namin na ang struct node ng aming talahanayan ay pagpunta sa ganito ang hitsura.
Kaya ito ay pagpunta sa magkaroon ng isang pansamantalang trabaho salita hanay ng mga laki LENGTH + 1.
Huwag kalimutan ang + 1, dahil ang maximum salita sa diksyunaryo ay 45
character.
At pagkatapos ay kami ay pagpunta sa kailangan isang extrang character para sa backslash zero.
>> At pagkatapos ay aming hashtable sa bawat bucket ay pagpunta sa mag-imbak ng
naka-link na listahan ng mga node.
Kami ay hindi gumagawa ng linear probing dito.
At kaya upang mai-link sa susunod sangkap sa mga bucket, kailangan namin ng isang
struct node * susunod.
OK.
Kaya na kung ano ang hitsura ng isang node tulad.
>> Ngayon dito ay ang deklarasyon sa aming mga hashtable.
Ito ay pagpunta sa may 16,834 mga bucket.
Ngunit ang numerong iyon ay hindi talagang mahalaga.
At sa wakas, kami ay pagpunta sa may global variable na laki hashtable, na
Pupunta upang simulan off bilang zero.
At ito ay pagpunta sa masubaybayan kung gaano maraming mga salita ay nasa aming diksyunaryo.
>> Kaya ipaalam sa tumagal ng isang pagtingin sa pag-load.
Pansinin na load, nagbabalik ito ng isang bool.
Ikaw nagbabalik ng tunay na kung matagumpay na ito ay load, at hindi totoo kung hindi man.
At ito ay tumatagal ng isang const pansamantalang trabaho * diksyonaryo, kung saan ay ang diksyunaryo
na nais naming buksan.
Kaya iyon ang unang bagay kami ay pagpunta sa gawin.
>> Kami ay pagpunta sa fopen ang diksyunaryo para sa pagbabasa.
At kami ay pagpunta sa may upang gumawa ng siguraduhin na ito ay nagtagumpay.
Kaya kung ibinalik ito null, pagkatapos kami ay hindi Matagumpay na buksan ang diksyunaryo.
At kailangan namin upang bumalik hindi totoo.
Ngunit sa pag-aakala na matagumpay na ginawa ito bukas, pagkatapos ay nais naming basahin ang
diksiyunaryo.
Kaya panatilihin looping hanggang sa mahanap namin ang ilang dahilan upang masira papalabas sa loop,
kung saan ipapakita namin makita.
Kaya panatilihin looping.
>> At ngayon kami ay pagpunta sa malloc isang solong node.
At syempre kailangan namin upang maisahimpapawid suriin muli.
Kaya kung mallocing ay hindi magtagumpay, pagkatapos ay gusto naming mag-ibis anumang node na namin
nangyari bago sa malloc, isara ang diksyunaryo at bumalik hindi totoo.
Ngunit hindi papansin ang na, sa pag-aakala namin nagtagumpay, pagkatapos ay nais naming gamitin fscanf
basahin ang isang solong salita mula sa aming diksyunaryo sa aming mga node.
Kaya tandaan na ang entry> salita ay ang pansamantalang trabaho salita buffer ng laki LENGHTH + 1
na aming pagpunta upang i-imbak ang salitang in
>> Kaya fscanf ay pagpunta upang bumalik 1, hangga't dahil ito ay matagumpay na mai-
basahin ang isang salita mula sa file.
Kung nangyari ang alinman sa isang error, o namin maabot ang dulo ng file,
Hindi nagbabalik 1.
Sa aling mga kaso hindi ito bumalik 1, sa wakas kami ay pagpunta sa magsimula ng
ito habang loop.
Kaya nakikita natin na sa sandaling matagumpay na mayroon kami basahin ang isang salita sa
entry> salita, pagkatapos kami ay pagpunta sa na salita gamit ang aming hash.
>> Hayaan ang kumuha ng isang pagtingin sa ang hash.
Kaya huwag talagang kailangan mo upang maunawaan ito.
At talagang nakuha lang namin ito ng hash gumana mula sa internet.
Ang tanging bagay na kailangan mo upang makilala ang na ito ay tumatagal ng isang const pansamantalang trabaho * salita.
Kaya tumatagal string na ito bilang input, at bumabalik isang wala pang kontratang int bilang output.
Kaya iyon ang lahat ng hash function na ay, ay ito tumatagal sa isang input at nagbibigay sa iyo ng isang
index sa hashtable.
>> Pansinin na aming moding sa pamamagitan ng NUM_BUCKETS, kaya ibinalik na halaga na
talaga ay isang index sa hashtable at hindi ini-index nang higit sa
hanggahan ng array.
Kaya ibinigay na function, kami ay pagpunta sa hash ang salita na aming basahin ang
diksiyunaryo.
At pagkatapos ay kami ay pagpunta sa gamitin na hash upang ipasok ang
entry sa hashtable.
>> Hashtable Ngayon hash ay ang kasalukuyang listahan na naka-link sa talahanayan.
At ito ay napaka-posible na ito ay para lamang null.
Gusto naming upang ipasok ang aming entry sa simula ng ito na naka-link listahan.
At kaya kami ay pagpunta sa may aming kasalukuyang entry point sa kung ano ang hashtable
Kasalukuyang nagtuturo sa.
At pagkatapos ay kami ay pagpunta upang mag-imbak, sa hashtable sa
hash, ang kasalukuyang entry.
Kaya matagumpay na ipasok ang dalawang mga linya ang entry sa simula ng
naka-link na listahan sa index na sa hashtable.
>> Sa sandaling tapos na kami doon, alam namin nakakita kami ng isa pang salita sa
diksyonaryo, at dinagdagan namin muli.
Kaya panatilihin namin ang paggawa na hanggang fscanf sa wakas ay ibinalik ng isang bagay na hindi pang-1 sa
na kung saang tandaan na kailangan namin upang palayain entry.
Kaya hanggang dito malloced kami ng isang entry.
At sinubukan naming basahin ang isang bagay mula sa diksyunaryo.
At kami ay hindi matagumpay na basahin isang bagay mula sa diksyonaryo, sa
Kung saan kailangan namin upang palayain ang entry na talaga namin kailanman ilagay sa
hashtable, at sa wakas ay masira.
>> Sa sandaling magsimula namin na kailangan namin upang makita, mahusay, ay masira kami out dahil mayroong
ay isang error sa pagbabasa mula sa file?
O kaya ay masira out namin dahil kami Naabot ang dulo ng file?
Kung nagkaroon ng error, at pagkatapos ay gusto naming ibalik hindi totoo.
Dahil ang pag-load ay hindi magtagumpay.
At sa proseso ng gusto naming alisan ng bala lahat ng mga salita na binabasa namin sa, at
isara ang file na diksiyunaryo.
>> Sa pag-aakala namin ginawa magtagumpay, pagkatapos namin lamang kailangan pa rin upang isara ang diksyunaryo
maghain, at sa wakas ay nagbabalik ng tunay na mula noong namin Matagumpay na na-load sa diksyunaryo.
At na ito para sa pag-load.
Kaya ngayon suriin, bibigyan ng load hashtable, ay pagpunta sa ganito ang hitsura.
Kaya tingnan, nagbabalik ito ng isang bool, na pagpunta upang ipahiwatig kung ang pumasa sa mga
sa pansamantalang trabaho * salita, kung ang pumasa sa mga sa string ay nasa aming diksyunaryo.
Kaya kung ito ay nasa sa diksyunaryo, kung ito ay nasa aming hashtable,
magkakaroon kami nagbabalik ng tunay.
At kung hindi, magkakaroon kami bumalik hindi totoo.
>> Given ito nakapasa sa salita, kami ay pagpunta sa hash ang salita.
Ngayon isang mahalagang bagay upang makilala ang na sa pagkarga Alam namin na ang lahat ng mga
salita kami ay pagpunta sa maging mas mababa kaso.
Ngunit dito kami ay hindi kaya sigurado.
Kung tumagal kami ng isang tumingin sa aming hash, ang aming hash talaga
ay mas mababa casing bawat karakter ng salita.
Kaya anuman ang capitalization ng salita, ang aming hash ay ang pagbalik
ang parehong index para sa anumang mga capitalization ay, gaya ng ang mga ito ay may
ibinalik para sa isang ganap na lowercase bersyon ng salita.
Mabuti na.
Iyon lang ang aming index ay sa hashtable para sa salitang ito.
>> Ngayon na ito para sa loop ay pagpunta sa umulit sa ibabaw ng naka-link na listahan
na noon ay sa index iyon.
Kaya't mapapansin ay Sinisimulan namin entry upang tumuro sa index iyon.
Kami ay pagpunta upang magpatuloy habang entry! = null.
At tandaan na ina-update ang pointer sa aming mga naka-link na listahan entry = entry> susunod.
Kaya mayroon aming kasalukuyang entry point sa ang susunod na item sa naka-link na listahan.
>> Kaya para sa bawat entry sa naka-link na listahan, kami ay pagpunta sa gamitin strcasecmp.
Ito ay hindi strcomp.
Dahil sa sandaling muli, nais naming gawin kaso bagay insensitively.
Kaya ginagamit namin strcasecmp upang ihambing ang salita na dumaan sa ito
function na laban sa mga salita na sa entry.
Kapag bumalik ito sa zero, ibig sabihin nagkaroon isang tugma, kung saan nais naming
nagbabalik ng tunay.
Kami matagumpay nahanap ang salita sa aming hashtable.
>> Kung nagkaroon hindi isang tugma, pagkatapos kami ay pagpunta sa loop muli at tumingin sa
susunod na entry.
At patuloy kaming looping habang doon mga entry sa naka-link na ito listahan.
Ano ang mangyayari kung masira namin out na ito para sa loop?
Nangangahulugan iyon na hindi kami nakahanap ng isang entry na tugmang salita na ito, kung saan
bumalik kami huwad upang ipahiwatig na ang aming hashtable Hindi naglalaman ang salitang ito.
At na ang isang tseke.
>> Kaya ipaalam sa tumagal ng isang pagtingin sa laki.
Laki Ngayon ay magiging kaakit-akit simple.
Dahil tandaan sa pag-load, para sa bawat salita nahanap namin, incremented kami ng isang global
variable na laki hashtable.
Kaya ang function ng laki ay lamang ng pagpunta upang bumalik global variable.
At na ito.
>> Ngayon sa wakas, kailangan naming mag-ibis ang diksyunaryo-sabay ang lahat ng bagay tapos na.
Kaya paano kami makapupunta sa gawin iyon?
Mag-right dito kami looping sa ibabaw lahat ng mga bucket ng aming table.
Kaya may mga NUM_BUCKETS bucket.
At para sa bawat naka-link na listahan sa aming hashtable, kami ay pagpunta sa loop sa ibabaw
ang kabuuan ng mga naka-link na listahan, pagbabakante bawat elemento.
>> Ngayon kailangan namin upang maging maingat.
Kaya dito mayroon kaming isang pansamantalang variable na pag-iimbak ang pointer sa susunod
elemento sa naka-link na listahan.
At pagkatapos ay kami ay pagpunta sa libreng ang kasalukuyang elemento.
Kailangan naming siguruhin ang ginagawa namin ito dahil kami Hindi maaaring lamang palayain ang kasalukuyang elemento
at pagkatapos ay subukang i-access ang susunod na pointer, dahil sa sandaling na-nabakante namin ito,
nagiging di-wasto ang memory.
>> Kaya kailangan namin upang panatilihin sa paligid ng isang pointer upang sa susunod na elemento, pagkatapos ay maaari naming palayain ang
kasalukuyang elemento, at pagkatapos ay maaari naming i-update aming kasalukuyang elemento upang tumuro sa
sa susunod na elemento.
Kami na magugustuhan loop habang mayroong mga elemento sa naka-link na listahan.
Gagawin namin ang na para sa lahat na naka-link mga listahan sa hashtable.
At sa sandaling tapos na kami sa na, hindi namin ganap deskargado ang hashtable, at
tapos na kami.
Kaya imposibleng para sa alisan ng bala upang kailanman bumalik hindi totoo.
At kapag tapos na kami, namin bumalik lang totoo.
>> Bigyan ng solusyon ang isang try Hayaan.
Kaya ipaalam sa tumagal ng isang pagtingin sa kung ano ang aming struct node magiging hitsura.
Narito makita namin kami ay pagpunta sa magkaroon ng isang bool salita at isang struct node * mga bata
bracket alpabeto.
Kaya ang unang bagay na maaari mong nagtataka, kung bakit ay alpabeto
ed tinukoy bilang 27?
Well, tandaan na kami ay pagpunta sa kailangan na paghawak ng mga kudlit.
Kaya na pupuntahan na medyo ng isang espesyal na kaso sa buong programa na ito.
>> Ngayon tandaan kung paano ang isang trie talaga gumagana.
Sabihin nating kami sa paglilista ng salita "Cats." Pagkatapos mula sa root ng trie,
kami ay pagpunta sa tumingin sa mga bata array, at kami ay pagpunta sa tumingin sa
index na tumutugon sa titik C. Kaya na mai-index 2.
Kaya ibinigay na, kalooban na bigyan kami ng isang bagong node.
At pagkatapos ay makikipagtulungan kami mula sa na node.
>> Kaya ibinigay na node, kami ay isang beses muli pagpunta sa tumingin sa mga anak ng array.
At kami ay pagpunta upang tumingin sa index zero upang tumugma sa A sa pusa.
Kaya pagkatapos kami ay pagpunta upang pumunta sa na node, at ibinigay na node kami ay pagpunta
upang tumingin sa dulo ito ay isang tumutugon sa T. At gumagalaw sa sa na node,
sa wakas, ganap namin ay tumingin sa pamamagitan ng aming salitang "pusa." At ngayon bool
salita ay dapat na ipahiwatig kung ito ibinigay na salita ay tunay na isang salita.
>> Kaya bakit kailangan namin na espesyal na kaso?
Well kung ano ng salitang "sakuna" ay nasa aming diksyunaryo, ngunit ang
salitang "pusa" ay hindi?
Kaya at naghahanap upang makita kung ang salitang "pusa" ay sa aming diksyonaryo, kami ay
pagpunta sa matagumpay na tingnan ng masinsinan ang mga indeks ng C-A-T sa rehiyon na node.
Ngunit iyon ay dahil lamang sakuna nangyari upang lumikha ng mga node sa paraan
mula C-A-T, ang lahat ng mga paraan upang sa dulo ng salita.
Kaya bool salita ay ginagamit upang ipahiwatig kung ang ito partikular na lokasyon
talaga ay nagpapahiwatig ng isang salita.
>> Ayos lang.
Kaya ngayon na alam namin kung ano ito ay trie pagpunta sa hitsura, tingnan natin ang ipaalam
load ang function.
Kaya pagkarga ay pagpunta upang magbalik ng bool para kung namin matagumpay o
unsuccessfully load ang diksyunaryo.
At ito ay magiging diksyunaryo na gusto naming i-load.
>> Kaya unang bagay na ikaw ay naming gawin ay bukas up na diksyunaryo para sa pagbabasa.
At mayroon kaming upang tiyakin hindi namin ginawa mabibigo.
Kaya kung ang diksiyonaryo ay hindi Matagumpay na nabuksan, at ibabalik ito
null, kung saan kami ay pagpunta sa bumalik hindi totoo.
Ngunit sa pag-aakala na ito matagumpay binuksan, pagkatapos ay maaari naming talagang basahin
sa pamamagitan ng diksyunaryo.
>> Kaya unang bagay na kami ay pagpunta sa gusto lang gawin ay mayroon kaming na ito
global variable na ugat.
Ngayon ugat ay magiging isang node *.
Ito ay sa tuktok ng aming trie na kami pagpunta sa ma-iterating sa pamamagitan ng.
Kaya ang unang bagay na aming pagpunta sa gusto lang gawin ay magtalaga ng
memory para sa aming mga ugat.
Pansinin na ginagamit namin ang calloc function, na kung saan ay isa lamang ang parehong
bilang ang malloc function, maliban ito ay garantisadong upang magbalik ng bagay na
ganap zeroed out.
Kaya kung ginamit namin malloc, gusto naming i- pumunta sa pamamagitan ng lahat ng mga mungkahi ukol sa aming mga
node, at tiyakin na ang mga ito ay lahat null.
Kaya ang gagawin calloc na para sa amin.
>> Ngayon tulad ng malloc, kailangan naming gumawa Tiyakin na ang paglalaan ay talagang
matagumpay.
Kung ito ibinalik null, pagkatapos namin kailanganin mong isara o diksyunaryo
maghain at bumalik hindi totoo.
Kaya kung ipagpalagay na laang-gugulin na matagumpay, kami ay pagpunta sa gumamit ng isang node *
cursor upang umulit sa pamamagitan ng aming trie.
Kaya aming Roots hindi kailanman pagpunta sa magbago, ngunit kami ay pagpunta upang gamitin ang cursor sa
talaga pumunta mula sa node sa node.
>> Kaya sa na ito para sa loop na binabasa namin sa pamamagitan ng file diksiyunaryo.
At aming ginagamit fgetc.
Fgetc ay pagpunta sa grab isang solong karakter mula sa file.
Kami ay pagpunta sa magpatuloy daklot character habang hindi namin maabot ang
dulo ng file.
>> Mayroong dalawang mga kaso na kailangan namin upang mahawakan.
Ang una, kung ang karakter ay hindi isang bagong linya.
Upang malaman namin kung ito ay isang bagong linya, pagkatapos ay Ikinalulungkot namin tungkol sa paglipat sa isang bagong salita.
Ngunit sa pag-aakala ay hindi ito isang bagong linya, pagkatapos ay dito gusto naming malaman kung ang
index namin ang pagpunta sa index sa sa mga anak ng array na
itinuturing namin ang bago.
>> Kaya, tulad ng sinabi ko dati, kailangan naming i- espesyal na kaso ang kudlit.
Pansinin na aming ginagamit ang tatlong bagay operator dito.
Kaya kami ay pagpunta sa basahin ito bilang, kung ang character na binabasa namin sa isang
kudlit, pagkatapos kami ay pagpunta upang i-set index = "alpabeto" -1, na
maging index 26.
>> Iba Pa, kung ito ay hindi isang kudlit, mayroong kami ay pagpunta upang itakda ang index
katumbas ng c - isang.
Kaya tandaan pabalik mula sa dati p-sets, c - isang ay pagpunta sa bigyan kami ng mga
alpabetikong posisyon ng C. Kaya kung C ay ang letrang A, aabutin ang
bigyan kami ng index zero.
Para sa titik B, ito ay magbibigay sa amin index 1, at iba pa.
>> Kaya ito ay nagbibigay sa amin ng index sa mga anak ng array na gusto namin.
Ngayon kung ito index ay kasalukuyang null sa ang mga anak, ay nangangahulugan na na ang isang node
Sa kasalukuyan ay hindi umiiral mula ang path na iyon.
Kaya kailangan naming maglaan isang node para ang path na iyon.
Iyon ay kung ano ang gagawin namin dito.
>> Kaya kami ay pagpunta sa muli gamitin ang calloc function, kaya na namin Hindi mo na kailangang
Zero ang lahat ng mga payo.
At muli kailanganin naming suriin na calloc ay hindi mabibigo.
Kung calloc nabigo, pagkatapos kailangan namin upang mag-ibis ang lahat ng bagay, isara ang aming
diksyonaryo, at ibalik hindi totoo.
Kaya sa pag-aakala na hindi ito mabibigo, at pagkatapos ay ito ay lilikha ng bagong bata para sa amin.
At pagkatapos ay magpapatuloy kami sa bata na iyon.
Ang aming cursor ay umulit pababa sa bata na iyon.
>> Ngayon kung hindi ito ay walang bisa upang magsimula sa, pagkatapos ay ang cursor maaari lamang umulit
pababa sa bata na walang tunay pagkakaroon upang magtalaga ng kahit ano.
Ito ay ang kaso kung saan unang namin ang nangyari maglaan ang salitang "pusa." At
Nangangahulugan itong kapag tayo pupunta maglaan "Sakuna," ay hindi kami kailangan upang lumikha ng
node para sa C-A-T muli.
Sila ay umiiral na.
>> Ano ang tao?
Ito ang kalagayan kung saan c noon ay backslash n, kung saan c ay isang bagong linya.
Ang ibig sabihin nito na matagumpay na mayroon kami Nakumpleto ang isang salita.
Ngayon kung ano ang gusto naming gawin kapag kami Matagumpay na nakumpleto ang isang salita?
Kami ay pagpunta sa gamitin ang salita patlang sa loob ng aming struct node.
Gusto naming i-set na sa totoo.
Kaya na nagpapahiwatig na ito node ay nagpapahiwatig ng isang matagumpay na
salita, isang aktwal na salita.
>> Ngayon nakatakda na sa totoo.
Gusto naming upang i-reset ang aming cursor sa punto upang muli sa simula ng trie.
At sa wakas, dinagdagan ng aming diksyunaryo laki, dahil nakakita kami ng isa pang trabaho.
Kaya kami ay pagpunta upang panatilihin ang paggawa na iyon, pagbabasa sa katangian ng karakter,
bumubuo ka ng mga bagong nodes sa aming trie at para sa bawat salita sa diksyunaryo, hanggang sa
sa wakas namin maabot C! = EOF, kung saan kaso masira kami sa labas ng file.
>> Ngayon mayroong dalawang mga kaso sa ilalim na maaring pindutin namin EOF.
Ang una ay kung nagkaroon ng error pagbabasa mula sa file.
Kaya kung nagkaroon ng error, namin kailangan na gawin ang tipikal.
Alisan ng bala ang lahat ng bagay, malapit ang file, bumalik hindi totoo.
Sa pag-aakala nagkaroon hindi isang error, na Ang ibig sabihin lang talaga pindutin namin ang katapusan ng
ang file, na kung saan, isara namin ang maghain at nagbabalik ng tunay na mula noong namin
Matagumpay na na-load diksyunaryo sa aming trie.
>> Kaya ni check out check ngayon hayaan.
Naghahanap sa check-andar, makikita natin check na pagpunta upang magbalik ng bool.
Ibinabalik nito ang totoo kung ang salitang ito na ito ini ang pumasa ay nasa aming trie.
Ibinabalik nito ang hindi totoo kung hindi man.
Kaya paano mo matukoy kung ang salitang ito ay nasa aming trie?
>> Nakakakita kami dito na, tulad ng dati, kami ay pagpunta upang gamitin ang cursor na umulit
sa pamamagitan ng aming trie.
Ngayon dito kami ay pagpunta upang umulit lagpas sa aming buong salita.
Kaya iterating sa ibabaw ng salita hindi namin nakaraan, kami ay pagpunta upang matukoy ang
index sa mga bata array na tumutugon sa salita bracket I. Kaya ito
Pupunta upang tumingin nang eksakto tulad ng load, kung saan kung salita [i]
ay isang kudlit, pagkatapos ay nais naming upang gamitin ang index "alpabeto" - 1.
Dahil natukoy namin na iyon ay kung saan kami ay pagpunta upang mag-imbak
apostrophes.
>> Iba Pa kami ay pagpunta upang gamitin ang dalawang mas mababang mga salita tandaan Kaya bracket I. na salita maaari
May di-makatwirang paggamit ng malaking titik.
At kaya gusto naming matiyak na hindi namin gamit ang isang maliit na mga bersyon ng mga bagay.
At pagkatapos ay ibabawas mula sa na 'ang isang' upang sabay muli magbibigay sa amin ang alpabetikong
posisyon ng na character.
Kaya na pupuntahan maging aming index papunta sa mga anak ng array.
>> At ngayon kung index na papunta sa mga bata array ay walang bisa, ibig sabihin namin
hindi na magpatuloy iterating down na aming trie.
Kung iyon ang kaso, ang salitang ito ay hindi maaaring marahil maging sa aming trie.
Dahil parang ito ay, na gagawin ibig sabihin doon ay magiging isang path
pababa sa salitang iyon.
At hindi mo nais makaharap null.
Kaya Nakakaranas ng mga null, bumalik kami ng hindi totoo.
Salita ay wala sa diksyonaryo.
Kung ito ay hindi null, pagkatapos kami ay pagpunta sa magpatuloy iterating.
>> Kaya ka ng pagpunta namin out doon cursor upang tumuro sa partikular na
node sa index iyon.
Panatilihin namin ang paggawa na sa buong ang buong salita, sa pag-aakala
kami ay hindi kailanman pindutin null.
Iyon ay nangangahulugang namin nagawang upang makakuha ng sa pamamagitan ng ang buong salita at hanapin
isang node sa aming try.
Ngunit kami ay hindi masyadong pa tapos.
>> Hindi namin nais upang bumalik lamang totoo.
Gusto naming bumalik cursor> salita.
Dahil tandaan muli, ay "pusa" ay hindi sa aming diksyonaryo, at "sakuna"
ay, pagkatapos kami ay matagumpay na makuha namin sa pamamagitan ng salitang "pusa." Ngunit cursor
salita ay hindi totoo at hindi totoo.
Kaya bumalik kami cursor salita upang ipahiwatig kung ito node ay talagang isang salita.
At na ito para sa check.
>> Kaya ni tingnan ang laki ipaalam.
Kaya laki ay magiging kaakit-akit sa madaling dahil, alalahanin sa pag-load, hindi namin
incrementing laki ng diksyunaryo para sa bawat salita na nakatagpo kami.
Kaya laki ay pagpunta lamang sa bumalik laki na diksiyunaryo.
At na ito.
>> Kaya sa wakas ay mag-ibis namin.
Kaya mag-ibis, kami ay pagpunta sa gumamit ng isang recursive function na upang aktwal na gawin ang lahat
ng trabaho para sa amin.
Kaya aming mga function ay pagpunta sa tawagin sa unloader.
Ano ang unloader pagpunta sa gawin?
Nakakakita kami dito na unloader ay pagpunta sa umulit sa ibabaw ng lahat ng mga bata sa
ang partikular na node.
At kung ang bata node ay hindi null, pagkatapos kami ay pagpunta sa
alisan ng bala ang bata node.
>> Kaya ito ay sa iyo recursively alisan ng bala lahat ng ating mga anak.
Sa sandaling sigurado kami na ang lahat ng ating mga anak Na-deskargado, pagkatapos namin
Maaari palayain ang ating mga sarili, sa gayon alisan ng bala ang ating mga sarili.
Ito ay gagana recursively alisan ng bala ang buong trie.
At pagkatapos ay isang beses na tapos na, maaari naming bumalik lang totoo.
Hindi maaaring mabigo alisan ng kargada.
Lamang kami pagbabakante bagay.
Kaya sa sandaling tapos na kami pagbabakante ang lahat ng bagay, nagbabalik ng tunay.
At na ito.
Ang pangalan ko ay Rob.
At ito ay speller.
>> [MUSIC nagpe-play]