>> [Музички]
>> Роб BOWDEN: Здраво.
Јас сум Роб.
И ајде ова решение надвор.
Па еве ние ќе се спроведе општа маса.
Можеме да видиме дека struct јазол на нашата маса ќе изгледа вака.
Па затоа се случува да имаат знак збор низа од големината должина + 1.
Не заборавајте + 1, со оглед на максимум збор во речникот е 45
карактери.
А потоа ние ќе ви треба една дополнителна карактер за обратна коса црта нула.
>> А потоа нашите hashtable во секој кофа ќе се складира
поврзана листа на јазли.
Ние не правиме линеарни љубопитство тука.
И така со цел да се поврзат со следниот елемент во кофа, потребен ни е
struct јазол * следната.
OK.
Значи тоа е она што еден јазол изгледа.
>> Сега тука е декларација на нашите hashtable.
Тоа се случува да имаат 16.834 кофи.
Но тој број не е важно.
И, конечно, ние ќе треба да имаат глобалната променлива hashtable големина, што
се случува да започнете како нула.
И тоа се случува да ги пратите на тоа како многу зборови се наоѓаат во нашата речникот.
>> Па ајде да ги разгледаме во товарот.
Забележите дека товарот, го враќа bool.
Ќе се вратите точно ако тоа беше успешно вчитан, и лажни поинаку.
И е потребно const char * речник, кој е речникот
дека сакаме да се отвори.
Па тоа е првото нешто ние ќе се направи.
>> Ние ќе fopen на речник за читање.
И ние ќе треба да се направи сигурни дека тоа успеа.
Значи, ако се врати NULL, тогаш ние не сме успешно да се отвори во речникот.
И ние треба да се врати лажни.
Но претпоставувајќи дека тоа го правеше успешно отвори, а потоа ние сакаме да го прочитате
речникот.
Значи имајте looping додека не се најде некој причина да се пробие на овој циклус,
кој ќе видиме.
Значи имајте looping.
>> И сега ние ќе треба да Примерок еден јазол.
И се разбира, ние треба да воздух проверете повторно.
Па ако mallocing не успее, тогаш ние сакаме да се исклучи било кој јазол дека ние
се случи со Примерок пред, во близина на речник и да се врати лажни.
Но игнорирањето тоа, претпоставувајќи дека успеа, тогаш сакаме да се користи fscanf
да се прочита еден збор од нашиот речникот во нашите јазол.
Па се сеќавам дека влез> збор е знак Зборот тампон големина LENGHTH + 1
дека ние ќе треба да се сместат на зборот внатре
>> Па fscanf се случува да се врати 1, се додека како што беше во состојба успешно да
чита зборот од датотеката.
Ако било грешка се случува, или ние стигнат до крајот на датотеката, таа
нема да се врати 1.
Во кој случај не го врати 1, ние сме конечно ќе излезат од
ова додека јамка.
Така можеме да видиме дека еднаш имаме успешно чита збор во
влез> зборот, тогаш ние ќе треба да дека Зборот за користење на нашата хеш функција.
>> Ајде да ги разгледаме во хаш функција.
Така да навистина не треба да се разбере ова.
А всушност ние само се повлече овој хаш функционира од интернет.
Единственото нешто што треба да се признае е дека ова се const char * збор.
Па тоа е преземање на низа како влез, и враќање на непотпишана int како излез.
Па тоа е сите хеш функција е, тоа е зема во влез и ви дава
индекс во hashtable.
>> Забележете дека ние сме moding од NUM_BUCKETS, така што вредност врати
всушност е индекс во hashtable и не индекс надвор од
границите на низата.
Па со оглед на тоа функционира, ние ќе да хаш зборот што го читаме
речникот.
А потоа ние ќе го користите дека хаш да го вметнете
влез во hashtable.
>> Сега hashtable хаш е моменталниот поврзана листа во табелата.
И тоа е многу можно дека тоа е само NULL.
Ние сакаме да го внесете нашиот влез на почетокот на овој поврзана листа.
И така ние си оди за да имаат нашите сегашни влезна точка на она што hashtable
во моментов посочува.
И тогаш ние ќе ги чувате, во hashtable во
хаш, сегашниот влез.
Значи овие две линии успешно вметнете влез на почетокот на
поврзана листа на тој индекс во hashtable.
>> Откако ќе завршиш со тоа, знаеме кои ние откривме друг збор во
речник, и ние прираст повторно.
Па ние го задржи тоа го прават додека fscanf конечно се врати нешто не-1 на
која точка да се запамети дека ние треба да се ослободи влез.
Значи тука имаме malloced запис.
И се обидовме да прочитате нешто од речникот.
И ние не успешно го прочитате нешто од речникот, во
кој случај ние треба да се ослободи влезот дека ние всушност никогаш не се стави во
hashtable, и конечно се скрши.
>> Откако ќе се пробие ние треба да се види, добро, не ни се пробие затоа што има
Се појави грешка при читањето од датотеката?
Или не ние се пробие, бидејќи ние до крајот на датотеката?
Ако има грешка, тогаш ние сакаме да се врати лажни.
Бидејќи товарот не успее.
И во процесот ние сакаме да се исклучи сите зборови, што читаме во, и
затвори речникот.
>> Претпоставувајќи ние не успее, тогаш ние само уште треба да се затвори речникот
поднесе, и конечно враќање вистина, бидејќи ние успешно вчитан речникот.
И тоа е тоа за товарот.
Па сега провери, со оглед натоварени hashtable, ќе изгледа вака.
Па провери, го враќа bool, што е ќе покаже дали помина
во char * збор, дали помина во стринг е во нашата речникот.
Значи, ако тоа е во речникот, ако тоа е во нашата hashtable,
ние ќе се врати вистина.
И ако тоа не е, ние ќе се врати лажни.
>> Имајќи го предвид ова донесен во збор, ние сме ќе хаш на зборот.
Сега важна работа да се признае е дека во товарот знаевме дека сите
зборови ние ќе биде помал случај.
Но тука ние не сме толку сигурни.
Доколку ги разгледаме во нашата хеш функција, нашите хаш функција, всушност,
е помал обвивка секој карактер на зборот.
Значи без оглед на капитализација на збор, нашата hash функција е враќање
истиот индекс за без оглед на капитализација е, како што ќе има
врати за сосема мали верзија на зборот.
Во ред.
Тоа е нашиот индекс е во Hashtable за овој збор.
>> Сега ова за телефонска линија ќе iterate преку поврзана листа
кој беше во тој индекс.
Така забележите ние сме иницијализацијата влез да се укаже на тој индекс.
Ние ќе продолжиме додека влез! = NULL.
И се сеќавам дека ажурирање на покажувачот во нашата поврзана листа влез = влез> Next.
Па имаат нашите сегашни влезна точка за да следната точка во поврзана листа.
>> Значи за секој влез во поврзана листа, ние ќе го користите strcasecmp.
Тоа не е strcomp.
Бидејќи уште еднаш, ние сакаме да се прават работите случај буквите.
Па ние ги користиме strcasecmp да се споредат збор кој беше донесен во текот на овој
функција против зборот што е во овој запис.
Ако го враќа нула, што значи дека имаше еден натпревар, во кој случај ние сакаме да
врати вистина.
Ние успешно се најде на збор во нашите hashtable.
>> Ако не беше еден натпревар, тогаш ние сме ќе јамка повторно и се погледне на
Следниот влез.
И ние ќе продолжиме looping додека постојат се записи во оваа поврзани листа.
Што се случува ако ние се скрши надвор од овој за телефонска линија?
Тоа значи дека ние не најде запис дека одговараше овој збор, во кој случај
ние се врати лажни за да се покаже дека нашите hashtable не содржи овој збор.
И тоа е чек.
>> Па ајде да ги разгледаме во големина.
Сега големина ќе биде прилично едноставна.
Од сеќавам во оптоварување, за секој збор најдовме, ние зголемува глобалната
променлива големина hashtable.
Па големината функција е само ќе да се вратат глобалната променлива.
И тоа е тоа.
>> Сега, конечно, ние треба да се вчита на речник еднаш сè е направено.
Па, како ќе се дојде да го направите тоа?
Токму тука ние сме looping преку сите кофи со нашата маса.
Па така постојат NUM_BUCKETS кофи.
И за секоја поврзана листа во нашата hashtable, ние ќе треба да прават јамки низ
интегритет на поврзаните листа, ослободување секој елемент.
>> Сега ние треба да се биде внимателен.
Значи тука имаме привремена променлива тоа е чување на покажувачот на следната
елемент во поврзана листа.
А потоа ние ќе слободен тековниот елемент.
Ние треба да бидеме сигурни дека ние го правиме ова, бидејќи ние не може само слободен тековниот елемент
а потоа се обиде да пристапи на следната покажувач, бидејќи еднаш ние сме го ослободија,
меморија станува неважечка.
>> Значи ние треба да се задржи околу покажувачот на следниот елемент, тогаш можеме да го ослободи
тековниот елемент, а потоа можеме да се ажурира нашите сегашни елемент да се укаже на
следниот елемент.
Ќе јамка додека постојат елементи во овој поврзана листа.
Ние ќе го направи тоа за сите поврзани листи во hashtable.
И штом ќе завршиш со тоа, ние сме целосно истоваруваат hashtable, и
ние сме направиле.
Така што е невозможно за бриши да некогаш се врати лажни.
И кога ќе завршиш, ние само врати вистина.
>> Ајде да им даде на ова решение, се обиде.
Па ајде да ги разгледаме во она што нашите struct јазол ќе изгледа.
Овде можеме да видиме ние ќе имаат bool збор и struct јазол * деца
заградата писмо.
Така првото нешто што може да биде се прашувам, зошто е ALPHABET
ед дефинирана како 27?
Добро, се сеќавам дека ние ќе треба да се справува со апостроф.
Така што нема да биде нешто на некој посебен случај во текот на оваа програма.
>> Сега се сеќавам како TRIE всушност работи.
Да речеме дека ние сме индексирање зборот "Мачки". Потоа од коренот на TRIE,
ние ќе се погледне на деца низа, и ние ќе треба да се погледне на
индекс, кој одговара на писмото C. Значи дека ќе бидат индексирани 2.
Па со оглед на тоа, дека ќе ни даде нов јазол.
А потоа ние ќе работат од тој јазол.
>> Па со оглед на тоа јазол, ние сме уште еднаш ќе се погледне на децата низа.
И ние ќе да се погледне во индекс нула за да одговараат на А во мачка.
Па тогаш ние ќе треба да одат на тој јазол, и со оглед на тоа јазол ние ќе
да се погледне на крајот тоа е одговара со Т и премина на тој јазол,
Конечно, имаме целосно погледна преку нашето слово "мачка". И сега bool
зборот би требало да покажат дали ова даден збор е всушност еден збор.
>> Па зошто не ни треба тој посебен случај?
Па, она што на зборот "катастрофа" е во нашата речник, но
Зборот "мачка" не е?
Па и бара да се види дали зборот "мачка" е во нашата речник, ние сме
ќе успешно се погледне преку индексите C-A-T во регионот јазол.
Но, тоа е само затоа што катастрофа се случи да се создаде јазли на пат
од C-A-T, сите на начин да на крајот на збор.
Па bool збор се користи за да се покаже дали овој одредена локација
всушност укажува на зборот.
>> Во ред е.
Па сега дека знаеме што TRIE е ќе изгледа, ајде да се погледне на
вчитување функција.
Значи оптоварување се случува да се врати bool за тоа дали ние успешно или
неуспешно натоварен речникот.
И ова ќе биде речникот дека сакаме да се вчита.
>> Па првото нешто сакаме да направите е да отворите до кои речник за читање.
И ние треба да бидете сигурни дека ние не успеваат.
Па ако речникот не беше успешно отворен, ќе се врати
нула, во кој случај ние сме ќе се врати лажни.
Но претпоставувајќи дека тоа успешно отвори, тогаш ние всушност може да се прочита
преку речникот.
>> Па првото нешто ние ќе треба да сакате да направите е да ја имаме оваа
глобалната променлива корен.
Сега корен ќе биде еден јазол *.
Тоа е на врвот на нашата TRIE дека ние сме ќе треба да се процесирањето преку.
Така првото нешто што ние ќе да сакаат да направите е да се доделат
меморија за нашиот корен.
Забележете дека ние сме со користење на calloc функција, која е во основа иста
како Примерок функција, освен тоа е гарантирано да се вратат нешто што е
целосно zeroed надвор.
Значи, ако ние се користи Примерок, ние ќе треба да се поминат низ сите покажувачи во нашата
јазол, и бидете сигурни дека сите тие се ништовни.
Па calloc ќе го правам тоа за нас.
>> Сега само како Примерок, ние треба да се направи сигурни дека распределбата беше, всушност,
успешна.
Ако ова се врати на нула, тогаш ние треба да се затвори или речник
датотека и враќање false.
Значи под претпоставка дека распределбата беше успешна, ние ќе треба да се користи еден јазол *
курсорот да iterate преку нашата TRIE.
Па нашите корени никогаш нема да се промени, но ние ќе се користи покажувачот
всушност, оди од јазол да јазол.
>> Така што во овој за телефонска линија читаме преку речникот.
И ние сме со користење fgetc.
Fgetc се случува да го зграби еден карактер од датотеката.
Ние ќе продолжиме грабање карактери, додека ние не се постигне
крајот на датотеката.
>> Постојат два случаи ние треба да се справи.
Прво, ако карактерот не е нова линија.
Па знаеме дали тоа беше нова линија, а потоа ние сме за да се движи кон нов збор.
Но под претпоставка дека тоа не е нова линија, а потоа Еве ние сакаме да дознаам
индекс ние ќе индекс во кај децата низа што
ние погледна порано.
>> Значи, како што реков претходно, ние треба да се посебен случај на апостроф.
Забележете ние сме со користење на тројна оператор тука.
Па ние ќе го прочитате овој пример, ако ликот што читаме во беше
апостроф, тогаш ние ќе треба да се постави индекс = "азбука", која -1 ќе
биде индекс 26.
>> Друго, ако не беше апостроф, има ние ќе се постави на индекс
еднаква на c - a.
Значи се сеќавам назад од претходно п-сетови, в - а се случува да ни даде
азбучен позиција на C. Значи, ако C е буквата А, ова ќе
ни даде индекс нула.
За буквата Б, тоа ќе им даде ни индекс 1, и така натаму.
>> Па ова ни дава индекс во деца низа што сакаме.
Сега, ако овој индекс е моментално null во децата, што значи дека еден јазол
во моментов не постојат од тој пат.
Значи ние треба да ги распредели јазол за тој пат.
Тоа е она што ние ќе направиме тука.
>> Па ние ќе повторно да ги користите calloc функција, така што ние не треба да се
нула надвор сите покажувачи.
И повторно треба да се провери дека calloc не пропадне.
Ако calloc не успее, тогаш ние треба да се исклучи сè, да ги затвориме
речник, и да се врати лажни.
Значи под претпоставка дека тоа не успее, тогаш ова ќе се создаде нов дете за нас.
И потоа ќе одат на тоа дете.
Нашите курсорот ќе iterate надолу за да тоа дете.
>> Сега, ако ова не е нула за да започне со тоа, тогаш покажувачот само да iterate
надолу за да тоа дете без всушност мора да се доделат ништо.
Ова е случај каде што првпат се случи распредели на зборот "мачка". И
тоа значи дека кога одиме за алоцирање на "Катастрофа", ние не треба да се создаде
јазли за C-A-T повторно.
Тие веќе постои.
>> Што е ова на друго место?
Ова е состојба каде што в беше обратна коса црта n, каде в е нова линија.
Ова значи дека имаме успешно заврши збор.
Сега што сакаме да правиме кога ќе успешно заврши еден збор?
Ние ќе се користи овој збор поле внатрешноста на нашите struct јазол.
Ние сакаме да го поставите тоа да се оствари.
Така што укажува на тоа дека овој јазол покажува успешна
збор, вистински збор.
>> Сега го поставите тоа да се оствари.
Ние сакаме да ги ресетирате нашите курсорот точка на почетокот на TRIE повторно.
И конечно, прираст нашите речник големина, бидејќи ние се најде друга работа.
Па ние ќе да се задржи тоа го прават, читање во знак по знак,
изградба на нови јазли во нашата TRIE и за секој збор во речникот, додека
ние конечно се постигне Ц! = EOF, во која случај ние се пробие на датотеката.
>> Сега постојат два случаи под кои би можеле да имаат хит EOF.
Првиот е ако имало грешка читање од датотеката.
Значи, ако имало грешка, ние треба да се направи типичен.
Бриши сè, во близина датотеката, враќање false.
Под претпоставка дека не беше грешка, дека само значи дека ние всушност хит на крајот на
на датотеката, во кој случај, ние затвори датотека и враќање вистина, бидејќи ние
успешно вчитан речник во нашите TRIE.
>> Па сега нека проверат чек.
Гледање на проверка функција, гледаме таа опција ќе се врати bool.
Тоа враќа true ако овој збор дека тоа е се пренесува е во наши TRIE.
Го враќа false.
Па како ви се утврди дали овој збор е во наши TRIE?
>> Гледаме дека овде, исто како и пред тоа, ние ќе се користи покажувачот да iterate
преку нашата TRIE.
Сега тука ние ќе iterate над целата наша збор.
Па процесирањето над зборот ние сме минато, ние ќе утврди
индекс во низа деца кои одговара на зборот заградата I. Значи ова
се случува да изгледаат точно како оптоварување, каде што ако зборот [i]
е апостроф, тогаш сакаме да се користи индекс "азбука" - 1.
Бидејќи ние утврди дека е местото каде што ние ќе треба да се сместат
апострофи.
>> Друг ние ќе користат две пониски збор заградата I. Значи се сеќавам тој збор може да
имаат произволен капитализација.
И затоа сакаме да бидете сигурни дека ние сме користење на мали верзија на нештата.
А потоа одземе од тоа "а" уште повторно ни даде азбучен
позиција на таа карактер.
Така што ќе биде нашиот индекс во децата низа.
>> И сега, ако тој индекс во децата низа е нула, тоа значи дека ние
не може да продолжи процесирањето одредување на нашите TRIE.
Ако тоа е случај, овој збор не може можност да биде во нашите TRIE.
Бидејќи ако тоа се, кои би значи дека ќе биде патеката
одредување на тој збор.
И никогаш не би се судрите со нула.
Така наиде на нула, ќе се вратиме лажни.
Зборот не е во речникот.
Ако не беше нула, тогаш ние сме ќе процесирањето продолжи.
>> Па ние ќе таму курсорот да се укаже на тоа особено
јазол на тој индекс.
Ние го задржи тоа дека во текот на целиот збор, претпоставувајќи
ние никогаш не го погоди нула.
Тоа значи дека бевме во можност да се добие преку целиот збор и да се најде
јазол во нашата проба.
Но, ние не сме сосема направиле досега.
>> Ние не сакаме само да се врати вистина.
Ние сакаме да се врати курсорот> зборот.
Од сеќавам еднаш, е "мачка" не е во нашата речник, и "катастрофа"
е, тогаш ние ќе успешно ќе го добиеме преку зборот "мачка". Но курсорот
Зборот ќе биде лажен и не е точно.
Па ние се врати курсорот збор за да се покаже дали овој јазол е всушност еден збор.
И тоа е тоа за чек.
>> Па ајде проверете големина.
Па големината ќе биде прилично лесно бидејќи, се сеќавам во оптоварување, ние сме
зголемување, Речник големина за секој збор што се сретнуваме.
Па големината е само ќе врати речник големина.
И тоа е тоа.
>> Па на крај имаме исклучи.
Па бриши, ние ќе треба да се користи рекурзивен функција да всушност прават сите
на работа за нас.
Значи, нашата функција ќе бидат повикани unloader.
Што unloader случува да се направи?
Гледаме дека овде unloader се случува да се iterate во текот на сите деца во
ова особено јазол.
И ако јазол не е нула, тогаш ние ќе треба да
бриши јазол.
>> Значи ова е дека рекурзивно бриши сите на нашите деца.
Еднаш ние сме сигурни дека сите наши деца се растоварува, тогаш ние
може да се ослободиме, па бриши нас самите.
Ова ќе работи рекурзивно бриши целиот TRIE.
А потоа, откако тоа е направено, ние само може да се врати вистина.
Бриши не може да пропадне.
Ние сме само што си заштедувате работи.
Значи еднаш сме завршиш ослободување сè, се врати вистина.
И тоа е тоа.
Моето име е Роб.
И тоа беше правопис.
>> [Музички]