[Powered by Google Translate] [Walkthrough - Проблем Постави 5]
[Zamyla Чан - Универзитетот Харвард]
[Ова е CS50. - CS50.TV]
>> Во ред. Здраво на сите, и добредојде да можи 5.
>> Pset5 е спелувањето грешки, во која ќе се прави магија-Проверка на.
Магија-дама се исклучително важни.
Има оваа некогаш ви се случило?
Работите многу, многу соберат на хартија за судир
а потоа уште завршуваат добивање на многу сјај Раде како D или D =
и сите, бидејќи вие сте liverwurst спојлер во кит широк збор.
Да, лекторирање вашиот пиперки е прашање на, најважната импотенција.
Ова е проблем кој влијае машки, машки студенти.
Јас бев еднаш изјави од страна на моите Sith одделение мачителот дека никогаш нема да влезат во добар колега.
И тоа е сè што некогаш сакав, тоа е се секое дете сака во мојата возраст,
само за да добие во добар колега.
И тоа не само било кој колега. Не сакав да одам во Брегот на Слоновата правни колега.
Значи, ако јас не подобрување, нема да биде мојот сон да одат на Харвард,
Jale, или затвор - знаеш, во затворот, Њу Џерси.
Па јас добив магија-Проверка на.
Тоа е малку извадок од една од моите омилени говорениот збор уметници, Тејлор Мали.
Како и да е, како што вели, важноста на се има магија-Проверка е многу важна.
>> Така добредојдени да можи 5, во која ќе се зборува за pset5: Грешките во правописот,
во која ќе се прави нашата сопствена магија-Проверка на.
Лента со алатки за оваа недела, дистрибуција код, ќе биде важно да се погледне
само да се разбере различни функции кои вашиот речник ќе има.
Ние сме всушност ќе треба да се има повеќе. В датотеки, кои заедно прават нашите pset.
И така гледајќи низ различни аспекти, иако ние, всушност, не уредување
еден од датотеки, speller.c, знаејќи како тоа функционира со однос на dictionary.c,
кои ќе бидат писмено, се случува да биде многу важно.
Спец pset исто така, содржи многу корисни информации
во однос на она што може да се претпостави, правила и работи како што,
па не заборавајте да го прочитате pset спецификации внимателно за совети.
И кога се двоумите на некое правило или нешто слично, тогаш секогаш се однесуваат на pset спецификации
или да дискутирате.
Ова pset се случува да се потпираат на покажувачи,
затоа сакаме да се осигураме дека можеме се разбере разликата помеѓу додавајќи ѕвезди
пред името на покажувачот и ampersands, како да ги ослободи, итн
Значи дека е господар на покажувачи се случува да биде многу корисна во овој проблем во собата.
Ние ќе се погледне во поврзани листи малку повеќе,
каде што имаме елементи што ние го нарекуваме јазли, кои имаат како вредност, како и покажувач
до следниот јазол, и така суштински ги поврзува различните елементи еден по друг.
Постојат неколку различни опции за спроведување на вашиот вистински речникот.
Ние ќе се погледне во два главни методи, што е хеш табели и потоа се обидува.
Во двата од овие, тие вклучуваат некој вид на идејата за поврзани листа
каде што ќе имаат елементи поврзани една со друга.
И така ние ќе се погледне околу тоа како може да биде во можност да работат околу поврзани листи,
создаде нив, отидете во смисла на тоа како, на пример, вметнете јазол во неа
или слободен сите јазли, како и.
Во однос на ослободувањето јазли, што е навистина важно
дека секогаш кога Примерок меморија, потоа ние ја ослободи.
Значи ние сакаме да се осигураме дека нема покажувачот се враќа unfreed, дека ние немаме меморија протекување.
Ние ќе се воведе алатка наречена Valgrind кој работи вашата програма
и проверува дали сите меморија, која ви распределени потоа ослободени.
Вашиот pset е само заврши кога таа работи и има целосна функционалност,
но, исто така, Valgrind ви кажува дека не сум нашол некое меморија протекување.
Конечно, за овој pset, навистина сакам да го истакнам -
Мислам, како и обично, јас сум дефинитивно поддржувач на користење на пенкало и хартија за вашиот проблем сетови,
но за ова, мислам дека пенкало и хартија ќе биде особено важно
кога сакате да се цртање стрелките за да работи и разбирање на тоа како работите работа.
Значи дефинитивно обидете да го користите пенкало и хартија да се подготви работи надвор пред да се кодирање
бидејќи тоа би можело да се добие малку неуредна.
>> Прво, ајде да одиме во поврзани листи малку.
Поврзани листи се состои од јазли, каде секој јазол има вредност поврзани со него,
како и покажувач кон следниот јазол по него.
Неколку работи важно со поврзани листи се што треба е да се запамети
каде нашиот прв јазол е, а потоа, кога веќе знаеме каде првиот јазол е,
на тој начин можеме да пристапите на јазол дека првиот јазол поени
а потоа еден по кои и онаа по неа.
А потоа последниот елемент во вашиот поврзани листа е показател дека јазол
секогаш ќе се укаже NULL.
Кога еден јазол поени во NULL, тогаш знаете дека сте стигнале до крајот на листата,
дека тој јазол е последната, дека нема ништо после тоа.
Овде, во овој шематски, ќе видите дека стрелите се покажувачи,
и сина дел е каде што вредноста се складира,
а потоа црвено поле со покажувачот е покажувач на јазол
укажува на следниот јазол по него.
И за да можете да видите тука, на јазол Д ќе укаже на NULL, бидејќи тоа е последниот елемент во листата.
>> Да ги погледнеме како да се дефинира структурата за еден јазол.
И бидејќи ние сакаме да има повеќе јазли,
ова ќе стане typedef struct
во која ние ќе да има неколку различни случаи на јазли.
И така ние го дефинираме како нов тип на податок.
Еве, ние имаме typedef struct јазол.
Во овој пример, ние сме се занимаваат со целобројни јазли,
па ние имаме цел број наречен вредност, а потоа имаме уште покажувач,
и во овој случај, тоа е покажувач кон еден јазол, па ние имаме struct јазол * наречен следната.
И тогаш се повикуваат целата оваа работа јазол.
Бидете сигурни дека ќе го следат овој синтакса.
Забележете дека јазол е всушност референцирани погоре, како и под кадрави загради.
Потоа да ги пратите на тоа каде мојот прв јазол е во овој поврзани листа,
тогаш имам еден јазол покажувач кој се нарекува главата, и јас Примерок простор доволно за големината на еден јазол.
Информации, меѓутоа, дека главата е всушност еден јазол покажувачот за разлика од вистински јазол себе.
Па главата всушност не содржи никаква вредност,
тоа само укажува на кое првиот јазол во мојот поврзани листа е.
>> Да се ​​добие подобро чувство на поврзани листи, бидејќи тоа е многу важно
да ги пратите на што си сигурен дека ќе се одржи на снабдување,
Сакам да мислам на тоа како луѓето во линија држејќи се за раце,
каде што секој човек се држат за раце со следниот.
Не можете да видите во овој цртеж, но во основа тие се укажува на следниот лице
што е во нивниот синџир.
И така, ако сакате да напречни поврзани листа, каде што овие луѓе -
Замислете сите оние луѓе имаат вредности поврзани со нив
и, исто така, укажуваат на следното лице во линија -
ако сакате да напречни поврзани листа, на пример, да ја уредувајте вредностите
или потрага по вредност или нешто слично,
тогаш ќе сакаат да имаат покажувач кон одредена личност.
Така ние ќе да има податочен тип јазол покажувач.
За овој пример, ајде да го наречеме курсорот.
Друг заеднички начин да го именува ова ќе биде iterator или нешто слично
бидејќи тоа е процесирањето над, а всушност се движат кој јазол тоа укажува на.
Ова тука ќе биде нашата курсорот.
Нашите курсорот прво ќе укаже на првиот елемент во нашата листа.
И така она што сакате да го направите е ние во основа ќе биде продолжување на курсорот,
преместувајќи го од земја до земја.
Во овој случај, ние сакаме да ја преместите во следниот елемент во листата.
Со низи, она што ние би направите е ние едноставно ќе се каже ние го зголеми индексот од 1.
Во овој случај, она што треба да направите е всушност најдете кое лице оваа актуелна лице е да се покажува,
и дека ќе биде следната вредност.
Значи, ако курсорот е само еден јазол покажувач, тогаш она што сакате да го направите
е ние сакаме да се дојде до вредноста што курсорот е да се покажува.
Ние сакаме да се дојде до тој јазол, а потоа, откако сме во тој јазол, се најде каде се укажува на.
Да се ​​дојде до вистински јазол дека курсорот е да се покажува,
обично ја покажуваат со (* курсорот).
Тоа ќе ви даде вистински јазол дека курсорот е да се покажува.
А потоа после тоа, она што сакате да направите е ние сакаме да пристапите
она што следната вредност јазол е.
Да го сторат тоа, за да пристапите на вредности во внатрешноста на struct, имаме точка оператор.
Па тогаш тоа ќе биде (* курсорот). Следната.
Но, ова е малку неуредна, во смисла на постоење на голема заграда околу * курсорот,
и така ние се замени целата оваа изјава со курсорот->.
Ова е спринт, а потоа поголема од знак, така што стрела.
курсорот-> следната.
Кои, всушност, ќе ти јазол дека курсорот поени. Таа вредност е следната.
Значи наместо ѕвездата и точка, ти си замена дека со стрела.
Бидете внимателни да бидете сигурни дека ќе се обидат да ја користите оваа синтакса.
>> Сега дека ние имаме курсорот, ако сакаме да пристапите на вредност,
пред тоа, моравме курсорот-> следната,
но за да пристапите на вредноста на јазол дека курсорот е да се покажува, ние едноставно се каже
јазол-> вредност.
Од таму, тоа е на податочен тип што и ние сме дефинирани вредностите и јазли да биде.
Ако тоа е int јазол, тогаш курсорот-> вредноста е само ќе биде цел број.
Значи можеме да направиме операции на тоа, проверете еднаквости, додели различни вредности, итн
Па тогаш што сакате да го направите ако сакате да ги преместите курсорот на следниот лице,
вие всушност промена на вредноста на курсорот.
Од курсорот е еден јазол покажувач, ќе го смените вистински покажувачот адреса
на адресата на следниот јазол во вашата листа.
Ова е само дел од кодот каде што можете да iterate.
Каде што имам коментар се направи нешто,
тоа е каде што сте веројатно нема да пристапите на вредноста
или направи нешто да се направи со таа специфична јазол.
Да ја започнете, јас велам дека мојот курсорот на почетокот
се случува да се укаже на првиот елемент во поврзани листа.
И така до пред, јас го дефинира како шеф на јазол.
>> Како што веќе напоменав претходно, ослободувајќи е навистина важно.
Вие сакате да бидете сигурни дека ќе се ослободи секој елемент во листата Откако ќе завршите со него.
Кога не треба да референца било која од овие совети веќе,
вие сакате да бидете сигурни дека ќе ги ослободи сите оние покажувачи.
Но сакате да бидете многу внимателни овде во која сакате да се избегне каква било меморија протекување.
Ако сте слободни едно лице предвреме, тогаш сите совети кои тој јазол поени
се случува да се изгуби.
Да се ​​вратам на лице пример да се направи малку повеќе високо ризична,
ајде да ги имаат овие луѓе, освен во овој случај тие се лебди над езерото со чудовиште.
Ние сакаме да бидете сигурни дека секогаш кога ослободи, ние не губат
и нека оди на сите јазли пред ние всушност ги ослободи.
На пример, ако сте во ситуација да едноставно се јавите бесплатно на овој човек овде,
тогаш тој ќе биде ослободен, но тогаш сите од овие момци, тогаш ќе бидат изгубени
и тие ќе лебдат надвор и да падне долу.
Значи, ние сакаме да се осигураме дека наместо тоа, ние сакаме да се задржи линк до останатите.
Нашата глава покажувач, што укажува на првиот елемент во листата.
Тоа е вид на како јаже закотвување прво лице.
Што можеби ќе сакате да направите кога ќе се ослободи листа се имаат -
Ако сакате да се ослободи првиот елемент, а потоа ќе може да има привремен покажувачот
што укажува на она што првиот елемент е.
Значи имате привремена покажувач укажува тука.
На тој начин, ние имаме одржи на првиот јазол.
И тогаш, бидејќи знаеме дека првиот јазол ќе биде ослободен,
тогаш можеме да се помести ова јаже, ова сидро, нашата глава,
всушност да укаже на она што првиот е да се покажува.
Значи оваа глава всушност укажува на вториот елемент сега.
Сега ние се дозволени да се ослободи што се чуваат во Temp,
и така ние може да се избрише дека без тоа загрозување на сите други јазли во нашата листа.
Друг начин на кој можете да го направите ова може да биде
секој пат кога ќе само ги ослободи последниот елемент во листата
затоа што тие се загарантирани да не се покажа ништо.
Па може само да се ослободи овој, тогаш слободно овој, тогаш слободно ова.
Тоа дефинитивно работи, но е малку побавен, бидејќи според природата на поврзани листи,
не можеме само веднаш скок до последен.
Ние мора да напречни секој елемент во поврзани листа
и проверете дали тоа е некој што укажува на NULL, проверете во секое време,
а потоа откако ќе стигне до крајот, а потоа слободно тоа.
Ако сте биле за да се направи овој процес, вие всушност ќе биде проверка тука,
проверка тука, потоа проверка тука, ослободувајќи го,
потоа ќе се вратам, проверка тука, проверка тука, ослободувајќи го,
проверка тука, а потоа го ослободи.
Кој потребно е малку повеќе време. Да.
>> [Студент] Дали тоа ќе биде можно да се направи поврзани листа која продавници излез покажувачот на крајот?
Тоа дефинитивно ќе биде можно.
Да го повтори прашањето, дали е можно да имаат поврзани листа структура
како што имате покажувачот покажува кон крајот на поврзани листа?
Јас би рекол дека е можно, и секој пат кога ќе внесете нешто во вашиот поврзани листа
ќе треба да се ажурира дека покажувачот и работи како што.
Вие ќе треба еден јазол * опашка, на пример.
Но, кога сте спроведување на оваа функција, треба да мислат на размени,
како колку пати сум јас ќе биде процесирањето во текот на овој,
Колку е тешко ќе биде да ги пратите на опашката, како и на главата
како и моите iterator, и работи како што.
Дали тоа - >> [Студент] Да.
Тоа е можно, но во поглед на дизајнот одлуки, треба да се разгледуваат опциите.
>> Тука е скелетот на код кој ќе ви овозможи да се ослободи секој елемент во поврзани листа.
Повторно, бидејќи јас сум процесирањето над поврзани листа, јас сум случува да сакаат да имаат некој вид на курсорот
или iterator.
Ние сме процесирањето додека курсорот е NULL.
Вие не сакате да iterate кога курсорот е NULL
затоа што тоа значи дека не постои ништо во листата.
Па потоа тука можам да направам привремена јазол *
укажува на она што сум размислува е прв на мојата листа,
а потоа се движи мојот курсорот пред 1 и тогаш слободно она што го имавме во привремено чување.
>> Сега доаѓаме до вметнување во поврзани листи.
Јас имам три јазли во мојата поврзана листа, и ајде да одиме со едноставен случај
каде што сакате да го внесете друг јазол на крајот на нашиот поврзани листа.
Да го сторат тоа, сите ние би направите е ние би напречни
да се најде каде што на тековната крајот на поврзани листа е, па без разлика кој јазол е да се покажува на NULL -
тоа е оваа -
и тогаш велат дека, всушност, ова не се случува да биде последен јазол;
ние всушност ќе имаме уште еден.
Значи ќе имаме оваа актуелна една точка на она што ние сме вметнување.
Па сега овој црвено лице тука станува последниот јазол во поврзани листа.
И така карактеристична за последниот јазол во поврзани листа е тоа што укажува на NULL.
Па тогаш што ќе треба да направите е да поставите покажувачот овој црвено човек да NULL. Таму.
>> Но, што ако сакаме да вметнете јазол помеѓу вториот и третиот?
Тоа не е толку едноставен, затоа што сакате да бидете сигурни
дека ние не се прости од било кој јазол во нашата поврзани листа.
Што ќе треба да направите е да бидете сигурни дека ние самите се зацврсти на секој од нив.
На пример, да ја наречеме оваа втората.
Ако ти рече дека втората сега укажува на тоа нова
и што ја направивте покажувач таму, тогаш тоа ќе резултира со овој човек се губи
бидејќи не постои каква било поврзаност со него.
Наместо - Јас ќе подготви ова повторно. Извинете мојот уметнички способности.
Ние знаеме дека не можеме само директно ги поврзува 2 до нов.
Ние мора да бидете сигурни дека ние се држи до последен.
Она што можеби ќе сакате да направите е да имаат привремен покажувачот
на елементот што се случува да се додадат на.
Па тогаш имаме привремено покажувачот таму.
Бидејќи знаеме дека овој третиот се чува песна на,
2 сега може да водат до нашиот нов.
И ако оваа нова црвена човек ќе биде помеѓу 2 и 3,
тогаш што е показател дека момчето ќе се укаже? >> [Студент] Темп.
Темп. Да.
Па тогаш следната вредност овој црвено момчето ќе биде Темп.
Кога сте вметнување во поврзани листи, видовме што би можеле да
лесно да додадете нешто на крајот, преку создавање на привремена низа,
или ако сакавме да додадете нешто во средината на нашата низа,
тогаш тоа ќе потрае малку повеќе довлечкаа наоколу.
Ако сакате да, на пример, има подредени поврзани листа,
тогаш мора да се вид на тежат на трошоците и придобивките од тој
затоа што ако сакате да имате решат низа, тоа значи дека секогаш кога ќе се вметне во него,
тоа ќе потрае малку повеќе време.
Сепак, ако сакате да подоцна, како ќе најдеме ние ќе сакаме,
пребарување преку поврзани листа, тогаш тоа би можело да биде полесно ако знаете дека сè е во ред.
Па можеби ќе сакате да тежат на трошоците и придобивките од тоа.
>> Друг начин да се вметне во поврзани листа е да се вметне во самиот почеток на листата.
Ако ние ја црпиме нашата сидро тука - ова е нашата глава -
а потоа се овие луѓе поврзани со него,
и тогаш имаме нов јазол да се вметнува во почетокот,
тогаш што би можеле да сакате да направите?
Што ќе биде во ред со само велејќи Сакам да се поврзат црвена до сина,
затоа што тоа е првиот?
Што би се случило овде?
Сите овие три ќе се изгуби.
Значи ние не сакаме да го стори тоа.
Повторно, ние научивме дека ние треба да имаат некој вид на привремена покажувач.
Ајде да изберете да имате привремена точка за овој човек.
Тогаш можеме да имаат сини една точка до привремена
а потоа црвена точка на сината боја.
Причината зошто јас сум со користење на луѓето овде е затоа што ние навистина сакаме да се визуелизира
држејќи се за луѓе и што си сигурен дека имаме линк до нив
пред да се прости од друга страна или нешто слично.
>> Сега кога имаме чувство на поврзани листи - како да се создаде поврзани листа
и да се создаде структури за кои се состојат од типот дефиниција за еден јазол
а потоа си сигурен дека имаме покажувачот на главата на тој поврзани листа -
Откако ќе го имаат тоа и знаеме како да напречни преку низа,
пристапите на различни елементи, знаеме како да се вметне и знаеме како да ги ослободи,
тогаш ние може да се добие во спелувањето грешки.
Како и обично, ние имаме дел од прашањата кои ќе ти користи за да работат со поврзани листи
и различни структури, како што редици и Купишта.
Тогаш можеме да се преселат во спелувањето грешки.
>> Спелувањето грешки има во дистрибуцијата кодот неколку датотеки на важност.
Прво ќе забележиме дека имаме оваа Makefile тука,
кои не сме навистина се соочуваат порано.
Ако сте виделе внатрешноста на pset5 папка, ќе забележите дека имате. Ж датотека,
тогаш имаш две. в датотеки.
Што ова Makefile не е порано, ние само би внеси го направи, а потоа името на програмата
и тогаш ќе видите сите овие аргументи и знамињата донесен во на компајлерот.
Што Makefile не е ни овозможува да ги собере неколку датотеки одеднаш
и помине во знамиња што сакаме.
Тука ние само види таму е хедер датотека тука.
Тогаш ние всушност имаат две изворни датотеки.
Имаме speller.c и dictionary.c.
Вие сте добредојдени да ги уредувате Makefile ако сакате.
Забележете дека тука ако го напишете чиста, тогаш она што го прави тоа е, всушност, ги отстранува нешто
што е суштината.
Ако ли сегментација грешка, во основа ќе добиете основни депонија.
Значи оваа грда малку датотека ќе се појави во вашиот директориум наречен јадро.
Ќе сакате да ја отстрани таа да го чисти.
Таа ги отстранува сите exe фајлови и. O датотеки.
>> Ајде да ги разгледаме во dictionary.h.
Ова се вели дека се декларира функционалноста на речникот.
Имаме Максималната должина за секој збор во речникот.
Велиме дека ова ќе биде најдолг можен збор. Тоа е со должина од 45.
Па ние нема да имате било какви зборови кои ги надминуваат таа должина.
Еве ние едноставно имаат функција прототипи.
Ние немаме вистински имплементација, бидејќи тоа е она што ќе се прави за овој pset.
Но, она што тоа не е, бидејќи ние сме се занимаваат со поголеми фајлови тука
и функционалноста на поголем обем, тоа е корисно да се има. ж датотека
така што некој друг читање или со користење на кодот може да се разбере она што се случува.
А можеби и тие сакаат да се имплементираат обидува, ако не хаш маси или обратно.
Тогаш тие би рекол мојот товар функција,
конкретната имплементација ќе се разликуваат, но овој прототип нема да се промени.
Еве ние се провери, кој враќа true ако даден збор е во речникот.
Тогаш имаме оптоварување, што во основа ги зема во речникот
а потоа го вчитува во некои податоци структура.
Имаме големина, кои, кога се нарекува, се враќа на големината на вашиот речник,
колку зборови се чуваат во него,
а потоа бриши, кој ослободува сите меморија која може да се дигаше
правејќи вашиот речник.
>> Ајде да ги разгледаме во dictionary.c.
Ќе видиме дека таа изгледа многу слично на dictionary.h, освен сега тоа само ги има сите овие Todos во неа.
И така тоа е вашата работа. Конечно, ќе се пополнување speller.c со сите на овој код.
Dictionary.c, кога работи, не е навистина се случува да се направи нешто,
па ние со нетрпение кон speller.c да се види фактичката имплементација на магија-Проверка на.
И покрај тоа што нема да биде уредување на било кој на овој законик,
важно е да се читаат, разбираат кога е оптоварување нарекува, кога сум јас повикувајќи чек,
само да се разбере, планирам тоа надвор, да видиме како функција работи.
Можеме да видиме дека тоа е проверка за правилно користење.
Во суштина, кога некој работи правопис, ова покажува дека тоа е опционално
за нив да помине во речникот датотека, бидејќи таму ќе биде стандардно речникот.
А потоа тие треба да поминат во текстот да биде магија-проверка.
rusage занимава со време, бидејќи дел од овој pset кои ние ќе се справи со подоцна
не е само добивање на функционирање магија-Проверка на работа
но всушност добивање на тоа да биде брзо.
И така тогаш тоа е каде rusage се случува да дојде внатре
Еве, гледаме првиот повик на еден од нашите dictionary.c датотеки, кој е товарот.
Оптоварување враќа точно или неточно - вистински врз успехот, лажни врз неуспех.
Значи, ако во речникот не е натоварен правилно, тогаш speller.c ќе се врати 1 и се повлече.
Но, ако тоа се вчита правилно, тогаш тоа ќе продолжи.
Ние продолжуваме, и можеме да видиме некои датотека I / O тука,
каде што тоа се случува да се занимаваат со отворање на текстуална датотека.
Еве, што тоа не е магија-проверка секој збор во текстот.
Значи она што speller.c прави токму тука е процесирањето над секој од зборовите во текстуална датотека
а потоа ги проверуваат во речникот.
Еве, ние имаме Булова погрешно напишани дека ќе се види дали проверка враќа точно или не.
Ако зборот е всушност во речникот, тогаш проверете ќе се врати вистина.
Тоа значи дека зборот не е погрешно напишани.
Значи погрешно напишани би било погрешно, и тоа е причината зошто имаме тресне таму, индикација.
Ние постојано да одам, а потоа следи колку погрешно напишани зборови
постојат во датотека.
Тоа продолжува и затвора датотека.
Потоа тука, таа извештаи колку погрешно напишани зборови сте имале.
Ја пресметува колку време е потребно за да се вчита во речникот,
колку време е потребно за да се провери тоа,
колку време е потребно за да се пресмета големината,
кои, како ќе одиме натаму, треба да биде многу мал,
а потоа колку време го зеде да се исклучи речникот.
Еве погоре можеме да видиме на повикот да се исклучи тука.
Ако ние се провери за големината тука,
тогаш можеме да видиме дека тука е повик за големината каде што ја одредува големината на речникот.
Страшни.
>> Нашата задача за оваа pset е да се имплементира оптоварување, што ќе внесе речникот
податочна структура - кое ке го одберете, тоа да биде хаш табелата или обидете -
со зборови од речникот.
Потоа мора големина, која ќе се врати на бројот на зборови во речникот.
И ако спроведе оптоварување на паметен начин, тогаш големината треба да биде прилично лесно.
Тогаш сте се провери, што ќе провери дали даден збор е во речникот.
Значи speller.c поминува во низа, а потоа мора да се провери дали стрингот
е содржан во рамките на вашиот речник.
Забележете дека ние обично имаат стандард речници,
но во овој pset, во основа било кој речник донесен во кој било јазик.
Па ние не може само да се претпостави дека зборот на е внатре.
Зборот foobar може да се дефинира во одреден речник што помине внатре
И тогаш имаме бриши, која го ослободува речник од меморијата.
>> Прво, јас би сакал да одам во текот на хаш табелата метод
за тоа како ние би можеле да ги спроведе сите од овие четири функции,
а потоа јас ќе одам во текот на обидува метод, како што ги спроведуваме овие четири функции,
и на крајот се зборува за некои општи совети кога сте правење на pset
а исто така и како може да биде во можност да го користите Valgrind да се провери за меморија протекување.
>> Ајде да се во хеш табелата метод.
А хаш табелата се состои од листа на кофи.
Секој вредност, секој збор, се случува да одам во една од овие кофи.
А хаш табелата идеално рамномерно ја распределува на сите овие вредности кои сте минува во
и потоа да ги населува во кофа дека таквите секоја канта
има околу еднаков број на вредности во него.
Структурата за хаш табелата, имаме низа на поврзани листи.
Што правиме е кога ќе помине во вредност, ние провериш од каде таа вредност треба да припаѓаат,
кој кофа таа и припаѓа, а потоа ставете ја во поврзаните листа поврзани со таа кофа.
Тука, она што го имам е хаш функција.
Тоа е int хаш табелата.
Значи за прв кофата, било цели броеви под 10 одат во првиот кофа.
Секое броеви над 10, но под 20 одат во второ,
а потоа така натаму и така натаму.
За мене, секоја канта се претставуваат овие броеви.
Сепак, велат дека требаше да помине во 50, на пример.
Се чини како ако првите три содржат голем број на десет броеви.
Но сакам да им овозможи на мојот хаш табелата да се земе во било кој вид на цели броеви,
па тогаш ќе морам да ги филтрираат сите броеви над 30 во последната кофа.
И така тогаш тоа ќе резултира со еден вид на неурамнотежен хаш табелата.
Да повторам, хаш табелата е само низа на кофи
каде што секој кофа е поврзано листа.
И така да се утврди каде секоја вредност оди, кои кофа што ќе влегува,
сте ќе сакате она што се нарекува hash функција
која зема вредност, а потоа вели оваа вредност одговара на одредени кофа.
Значи погоре во овој пример, мојот хаш функција зеде секоја вредност.
Го проверуваат дали тоа беше помалку од 10.
Ако тоа беше, тоа ќе го стави во првиот кофа.
Се проверува дали тоа е помалку од 20, го става во вториот ако е точно,
проверува дали тоа е помалку од 30, а потоа го става во третата кофата,
а потоа сè друго само паѓа на четвртата кофа.
Значи секогаш кога ќе имаат вредност, вашите хаш функција
ќе се одржи таа вредност во соодветната корпа.
Хаш функција во основа треба да знае колку корпи имаш.
Вашиот хаш табелата големина, бројот на кофи имате,
дека ќе биде фиксен број кој е до вас, за вас е да одлучите,
но тоа нема да биде фиксен број.
Така да твојот hash функција ќе се потпрам на тоа да се утврди кои кофа секој клуч оди во
како што тоа е рамномерно распределена.
Слична на нашата имплементација на поврзани листи, сега секој јазол во хеш табелата
е, всушност, ќе имаат еден вид знак.
Значи имаме знак низа наречен збор, а потоа уште еден покажувач кон следниот јазол,
што има смисла бидејќи тоа нема да биде поврзана листа.
Се сеќавам кога ние се поврзани листи, не сум направил еден јазол * нарекува глава
што беше посочувајќи на првиот јазол во поврзани листа.
Но, за нашите хаш табелата, бидејќи имаме повеќе поврзани листи,
она што го сакаме е ние сакаме нашите хаш табелата да биде како "Што е кофа?"
А кофа е само листа на јазол покажувачи,
и така секој елемент во кофа е, всушност, укажува на соодветните поврзани листа.
Да се ​​вратам на овој шематски, ќе видите дека на кофи и самите се на стрелките,
не е вистински јазли.
Еден од суштинско значење сопственост на хаш функции е дека тие се детерминистички.
Тоа значи дека секогаш кога ќе хаш број 2,
таа секогаш треба да се врати на истиот кофа.
Секој вредност што оди во хеш функција, ако се повтори,
мора да го добиете истиот индекс.
Така да твојот hash функција враќа индекс на низата
каде што вредноста му припаѓа.
Како што споменав порано, бројот на кофи е фиксна,
и така вашата индекс, кој ќе се вратите мора да биде помал од бројот на кофи
но е поголем од 0.
Причината зошто имаме хаш функции наместо на само еден единствен поврзани листа
или една единствена низа е дека ние сакаме да биде во можност да скокне до одреден дел најлесно
ако знаеме карактеристика на вредност -
наместо да пребарувате низ цела речник,
биде во можност да скокне до одреден дел од неа.
Вашиот хаш функција треба да се земе предвид дека идеално,
секоја канта има приближно ист број на копчиња.
Од хаш табелата е серија на поврзани листи,
тогаш поврзани листи самите се случува да имаат повеќе од еден јазол.
Во претходниот пример, два различни броеви, иако тие не беа еднакви,
кога hashed, ќе се врати истиот индекс.
Значи, кога ќе се занимаваат со зборови, со еден збор кога hashed
ќе бидат исти hash вредност како друг збор.
Тоа е она што ние го нарекуваме судир, кога имаме еден јазол, кога hashed,
на поврзани листа во тоа кофа не е празно.
Техниката што ние го нарекуваме постои линеарна љубопитство,
каде и да одите во поврзани листа, а потоа се најде таму каде што сакате да го внесете тој јазол
бидејќи имате судир.
Можете да видите дека таму не може да биде трампа тука, нели?
Ако имате многу мали хаш табелата, многу мал број на корпи,
тогаш ви се случува да имаат многу судири.
Но, тогаш ако се направи многу големи хаш табелата,
ти си веројатно нема да се минимизира судири,
но тоа ќе биде многу голема податочна структура.
Таму ќе биде размени со тоа.
Значи, кога сте правење на вашиот pset, обидете се да се позанимавам
помеѓу можеби прави помали хаш табелата
но потоа знаејќи дека тоа ќе потрае малку подолго да напречни различни елементи
на оние поврзани листи.
>> Што оптоварување се случува да направите е да iterate над секој збор во речникот.
Поминува покажувачот на речникот датотека.
Значи сте ќе треба да ги искористат предностите на датотека I / O функции кои ви владее во pset4
и iterate над секој збор во речникот.
Сакате секој збор во речникот да стане нов јазол,
и си оди за да поставите секој еден од оние јазли во внатрешноста на вашиот речник податоци структура.
Секогаш кога ќе добие нов збор, знаеш дека тоа се случува да стане јазол.
Па можете да се обратите достапен и Примерок еден јазол покажувачот за секој нов збор што го имате.
Еве јас го повикувам мојот јазол покажувачот new_node и јас сум mallocing што? Големината на еден јазол.
Потоа да го прочитате вистински низа од датотека, бидејќи речникот е, всушност, чуваат
со еден збор, а потоа нова линија, она што можеме да ги искористат предностите на
е во функција fscanf,
при што датотеката е во речникот датотека, дека ние сме поминале во,
така што скенира датотеката за една низа и места кои стринг во последните аргумент.
Ако се сеќавате назад кон една од предавања, кога отидовме во текот
и вид на излупени слоеви врати на библиотеката CS50,
видовме имплементација на fscanf таму.
Да се ​​вратиме на fscanf, имаме датотека која ние ја читаш од,
ние сме во потрага по низа во таа датотека, а потоа ние тоа ставање во
тука имам new_node-> зборот, бидејќи new_node е еден јазол покажувач,
не е вистински јазол.
Па тогаш сакам да кажам дека new_node, сакам да одам на јазол дека тоа укажува на
а потоа му ја додели таа вредност во Word.
Ние сакаме да тогаш земи тој збор и вметнете ја во хеш табелата.
Сфатат дека ние направивме new_node еден јазол покажувачот
бидејќи ние ќе сакаат да знаат што адресата на тој јазол е
кога ќе го вметнете во затоа структурата на јазли себе, на struct,
е дека тие имаат покажувач кон нов јазол.
Па тогаш што е адресата на тој јазол ќе се укаже?
Таа адреса ќе биде new_node.
Дали тоа има смисла, зошто правиме new_node еден јазол * што е спротивно на јазол?
Во ред.
Имаме збор. Таа вредност е new_node-> зборот.
Што содржи збор од речникот што сакаме да го внесете.
Значи она што сакате да го направите е да сакаме да се јавите на нашите хаш функција на тој стринг
бидејќи нашите хаш функција зема во низа, а потоа ни се враќа цел број,
каде што број е индекс каде Hashtable во тој индекс претставува дека кофа.
Ние сакаме да се земе дека индексот, а потоа одат за тоа индексот на хаш табелата
а потоа ја користат таа поврзани листа за да вметнете јазол во new_node.
Запомнете дека сепак се одлучите да го внесете вашиот јазол,
дали тоа е во средината ако сакате да го решите
или на почетокот или на крајот, само бидете сигурни дека вашата последна јазол секогаш укажува на NULL
затоа што тоа е единствениот начин на кој знаеме каде последниот елемент од нашата поврзани листа е.
>> Ако големината е цел број кој го претставува бројот на зборови во речникот,
тогаш еден начин да го направите ова е дека секогаш кога големина се нарекува
ние одат преку секој елемент во нашата хаш табелата
а потоа iterate преку секоја поврзани листа во рамките на хаш табелата
а потоа се пресмета должината на тоа, зголемување на нашите контра 1 до 1.
Но, секој пат таа големина се нарекува, тоа ќе трае долго време
затоа што ние ќе треба да биде линеарно љубопитство секој поврзани листа.
Наместо тоа, тоа ќе биде многу полесно ако ги пратите на колку зборови се пренесуваат внатре
Па тогаш ако вклучуваат контра во вашиот товар функција
дека надградби како што е потребно, тогаш контра, ако го поставите на глобалната променлива,
ќе бидете во можност да се пристапи од страна големина.
Значи она што големина едноставно не можеше да стори е во една линија, туку само го врати денарска противвредност,
големината на речникот, кој веќе се опфатени со товарот.
Тоа е она што мислев кога реков ако се спроведе оптоварување во корисен начин,
тогаш големина ќе биде прилично лесно.
>> Па сега ние да се провери.
Сега ние сме се занимаваат со зборови од влезот текстуална датотека,
и така ние ќе се проверува дали сите оние влез зборови
се всушност во речникот или не.
Слично на трка, ние сакаме да им овозможи за случајот нечувствителност.
Вие сакате да бидете сигурни дека сите зборови донесен во, иако тие се мешани случај,
кога наречен со низа споредба, се еквивалентни.
Зборовите во речникот текстуални датотеки се всушност сите мали букви.
Друга работа е тоа што може да се претпостави дека секој збор донесен во секој стринг,
ќе биде или азбучен или содржат апострофи.
Апостровите се случува да биде валидна зборови во нашиот речник.
Значи, ако имате еден збор со апостроф S, тоа е вистински легитимен збор во вашиот речник
тоа ќе биде еден од јазли во вашиот хаш табелата.
Проверете работи со ако зборот постои, тогаш тоа мора да биде во нашите хаш табелата.
Ако зборот во речникот, тогаш сите зборови во речникот се во хеш табелата,
па ајде да погледнеме за овој збор во хеш табелата.
Ние знаеме дека, бидејќи ние спроведува нашите хаш функција
така што секој единствен збор е секогаш hashed со иста вредност,
тогаш знаеме дека наместо пребарувањето преку нашите цела хаш табелата,
ние всушност може да се најде поврзани со листата што тој збор треба да припаѓаат.
Ако тоа се во речникот, тогаш тоа ќе биде во таа кофа.
Што да правиме, ако зборот е името на нашата стринг помина во,
можеме само хаш тој збор и поглед на поврзани листа
на вредноста на Hashtable [хаш (зборот)].
Од таму, она што можеме да направиме е имаме помали подмножество на јазли за пребарување за овој збор,
и така ние може да напречни поврзани листа, со користење на пример од почетокот на Walkthrough,
и потоа побарајте стринг споредуваат по зборот каде курсорот е да се покажува,
тој збор, и да видиме дали тие се споредуваат.
Во зависност од начинот на кој да ги организирате вашите хеш функција,
ако тоа е сортирана, може да биде во можност да се врати лажни малку порано,
но ако тоа е вон едиции, тогаш ќе сакате да продолжи минуваат преку вашиот поврзани листа
додека не го најде последниот елемент од листата.
И ако сеуште не сум нашол зборот од кога сте достигнавме крајот на поврзани листа,
тоа значи дека вашиот збор не постои во речникот,
и така тој збор не е валиден,
и проверка треба да се врати лажни.
>> Сега доаѓаме да се исклучи, каде што сакате да ги ослободи сите на јазли кои имаме malloc'd,
така слободно сите јазли во внатрешноста на нашите хаш табелата.
Ние ќе сакате да iterate во текот на сите поврзани листи и бесплатни на сите јазли во тоа.
Ако погледнете погоре во можи на пример, каде што ослободат поврзани листа,
тогаш ќе сакате да го повтори овој процес за секој елемент во хеш табелата.
И јас ќе одам во текот на овој кон крајот на Walkthrough,
но Valgrind е алатка каде што можете да видите дали сте правилно ослободен
секој јазол дека сте malloc'd или нешто друго што сте malloc'd, сите други покажувач.
Значи тоа е хеш табели, каде што имаме ограничен број на корпи
и хаш функција која ќе трае вредност, а потоа му ја додели таа вредност до одреден кофа.
>> Сега доаѓаме до обиди.
Се обидува вид на изгледаат вака, и јас исто така ќе го извлече пример.
Во суштина, имаш цела низа на потенцијални букви,
а потоа кога сте изградба на зборот,
дека писмото може да биде поврзан за речник на широк спектар на можности.
Некои зборови започне со C, но потоа продолжи со A,
но другите продолжуваат со O, на пример.
А Trie е начин на визуелизација на сите можни комбинации на овие зборови.
А Trie се случува да ги пратите на редоследот на буквите кои го сочинуваат зборови,
разгранување надвор кога е потребно, кога една буква може да се следи од страна на повеќе од букви,
и на крајот се покаже на секоја точка дали тој збор е валидна или не
бидејќи ако сте правопис на зборот МАТ, MA јас не мислам дека е валидна збор, но МАТ е.
И така во вашиот Trie, тоа ќе значи дека по МАТ тоа е всушност валидна збор.
Секој јазол во нашата Trie е, всушност, ќе содржи низа на јазол покажувачи,
и ние ќе имаат, поточно, 27 од овие јазол покажувачи,
една за секоја буква во азбуката, како и апостроф карактер.
Секој елемент во таа низа е сама по себе нема да укаже на друг јазол.
Значи, ако тој јазол е NULL, ако нема ништо после тоа,
тогаш знаеме дека нема повеќе букви во тој збор низа.
Но, ако тој јазол не е NULL, тоа значи дека постојат повеќе букви во тоа писмо секвенца.
А потоа понатаму, секој јазол покажува дали тоа е последниот карактер на зборот или не.
>> Ајде да одиме во еден пример на Trie.
Прво морам соба за 27 јазли во оваа низа.
Ако имам зборот БАР -
Ако имам зборот БАР и сакам да вметнете дека во,
првата буква е Б, па ако ми Trie е празна,
Б е втората буква од азбуката, така што јас ќе одам да изберат да се стави ова овде на овој индекс.
Одам да имаат Б тука.
Б ќе биде еден јазол што укажува на друга низа на сите можни знаци
дека може да се следат по писмото Б
Во овој случај, јас сум се занимаваат со зборот БАР, па ќе одиме тука.
По, имам писмо R, па потоа А сега укажува на своја комбинација,
а потоа R ќе биде тука.
БАР е комплетен збор, па потоа јас ќе одам да имаат Р точка до друг јазол
која вели дека тој збор е валидна.
Тој јазол, исто така, ќе имаат низа на јазли,
но тие би можеле да бидат NULL.
Но, во основа, може да продолжи така.
Тоа ќе стане малку повеќе јасно кога ќе одиме на друго пример,
па само го носат со мене таму.
Сега имаме БАР внатрешноста на нашите речникот.
Сега велат дека имаме зборот Баз.
Започнуваме со Б, а ние веќе имаат Б како еден од писмата што е во нашиот речник.
Тоа е проследено со А ние имаме веќе.
Но, тогаш, наместо тоа, имаме Z следниве.
Па тогаш елемент во нашата низа ќе биде Z,
и така тогаш тоа е ќе укажуваат на уште еден валиден крајот на зборот.
Така можеме да видиме дека кога ќе продолжи преку Б, а потоа,
постојат две различни опции во моментов во нашата речник за зборови што почнуваат со B и A.
Велат сакавме да внесете зборот foobar.
Тогаш ние ќе го направи влез во Ф
F е еден јазол што укажува на цела низа.
Ние ќе најдете О, одете на О О потоа и линкови до целата листа.
Ќе имаме Б, а потоа продолжи, би имале, а потоа Р
Па тогаш foobar преминува на целиот пат до foobar е точниот збор.
И така тогаш ова ќе биде валидна збор.
Сега велат нашите следниот збор во речникот е всушност зборот foo.
Ние би рекол Ф Она што следува F?
Јас всушност веќе имаат простор за О, па јас ќе одам да продолжи.
Јас не треба да се направи нов една. Продолжи.
Foo е валидна збор во овој речник, па потоа јас ќе одам да укажуваат
дека тоа е валиден.
Ако престанам секвенца таму, кои ќе бидат точни.
Но, ако ние продолживме нашата низа од FOO до Б
и само имаше FOOB, FOOB не е збор, а тоа не е означено како валидна.
Во Trie, имате секој јазол означува дали тоа е валидна збор или не,
а потоа секој јазол, исто така, има низа од 27 јазли совети
кои потоа точка на јазли себе.
>> Еве еден начин за тоа како можеби ќе сакате да се дефинира ова.
Сепак, исто како во хеш табелата пример, каде што имавме еден јазол * главата
за означување на почетокот на нашиот поврзани листа, ние исто така ќе сакате
некој начин на знаејќи каде на почетокот на нашата Trie е.
Некои луѓе го нарекуваат обидува дрвја, а тоа е каде корен доаѓа.
Затоа сакаме коренот на нашите дрво за да бидете сигурни дека ќе остане основа
до каде нашите Trie е.
Ние веќе вид на преминале
начинот на кој може да размислува за вчитување на секој збор во речникот.
Во суштина, за секој збор што сте ќе сакате да iterate преку вашиот Trie
и знаејќи дека секој елемент кај децата - ние го нарече деца во овој случај -
одговара на различни писмо, сте ќе сакате да се провери овие вредности
во тој одреден индекс, кој одговара на писмото.
Толку размислување на целиот пат назад кон Цезар и Vigenere,
знаејќи дека секоја буква можете вид на мапа назад кон индекс азбучен,
дефинитивно преку Z ќе биде прилично лесно да се мапираат со азбучен писмо,
но за жал, апостровите се исто така прифатена карактер со зборови.
Јас не сум сигурен дека дури и она што ASCII вредност е,
па за тоа ако сакате да најдете индекс да се одлучи дали сакате да се биде или првиот
или последната, ќе треба да се направи хард кодирани чек за тоа
а потоа се стави дека во 26 индекс, на пример.
Па тогаш сте проверка на вредноста на деца [i]
каде што [i] соодветствува на она писмо сте на.
Ако тоа е NULL, што значи дека во моментов не е било можно букви
произлегуваат од таа претходната секвенца, па сте ќе сакате да Примерок
и направи нов јазол и дека имаат деца [i] точка за да ја
така што ќе се создаде - кога вметнува писмо во правоаголникот -
што децата не-NULL и точка во која нов јазол.
Но, ако тоа не е NULL, како во нашата пример на foo
кога ние веќе foobar, ќе продолжиме,
и ние не сме воопшто да прави нов јазол туку само поставување is_word на true
на крајот на тој збор.
>> Па тогаш како и досега, бидејќи тука си имаш работа со секоја буква во еден момент,
тоа ќе биде полесно за вас за големина, наместо да се пресмета
и да си одат низ целото дрво и пресметајте колку деца имам
а потоа разгранување надвор, сеќавајќи се колку се на левата страна и на десната страна
и работи како што, тоа ќе биде многу полесно за вас
ако само ги пратите на колку зборови ќе бидете додавајќи во
кога си имаш работа со товарот.
И така, тогаш тој начин големина само да се вратат глобалната променлива на големина.
>> Сега доаѓаме да се провери.
Истите стандарди како и досега, каде што сакате да се овозможи случај нечувствителност.
Исто така, ние се претпостави дека конците се само азбучен карактери или апострофи
затоа што децата е низа од 27 долги,
па сите букви од азбуката плус апостроф.
За да провериш што ќе сакате да направите е ќе сакате да започнете во коренот
бидејќи коренот ќе укажуваат на низа која содржи
сите можни почетни букви на зборот.
Сте ќе почне таму,
а потоа ви се случува да се провери е оваа вредност NULL или не,
бидејќи ако вредноста е нула, тоа значи дека на речникот нема никакви вредности
кои содржат тоа писмо, во кои особено ред.
Ако тоа е NULL, тогаш тоа значи дека зборот е погрешно напишан веднаш.
Но, ако тоа не е NULL, тогаш може да се продолжи,
каже дека првата буква е можно првата буква во зборот,
па сега сакам да проверите дали второто писмо, таа секвенца, е во рамките на мојот речник.
Значи сте ќе треба да одат на индексот на децата од првиот јазол
и проверете дали тоа второто писмо постои.
Тогаш ќе повторам дека процесот да се провери дали таа секвенца е валидна или не
во рамките на вашиот Trie.
Секогаш кога јазол деца во тоа индексни поени во NULL,
знаеш дека таа секвенца не постои,
но тогаш, ако го достигнете крајот на зборот дека сте внесуваат,
тогаш ќе сакате да се провери сега што сум ги завршат оваа серија
и ја најдов во мојот Trie, е дека зборот валидни или не?
И така, тогаш ќе сакате да се провери тоа, а тоа е кога, ако го нашол дека низа,
тогаш ќе сакате да се провери дали тој збор е валидна или не
бидејќи сеќавам назад во претходниот случај дека јас привлече каде имавме FOOB,
тоа беше валидна секвенца која најдовме, но не беше вистински валидна самата збор.
>> Слично на тоа, за истовар во обиди дека сакате да го бриши сите јазли во вашиот Trie.
Жал ми е. Слично на хаш маси каде во бриши ние ослободени сите јазли,
во обиди сакаме исто така да ги ослободи сите на јазли.
Бриши, всушност, ќе работат најлесниот од дното кон врвот
бидејќи тие се во суштина поврзани листи.
Значи ние сакаме да се осигураме дека можеме се држи до сите вредности
и слободна сите од нив експлицитно.
Што ви се случува да сакате да направите, ако си работат со Trie
е да патуваат до дното и слободно најниска можна јазол првиот
и потоа оди до сите оние деца и тогаш слободно на сите оние,
одат нагоре, а потоа бесплатно, итн
Вид на како се занимаваат со долниот слој на Trie првиот
а потоа ќе до врвот еднаш сте ослободени сè.
Ова е добар пример за тоа каде рекурзивен функција може да ни се најде.
Откако ќе ослободи долниот слој на вашиот Trie,
тогаш јавете се исклучи на остатокот од него,
што си сигурен дека ве ослободи секој мини -
Можете вид на може да се визуелизира како мини обидува.
Па имате вашиот корен тука.
Јас сум само тоа поедноставување, па јас не треба да се подготви 26 од нив.
Па имате овие, а потоа овие претставуваат секвенци на зборовите
каде што сиве овие мали кругови се букви кои важат секвенци на букви.
Нека продолжи само малку повеќе.
Што ви се случува да сакате да направите, е слободен дното тука и тогаш слободно овој
и тогаш слободно ова на дното пред да се ослободи првите една до тука
бидејќи ако сте слободни нешто во втор степен тука,
тогаш вие всушност ќе го изгубат оваа вредност овде.
Тоа е причината зошто е важно во бриши за Trie да бидете сигурни дека ќе се ослободи дното во прв план.
Што можеби ќе сакате да направите е да се каже за секој јазол
Сакам да се исклучи сите деца.
>> Сега дека ние сме поминале над бриши за хаш табелата метод, како и начинот Trie,
ние ќе сакате да се погледне во Valgrind.
Valgrind трчате со следниве команди.
Имате valgrind-V.
Вие сте проверка за сите протекување кога ќе ја стартувате правопис даден овој одредено текст
бидејќи правопис треба да се земе во текстуална датотека.
Значи Valgrind ќе се кандидира на вашиот програма, да ти кажам колку бајти можете распределени,
колку бајти сте ослободени, а тоа ќе ви каже дали сте ослободени само доволно
или дали не сте доволно слободни,
или понекогаш може дури и над-бесплатно, како бесплатен еден јазол што веќе е ослободен
и така тоа ќе ви врати грешки.
Ако користите Valgrind, тоа ќе ви даде некои пораки
означува дали сте ослободени или помалку од доволно, доволно,
или повеќе од доволно пати.
>> Дел од оваа pset, тоа е задолжително да се спротивстават на Биг одбор.
Но, кога ние сме се занимаваат со овие структури на податоци
тоа е вид на забавно да се види колку брзо и колку ефикасна вашата структури на податоци може да биде.
Дали вашиот хаш функција резултира во многу судири?
Или е вашите податоци големина навистина голема?
Е потребно многу време да напречни?
Во дневникот на правопис, тоа излези колку време имате потреба при користење да се вчита,
да се провери, да се спроведе големина, и да се исклучи,
и така тие се испратени во големите одбор,
каде што може да се натпреварува против своите соученици
и некои членови на персоналот да се види кој има најбрзо магија-Проверка на.
Едно нешто што јас би сакал да се напомене за хаш маси
е дека постојат некои прилично едноставна хаш функции што би можеле да замислите.
На пример, имате 26 кофи, и така секој кофа
соодветствува на првата буква во зборот,
но тоа ќе резултира со доста неурамнотежен хаш табелата
бидејќи постојат многу помалку зборови што почнуваат со X од почеток со M, на пример.
Еден начин да се обратите за правопис е ако сакате да ги добиете сите од други функционалноста надолу,
тогаш само користење на едноставни хаш функција да биде во можност да ја добиете вашата код се извршува
а потоа се врати и менување на големината на вашиот хаш табелата и дефиниција.
Постојат многу ресурси на интернет за хаш функции,
и така за оваа pset ви е дозволено да истражување хаш функциите на интернет
за некои совети и инспирација додека вие бидете сигурни да се цитираат каде што сте го добиле од.
Вие сте добредојдени да се погледне и интерпретираат некои хаш функција дека ќе најдете на интернет.
Назад кон тоа, може да биде во можност да се види дали некој користи Trie
дали нивното спроведување е побрз од вашиот хаш табелата или не.
Можете да ги достават до Големиот одбор неколку пати.
Тоа ќе го снимите вашиот најновите влез.
Па можеби ќе го промените вашиот hash функција и потоа сфаќаат дека тоа е всушност многу побрзо
или многу побавно отколку порано.
Тоа е малку забавен начин.
Секогаш има 1 или 2 членови на персоналот кои се обидуваат да се направи најмал можен речник,
па тоа е секогаш забавно да се погледне.
>> Користењето на pset е да извршите правопис со изборен речникот
а потоа задолжително текст фајл.
По дифолт, кога ќе ја стартувате правопис со само еден текст фајл и не определи речник,
тоа се случува да го користите речникот текстуална датотека, голем еден
во cs50/pset5/dictionaries папка.
Дека еден има над 100.000 зборови.
Тие исто така имаат мал речник, кој има значително помалку зборови
дека CS50 има направено за вас.
Сепак, можете многу лесно само да направите свој речник
ако само сакате да се работи во мали примери -
На пример, ако сакате да го користите gdb и знаеш специфични вредности
што сакате вашиот хаш табелата да планирам да.
Така што само може да се направи свој текст датотека само со БАР, Баз, foo, а foobar,
направи тоа во текст датотека, изделат оние секоја со 1 линија,
а потоа направи свој текст датотека која буквално содржи само можеби 1 или 2 зборовите
така што ќе знаат точно што излезот треба да биде.
Некои од примерокот текстуални датотеки кои Големата одбор кога ќе ја стартувате предизвик ќе ги провери
се Војна и мир и Џејн Остин романот или нешто слично.
Значи, кога сте на почетокот, тоа е многу полесно да се направи свој текст датотеки
кои содржат само неколку зборови или можеби 10
така што ќе може да предвиди што резултатот треба да биде
а потоа го провериш против тоа, па повеќе од контролирани пример.
И така, бидејќи ние сме се занимаваат со предвидувањето и цртање работите околу,
повторно Сакам да ве охрабруваме да ги користите пенкало и хартија
затоа што тоа е навистина ќе ви помогне со оваа една -
цртање на стрели, како хеш табелата или како вашиот Trie изгледа,
кога сте ослободувајќи нешто каде што стрели се случува,
ви се држи за доволно, гледате какви било врски исчезнуваат
и паѓање во бездната на протекоа меморија.
Затоа ве молам, обидете се да се подготви работи надвор, дури и пред да стигнете до пишување код надолу.
Нацртај работи надвор, така што ќе се разбере како се одвиваат работите на работа
затоа што тогаш јас гарантирам дека ќе работи во помалку покажувачот muddles таму.
>> Во ред.
Сакам да ви посакам многу среќа со овој pset.
Тоа е веројатно најтешкиот еден.
Затоа пробајте да започне рано, цртаат работи надвор, цртаат работи надвор, и среќа.
Ова беше можи 5.
>> [CS50.TV]