>> დინამიკები 1: მოდით მივცეთ ეს გამოსავალი ცდილობენ.
მოდით შევხედოთ რა არის ჩვენი Struct კვანძის ჰგავს.
აქ ჩვენ ვხედავთ, ჩვენ ვაპირებთ აქვს Bool Word და struct კვანძის ვარსკვლავი
ბავშვები bracket ანბანი.
ასე რომ, პირველი, რაც თქვენ შეიძლება გაინტერესებთ, რატომ ანბანი hash განისაზღვრება, როგორც 27?
ისე, გვახსოვდეს, რომ ჩვენ ვაპირებთ გვჭირდება უნდა გატარება აპოსტროფი, ასე რომ,
რომ აპირებს იყოს გარკვეულწილად სპეციალური შემთხვევაში მთელი ამ პროგრამის.
>> OK, ახლა, მახსოვს, როგორ Trie რეალურად მუშაობს.
ვთქვათ ჩვენ ინდექსირებას სიტყვა კატა, შემდეგ კი root ჩვენი trie,
ჩვენ ვაპირებთ შევხედოთ ბავშვები მასივი, და ჩვენ ვაპირებთ შევხედოთ
ინდექსი, რომელიც შეესაბამება წერილი C. ასე რომ იქნებოდა ინდექსი ორი.
ასე რომ, თუ გავითვალისწინებთ, რომ, რომელიც მოგვცემს ახალი კვანძის, და მაშინ ჩვენ გამოგიგზავნით
მუშაობა რომ კვანძის.
>> ასე რომ, თუ გავითვალისწინებთ, რომ კვანძის, ჩვენ კიდევ ერთხელ ვაპირებთ შევხედოთ ბავშვები მასივი,
და ჩვენ ვაპირებთ შევხედოთ მაჩვენებელი ნულოვანი შეესაბამება in კატა.
ასე რომ მაშინ ჩვენ ვაპირებთ წასვლა რომ კვანძის, და იმის გათვალისწინებით, რომ კვანძის, ჩვენ ვაპირებთ
შევხედოთ ინდექსი, რომელიც შეესაბამება თ და მოძრავი, რომ კვანძის,
საბოლოოდ, ჩვენ მთლიანად ჩანდა ჩვენი სიტყვა Cat, და ახლა bool
სიტყვა უნდა მიუთითოს, ამ მოცემული სიტყვა არის რეალურად სიტყვა.
>> რატომ გვჭირდება, რომ განსაკუთრებულ შემთხვევაში?
ისე, რა, თუ სიტყვა კატასტროფა არის ჩვენი ლექსიკონი, მაგრამ
სიტყვა cat არ არის?
ასე რომ ეძებს თუ სიტყვა კატა ჩვენი ლექსიკონი, ჩვენ ვაპირებთ
წარმატებით გაეცნონ ინდექსები C-A-T და მიაღწიოს კვანძის, მაგრამ ეს
მხოლოდ იმიტომ, რომ კატასტროფა მოხდა შექმნა კვანძების გზა C-A-T ყველა
გზა ბოლომდე სიტყვა.
ასე რომ, bool Word გამოიყენება მიუთითოს, ამ კონკრეტულ განთავსების რეალურად
მიუთითებს სიტყვა.
>> ყველა უფლება, ასე რომ, ახლა, რომ ჩვენ ვიცით, თუ რა Trie აპირებს გამოიყურებოდეს, მოდით შევხედოთ
იმ Load ფუნქცია.
ასე რომ Load დაბრუნებას აპირებს bool განთავსების არა ჩვენ წარმატებულად
უშედეგოდ დატვირთული ლექსიკონი და ეს იქნება ლექსიკონი
რომ ჩვენ გვინდა ჩატვირთვა.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ ღიაა , რომ ლექსიკონი მოსმენით.
ჩვენ უნდა დავრწმუნდეთ, რომ ჩვენ არ ვერ, ასე რომ, თუ ლექსიკონში არ იყო
წარმატებით გაიხსნა, იგი დაბრუნდება არა, ამ შემთხვევაში ჩვენ ვაპირებთ
დაბრუნების ცრუ.
მაგრამ თუ გავითვალისწინებთ, რომ წარმატებით გახსნა, მაშინ ჩვენ შეგვიძლია რეალურად წაიკითხა
მეშვეობით ლექსიკონი.
>> ასე რომ, პირველი, რაც ჩვენ ვაპირებთ გვინდა გავაკეთოთ ჩვენ ამ
გლობალური ცვლადი root.
ახლა, root იქნება კვანძის ვარსკვლავი.
ის ზედა ჩვენი trie, რომ ჩვენ იქნება iterating მეშვეობით.
ასე რომ, პირველი, რაც ჩვენ ვაპირებთ მინდა გავაკეთოთ არის გამოყოს მეხსიერება ჩვენი root.
>> გაითვალისწინეთ, რომ ჩვენ გამოყენებით calloc ფუნქცია, რომელიც ძირითადად იგივე
როგორც Malloc ფუნქციის გარდა, ის გარანტირებული დაბრუნებას, რაც არის
სრულიად zeroed out.
ასე რომ, თუ ჩვენ Malloc, ჩვენ უნდა გავლა ყველა პოინტერები ჩვენი
კვანძის და დარწმუნდით, რომ ისინი ყველა null.
ასე calloc ყველაფერს გავაკეთებთ, რომ ჩვენთვის.
>> ახლა, ისევე, როგორც Malloc, ჩვენ გვჭირდება, რათა დარწმუნებული ვარ, რომ გამოყოფა რეალურად
წარმატებული.
თუ ეს დაბრუნდა null, მაშინ ჩვენ უნდა დახუროთ ჩვენი ლექსიკონი
ფაილი და დააბრუნებს: FALSE.
ასე ვთქვათ გამოყოფილი იყო წარმატებული, ჩვენ ვაპირებთ გამოვიყენოთ კვანძის
ვარსკვლავი კურსორი iterate ჩვენი trie.
ასე რომ, ჩვენი root არასდროს შეიცვლება, მაგრამ ჩვენ ვაპირებთ გამოვიყენოთ კურსორი
რეალურად წასვლა კვანძის კვანძის.
>> ყველა უფლება, ასე ამ მარყუჟის, ჩვენ ვართ კითხულობს მეშვეობით ლექსიკონი ფაილი,
და ჩვენ გამოყენებით at fgetc.
ასე რომ fgetc აპირებს დაიბრუნოს ერთი ხასიათი ფაილი.
ჩვენ ვაპირებთ გავაგრძელოთ grabbing გმირები ჩვენ კი არ აღწევს
ფაილის ბოლოში, ასე რომ ორ შემთხვევაში ჩვენ უნდა გაუმკლავდეს.
პირველი, თუ ხასიათი არ იყო ახალი ხაზი, ასე რომ, ჩვენ ვიცით, თუ ეს იყო ახალი
ხაზი, მაშინ ჩვენ შესახებ გადაადგილება ახალი სიტყვა.
მაგრამ ვთქვათ, რომ ეს არ იყო ახალი ხაზი, მაშინ აქ, ჩვენ გვინდა, რომ გაერკვნენ
index ჩვენ ვაპირებთ ინდექსი შევიდა ბავშვთა მასივი,
ჩვენ შევხედე ადრე.
>> ასე რომ, როგორც ვთქვი ადრე, ჩვენ გვჭირდება განსაკუთრებულ შემთხვევაში აპოსტროფი.
გაითვალისწინეთ, ჩვენ გამოყენებით ternary ოპერატორი აქ, ამიტომ ჩვენ ვაპირებთ წაკითხვის
ეს თითქოს ხასიათი ვკითხულობთ იყო აპოსტროფი, მაშინ ჩვენ ვაპირებთ
მითითებული მაჩვენებელში ანბანი minus 1, რომელიც იქნება ინდექსი 26.
სხვაგან, თუ ეს არ იყო აპოსტროფი, მაშინ ჩვენ ვაპირებთ მითითებული ინდექსი
ტოლი გ მინუს.
ასე გვახსოვს უკან წინა p კომპლექტი, გ მინუს აპირებს მოგვცეს
ანბანური პოზიცია c ასე რომ, თუ გ არის წერილი, ეს იქნება
მოგვცეს მაჩვენებელი ნულოვანი.
იყიდება წერილი B, ეს საშუალებას მისცემს ჩვენს ინდექსი 1, და ა.შ..
>> ასე რომ, ეს გვაძლევს ინდექსი შევიდა ბავშვები მასივი, რომ ჩვენ გვინდა.
ახლა, თუ ეს მაჩვენებელი ამჟამად null in ბავშვები მასივი, ეს იმას ნიშნავს რომ
კვანძის ამჟამად არ არსებობდა რომ გზა, ამიტომ ჩვენ უნდა გამოყოს
კვანძის, რომ გზა.
ეს არის ის, რასაც ჩვენ ვაკეთებთ აქ.
ამიტომ, ჩვენ ვაპირებთ, კიდევ ერთხელ, გამოიყენოთ calloc ფუნქცია ისე, რომ ჩვენ არ გვაქვს
ნულოვანი out ყველა პოინტერები, და ჩვენ, ერთხელ, უნდა შეამოწმოთ, რომ calloc
არ ჩავარდება.
იმ შემთხვევაში, თუ calloc არ ვერ, მაშინ ჩვენ უნდა განიტვირთოს ყველაფერი, დავხუჭავთ
ლექსიკონი, და დააბრუნებს: FALSE.
>> ასე რომ, ვთქვათ, რომ ეს არ ვერ, მაშინ ეს იქნება შექმნათ ახალი ბავშვი ჩვენთვის,
და მაშინ ჩვენ წასვლა რომ ბავშვი.
ჩვენი კურსორი iterate ქვემოთ რომ ბავშვი.
ახლა, თუ ეს არ იყო null დაიწყოს, მაშინ კურსორი შეგიძლიათ უბრალოდ iterate
ქვემოთ რომ ბავშვის გარეშე, ფაქტობრივად, მქონე გამოყოფას არაფერი.
ეს არის საქმე, სადაც ჩვენ პირველად მოხდა გამოყოს სიტყვა კატა, და
ეს ნიშნავს, რომ როდესაც ჩვენ მივდივართ გამოუყოს კატასტროფა, ჩვენ არ უნდა შევქმნათ
კვანძების C-A-T ერთხელ.
ისინი უკვე არსებობს.
>> OK, ასე რომ რა არის ეს სხვა?
ეს არის მდგომარეობა, სადაც c იყო backslash N, სადაც c იყო ახალი ხაზი.
ეს ნიშნავს, რომ ჩვენ წარმატებით დასრულებული სიტყვა.
ახლა, რა გვინდა გავაკეთოთ, როდესაც ჩვენ წარმატებით დასრულდა სიტყვა?
ჩვენ ვაპირებთ გამოვიყენოთ ეს სიტყვა ველი შიგნით ჩვენი struct კვანძში.
>> ჩვენ გვინდა, რომ მითითებული, რომ მართალია, ისე, რომ მიუთითებს იმაზე, რომ ამ კვანძის მიუთითებს
წარმატებული სიტყვა ფაქტობრივი სიტყვა.
ახლა მითითებული, რომ ასეა.
ჩვენ გვინდა, რომ აღადგინოთ ჩვენი კურსორი წერტილი დასაწყისში trie ერთხელ.
და ბოლოს, ნამატი ჩვენი ლექსიკონი ზომა, რადგან აღმოვაჩინეთ, სხვა სიტყვა.
>> ყველა უფლება, ამიტომ ჩვენ ვაპირებთ აკეთეთ რომ კითხულობს ხასიათი
ხასიათი, აშენებს ახალ კვანძების ჩვენი trie და თითოეული სიტყვა
ლექსიკონი, სანამ ჩვენ საბოლოოდ მიაღწიოს გ შეადგენს EOF, ამ შემთხვევაში, ჩვენ შესვენება
out of ფაილი.
ახლა, არსებობს ორი გათვალისწინებულ შემთხვევაში რომელიც ჩვენ შეიძლება არ მოხვდა EOF.
პირველი არის ის, იყო თუ არა შეცდომა კითხულობს ფაილი ასე რომ, თუ არ იყო
შეცდომა, ჩვენ უნდა გავაკეთოთ ტიპიური განიტვირთოს ყველაფერი, დახურეთ ფაილი,
დაბრუნების ცრუ.
ვთქვათ, არ იყო შეცდომა, რომელიც მხოლოდ იმას ნიშნავს, ჩვენ რეალურად მოხვდა ბოლოს
ფაილი, ამ შემთხვევაში, ჩვენ დახურვა ფაილი და დააბრუნოს True, რადგან ჩვენ
წარმატებით დატვირთული ლექსიკონი ჩვენს trie.
>> ყველა უფლება, ასე რომ, ახლა მოდით შეამოწმეთ შემოწმება.
ეძებს Check ფუნქცია, ჩვენ ვხედავთ რომ Check დაბრუნებას აპირებს bool.
ის დააბრუნებს True, თუ ეს სიტყვა, რომ მიმდინარეობს გავიდა ჩვენს trie.
ის დააბრუნებს False მიიღო.
>> ასე რომ, როგორ მივდივართ თუ არა ეს სიტყვა არის ჩვენი trie?
ჩვენ ვხედავთ, რომ აქ, ისევე, როგორც ადრე, ჩვენ ვაპირებთ გამოვიყენოთ კურსორი iterate
ჩვენი trie.
ახლა, აქ, ჩვენ ვაპირებთ iterate მეტი ჩვენი მთელი სიტყვა.
ასე რომ iterating მეტი სიტყვა ვართ გავიდა, ჩვენ ვაპირებთ, რათა დადგინდეს
ინდექსი შევიდა ბავშვები მასივი, შეესაბამება სიტყვა bracket i.
ასე რომ, ეს აპირებს გამოიყურებოდეს ზუსტად ისევე, დატვირთვის, სადაც თუ სიტყვა bracket i არის
აპოსტროფი, მაშინ ჩვენ გვინდა გამოვიყენოთ ინდექსი ანბანი მინუს 1 რადგან ჩვენ გადაწყვეტილი
რომ არის, სადაც ჩვენ ვაპირებთ შესანახად apostrophes.
>> Else ჩვენ ვაპირებთ გამოვიყენოთ tolower სიტყვა bracket i.
ასე მახსოვს, რომ სიტყვა შეიძლება ჰქონდეს თვითნებური კაპიტალიზაცია, და ამიტომ ჩვენ
გვინდა დავრწმუნდეთ, რომ ჩვენ გამოყენებით ამას მობილური რამ.
და შემდეგ სხვაობა, რომ ამას რომ, კიდევ ერთხელ, მოგვცეს
ანბანური პოზიცია რომ ხასიათი.
ასე რომ იქნება ჩვენი ინდექსი შევიდა ბავშვები მასივი.
>> და ახლა, თუ ეს ინდექსი შევიდა ბავშვები მასივი null, ეს ნიშნავს, რომ ჩვენ
ვეღარ გააგრძელებს iterating ქვემოთ ჩვენი trie.
თუ ეს საქმე, ეს სიტყვა არ შეიძლება შესაძლოა იყოს ჩვენი trie, რადგან თუ იგი
იყო, ეს იმას ნიშნავს, იქ იქნება გზა ქვემოთ რომ სიტყვა და თქვენ
არასდროს ექმნებათ null.
ასე რომ, შესახებ, null, ვბრუნდებით ყალბი.
სიტყვა არ არის ლექსიკონში.
თუ ეს არ იყო null, მაშინ ჩვენ ვაპირებთ გაგრძელდება iterating, ამიტომ ჩვენ ვაპირებთ
განაახლოთ ჩვენი კურსორი აღვნიშნო, რომ კერძოდ კვანძის, რომ ინდექსი.
>> ასე რომ, ჩვენ აკეთეთ, რომ მთელი მთელი სიტყვა.
ვთქვათ, ჩვენ არ მოხვდა null, ანუ ჩვენ შევძელით, რომ მიიღოთ მთელი
მსოფლიოში და იპოვოს კვანძის ჩვენს trie, მაგრამ ჩვენ არ საკმაოდ გაკეთდეს არავის გაუკეთებია.
ჩვენ არ გვინდა, რომ უბრალოდ დააბრუნოს True.
ჩვენ გვინდა დაბრუნდეს კურსორი შეცდომა სიტყვა მას შემდეგ, მახსოვს, ერთხელ, თუ კატა არ არის
ჩვენი ლექსიკონი და კატასტროფა, მაშინ ჩვენ წარმატებით ვუკავშირდებოდი
სიტყვა კატა, მაგრამ კურსორი სიტყვა იქნება ყალბი და არ შეესაბამება სიმართლეს.
ასე რომ, ჩვენ დაბრუნდება კურსორი სიტყვა მიუთითოს თუ არა ამ კვანძის რეალურად სიტყვა,
და რომ ეს შემოწმება.
>> მოდით შეამოწმეთ ზომა.
ასე რომ ზომა იქნება საკმაოდ ადვილი მას შემდეგ, მახსოვს Load, ჩვენ
დამატება ლექსიკონი ზომა თითოეული სიტყვა, რომ ჩვენ ვაწყდებით.
ასე რომ ზომა არის მხოლოდ დაბრუნებას აპირებს ლექსიკონი ზომის, და რომ არის ის.
>> ყველა უფლება, ასე ბოლოს, ჩვენ განიტვირთოს.
ასე რომ განიტვირთოს, ჩვენ ვაპირებთ გამოვიყენოთ რეკურსიული ფუნქცია რეალურად ყველაფერი
მუშაობა ჩვენთვის, ისე ჩვენი ფუნქცია აპირებს ეწოდოს Unloader.
რა არის Unloader აპირებს?
ჩვენ ვხედავთ, აქ რომ Unloader აპირებს iterate მეტი ყველა ბავშვები
ამ კონკრეტულ კვანძის და თუ ბავშვს კვანძის არის არ null, მაშინ ჩვენ ვაპირებთ
განიტვირთოს კვანძზე.
>> ასე რომ, ეს აპირებს რეკურსიული განიტვირთოს ყველა ჩვენი შვილები.
მას შემდეგ, რაც ჩვენ დარწმუნებული ვარ, რომ ყველა ჩვენი ბავშვები უკვე დაცალა, მაშინ ჩვენ
შეგიძლიათ გასათავისუფლებლად საკუთარ თავს, ასე რომ განიტვირთოს ourself.
ასე რომ, ეს იქნება რეკურსიული განიტვირთოს მთელი trie, და შემდეგ კიდევ, რომ ის,
გაკეთდეს, შეგვიძლია უბრალოდ დააბრუნოს True.
განიტვირთოს ვერ ვერ, ჩვენ მხოლოდ ათავისუფლებს რამ.
ასე რომ ერთხელ ჩვენ გავაკეთეთ ათავისუფლებს ყველაფერი, დაბრუნების ჭეშმარიტი.
და რომ არის ის.
ჩემი სახელი არის რობ, და ამ იყო [INAUDIBLE].