>> [მუსიკის დაკვრა]
>> რობ Bowden: Hi.
მე Rob.
და მოდით ეს გამოსავალი.
ასე რომ, აქ ჩვენ ვაპირებთ განხორციელება საერთო მაგიდასთან.
ჩვენ ვხედავთ, რომ struct კვანძის ჩვენი მაგიდა აპირებს გამოიყურებოდეს მოსწონს ეს.
ასე რომ, ის აპირებს აქვს char სიტყვა მასივი ზომა სიგრძე + 1.
ნუ დაგავიწყდებათ + 1, რადგან მაქსიმალური სიტყვა ლექსიკონი 45
სიმბოლო.
და მაშინ ჩვენ ვაპირებთ გვჭირდება ერთი ზედმეტი ხასიათი backslash ნულოვანი.
>> და მაშინ ჩვენი hashtable თითოეულ bucket აპირებს შესანახად
დაკავშირებული სიაში კვანძების.
ჩვენ ამას არ ვაკეთებთ ხაზოვანი საცდელი აქ.
და რათა დააკავშიროს მომდევნო ელემენტს bucket, ჩვენ გვჭირდება
struct კვანძის * შემდეგი.
OK.
ასე რომ რა კვანძის ჰგავს.
>> ახლა აქ არის დეკლარაცია ჩვენი hashtable.
ის აპირებს აქვს 16.834 თაიგულების.
მაგრამ, რომ ნომერი ნამდვილად არ აქვს.
და ბოლოს, ჩვენ ვაპირებთ აქვს გლობალური ცვლადი hashtable ზომა, რომელიც
აპირებს დაიწყოს off როგორც ნულოვანი.
და ის აპირებს ტრეკზე, თუ რამდენად ბევრი სიტყვა ჩვენს ლექსიკონში.
>> მოდით შევხედოთ დატვირთვა.
გაითვალისწინეთ, რომ დატვირთვა, ის დააბრუნებს bool.
თქვენ დაბრუნდება ნამდვილი, თუ ეს იყო წარმატებით დატვირთული, და ცრუ სხვაგვარად.
და ეს ხდება const char * ლექსიკონი, რაც ლექსიკონი
რომ ჩვენ გვინდა გახსნა.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ, რომ გავაკეთოთ.
>> ჩვენ ვაპირებთ fopen ლექსიკონი მოსმენით.
და ჩვენ ვაპირებთ უნდა გააკეთოთ დარწმუნებული ვარ, რომ ეს შეძლო.
ასე რომ, თუ ის დაბრუნდა NULL, მაშინ ჩვენ არ წარმატებით გახსნა ლექსიკონი.
და ჩვენ გვჭირდება დაბრუნების ცრუ.
მაგრამ თუ გავითვალისწინებთ, რომ ეს წარმატებით ღია, მაშინ ჩვენ გვინდა წაიკითხოთ
ლექსიკონი.
გააგრძელეთ looping სანამ ჩვენ გამოძებნოს მიზეზი შესვენება out ამ მარყუჟის,
რომელიც ჩვენ დავინახავთ.
გააგრძელეთ looping.
>> და ახლა ჩვენ ვაპირებთ malloc ერთი კვანძის.
და რა თქმა უნდა, ჩვენ უნდა ეთერში შეამოწმოს ერთხელ.
ასე რომ, თუ mallocing არ გამოუვათ, მაშინ ჩვენ გვინდა, რომ განიტვირთოს ნებისმიერი კვანძის რომ ჩვენ
მოხდა malloc ადრე, დახუროს ლექსიკონი და დაბრუნების ცრუ.
მაგრამ იგნორირება, რომ ვთქვათ, ჩვენ შეძლო, მაშინ ჩვენ გვინდა გამოვიყენოთ fscanf
წაკითხვის ერთი სიტყვა ჩვენი ლექსიკონი ჩვენს კვანძში.
ასე მახსოვს, რომ entry> სიტყვა არის char სიტყვა ბუფერის ზომა LENGHTH + 1
რომ ჩვენ ვაპირებთ შესანახად სიტყვა შემოსული
>> ასე fscanf დაბრუნებას აპირებს 1, ხანგრძლივი რადგან შეძლო წარმატებით
წაიკითხა სიტყვა ფაილი.
თუ არც შეცდომა ხდება, ან ჩვენ მიაღწიონ ბოლომდე ფაილი, ის
არ დაბრუნდება 1.
ამ შემთხვევაში ეს არ დააბრუნებს 1, ჩვენ საბოლოოდ აპირებს დაარღვიოს out of
ამ ხოლო loop.
ასე რომ, ჩვენ ვხედავთ, რომ ერთხელ ჩვენ წარმატებით წაიკითხა სიტყვა შევიდა
შესვლის> სიტყვა, მაშინ ჩვენ ვაპირებთ, რომ სიტყვა ჩვენი ქეშირების ფუნქცია.
>> მოდით შევხედოთ ქეშირების ფუნქცია.
ასე, რომ თქვენ ნამდვილად არ უნდა ამის გაგება.
და რეალურად ჩვენ უბრალოდ გამოყვანილია ამ hash ფუნქციონირებს ინტერნეტში.
ერთადერთი, რაც თქვენ უნდა აღიაროს არის რომ ეს იღებს const char * სიტყვა.
ამიტომ აღების სიმებიანი, როგორც შეყვანის და დაბრუნების unsigned int როგორც გამომავალი.
ასე რომ ყველა ქეშირების ფუნქცია, არის ის იღებს შეყვანის და გაძლევთ
ინდექსი შევიდა hashtable.
>> გაითვალისწინეთ, რომ ჩვენ moding მიერ NUM_BUCKETS, ასე რომ ღირებულება დაბრუნდა
რეალურად არის ინდექსი შევიდა hashtable და არ index მიღმა
ფარგლებში მასივი.
ასე რომ, თუ გავითვალისწინებთ, რომ ფუნქცია, ჩვენ ვაპირებთ to hash სიტყვა, რომელიც ვკითხულობთ
ლექსიკონი.
და მაშინ ჩვენ ვაპირებთ გამოვიყენოთ რომ hash ჩასასმელად
შესვლის hashtable.
>> ახლა hashtable hash მიმდინარე დაკავშირებული სიაში ცხრილში.
და ეს ძალიან შესაძლებელია რომ ეს მხოლოდ NULL.
გვინდა ჩადეთ ჩვენი შესვლის დროს დაწყებული ამ უკავშირდება სიაში.
ასე რომ, ჩვენ ვაპირებთ, რომ ჩვენი დღევანდელი შესვლის წერტილი რა hashtable
ამჟამად მიუთითებს.
და მაშინ ჩვენ ვაპირებთ შესანახად, ამ hashtable ზე
hash, მიმდინარე ჩანაწერი.
ასე რომ, ეს ორი ხაზი წარმატებით ჩადეთ შესვლის დასაწყისში
უკავშირდება სია იმ ინდექსი ამ hashtable.
>> მას შემდეგ, რაც ჩვენ გავაკეთეთ, რომ, ჩვენ ვიცით, რომ ჩვენ ვნახეთ ერთი სიტყვა
ლექსიკონი, და ჩვენ ნამატი ერთხელ.
ასე რომ, ჩვენ აკეთეთ, რომ სანამ fscanf საბოლოოდ დაბრუნდა რაღაც არასამთავრობო 1 at
სადაც წერტილი გვახსოვდეს, რომ ჩვენ უნდა გავათავისუფლოთ ჩანაწერი.
ასე რომ, აქ ჩვენ malloced ჩანაწერი.
და ჩვენ შევეცადეთ წავიკითხე რაღაც საწყისი ლექსიკონი.
და ჩვენ არ წარმატებით წაკითხული რაღაც ლექსიკონი, in
ასეთ შემთხვევაში, ჩვენ უნდა გავათავისუფლოთ შესვლის რომ ჩვენ არასოდეს რეალურად ამოქმედებული
hashtable, და საბოლოოდ დაარღვიოს.
>> ერთხელ ჩვენ შესვენება out ჩვენ უნდა დაინახოს, ასევე, არც ჩვენ შესვენება out რადგან იქ
შეცდომა კითხულობს ფაილი?
ან საერთოდ ჩვენ შესვენება out რადგან ჩვენ მიაღწია ბოლოს ფაილი?
იყო თუ არა შეცდომა, მაშინ ჩვენ გვინდა, რომ დაბრუნების ცრუ.
იმის გამო, რომ დატვირთვა არ გავიდა.
და ამ პროცესში ჩვენ გვინდა, რომ განიტვირთოს ყველა სიტყვა, რომ ვკითხულობთ და
დახურვა ლექსიკონი ფაილი.
>> ვთქვათ, ჩვენ არ გამოუვათ, მაშინ ჩვენ უბრალოდ მაინც უნდა დახუროს ლექსიკონი
ფაილი, და საბოლოოდ იქნება TRUE, რადგან ჩვენ წარმატებით დატვირთული ლექსიკონი.
და რომ ეს დატვირთვა.
ახლა შევამოწმოთ, თუ გავითვალისწინებთ დატვირთული hashtable, აპირებს გამოიყურებოდეს მოსწონს ეს.
ასე რომ, შემოწმება, ის დააბრუნებს bool, რომელიც აპირებს მიუთითებს თუ არა გავიდა
in char * სიტყვა, თუ არა გავიდა in string არის ჩვენი ლექსიკონი.
ასე რომ, თუ ეს ლექსიკონი, თუ ეს არის ჩვენი hashtable,
დავიბრუნებთ ჭეშმარიტი.
და თუ ეს ასე არ არის, ჩვენ დაბრუნების ცრუ.
>> აქედან გამომდინარე გავიდა სიტყვა, ჩვენ ვაპირებ hash სიტყვა.
ახლა მთავარია, რომ აღიარებენ, რომ დატვირთვა ვიცოდით, რომ ყველა
სიტყვა ჩვენ ვაპირებთ, რომ იყოს ქვედა შემთხვევაში.
მაგრამ აქ ჩვენ არ ვარ დარწმუნებული.
თუ ჩვენ შევხედოთ ჩვენი ქეშირების ფუნქცია, ჩვენი ქეშირების ფუნქცია რეალურად
ნაკლებია გარსაცმები თითოეული ხასიათი სიტყვა.
ასე რომ, მიუხედავად იმისა, კაპიტალიზაცია სიტყვა, ჩვენი ქეშირების ფუნქცია არის დაბრუნების
იგივე მაჩვენებელი, რასაც კაპიტალიზაცია არის, როგორც ეს იქნებოდა
დაბრუნდა სრულიად ამას მობილური სიტყვას.
კარგად.
რომ ჩვენი ინდექსი შევიდა hashtable ეს სიტყვა.
>> ახლა ამ for loop აპირებს iterate მეტი უკავშირდება სიაში
რომ იყო, რომ ინდექსი.
ასე რომ შეამჩნია ჩვენ ინიციალიზებისას შესვლის აღვნიშნო, რომ ინდექსი.
ჩვენ ვაპირებთ გავაგრძელოთ ხოლო შესვლის! = NULL.
და გვახსოვდეს, რომ განახლება მაჩვენებელი ჩვენს უკავშირდება სიაში შესვლის = entry> მომავალი.
ასე რომ ჩვენი დღევანდელი შესვლის წერტილი მომდევნო ნივთის უკავშირდება სიაში.
>> ასე რომ, ყოველი შესვლის უკავშირდება სია, ჩვენ ვაპირებთ გამოვიყენოთ strcasecmp.
ეს არ არის strcomp.
იმიტომ, რომ კიდევ ერთხელ, ჩვენ გვინდა გავაკეთოთ რამ შემთხვევაში insensitively.
ასე რომ, ჩვენ ვიყენებთ strcasecmp შედარება სიტყვა, რომელიც მიღებულ იქნა ამ
ფუნქციის წინააღმდეგ სიტყვა რომ არის ამ ჩანაწერს.
იმ შემთხვევაში, თუ ის დააბრუნებს ნულოვანი, ეს ნიშნავს, რომ იქ იყო მატჩი, რომლის დროსაც ჩვენ გვინდა
TRUE.
ჩვენ წარმატებით ი სიტყვა ჩვენს hashtable.
>> იმ შემთხვევაში, თუ არ იყო მატჩი, მაშინ ჩვენ აპირებს loop ერთხელ და შევხედოთ
შემდეგი ჩანაწერი.
და ჩვენ გავაგრძელებთ looping ხოლო არსებობს არის მასალაა ამ უკავშირდება სიაში.
რა მოხდება, თუ ჩვენ შესვენება გარეთ ამ loop?
ეს ნიშნავს, რომ ჩვენ ვერ ჩანაწერი, რომ შესაბამისი სიტყვა, რომლის დროსაც
ჩვენ დაბრუნების ცრუ მიუთითებს იმაზე, რომ ჩვენი hashtable არ შეიცავს ამ სიტყვას.
და ეს ქვითარი.
>> მოდით შევხედოთ ზომის.
ახლა ზომა იქნება საკმაოდ მარტივია.
მას შემდეგ, რაც მახსოვს დატვირთვა, თითოეული სიტყვა ჩვენ აღმოვაჩინეთ, ჩვენ incremented გლობალურ
ცვლადი hashtable ზომა.
ასე რომ ზომით ფუნქცია უბრალოდ აპირებს დაბრუნებას გლობალური ცვლადი.
და რომ არის ის.
>> ახლა საბოლოოდ, ჩვენ უნდა განიტვირთოს ლექსიკონი ერთხელ ყველაფერი კეთდება.
ასე რომ, თუ ჩვენ ვაპირებთ, რომ გავაკეთოთ?
აქ ჩვენ looping ზე ყველა თაიგულების ჩვენს მაგიდასთან.
ასე რომ, არსებობს NUM_BUCKETS თაიგულების.
და თითოეული უკავშირდება სიაში ჩვენი hashtable, ჩვენ ვაპირებთ loop მეტი
მთლიანად უკავშირდება სია, გამონთავისუფლების თითოეულ ელემენტს.
>> ახლა ჩვენ უნდა ვიყოთ ფრთხილად.
ასე რომ, აქ ჩვენ გვაქვს დროებითი ცვლადი რომ შენახვის მომცეთ შემდეგი
ელემენტს უკავშირდება სიაში.
და მაშინ ჩვენ ვაპირებთ უფასო მიმდინარე ელემენტს.
ჩვენ უნდა დავრწმუნდეთ, ჩვენ ამის გაკეთება, რადგან ჩვენ არ შეგიძლიათ უბრალოდ გასათავისუფლებლად მიმდინარე ელემენტს
და შემდეგ ცდილობენ, რათა შეამოწმონ მომდევნო მაჩვენებელი, მას შემდეგ, რაც ერთხელ ჩვენ გაათავისუფლეს მას,
მეხსიერების ხდება არასწორია.
>> ამიტომ, ჩვენ უნდა შევინარჩუნოთ გარშემო მომცეთ შემდეგი ელემენტს, მაშინ ჩვენ შეგვიძლია გასათავისუფლებლად
მიმდინარე ელემენტს, და შემდეგ შეგვიძლია განახლება ჩვენი დღევანდელი ელემენტს აღვნიშნო
მომდევნო ელემენტს.
ჩვენ loop ხოლო არსებობს ელემენტები ამ უკავშირდება სიაში.
ჩვენ ყველაფერს გავაკეთებთ, რომ ყველა დაკავშირებული სიების hashtable.
და კიდევ ჩვენ გაკეთდეს, რომ ჩვენ მთლიანად დაცალა hashtable და
ჩვენ გავაკეთეთ.
ასე რომ შეუძლებელია განიტვირთოს ოდესმე დაბრუნების ცრუ.
და როდესაც ჩვენ გავაკეთეთ, ჩვენ უბრალოდ დააბრუნოს ჭეშმარიტი.
>> მოდით მივცეთ ამ გადაწყვეტა ცდილობენ.
მოდით შევხედოთ რა არის ჩვენი struct კვანძის ჰგავს.
აქ ჩვენ ვხედავთ, ჩვენ ვაპირებთ აქვს bool სიტყვა და struct კვანძის * ბავშვები
bracket ანბანი.
ასე რომ პირველი რაც თქვენ შეიძლება გაინტერესებთ, რატომ არის ALPHABET
ed განისაზღვრება, როგორც 27?
ისე, გვახსოვდეს, რომ ჩვენ ვაპირებთ გვჭირდება უნდა გატარება აპოსტროფი.
ასე რომ იქნება გარკვეულწილად განსაკუთრებულ შემთხვევაში მთელი ამ პროგრამის.
>> ახლა მახსოვს, როგორ trie რეალურად მუშაობს.
ვთქვათ ჩვენ ინდექსირებას სიტყვა "კატა". შემდეგ ფესვი trie,
ჩვენ ვაპირებთ შევხედოთ ბავშვები მასივი, და ჩვენ ვაპირებთ შევხედოთ
ინდექსი, რომელიც შეესაბამება წერილი C. ასე რომ იქნება ინდექსირებული 2.
ასე რომ, რაც მოგვცეს ახალი კვანძში.
და მაშინ ჩვენ ვიმუშავებთ იმ კვანძში.
>> ასე რომ, თუ გავითვალისწინებთ, რომ კვანძის, ჩვენ კიდევ ერთხელ ვაპირებთ შევხედოთ ბავშვების მასივი.
და ჩვენ ვაპირებთ შევხედოთ მაჩვენებელი ნულოვანი შეესაბამება in კატა.
ასე რომ მაშინ ჩვენ ვაპირებთ წასვლა რომ კვანძის, და იმის გათვალისწინებით, რომ კვანძის ჩვენ ვაპირებთ
შევხედოთ ბოლომდე ეს შეესაბამება თ და მოძრავი, რომ კვანძის,
საბოლოოდ, ჩვენ მთლიანად ჩანდა ჩვენი სიტყვა "კატა". და ახლა bool
სიტყვა უნდა მიუთითოს, ამ მოცემული სიტყვა არის რეალურად სიტყვა.
>> რატომ გვჭირდება, რომ განსაკუთრებულ შემთხვევაში?
რას სიტყვა "კატასტროფა" არის ჩვენი ლექსიკონი, მაგრამ
სიტყვა "კატა" არ არის?
ასე და ეძებს თუ სიტყვა "კატა" არის ჩვენი ლექსიკონი, ჩვენ
აპირებს წარმატებით გადახედეთ ინდექსების C-A-T რეგიონში კვანძში.
მაგრამ ეს მხოლოდ იმიტომ, რომ კატასტროფა მოხდა შექმნათ კვანძების გზაზე
ეხლა C-A-T, ყველა გზა ბოლოს სიტყვა.
ასე რომ, bool სიტყვა გამოიყენება მიუთითოს, ამ კონკრეტულ მდებარეობა
რეალურად ასახავს სიტყვა.
>> ყველა უფლება.
ახლა რომ ჩვენ ვიცით, რა trie არის აპირებს გამოიყურებოდეს, მოდით შევხედოთ
ჩატვირთვა ფუნქცია.
ასე დატვირთვის დაბრუნებას აპირებს bool განთავსების არა ჩვენ წარმატებულად
უშედეგოდ დატვირთული ლექსიკონი.
და ეს იქნება ლექსიკონი რომ ჩვენ გვინდა ჩატვირთვა.
>> ასე რომ, პირველი, რაც ჩვენ უნდა გავაკეთოთ არის ღია , რომ ლექსიკონი მოსმენით.
და ჩვენ უნდა დავრწმუნდეთ, ჩვენ არ ჩავარდება.
ასე რომ, თუ ლექსიკონში არ იყო წარმატებით გაიხსნა, იგი დაბრუნდება
null, ამ შემთხვევაში ჩვენ დაბრუნებას აპირებს ყალბი.
მაგრამ თუ გავითვალისწინებთ, რომ წარმატებით გახსნა, მაშინ ჩვენ შეგვიძლია რეალურად წაიკითხა
მეშვეობით ლექსიკონი.
>> ასე რომ, პირველი, რაც ჩვენ ვაპირებთ გვინდა გავაკეთოთ ჩვენ ამ
გლობალური ცვლადი root.
ახლა root იქნება კვანძის *.
ის ზედა ჩვენი trie, რომ ჩვენ იქნება iterating მეშვეობით.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ გსურთ არის გამოუყოფს
მეხსიერების ჩვენი root.
გაითვალისწინეთ, რომ ჩვენ გამოყენებით calloc ფუნქცია, რომელიც ძირითადად იგივე
როგორც malloc ფუნქციის გარდა, ის გარანტირებული დაბრუნებას, რაც არის
სრულიად zeroed out.
ასე რომ, თუ ჩვენ malloc, ჩვენ უნდა გავლა ყველა პოინტერები ჩვენი
კვანძის, და დარწმუნდით, რომ ისინი ყველა null.
ასე calloc ყველაფერს გავაკეთებთ, რომ ჩვენთვის.
>> ახლა, ისევე, როგორც malloc, ჩვენ გვჭირდება, რათა დარწმუნებული ვარ, რომ გამოყოფა იყო, ფაქტობრივად,
წარმატებული.
თუ ეს დაბრუნდა null, მაშინ ჩვენ უნდა დახუროს ან ლექსიკონი
ფაილი და დაბრუნების ცრუ.
ასე რომ, ვთქვათ, რომ გამოყოფის იყო წარმატებული, ჩვენ ვაპირებთ გამოვიყენოთ კვანძის *
კურსორი iterate ჩვენი trie.
ასე რომ, ჩვენი ფესვები არასოდეს შეიცვლება, მაგრამ ჩვენ ვაპირებთ გამოვიყენოთ კურსორი
რეალურად წასვლა კვანძის კვანძის.
>> ასე რომ, ამ for loop ჩვენ კითხულობს მეშვეობით ლექსიკონი ფაილი.
და ჩვენ გამოყენებით fgetc.
Fgetc აპირებს დაიბრუნოს ერთი ხასიათი ფაილი.
ჩვენ ვაპირებთ გავაგრძელოთ grabbing გმირები ჩვენ კი არ აღწევს
ფაილის ბოლოში.
>> არსებობს ორი შემთხვევა ჩვენ უნდა გაუმკლავდეს.
პირველი, თუ ხასიათი არ იყო ახალი ხაზი.
ასე რომ, ჩვენ ვიცით, თუ ეს იყო ახალი ხაზი, მაშინ ჩვენ შესახებ გადაადგილება ახალი სიტყვა.
მაგრამ ვთქვათ, რომ ეს არ იყო ახალი ხაზი, მაშინ აქ ჩვენ გვინდა გაერკვნენ
index ჩვენ ვაპირებთ ინდექსი შევიდა ბავშვების მასივი,
ჩვენ შევხედე ადრე.
>> ასე რომ, როგორც ვთქვი, ჩვენ უნდა განსაკუთრებულ შემთხვევაში აპოსტროფი.
გაითვალისწინეთ, ჩვენ გამოყენებით ternary ოპერატორი აქ.
ამიტომ, ჩვენ ვაპირებთ, რომ წაიკითხონ ეს, თუ ხასიათი ვკითხულობთ იყო
აპოსტროფი, მაშინ ჩვენ ვაპირებთ მითითებული index = "ანბანი" -1, რომელიც
იყოს ინდექსი 26.
>> სხვაგან, თუ ეს არ იყო აპოსტროფი, არსებობს ჩვენ ვაპირებთ, რომ შექმნას ინდექსი
ტოლი გ - ს.
ასე მახსოვს უკან ადრე P-კომპლექტი, c - აპირებს მოგვცეს
ანბანური პოზიცია C. ასე რომ, თუ C არის წერილი, ეს იქნება
მოგვცეს მაჩვენებელი ნულოვანი.
იყიდება წერილი B, ეს მისცემს ჩვენს ინდექსი 1, და ა.შ..
>> ასე რომ, ეს გვაძლევს ინდექსი შევიდა ბავშვები მასივი, რომ ჩვენ გვინდა.
ახლა, თუ ეს მაჩვენებელი ამჟამად null in ბავშვებს, ეს ნიშნავს, რომ კვანძის
ამჟამად არ არსებობს რომ გზა.
ამიტომ, ჩვენ უნდა გამოყოს კვანძის, რომ გზა.
რომ ის, რასაც ჩვენ გავაკეთებთ აქ.
>> ამიტომ, ჩვენ ვაპირებთ, რომ კვლავ გამოიყენოთ calloc ფუნქცია, რომ ჩვენ არ უნდა
ნულოვანი out ყველა მითითებას.
და ჩვენ კვლავ უნდა შეამოწმოს რომ calloc არ ჩავარდება.
იმ შემთხვევაში, თუ calloc არ ვერ, მაშინ ჩვენ უნდა განიტვირთოს ყველაფერი, დავხუჭავთ
ლექსიკონი, და დაბრუნების ცრუ.
ასე რომ, ვთქვათ, რომ ეს არ ვერ, მაშინ ეს იქნება შექმნათ ახალი ბავშვი ჩვენთვის.
და მაშინ ჩვენ წასვლა რომ ბავშვი.
ჩვენი კურსორი iterate ქვემოთ რომ ბავშვი.
>> ახლა, თუ ეს არ იყო null დაიწყოს, მაშინ კურსორი შეგიძლიათ უბრალოდ iterate
ქვემოთ რომ ბავშვის გარეშე, ფაქტობრივად, მქონე გამოყოფას არაფერი.
ეს არის საქმე, სადაც ჩვენ პირველად მოხდა გამოყოფს სიტყვა "კატა". და
ეს ნიშნავს, რომ როდესაც ჩვენ მივდივართ გამოუყოს "კატასტროფის" ჩვენ არ უნდა შევქმნათ
კვანძების C-A-T ერთხელ.
ისინი უკვე არსებობს.
>> რა არის ეს სხვა?
ეს არის მდგომარეობა, სადაც c იყო backslash N, სადაც c იყო ახალი ხაზი.
ეს ნიშნავს, რომ ჩვენ წარმატებით დასრულებული სიტყვა.
ახლა რა გვინდა გავაკეთოთ, როდესაც ჩვენ წარმატებით დასრულდა სიტყვა?
ჩვენ ვაპირებთ გამოვიყენოთ ეს სიტყვა ველი შიგნით ჩვენი struct კვანძში.
ჩვენ გვინდა, რომ მითითებული, რომ ასეა.
ასე რომ, იმაზე მიუთითებს, რომ ამ კვანძის მიუთითებს, რომ წარმატებული
სიტყვა, ფაქტობრივი სიტყვა.
>> არის მითითებული, რომ ასეა.
ჩვენ გვინდა, რომ აღადგინოთ ჩვენი კურსორი წერტილი დასაწყისში trie ერთხელ.
და ბოლოს, ნამატი ჩვენი ლექსიკონი ზომა, რადგან აღმოვაჩინეთ, სხვა სამსახურში.
ამიტომ, ჩვენ ვაპირებთ, რომ შევინარჩუნოთ აკეთებს, რომ, კითხულობს ხასიათი ხასიათი,
აშენებს ახალ კვანძების ჩვენი trie და თითოეული სიტყვა ლექსიკონი, სანამ
ჩვენ საბოლოოდ მიაღწიოს C! = EOF, რომელშიც თუ ჩვენ შესვენება out of ფაილი.
>> ახლა არსებობს ორი შემთხვევა ქვეშ რომელიც ჩვენ შეიძლება არ მოხვდა EOF.
პირველი არის ის, იყო თუ არა შეცდომა კითხულობს ფაილი.
ასე რომ, თუ იყო შეცდომა, ჩვენ უნდა გავაკეთოთ დამახასიათებელი.
განიტვირთოს ყველაფერი, ახლო ფაილი, დაბრუნების ცრუ.
ვთქვათ, არ იყო შეცდომა, რომელიც მხოლოდ იმას ნიშნავს, ჩვენ რეალურად მოხვდა ბოლოს
ფაილი, ამ შემთხვევაში, ჩვენ დახურვა ფაილი და დააბრუნოს ჭეშმარიტი, რადგან ჩვენ
წარმატებით დატვირთული ლექსიკონი ჩვენს trie.
>> ახლა მოდით შეამოწმეთ ქვითარი.
ეძებს გამშვები ფუნქცია, ჩვენ ვხედავთ რომ გამშვები დაბრუნებას აპირებს bool.
ის ბრუნდება ნამდვილი, თუ ეს სიტყვა, რომ მიმდინარეობს გავიდა ჩვენს trie.
ის დააბრუნებს ცრუ სხვაგვარად.
ასე რომ, თუ თქვენ თუ არა ეს სიტყვა არის ჩვენი trie?
>> ჩვენ ვხედავთ, რომ აქ, ისევე, როგორც ადრე, ჩვენ ვაპირებთ გამოვიყენოთ კურსორი iterate
ჩვენი trie.
ახლა აქ ჩვენ ვაპირებთ iterate მეტი ჩვენი მთელი სიტყვა.
ასე რომ iterating მეტი სიტყვა ვართ წარსულში, ჩვენ ვაპირებთ, რათა დადგინდეს
ინდექსი შევიდა ბავშვები მასივი, შეესაბამება სიტყვა bracket I. ასე რომ, ეს
აპირებს გამოიყურებოდეს ზუსტად ისევე, დატვირთვის, სადაც თუ სიტყვა [i]
არის აპოსტროფი, მაშინ ჩვენ გვინდა გამოყენება ინდექსი "ანბანი" - 1.
იმიტომ, რომ ჩვენ განისაზღვრა, რომ არის, სადაც ჩვენ ვაპირებთ შესანახად
apostrophes.
>> Else ჩვენ ვაპირებთ გამოვიყენოთ ორი ქვედა სიტყვა bracket I. ასე რომ გვახსოვდეს, რომ სიტყვა
აქვს თვითნებური კაპიტალიზაცია.
ასე რომ, ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ გამოყენებით ამას მობილური რამ.
და შემდეგ სხვაობა, რომ "ა" კიდევ ერთხელ გვაძლევს ანბანური
პოზიცია, რომ ხასიათი.
ასე რომ იქნება ჩვენი ინდექსი შევიდა ბავშვები მასივი.
>> და ახლა, თუ ეს ინდექსი შევიდა ბავშვები მასივი null, ეს ნიშნავს, რომ ჩვენ
ვეღარ გააგრძელებს iterating ქვემოთ ჩვენი trie.
თუ ეს საქმე, ეს სიტყვა არ შეიძლება შესაძლოა იყოს ჩვენი trie.
მას შემდეგ, თუ ეს იყო, რომ ნიშნავს არ იქნება გზა
ქვემოთ რომ სიტყვა.
და თქვენ არასოდეს ექმნებათ null.
ასე რომ, შესახებ, null, ვბრუნდებით ყალბი.
სიტყვა არ არის ლექსიკონში.
თუ ეს არ იყო null, მაშინ ჩვენ გავაგრძელებთ iterating.
>> ამიტომ, ჩვენ ვაპირებთ იქ კურსორი აღვნიშნო, რომ კონკრეტული
კვანძის, რომ ინდექსი.
ჩვენ შევინარჩუნოთ აკეთებს, რომ მთელი მთელი სიტყვით, ვთქვათ,
ჩვენ არასოდეს მოხვდა null.
ეს ნიშნავს, რომ ჩვენ შევძელით მისაღებად მეშვეობით მთელი სიტყვა და იპოვოს
კვანძის ჩვენს ცდილობენ.
მაგრამ ჩვენ არ საკმაოდ გაკეთდეს არავის გაუკეთებია.
>> ჩვენ არ გვინდა, რომ უბრალოდ დააბრუნოს ჭეშმარიტი.
ჩვენ გვინდა დაბრუნდეს კურსორი> სიტყვა.
მას შემდეგ, რაც მახსოვს, ერთხელ, "კატა" არ არის ჩვენი ლექსიკონი, და "კატასტროფა"
არის, მაშინ ჩვენ წარმატებით მივიღებთ მეშვეობით სიტყვა "კატა". მაგრამ კურსორი
სიტყვა იქნება ყალბი და არ შეესაბამება სიმართლეს.
ასე რომ, ჩვენ დაბრუნდება კურსორი სიტყვა მიუთითოს თუ არა ამ კვანძის რეალურად სიტყვა.
და რომ ეს შემოწმება.
>> მოდით შეამოწმეთ ზომა.
ასე რომ ზომა იქნება საკმაოდ ადვილი რადგან, გახსოვდეთ, დატვირთვის, ჩვენ
დამატება ლექსიკონი ზომა თითოეული სიტყვა, რომ ჩვენ ვაწყდებით.
ასე რომ ზომით უბრალოდ აპირებს დაბრუნებას ლექსიკონი ზომა.
და რომ არის ის.
>> ასე რომ, ბოლოს ჩვენ განიტვირთოს.
ასე რომ განიტვირთოს, ჩვენ ვაპირებთ გამოვიყენოთ რეკურსიული ფუნქცია რეალურად ყველაფერი
მუშაობა ჩვენთვის.
ასე რომ, ჩვენი ფუნქცია აპირებს მოეთხოვოს unloader.
რა არის unloader აპირებს?
ჩვენ ვხედავთ, აქ რომ unloader აპირებს iterate მეტი ყველა ბავშვები
ამ კონკრეტულ კვანძში.
და თუ კვანძზე არ არის null, მაშინ ჩვენ ვაპირებთ
განიტვირთოს კვანძზე.
>> ასე რომ, ეს თქვენ რეკურსიული განიტვირთოს ყველა ჩვენი შვილები.
მას შემდეგ, რაც ჩვენ დარწმუნებული ვარ, რომ ყველა ჩვენი ბავშვები უკვე დაცალა, მაშინ ჩვენ
შეგიძლიათ გასათავისუფლებლად საკუთარ თავს, ასე რომ, განიტვირთოს საკუთარ თავს.
ეს იმუშავებს რეკურსიული განიტვირთოს მთელი trie.
და მერე კიდევ რომ კეთდება, ჩვენ შეგვიძლია უბრალოდ დააბრუნოს ჭეშმარიტი.
განიტვირთოს ვერ ჩავარდება.
ჩვენ უბრალოდ გამონთავისუფლების რამ.
ასე რომ ერთხელ ჩვენ გავაკეთეთ ათავისუფლებს ყველაფერი, TRUE.
და რომ არის ის.
ჩემი სახელი არის რობ.
და ეს იყო speller.
>> [მუსიკის დაკვრა]