>> [Музички]
>> Даг LLOYD: Добро, па така, оваа точка во се разбира,
ние сме опфатени голем број на основите на В. Знаеме многу за променливите, низи,
покажувачи, сето тоа добри нешта.
Тоа се сите вид на гради за да ја видите како основи,
но можеме да направиме повеќе, нели?
Ние може да се комбинираат работи заедно со интересни начини.
>> И па ајде да го направите тоа, ајде да почнеме да филијала надвор од она што ни дава С,
и да почне да креирате сопствени податоци структури користење на овие градежни
блокови заедно да се направи нешто навистина вредно, корисно.
Еден начин на кој можеме да го направите ова е да се зборува за колекционери.
Па досега имавме еден вид на податоци структура за застапување колекции
од допаѓа вредности, слични вредности.
Тоа би било низа.
Имаме збирки на цели броеви, или збирки на ликови и така натаму.
>> Структури се исто така еден вид на податоци структура за собирање на информации,
но тоа не е за собирање како вредности.
Тоа обично се меша различни типови на податоци заедно во внатрешноста на една кутија.
Но тоа не е сама по себе се користи за да синџирот заедно
или да се поврзете заедно слични предмети, како и низа.
Низи се одлични за елемент гледам нагоре, но да се потсетиме
дека тоа е многу тешко да се вметне во низа,
Освен ако не сме вметнување на На самиот крај на таа низа.
>> А најдобар пример имам за тоа е вметнување вид.
Ако се сеќавате нашата видео на вметнување вид,
имаше многу трошоци кои се вклучени во се има
да ги собереш елементи, и промена нив од начинот на кој да ги собере нешто
во средината на вашата низа.
Низи исто така страдаат од друга проблем, кој е нефлексибилност.
Кога ќе се изјаснат за низа, добиеме еден истрел во тоа.
Ние се да се каже, сакам ова многу елементи.
Може да биде 100, тоа би можело биде 1.000, тоа би можело
биде x каде што x е број кој на корисникот ни даде на брза или во командната
на линија.
>> Но ние само се добие една шанса кај него, ние не дојде до тогаш велат ох, јас, всушност,
потребни 101, или ми требаше х плус 20.
Предоцна, ние сме веќе прогласи низа, и ако сакаме да се добие 101 или x
плус 20, ние мора да се декларираат еден сосема поинаков низа,
копија на сите елементи на низата над, а потоа имаме доволно.
А што ако не сме во право, повторно, она што ако ние всушност се потребни 102, или x плус 40,
ние треба да го направите ова повторно.
Па тие се многу нефлексибилен за промена на големината на нашите податоци,
Но, ако ние се комбинираат заедно некои на основите дека ние сме веќе
научиле за покажувачи и структури, особено со употреба на динамичка меморија
распределба со Примерок, ние Може да се стави овие парчиња заедно
да се создаде нови податоци structure-- на одделно поврзани листа би можеле да say--
која ни овозможува да расте и да се смалуваат колекција на вредности
и ние нема да има никакви потроши простор.
>> Значи, повторно, ние го нарекуваме оваа идеја, овој поим, а поврзани листа.
Особено, во ова видео, ние сме Станува збор за одделно поврзани листа,
а потоа уште еден видео ќе зборуваме за двојно поврзана листи, што
е само варијација на тема тука.
Туку одделно поврзани листа се состои од јазли,
јазли само да биде апстрактен term-- тоа е само нешто јас го повикувам
тоа е еден вид на структурата, во основа, јас сум?
Само ќе го наречеме node-- и ова јазол има два члена, или две полиња.
Таа има податоци, обично цел број, карактер плови,
или може да биде некој друг тип на податоци што сте ги дефинира со еден вид дефиниција.
И тоа што содржи покажувач друг јазол од ист вид.
>> Па ние имаме две работи во внатрешноста на овој јазол, податоци и покажувач
до друг јазол.
И ако почнете да се визуелизира ова, може да се размислува за тоа
како еден синџир на јазли кои се поврзани заедно.
Имаме првиот јазол, таа содржи податоци, и покажувач
на вториот јазол, кој содржи на податоци, и покажувач кон третиот јазол.
И така тоа е причината зошто ние го нарекуваме поврзани листа, тие се поврзани заедно.
>> Што значи оваа специјална јазол структура изгледа?
Па, ако се потсетиме од нашата видео на дефинирање на сопствени типови, со тип дефиниција,
можеме да го дефинираме и structure-- напишете дефинира структурата се допаѓа ова.
tyepdef struct sllist, а потоа сум Користејќи Word вредност тука произволно
за да се покаже било кој тип на податоци навистина.
Вие би можеле да го поминат на цел број или подвижна запирка, може да имаш што сакаш.
Тоа не е ограничена на само цели броеви, или нешто слично.
Па вредноста е само произволна тип на податоци, а потоа и на покажувачот
до друг јазол од ист вид.
>> Сега, постои малку улов тука со дефинирање на структурата
кога тоа е структура авто-референтните.
Морам да имаат привремена именува за мојата структура.
На крајот од денот, јас јасно да сакате да го наречеме
SLL јазол, кој е во крајна линија на нови именува дел од мојата дефиниција за тип,
но не можам да го користите SLL јазол во средината на оваа.
Причината е, не сум создаде вид наречен SLL јазол
додека не го погоди овој крајната точка тука.
Се до таа точка, јас треба да имаат уште еден начин да се однесуваат на овој тип на податок.
>> И ова е само референцијални тип на податок.
Тоа, е тип на податоци на структура која содржи податоци,
и покажувач кон друг структура на истиот тип.
Значи ми треба да биде во можност да се однесуваат на овој тип на податоци, барем привремено,
па тоа дава привремена името на struct sllist
ми дозволува да потоа да се каже Јас сакам Покажувач на друг struct sllist,
на struct sllist ѕвезда, а потоа јас откако ќе заврши дефиниција,
Сега можам да го наречеме овој тип на SLL јазол.
>> Па затоа ќе го видите тука е привремено име тука,
но постојан име.
Понекогаш може да се види дефиниции на структурата,
на пример, дека не се авто-референтните, дека
немаат име назначувач тука.
Тоа само ќе кажам typedef struct, отвори кадрава голема заграда, а потоа го дефинираат.
Но, ако сте struct е само референцијален, како ова е,
што треба да се определи привремено име тип.
Но на крајот, сега што ние го направивме тоа,
ние само може да се однесуваат на овие јазли, овие единици,
како SLL јазли за цели на остатокот од оваа видео.
>> Добро, така што ние знаеме како да се создаде поврзани листа јазол.
Знаеме како да се дефинира на поврзани листа јазол.
Сега, ако ние се случува да се започне ги користите за да се соберат информации,
има неколку операции ние треба да се разбере и да работат со.
Што треба да знаеме како да се создаде на поврзани листа од тенок воздух.
Ако нема листа веќе, ние сакаме да се започне еден.
Значи ние треба да биде во можност за да се создаде поврзани листа,
ние треба да веројатно пребарување преку листа на врската
да се најде еден елемент што го барате.
Ние треба да бидат во можност да се вметне нови работи во листата,
сакаме нашата листа за да бидат во можност да се зголеми.
И слично, ние сакаме да биде во можност за бришење нешта од нашата листа,
сакаме нашата листа за да бидат во можност да се намали.
И на крајот на нашите програми, особено
ако се потсетиме дека ние сме динамично доделување меморија
за изградба на овие листи обично, сакаме да ги ослободи сите од таа меморија
кога ќе завршиш работа со него.
И така ние треба да бидат способни да ги избришете целиот поврзани листа во еден пропаднат пикирам.
Па ајде да одиме преку некои од овие операции
и како да ги визуелизира, зборува во pseudocode код конкретно.
Значи, ние сакаме да се создаде поврзани листа, па можеби и ние
сакате да го дефинираме функција со овој прототип.
SLL јазол ѕвезда, се создаде, и јас сум со полагање во еден аргумент, некои произволни податоци
напишете повторно, на некои произволни тип на податок.
Но јас сум returning-- оваа функција треба да врати кај мене покажувач, на поединечно
листа поврзана јазол.
Повторно, ние се обидуваме да се создаде на поврзани листа од тенок воздух,
па ми треба покажувач таа листа кога сум се направи.
>> Значи она што се вклучени тука чекори?
Па, прво нешто што сум случува да направите е динамички
одвои простор за нов јазол.
Повторно, ние сме создавање на него од тенок воздух, па ние треба да Примерок простор за тоа.
И, се разбира, веднаш откако ќе Примерок,
ние секогаш проверете да бидете сигурни дека нашите pointer-- ние не се врати назад на нула.
Затоа што ако ние се обидуваме и разликата е нулти покажувач,
ние ќе треба да претрпи segfault и ние не сакаме тоа.
>> Тогаш сакаме да се пополни во полето, ние сакаме да се иницијализира полето на вредноста
и се иницијализира на следното поле.
А потоа ние сакаме to-- крајот како функција прототип indicates-- сакаме
за да се вратите на покажувач на SLL јазол.
Значи она што го прават овој изгледа визуелно?
Па, прво ние ќе треба да се динамички одвои простор за нова SLL јазол,
па ние malloc-- тоа е визуелна претстава
на јазол ние само замислен.
И проверете да бидете сигурни тој не го null-- во овој случај,
сликата нема да има минат ако тоа беше нула,
ние би го снема меморија, па ние сме добри да одам таму.
Па сега сме на чекор Ц, иницијализира поле јазли вредност.
И, врз основа на оваа функција јавам јас користам тука,
изгледа како да сакаат да го поминат во 6, па јас ќе 6 во полето за вредност.
Сега, се иницијализира на следното поле.
Па, она што сум јас ќе го направи таму, не постои ништо следната, десно,
ова е единственото нешто во листата.
Значи она што е следното нешто во листата?
>> Тоа не треба да укажуваат на ништо, нели.
Нема ништо друго таму, па што е на концептот што го знаеме за тоа е nothing--
покажувачи за ништо?
Тоа треба да биде можеби сакаме да се стави null покажувачот таму,
а јас ќе претставуваат ништовни покажувачот како само црвена кутија,
ние не можеме да одиме понатаму.
Како што ќе видиме малку подоцна, ние ќе мора на крајот синџири
на стрелките поврзување овие јазли заедно,
но кога ќе удри на црвено поле, тоа е нула,
ние не можеме да одиме понатаму, тоа е крајот на листата.
>> И на крај, ние само сакаме да врати покажувач на овој јазол.
Па ние ќе го наречеме нови, и ќе се врати на нови
така што може да се користи во без оглед на функцијата го создал.
Па таму ќе одиме, Ние создадовме одделно листа поврзана јазол од тенок воздух,
и сега имаме список може да се работи со.
>> Сега, ајде да речеме веќе имаат голем синџир,
и ние сакаме да се најде нешто во неа.
И ние сакаме функција што се случува за да се вратите точно или неточно, во зависност
за тоа дали постои вредност во таа листа.
А функција прототип, или декларација за таа функција,
Можеби изгледа како this-- bool најде, и тогаш сакаме да се помине во два аргументи.
>> Првата, е покажувач кон Првиот елемент на поврзани листа.
Ова е всушност нешто што ќе секогаш сакате да ги пратите на тоа,
а, всушност, може да биде нешто што можете дури и се стави во глобалната променлива.
Откако ќе се создаде листа, секогаш, секогаш
сакате да ги пратите на многу Првиот елемент од листата.
На тој начин може да се однесува на сите други елементи од само по синџирот,
без да ги задржи покажувачи непроменети на секој елемент.
Вие само треба да ги пратите на првиот една, ако тие се сите оковани заедно.
>> А потоа и втората работа ние сме поминува во повторно
е произволно some-- без оглед на типот на податоци ние сме
барате таму е во внатрешноста на се надевам дека еден од јазли се во листата.
Па што се чекори?
Па, првото нешто што го направи е ние создаваме трансверзала покажувачот
што укажува на главата на листите.
Па, зошто го правиме тоа, ние веќе имаат покажувач на чело на листите,
зошто да не се само се движат дека еден наоколу?
Па, како да сум само рече: тоа е навистина важно за нас
за секогаш да ги пратите на Уште првиот елемент во листата.
И така тоа е, всушност, подобро да креирате дупликат на тоа,
и ја користат таа да се движат наоколу, така што никогаш не случајно се движат подалеку, или ние секогаш
имаат покажувач во одреден момент, кој е правото на првиот елемент од листата.
Па затоа е подобро да се создаде втората дека ние ги користиме за да се движат.
>> Тогаш ние само споредете дали поле за вредност на тој јазол
е она што го барате, а ако тоа е Не, ние само се движи кон следниот јазол.
А ние продолжуваме да го прават тоа над, и одново и одново,
се додека не се најде било кој елемент, или ние хит
null-- ние сте достигнавме крајот на листата и тоа не е таму.
Ова треба да се надеваме дека ѕвони на камбана на вас како е само линеарно пребарување,
ние сме само го реплицира во на одделно поврзани листа структура
наместо да користи низа да го направи тоа.
>> Па еве еден пример на на одделно поврзани листа.
Оваа една се состои од пет јазли, а ние имаме
покажувач на шефот на листа, кој се нарекува листата.
Првото нешто што сакате да направите е повторно, да се создаде тој traversal покажувачот.
Така што сега го имаме два покажувачи кои укажуваат на истото.
>> Сега, забележуваме дека тука, исто така, јас не мора да Примерок било простор за trav.
Јас не реков дека trav еднаква Примерок нешто, тој јазол веќе постои,
тој простор во меморијата веќе постои.
Па сите јас сум всушност прави е создавање друга покажувачот на него.
Јас не сум mallocing дополнителен простор, само треба сега два покажувачи
покажувајќи на една иста работа.
>> Така е на 2 она што јас го барате?
Па, не, па наместо тоа сум ќе се движи кон следниот.
Значи, во основа јас би рекол, trav trav еднаква на следната.
3 не е она што јас го барате, бр.
Па јас продолжи да оди преку, додека на крајот
стигне до 6 кое што е она што јас барам за врз основа на повик на функција
Имам на врвот таму, и така јас сум се направи.
>> Сега, што ако елементот сум барате не е во листата,
е се уште оди на работа?
Па, да се забележи дека на листата тука е суптилно различни,
и ова е уште една работа што е важно со поврзани листи,
вие не мора да се зачува нив во некоја посебна цел.
Можеш, ако сакате, но Вие веќе може да се забележи
дека ние не сме следење на она што бројот елемент ќе сме.
>> И тоа е еден вид на трговија кои ги имаат со поврзана листа стихови низи,
е тоа што немаме случаен пристап повеќе.
Ние не само да кажам, сакам да се оди на 0. елемент,
или 6-тиот елемент на мојот низа, што можам да направам во низа.
Не можам да кажам дека сакаат да одат на 0. елемент, или 6-тиот елемент,
или 25-елемент на мојот поврзани листа, не постои индекс поврзани со нив.
И така тоа не е навистина важно ако сакаме да го зачуваме нашето листа со цел.
Ако сакате да ви се Сигурно може, но има
Нема причина зошто тие треба да се да се чува во секој ред.
Значи, повторно, да се обидеме и 6 најдете во оваа листа.
Па, со почеток во почеток, ние не се најде 6,
а потоа ние не продолжи наоѓање 6, додека ние на крајот се дојде до тука.
Па сега trav поени на јазол кои содржат 8, и шест не е во таму.
>> Па следниот чекор ќе биде да се оди на следното покажувач,
така велат trav trav еднаква на следната.
Па, trav следната, означено со црвената кутија таму е нула.
Па постои никаде на друго место да се оди, а па во овој момент
можеме да заклучиме дека ние сме достигна крајот на поврзани листа,
и 6 не е во таму.
И тоа ќе се врати лажно во овој случај.
>> Добро, како ние да се вметне нов јазол во поврзаните листа?
Значи, ние сме биле во можност да се создаде на поврзани листа од никаде,
но ние веројатно сакате да изгради синџир и не
создаде еден куп на различни листи.
Сакаме да имаме една листа што има еден куп на јазли во него,
не еден куп на листи со еден јазол.
Па не можеме да се задржи само со користење на Создаде функција што е дефинирано погоре, ние сега
сакате да го вметнете во листа, која веќе постои.
>> Па овој случај, ние ќе да се помине во два аргументи,
на покажувачот на чело на таа поврзани листа дека сакаме да го додадете.
Повторно, тоа е зошто тоа е толку важно што ние секогаш
ги пратите на тоа, бидејќи тоа е единствениот начин на кој ние навистина
мора да се однесува на целата листа е само од страна на покажувач на првиот елемент.
Затоа сакаме да се помине во покажувач до првиот елемент,
и без оглед на вредноста што сакате да ги додадете на листата.
И на крајот на оваа функција ќе се врати на покажувачот
на новиот шеф на поврзани листа.
>> Кои се вклучени тука чекори?
Добро, исто како и со се создаде, ние треба да се динамички алоцира
простор за нов јазол, и проверете дека нема да ни снема меморија, повторно,
бидејќи ние сме со користење Примерок.
Тогаш сакаме да се доверат и внесете јазол,
па стави број, без разлика Вал е, во јазол.
Ние сакаме да се вметне на јазол на почетокот на поврзани листа.
>> Има причина што јас сакате да го направите ова, и тоа
би можело да биде добро да се направи втората за да го паузирате видео тука,
и да размислуваат за тоа зошто јас би сакал да внесете на почетокот на поврзани
листата.
Повторно, што споменав порано дека тоа не е навистина
важно дали сме ја зачува во било ред, па можеби тоа е поим.
И го виде она што ќе се случи ако ние сакаше to-- или од само една секунда
Пред Кога одевме преку интернет ви
можеше да се види она што може да се случи ако ние се обидувавме
да се вметне на крајот на листата.
Затоа што ние немаме покажувачот до крајот на листата.
>> Така од причина што јас би сакал да се вметне на почетокот,
е затоа што може да го направи тоа веднаш.
Имам покажувачот на почетокот, и ние ќе се види во овој визуелен во една секунда.
Но ако сакам да се вметне на крајот, Морам да започне на почетокот,
напречни сите на патот до крајот, а потоа го тактика на.
Така што би значело дека вметнување на крајот на листата
ќе стане О на n работењето, ќе се вратам
за нашата дискусија на компјутерската комплексност.
Тоа ќе станам О од n активност, каде што како што е на листата се поголеми и поголеми,
и поголем, тоа ќе станува повеќе и потешко да тактика нешто
за на крајот.
Но секогаш е навистина лесно да се тактика нешто на почетокот,
ти си секогаш во почетокот.
>> И ќе видиме визуелна на тоа повторно.
А потоа откако ќе завршиш, еднаш ние сме вметнува нов јазол,
ние сакаме да се вратат нашите покажувач на новиот шеф на поврзани листа, која
бидејќи ние сме вметнување на почетокот, всушност, ќе биде
покажувач на јазол ние само замислен.
Ајде да се визуелизира ова, бидејќи мислам дека тоа ќе ви помогне.
>> Значи тука е нашата листа, таа се состои од четири елементи, јазол кој содржи 15,
што укажува на еден јазол содржат 9, кое што
укажува на еден јазол кои содржат 13, што укажува на еден јазол содржи
10, кој има нула покажувачот како наредна покажувачот
така што е на крајот на листата.
Затоа сакаме да вметнете нов јазол со вредност 12
на почетокот на оваа листа, што ќе правиме?
Па, прво ние Примерок простор за јазол, а потоа ќе стави 12 во таму.
>> Така, сега сме постигнале одлуката точка, нели?
Имаме неколку совети кои би можеле да
се движи, кој треба да се движиме на прво место?
Треба да се направи 12 точка да новиот шеф на list--
или, извинете, ние треба да се направи 12 укажуваат на стариот шеф на листата?
Или ние треба да се каже дека листа сега почнува во 12.
Има разлика таму, а ние ќе се погледне
што ќе се случи со двете во една секунда.
>> Но, ова доведува до одлична тема за странична лента,
кој е во тоа што еден од најтешко работите со поврзани листи
е да се организираме на покажувачи во правилен ред.
Ако ви се движат работите на ред, можете да завршуваат случајно
orphaning остатокот од листата.
И еве еден пример за тоа.
Па ајде да одиме со идејата of-- Па, ние сме го креирале 12.
Знаеме 12 ќе биде новиот шеф на листата,
и така зошто не можеме само да се движат покажувачот на листата на точка таму.
>> Добро, па тоа е добро.
Па сега каде што го прави 12 Следна точка?
Мислам, визуелно може да се види дека тоа ќе се укаже на 15,
како луѓето, тоа е навистина очигледно за нас.
Како го прави компјутерот знаеш?
Ние немаме ништо што укажува на 15 веќе, нели?
>> Ние сме го изгубиле било способност да се однесуваат на 15.
Не можеме да кажеме нови стрелката еднаквите нешто, таму нема ништо.
Всушност, ние сме сирачиња остатокот од листата
со тоа, ние сме случајно скршен синџирот.
А ние сигурно не сакате да го направите тоа.
>> Значи, да се вратиме и да се обидат ова повторно.
Можеби вистинската работа да се направи е да се постават 12 следната покажувачот
до стариот чело на листата на прво место, тогаш можеме да се движиме на листата завршена.
И всушност, тоа е правилен ред дека ние
треба да се следат кога сме работа со одделно поврзани листа.
Ние секогаш сакаме да го поврзете нов елемент во листата,
пред да се преземе тој вид на важен чекор за промена
во кои главата на поврзани листа е.
Повторно, тоа е тоа темелно нешто, ние не сакаме да се изгуби патеката на тоа.
>> Значи, ние сакаме да се осигураме дека сè се оковани заедно,
пред да продолжат понатаму дека покажувачот.
И така ова ќе биде правилен ред, кој е да се поврзе 12 на листата,
потоа да се каже дека на листата организира 12.
Ако се рече листата започнува во 12 и а потоа се обидел да се поврзете 12 на листата,
веќе видовме што се случува.
Ние губиме листата по грешка.
>> Добро, па уште една работа да се зборува.
Што ако сакаме да се ослободи од цела поврзани листа одеднаш?
Повторно, ние сме mallocing сите овој простор, и така ние
се потребни за да се ослободи кога ќе завршиш.
Така, сега сакате да ја избришете целата поврзани листа.
Па, она што ние сакаме да го направи?
>> Ако ние сме достигна нултата покажувач, ние сакаат да престанат, инаку, само го избришете
остатокот од списокот, а потоа ме ослободи.
Бришење на одмор на листата, а потоа го ослободи тековната јазол.
Што значи тоа звучи како, што техника има разговаравме
во врска со претходно Дали тоа звучи како?
Избришете сите други, тогаш да се врати и да го избришете мене.
>> Тоа е рекурзија, го направивме Проблемот малку помали,
ние сме велејќи избришете сите друго, тогаш ќе може да ми ја избришеш.
И во периодот кој доаѓа, тој јазол ќе каже, да го избришете сите други.
Но на крајот ние ќе дојдеме до точка каде листата е нула,
и тоа е нашиот основен случај.
>> Па ајде да ги разгледаме во тоа, и како тоа може да работи.
Значи тука е нашата листа, тоа е истиот листата бевме само зборуваме,
и таму е чекори.
Има многу текст тука, но се надевам дека ќе им помогне на визуелизација.
>> Па ние have-- и јас исто така се повлече сочинуваат нашиот магацинот рамки илустрација
од нашата видео на повик Купишта, и се надевам дека сите на овој
заедно ќе ви покаже што се случува.
Значи тука е нашата pseudocode код.
Ако се постигне нула покажувач, да застане, инаку,
бришење на одмор на листата, тогаш слободно тековната јазол.
Значи, токму сега, list-- покажувачот дека ние сме
поминува во да се уништи до 12 поени.
12 не е нулти покажувач, па ние сме случува да ги избришете остатокот од листата.
>> Она што се бришење на Остатокот од нас кои се вклучени?
Па, тоа значи правење на јавете се да се уништи, велејќи:
дека 15 е на почетокот на Остатокот од листата што сакаат да го уништат.
И така на повикот да ги уништи 12 е вид на на чекање.
Тоа е замрзнат таму, чекајќи јавете се да се уништи 15, за да се стави крај на својата работа.
>> Па, 15 не е нулти покажувач, и па затоа се случува да се каже, во ред,
добро, бришење на одмор на листата.
Остатокот од листата започнува во 9, и така ние само ќе
почекајте додека не го избришете сите кои работи, а потоа се врати и да го избришете мене.
И 9 се случува да се каже, добро, Јас не сум null покажувач,
па бришење на одмор на листата од тука.
И така се обиде и да ги уништи 13.
13 вели, јас не сум null покажувач, истото, тоа поминува префрлуваат одговорноста.
10 не е нулти покажувач, 10 содржи null покажувач,
но 10 сама по себе не е е ништовни покажувачот во моментов,
и така што поминува дадените пари премногу.
>> И сега се листа поени таму, тоа Навистина би укажуваат some--
ако имав повеќе простор во сликата, тоа ќе укаже на некои случајни простор
дека ние не знаеме што е тоа.
Тоа е нула покажувачот иако, на листата е буквално тоа е сега во собата null вредности.
Тоа укажува дека право внатре црвена кутија.
Стигнавме нулти покажувач, па ние може да го запре, и сме подготвени.
>> И така што рамката е виолетова now-- на врвот на stack-- тоа е активната рамка,
но тоа е направено.
Ако ние сме достигна нулти покажувач, запре.
Ние не правиме ништо, ние не може да се ослободи нулти покажувач,
ние не Примерок било простор, и така сме подготвени.
Така што функција рамка е уништена, а ние
resume-- ние ги собереш каде што застанавте натпреварот со следниот највисок еден, што
е ова темно сина рамка тука.
Значи ние ги собереш право, каде што застанавте.
Ние избришани останатите листа веќе, па сега сме
случува да се ослободи тековната јазли.
Па сега ние може да го ослободи овој јазол, а сега ние сте достигнавме крајот на функцијата.
И така таа функција рамка е уништена, и ние ги собереш во светло сина еден.
>> Па тоа says-- Веќе done-- бришење на остатокот од листата, па
ослободи тековната јазол.
И сега на жолтата рамка е повторно на врвот на магацинот.
И така како што гледате, ние сме сега уништување на листата од десно кон лево.
>> Што би се случило, иако, ако сме ги направиле работите на погрешен начин?
Исто како кога се обидовме да додадете елемент.
Ако ние збркана синџирот, ако ние не се поврзете на покажувачи
во правилен ред, ако ние само ослободен првиот елемент,
ако ние само го ослободил врвот од листата, сега ние
нема да имаат начин да се однесуваат на остатокот од листата.
И така ќе имаме сираче сè,
ние би имале што е наречен меморија излегуваат во јавноста.
Ако се сеќавате од нашата видео на динамична алокација на меморија,
тоа не е многу добра работа.
>> Па како што реков, има неколку операции
дека ние треба да ги користите на работа со поврзана листа ефективно.
И може да се забележи пропуштив еден, бришење на еден елемент од поврзани
листата.
Причината го сторив тоа е тоа е всушност вид на
незгодно да се размислува за тоа како да ги избришете еден елемент од одделно
поврзани листа.
Ние треба да бидат во можност да ги прескокне нешто во листата, која
значи дека ние се дојде до point-- ние сакате да го избришете овој node--
но со цел да го направи тоа за да можеме не губат сите информации,
ние треба да се поврзе овој јазол овде, овде.
>> Па јас веројатно не дека во ред од визуелна перспектива.
Па ние сме на почетокот на нашата листа, ние сме се одвива преку,
сакаме да го избришете овој јазол.
Ако ние само го избришете, ние сме скршени синџирот.
Овој јазол, токму тука се однесува на сè друго,
што содржи синџирот од тука надвор.
>> Значи она што треба да се направи, всушност, откако ќе дојде до оваа точка,
е ние треба да се чекор назад еден, и поврзете овој јазол во текот на овој јазол,
па тогаш можеме да ги избришете од една во средината.
Но одделно поврзани листи не ни обезбеди начин да се врати назад.
Значи ние треба да се или да ја задржите два покажувачи, и да се движат
вид на надвор чекор, еден зад други како што ние одиме, или се дојде до точка
а потоа испрати друга покажувачот преку.
И како што можете да видите, тоа може да се добие малку неуредна.
За среќа, имаме уште еден начин да се грижи за тоа,
кога зборуваме за двојно поврзана листи.
>> Јас сум Даг Лојд, ова е CS50.