1
00:00:00,000 --> 00:00:02,832
>> [Музички]

2
00:00:02,832 --> 00:00:05,670

3
00:00:05,670 --> 00:00:08,560
>> Даг LLOYD: Добро, па така,
оваа точка во се разбира,

4
00:00:08,560 --> 00:00:15,300
ние сме опфатени голем број на основите на В.
Знаеме многу за променливите, низи,

5
00:00:15,300 --> 00:00:17,610
покажувачи, сето тоа добри нешта.

6
00:00:17,610 --> 00:00:21,610
Тоа се сите вид на гради
за да ја видите како основи,

7
00:00:21,610 --> 00:00:23,880
но можеме да направиме повеќе, нели?

8
00:00:23,880 --> 00:00:27,930
Ние може да се комбинираат работи
заедно со интересни начини.

9
00:00:27,930 --> 00:00:31,010
>> И па ајде да го направите тоа, ајде да почнеме
да филијала надвор од она што ни дава С,

10
00:00:31,010 --> 00:00:35,270
и да почне да креирате сопствени податоци
структури користење на овие градежни

11
00:00:35,270 --> 00:00:40,590
блокови заедно да се направи нешто
навистина вредно, корисно.

12
00:00:40,590 --> 00:00:43,420
Еден начин на кој можеме да го направите ова е
да се зборува за колекционери.

13
00:00:43,420 --> 00:00:48,360
Па досега имавме еден вид на податоци
структура за застапување колекции

14
00:00:48,360 --> 00:00:51,030
од допаѓа вредности, слични вредности.

15
00:00:51,030 --> 00:00:52,350
Тоа би било низа.

16
00:00:52,350 --> 00:00:57,020
Имаме збирки на цели броеви, или
збирки на ликови и така натаму.

17
00:00:57,020 --> 00:01:00,890
>> Структури се исто така еден вид на податоци
структура за собирање на информации,

18
00:01:00,890 --> 00:01:03,220
но тоа не е за собирање како вредности.

19
00:01:03,220 --> 00:01:08,090
Тоа обично се меша различни типови на податоци
заедно во внатрешноста на една кутија.

20
00:01:08,090 --> 00:01:10,750
Но тоа не е сама по себе
се користи за да синџирот заедно

21
00:01:10,750 --> 00:01:16,920
или да се поврзете заедно слични
предмети, како и низа.

22
00:01:16,920 --> 00:01:20,960
Низи се одлични за
елемент гледам нагоре, но да се потсетиме

23
00:01:20,960 --> 00:01:24,262
дека тоа е многу тешко
да се вметне во низа,

24
00:01:24,262 --> 00:01:26,470
Освен ако не сме вметнување на
На самиот крај на таа низа.

25
00:01:26,470 --> 00:01:29,730
>> А најдобар пример имам
за тоа е вметнување вид.

26
00:01:29,730 --> 00:01:31,650
Ако се сеќавате нашата видео
на вметнување вид,

27
00:01:31,650 --> 00:01:34,110
имаше многу
трошоци кои се вклучени во се има

28
00:01:34,110 --> 00:01:37,970
да ги собереш елементи, и промена нив
од начинот на кој да ги собере нешто

29
00:01:37,970 --> 00:01:41,290
во средината на вашата низа.

30
00:01:41,290 --> 00:01:44,690
Низи исто така страдаат од друга
проблем, кој е нефлексибилност.

31
00:01:44,690 --> 00:01:47,150
Кога ќе се изјаснат за низа,
добиеме еден истрел во тоа.

32
00:01:47,150 --> 00:01:49,790
Ние се да се каже, сакам
ова многу елементи.

33
00:01:49,790 --> 00:01:51,940
Може да биде 100, тоа би можело
биде 1.000, тоа би можело

34
00:01:51,940 --> 00:01:55,930
биде x каде што x е број кој на корисникот
ни даде на брза или во командната

35
00:01:55,930 --> 00:01:56,630
на линија.

36
00:01:56,630 --> 00:01:59,905
>> Но ние само се добие една шанса кај него, ние
не дојде до тогаш велат ох, јас, всушност,

37
00:01:59,905 --> 00:02:04,360
потребни 101, или ми требаше х плус 20.

38
00:02:04,360 --> 00:02:07,910
Предоцна, ние сме веќе прогласи
низа, и ако сакаме да се добие 101 или x

39
00:02:07,910 --> 00:02:12,050
плус 20, ние мора да се декларираат
еден сосема поинаков низа,

40
00:02:12,050 --> 00:02:15,540
копија на сите елементи на низата
над, а потоа имаме доволно.

41
00:02:15,540 --> 00:02:19,880
А што ако не сме во право, повторно, она што
ако ние всушност се потребни 102, или x плус 40,

42
00:02:19,880 --> 00:02:21,970
ние треба да го направите ова повторно.

43
00:02:21,970 --> 00:02:26,250
Па тие се многу нефлексибилен
за промена на големината на нашите податоци,

44
00:02:26,250 --> 00:02:29,360
Но, ако ние се комбинираат заедно некои
на основите дека ние сме веќе

45
00:02:29,360 --> 00:02:33,230
научиле за покажувачи и структури,
особено со употреба на динамичка меморија

46
00:02:33,230 --> 00:02:36,180
распределба со Примерок, ние
Може да се стави овие парчиња заедно

47
00:02:36,180 --> 00:02:40,960
да се создаде нови податоци structure-- на
одделно поврзани листа би можеле да say--

48
00:02:40,960 --> 00:02:45,400
која ни овозможува да расте и да се
смалуваат колекција на вредности

49
00:02:45,400 --> 00:02:48,800
и ние нема да има никакви потроши простор.

50
00:02:48,800 --> 00:02:53,320
>> Значи, повторно, ние го нарекуваме оваа идеја,
овој поим, а поврзани листа.

51
00:02:53,320 --> 00:02:56,320
Особено, во ова видео, ние сме
Станува збор за одделно поврзани листа,

52
00:02:56,320 --> 00:02:59,185
а потоа уште еден видео ќе зборуваме
за двојно поврзана листи, што

53
00:02:59,185 --> 00:03:01,560
е само варијација на тема тука.

54
00:03:01,560 --> 00:03:05,200
Туку одделно поврзани листа
се состои од јазли,

55
00:03:05,200 --> 00:03:08,559
јазли само да биде апстрактен term--
тоа е само нешто јас го повикувам

56
00:03:08,559 --> 00:03:10,350
тоа е еден вид на
структурата, во основа, јас сум?

57
00:03:10,350 --> 00:03:16,190
Само ќе го наречеме node-- и ова
јазол има два члена, или две полиња.

58
00:03:16,190 --> 00:03:20,300
Таа има податоци, обично
цел број, карактер плови,

59
00:03:20,300 --> 00:03:23,790
или може да биде некој друг тип на податоци
што сте ги дефинира со еден вид дефиниција.

60
00:03:23,790 --> 00:03:29,290
И тоа што содржи покажувач
друг јазол од ист вид.

61
00:03:29,290 --> 00:03:34,710
>> Па ние имаме две работи во внатрешноста на
овој јазол, податоци и покажувач

62
00:03:34,710 --> 00:03:36,380
до друг јазол.

63
00:03:36,380 --> 00:03:39,370
И ако почнете да се визуелизира
ова, може да се размислува за тоа

64
00:03:39,370 --> 00:03:42,280
како еден синџир на јазли кои
се поврзани заедно.

65
00:03:42,280 --> 00:03:45,070
Имаме првиот јазол, таа
содржи податоци, и покажувач

66
00:03:45,070 --> 00:03:49,110
на вториот јазол, кој содржи
на податоци, и покажувач кон третиот јазол.

67
00:03:49,110 --> 00:03:52,940
И така тоа е причината зошто ние го нарекуваме
поврзани листа, тие се поврзани заедно.

68
00:03:52,940 --> 00:03:56,070
>> Што значи оваа специјална
јазол структура изгледа?

69
00:03:56,070 --> 00:04:01,120
Па, ако се потсетиме од нашата видео на
дефинирање на сопствени типови, со тип дефиниција,

70
00:04:01,120 --> 00:04:05,400
можеме да го дефинираме и structure--
напишете дефинира структурата се допаѓа ова.

71
00:04:05,400 --> 00:04:11,240
tyepdef struct sllist, а потоа сум
Користејќи Word вредност тука произволно

72
00:04:11,240 --> 00:04:13,891
за да се покаже било кој тип на податоци навистина.

73
00:04:13,891 --> 00:04:16,890
Вие би можеле да го поминат на цел број или подвижна запирка,
може да имаш што сакаш.

74
00:04:16,890 --> 00:04:19,389
Тоа не е ограничена на само
цели броеви, или нешто слично.

75
00:04:19,389 --> 00:04:22,790
Па вредноста е само произволна
тип на податоци, а потоа и на покажувачот

76
00:04:22,790 --> 00:04:26,310
до друг јазол од ист вид.

77
00:04:26,310 --> 00:04:29,690
>> Сега, постои малку улов
тука со дефинирање на структурата

78
00:04:29,690 --> 00:04:33,030
кога тоа е структура авто-референтните.

79
00:04:33,030 --> 00:04:35,340
Морам да имаат привремена
именува за мојата структура.

80
00:04:35,340 --> 00:04:37,640
На крајот од денот, јас
јасно да сакате да го наречеме

81
00:04:37,640 --> 00:04:43,030
SLL јазол, кој е во крајна линија на нови
именува дел од мојата дефиниција за тип,

82
00:04:43,030 --> 00:04:47,450
но не можам да го користите SLL јазол
во средината на оваа.

83
00:04:47,450 --> 00:04:51,430
Причината е, не сум
создаде вид наречен SLL јазол

84
00:04:51,430 --> 00:04:55,200
додека не го погоди овој крајната точка тука.

85
00:04:55,200 --> 00:04:59,720
Се до таа точка, јас треба да имаат
уште еден начин да се однесуваат на овој тип на податок.

86
00:04:59,720 --> 00:05:02,440
>> И ова е само
референцијални тип на податок.

87
00:05:02,440 --> 00:05:06,314
Тоа, е тип на податоци на
структура која содржи податоци,

88
00:05:06,314 --> 00:05:08,480
и покажувач кон друг
структура на истиот тип.

89
00:05:08,480 --> 00:05:11,750
Значи ми треба да биде во можност да се однесуваат на
овој тип на податоци, барем привремено,

90
00:05:11,750 --> 00:05:14,910
па тоа дава привремена
името на struct sllist

91
00:05:14,910 --> 00:05:18,540
ми дозволува да потоа да се каже Јас сакам
Покажувач на друг struct sllist,

92
00:05:18,540 --> 00:05:24,690
на struct sllist ѕвезда, а потоа
јас откако ќе заврши дефиниција,

93
00:05:24,690 --> 00:05:27,220
Сега можам да го наречеме овој тип на SLL јазол.

94
00:05:27,220 --> 00:05:30,520
>> Па затоа ќе го видите тука е
привремено име тука,

95
00:05:30,520 --> 00:05:31,879
но постојан име.

96
00:05:31,879 --> 00:05:33,920
Понекогаш може да се види
дефиниции на структурата,

97
00:05:33,920 --> 00:05:36,570
на пример, дека не се
авто-референтните, дека

98
00:05:36,570 --> 00:05:39,390
немаат име назначувач тука.

99
00:05:39,390 --> 00:05:43,040
Тоа само ќе кажам typedef struct,
отвори кадрава голема заграда, а потоа го дефинираат.

100
00:05:43,040 --> 00:05:45,620
Но, ако сте struct е само
референцијален, како ова е,

101
00:05:45,620 --> 00:05:49,010
што треба да се определи
привремено име тип.

102
00:05:49,010 --> 00:05:51,310
Но на крајот, сега
што ние го направивме тоа,

103
00:05:51,310 --> 00:05:53,620
ние само може да се однесуваат на
овие јазли, овие единици,

104
00:05:53,620 --> 00:05:57,900
како SLL јазли за цели
на остатокот од оваа видео.

105
00:05:57,900 --> 00:06:00,900
>> Добро, така што ние знаеме како да се
создаде поврзани листа јазол.

106
00:06:00,900 --> 00:06:03,240
Знаеме како да се дефинира
на поврзани листа јазол.

107
00:06:03,240 --> 00:06:06,670
Сега, ако ние се случува да се започне
ги користите за да се соберат информации,

108
00:06:06,670 --> 00:06:10,360
има неколку операции ние
треба да се разбере и да работат со.

109
00:06:10,360 --> 00:06:12,860
Што треба да знаеме како да се создаде
на поврзани листа од тенок воздух.

110
00:06:12,860 --> 00:06:14,901
Ако нема листа веќе,
ние сакаме да се започне еден.

111
00:06:14,901 --> 00:06:16,960
Значи ние треба да биде во можност
за да се создаде поврзани листа,

112
00:06:16,960 --> 00:06:19,130
ние треба да веројатно пребарување
преку листа на врската

113
00:06:19,130 --> 00:06:21,830
да се најде еден елемент што го барате.

114
00:06:21,830 --> 00:06:24,430
Ние треба да бидат во можност да се вметне
нови работи во листата,

115
00:06:24,430 --> 00:06:25,930
сакаме нашата листа за да бидат во можност да се зголеми.

116
00:06:25,930 --> 00:06:28,638
И слично, ние сакаме да биде во можност
за бришење нешта од нашата листа,

117
00:06:28,638 --> 00:06:30,250
сакаме нашата листа за да бидат во можност да се намали.

118
00:06:30,250 --> 00:06:32,160
И на крајот на нашите
програми, особено

119
00:06:32,160 --> 00:06:34,550
ако се потсетиме дека ние сме
динамично доделување меморија

120
00:06:34,550 --> 00:06:38,337
за изградба на овие листи обично,
сакаме да ги ослободи сите од таа меморија

121
00:06:38,337 --> 00:06:39,670
кога ќе завршиш работа со него.

122
00:06:39,670 --> 00:06:44,627
И така ние треба да бидат способни да ги избришете
целиот поврзани листа во еден пропаднат пикирам.

123
00:06:44,627 --> 00:06:46,460
Па ајде да одиме преку
некои од овие операции

124
00:06:46,460 --> 00:06:51,192
и како да ги визуелизира,
зборува во pseudocode код конкретно.

125
00:06:51,192 --> 00:06:53,150
Значи, ние сакаме да се создаде
поврзани листа, па можеби и ние

126
00:06:53,150 --> 00:06:56,480
сакате да го дефинираме функција
со овој прототип.

127
00:06:56,480 --> 00:07:01,690
SLL јазол ѕвезда, се создаде, и јас сум со полагање
во еден аргумент, некои произволни податоци

128
00:07:01,690 --> 00:07:05,530
напишете повторно, на некои произволни тип на податок.

129
00:07:05,530 --> 00:07:10,482
Но јас сум returning-- оваа функција треба да
врати кај мене покажувач, на поединечно

130
00:07:10,482 --> 00:07:11,190
листа поврзана јазол.

131
00:07:11,190 --> 00:07:14,050
Повторно, ние се обидуваме да се создаде
на поврзани листа од тенок воздух,

132
00:07:14,050 --> 00:07:17,900
па ми треба покажувач
таа листа кога сум се направи.

133
00:07:17,900 --> 00:07:19,420
>> Значи она што се вклучени тука чекори?

134
00:07:19,420 --> 00:07:20,960
Па, прво нешто што сум
случува да направите е динамички

135
00:07:20,960 --> 00:07:22,550
одвои простор за нов јазол.

136
00:07:22,550 --> 00:07:26,689
Повторно, ние сме создавање на него од тенок
воздух, па ние треба да Примерок простор за тоа.

137
00:07:26,689 --> 00:07:28,480
И, се разбира, веднаш
откако ќе Примерок,

138
00:07:28,480 --> 00:07:31,692
ние секогаш проверете да бидете сигурни дека нашите
pointer-- ние не се врати назад на нула.

139
00:07:31,692 --> 00:07:33,650
Затоа што ако ние се обидуваме и
разликата е нулти покажувач,

140
00:07:33,650 --> 00:07:36,190
ние ќе треба да претрпи
segfault и ние не сакаме тоа.

141
00:07:36,190 --> 00:07:39,510
>> Тогаш сакаме да се пополни во полето,
ние сакаме да се иницијализира полето на вредноста

142
00:07:39,510 --> 00:07:41,690
и се иницијализира на следното поле.

143
00:07:41,690 --> 00:07:45,450
А потоа ние сакаме to-- крајот како
функција прототип indicates-- сакаме

144
00:07:45,450 --> 00:07:49,940
за да се вратите на покажувач на SLL јазол.

145
00:07:49,940 --> 00:07:51,710
Значи она што го прават овој изгледа визуелно?

146
00:07:51,710 --> 00:07:55,230
Па, прво ние ќе треба да се динамички
одвои простор за нова SLL јазол,

147
00:07:55,230 --> 00:07:58,320
па ние malloc-- тоа е
визуелна претстава

148
00:07:58,320 --> 00:08:00,020
на јазол ние само замислен.

149
00:08:00,020 --> 00:08:02,757
И проверете да бидете сигурни
тој не го null-- во овој случај,

150
00:08:02,757 --> 00:08:04,840
сликата нема да има
минат ако тоа беше нула,

151
00:08:04,840 --> 00:08:07,298
ние би го снема меморија,
па ние сме добри да одам таму.

152
00:08:07,298 --> 00:08:10,200
Па сега сме на чекор Ц,
иницијализира поле јазли вредност.

153
00:08:10,200 --> 00:08:12,280
И, врз основа на оваа функција
јавам јас користам тука,

154
00:08:12,280 --> 00:08:16,700
изгледа како да сакаат да го поминат во 6,
па јас ќе 6 во полето за вредност.

155
00:08:16,700 --> 00:08:18,865
Сега, се иницијализира на следното поле.

156
00:08:18,865 --> 00:08:21,640
Па, она што сум јас ќе го направи таму,
не постои ништо следната, десно,

157
00:08:21,640 --> 00:08:23,600
ова е единственото нешто во листата.

158
00:08:23,600 --> 00:08:27,206
Значи она што е следното нешто во листата?

159
00:08:27,206 --> 00:08:29,660
>> Тоа не треба да укажуваат на ништо, нели.

160
00:08:29,660 --> 00:08:33,600
Нема ништо друго таму, па што е
на концептот што го знаеме за тоа е nothing--

161
00:08:33,600 --> 00:08:35,638
покажувачи за ништо?

162
00:08:35,638 --> 00:08:37,929
Тоа треба да биде можеби сакаме
да се стави null покажувачот таму,

163
00:08:37,929 --> 00:08:40,178
а јас ќе претставуваат ништовни
покажувачот како само црвена кутија,

164
00:08:40,178 --> 00:08:41,559
ние не можеме да одиме понатаму.

165
00:08:41,559 --> 00:08:44,430
Како што ќе видиме малку подоцна,
ние ќе мора на крајот синџири

166
00:08:44,430 --> 00:08:46,330
на стрелките поврзување
овие јазли заедно,

167
00:08:46,330 --> 00:08:48,480
но кога ќе удри на
црвено поле, тоа е нула,

168
00:08:48,480 --> 00:08:51,150
ние не можеме да одиме понатаму,
тоа е крајот на листата.

169
00:08:51,150 --> 00:08:53,960
>> И на крај, ние само сакаме да
врати покажувач на овој јазол.

170
00:08:53,960 --> 00:08:56,160
Па ние ќе го наречеме нови,
и ќе се врати на нови

171
00:08:56,160 --> 00:08:59,370
така што може да се користи во
без оглед на функцијата го создал.

172
00:08:59,370 --> 00:09:03,100
Па таму ќе одиме, Ние создадовме одделно
листа поврзана јазол од тенок воздух,

173
00:09:03,100 --> 00:09:05,920
и сега имаме список може да се работи со.

174
00:09:05,920 --> 00:09:08,260
>> Сега, ајде да речеме веќе
имаат голем синџир,

175
00:09:08,260 --> 00:09:09,800
и ние сакаме да се најде нешто во неа.

176
00:09:09,800 --> 00:09:12,716
И ние сакаме функција што се случува
за да се вратите точно или неточно, во зависност

177
00:09:12,716 --> 00:09:15,840
за тоа дали постои вредност во таа листа.

178
00:09:15,840 --> 00:09:18,160
А функција прототип, или
декларација за таа функција,

179
00:09:18,160 --> 00:09:23,320
Можеби изгледа како this-- bool најде, и
тогаш сакаме да се помине во два аргументи.

180
00:09:23,320 --> 00:09:26,996
>> Првата, е покажувач кон
Првиот елемент на поврзани листа.

181
00:09:26,996 --> 00:09:29,620
Ова е всушност нешто што ќе
секогаш сакате да ги пратите на тоа,

182
00:09:29,620 --> 00:09:33,110
а, всушност, може да биде нешто што
можете дури и се стави во глобалната променлива.

183
00:09:33,110 --> 00:09:35,360
Откако ќе се создаде листа,
секогаш, секогаш

184
00:09:35,360 --> 00:09:38,990
сакате да ги пратите на многу
Првиот елемент од листата.

185
00:09:38,990 --> 00:09:43,690
На тој начин може да се однесува на сите други
елементи од само по синџирот,

186
00:09:43,690 --> 00:09:47,300
без да ги задржи покажувачи
непроменети на секој елемент.

187
00:09:47,300 --> 00:09:50,920
Вие само треба да ги пратите на првиот
една, ако тие се сите оковани заедно.

188
00:09:50,920 --> 00:09:52,460
>> А потоа и втората работа
ние сме поминува во повторно

189
00:09:52,460 --> 00:09:54,376
е произволно some--
без оглед на типот на податоци ние сме

190
00:09:54,376 --> 00:09:59,640
барате таму е во внатрешноста на
се надевам дека еден од јазли се во листата.

191
00:09:59,640 --> 00:10:00,980
Па што се чекори?

192
00:10:00,980 --> 00:10:04,250
Па, првото нешто што го направи е
ние создаваме трансверзала покажувачот

193
00:10:04,250 --> 00:10:06,015
што укажува на главата на листите.

194
00:10:06,015 --> 00:10:08,890
Па, зошто го правиме тоа, ние веќе
имаат покажувач на чело на листите,

195
00:10:08,890 --> 00:10:10,974
зошто да не се само се движат дека еден наоколу?

196
00:10:10,974 --> 00:10:13,140
Па, како да сум само рече:
тоа е навистина важно за нас

197
00:10:13,140 --> 00:10:17,580
за секогаш да ги пратите на
Уште првиот елемент во листата.

198
00:10:17,580 --> 00:10:21,270
И така тоа е, всушност, подобро
да креирате дупликат на тоа,

199
00:10:21,270 --> 00:10:25,350
и ја користат таа да се движат наоколу, така што никогаш не
случајно се движат подалеку, или ние секогаш

200
00:10:25,350 --> 00:10:30,430
имаат покажувач во одреден момент, кој е
правото на првиот елемент од листата.

201
00:10:30,430 --> 00:10:33,290
Па затоа е подобро да се создаде
втората дека ние ги користиме за да се движат.

202
00:10:33,290 --> 00:10:35,877
>> Тогаш ние само споредете дали
поле за вредност на тој јазол

203
00:10:35,877 --> 00:10:38,960
е она што го барате, а ако тоа е
Не, ние само се движи кон следниот јазол.

204
00:10:38,960 --> 00:10:41,040
А ние продолжуваме да го прават тоа
над, и одново и одново,

205
00:10:41,040 --> 00:10:44,811
се додека не се најде било кој
елемент, или ние хит

206
00:10:44,811 --> 00:10:47,310
null-- ние сте достигнавме крајот
на листата и тоа не е таму.

207
00:10:47,310 --> 00:10:50,540
Ова треба да се надеваме дека ѕвони на камбана
на вас како е само линеарно пребарување,

208
00:10:50,540 --> 00:10:54,430
ние сме само го реплицира во
на одделно поврзани листа структура

209
00:10:54,430 --> 00:10:56,280
наместо да користи низа да го направи тоа.

210
00:10:56,280 --> 00:10:58,210
>> Па еве еден пример на
на одделно поврзани листа.

211
00:10:58,210 --> 00:11:00,043
Оваа една се состои од
пет јазли, а ние имаме

212
00:11:00,043 --> 00:11:04,330
покажувач на шефот на
листа, кој се нарекува листата.

213
00:11:04,330 --> 00:11:07,385
Првото нешто што сакате да направите е
повторно, да се создаде тој traversal покажувачот.

214
00:11:07,385 --> 00:11:09,760
Така што сега го имаме два покажувачи
кои укажуваат на истото.

215
00:11:09,760 --> 00:11:15,025
>> Сега, забележуваме дека тука, исто така, јас не
мора да Примерок било простор за trav.

216
00:11:15,025 --> 00:11:18,970
Јас не реков дека trav еднаква Примерок
нешто, тој јазол веќе постои,

217
00:11:18,970 --> 00:11:21,160
тој простор во меморијата веќе постои.

218
00:11:21,160 --> 00:11:24,290
Па сите јас сум всушност прави е
создавање друга покажувачот на него.

219
00:11:24,290 --> 00:11:28,210
Јас не сум mallocing дополнителен
простор, само треба сега два покажувачи

220
00:11:28,210 --> 00:11:31,370
покажувајќи на една иста работа.

221
00:11:31,370 --> 00:11:33,710
>> Така е на 2 она што јас го барате?

222
00:11:33,710 --> 00:11:37,220
Па, не, па наместо тоа сум
ќе се движи кон следниот.

223
00:11:37,220 --> 00:11:41,740
Значи, во основа јас би рекол,
trav trav еднаква на следната.

224
00:11:41,740 --> 00:11:43,630
3 не е она што јас го барате, бр.

225
00:11:43,630 --> 00:11:45,780
Па јас продолжи да оди
преку, додека на крајот

226
00:11:45,780 --> 00:11:48,690
стигне до 6 кое што е она што јас барам
за врз основа на повик на функција

227
00:11:48,690 --> 00:11:51,600
Имам на врвот
таму, и така јас сум се направи.

228
00:11:51,600 --> 00:11:54,150
>> Сега, што ако елементот сум
барате не е во листата,

229
00:11:54,150 --> 00:11:55,510
е се уште оди на работа?

230
00:11:55,510 --> 00:11:57,120
Па, да се забележи дека на листата
тука е суптилно различни,

231
00:11:57,120 --> 00:11:59,410
и ова е уште една работа што е
важно со поврзани листи,

232
00:11:59,410 --> 00:12:01,780
вие не мора да се зачува
нив во некоја посебна цел.

233
00:12:01,780 --> 00:12:05,390
Можеш, ако сакате, но
Вие веќе може да се забележи

234
00:12:05,390 --> 00:12:09,310
дека ние не сме следење на
она што бројот елемент ќе сме.

235
00:12:09,310 --> 00:12:13,150
>> И тоа е еден вид на трговија кои ги
имаат со поврзана листа стихови низи,

236
00:12:13,150 --> 00:12:15,300
е тоа што немаме
случаен пристап повеќе.

237
00:12:15,300 --> 00:12:18,150
Ние не само да кажам, сакам
да се оди на 0. елемент,

238
00:12:18,150 --> 00:12:21,410
или 6-тиот елемент на мојот низа,
што можам да направам во низа.

239
00:12:21,410 --> 00:12:25,080
Не можам да кажам дека сакаат да одат на
0. елемент, или 6-тиот елемент,

240
00:12:25,080 --> 00:12:30,360
или 25-елемент на мојот поврзани листа,
не постои индекс поврзани со нив.

241
00:12:30,360 --> 00:12:33,660
И така тоа не е навистина важно
ако сакаме да го зачуваме нашето листа со цел.

242
00:12:33,660 --> 00:12:36,080
Ако сакате да ви се
Сигурно може, но има

243
00:12:36,080 --> 00:12:38,567
Нема причина зошто тие треба да се
да се чува во секој ред.

244
00:12:38,567 --> 00:12:40,400
Значи, повторно, да се обидеме и
6 најдете во оваа листа.

245
00:12:40,400 --> 00:12:43,200
Па, со почеток во
почеток, ние не се најде 6,

246
00:12:43,200 --> 00:12:47,690
а потоа ние не продолжи наоѓање
6, додека ние на крајот се дојде до тука.

247
00:12:47,690 --> 00:12:52,790
Па сега trav поени на јазол
кои содржат 8, и шест не е во таму.

248
00:12:52,790 --> 00:12:55,250
>> Па следниот чекор ќе биде
да се оди на следното покажувач,

249
00:12:55,250 --> 00:12:57,440
така велат trav trav еднаква на следната.

250
00:12:57,440 --> 00:13:00,750
Па, trav следната, означено со
црвената кутија таму е нула.

251
00:13:00,750 --> 00:13:03,020
Па постои никаде на друго место да се
оди, а па во овој момент

252
00:13:03,020 --> 00:13:06,120
можеме да заклучиме дека ние сме достигна
крајот на поврзани листа,

253
00:13:06,120 --> 00:13:07,190
и 6 не е во таму.

254
00:13:07,190 --> 00:13:10,980
И тоа ќе се врати
лажно во овој случај.

255
00:13:10,980 --> 00:13:14,540
>> Добро, како ние да се вметне нов
јазол во поврзаните листа?

256
00:13:14,540 --> 00:13:17,310
Значи, ние сме биле во можност да се создаде
на поврзани листа од никаде,

257
00:13:17,310 --> 00:13:19,370
но ние веројатно сакате да
изгради синџир и не

258
00:13:19,370 --> 00:13:22,620
создаде еден куп на различни листи.

259
00:13:22,620 --> 00:13:25,700
Сакаме да имаме една листа што
има еден куп на јазли во него,

260
00:13:25,700 --> 00:13:28,040
не еден куп на листи со еден јазол.

261
00:13:28,040 --> 00:13:31,260
Па не можеме да се задржи само со користење на Создаде
функција што е дефинирано погоре, ние сега

262
00:13:31,260 --> 00:13:33,860
сакате да го вметнете во
листа, која веќе постои.

263
00:13:33,860 --> 00:13:36,499
>> Па овој случај, ние ќе
да се помине во два аргументи,

264
00:13:36,499 --> 00:13:39,290
на покажувачот на чело на таа
поврзани листа дека сакаме да го додадете.

265
00:13:39,290 --> 00:13:40,910
Повторно, тоа е зошто тоа е толку
важно што ние секогаш

266
00:13:40,910 --> 00:13:43,400
ги пратите на тоа, бидејќи
тоа е единствениот начин на кој ние навистина

267
00:13:43,400 --> 00:13:46,690
мора да се однесува на целата листа е
само од страна на покажувач на првиот елемент.

268
00:13:46,690 --> 00:13:49,360
Затоа сакаме да се помине во
покажувач до првиот елемент,

269
00:13:49,360 --> 00:13:52,226
и без оглед на вредноста што
сакате да ги додадете на листата.

270
00:13:52,226 --> 00:13:54,600
И на крајот на оваа функција
ќе се врати на покажувачот

271
00:13:54,600 --> 00:13:57,980
на новиот шеф на поврзани листа.

272
00:13:57,980 --> 00:13:59,700
>> Кои се вклучени тука чекори?

273
00:13:59,700 --> 00:14:02,249
Добро, исто како и со се создаде,
ние треба да се динамички алоцира

274
00:14:02,249 --> 00:14:05,540
простор за нов јазол, и проверете
дека нема да ни снема меморија, повторно,

275
00:14:05,540 --> 00:14:07,150
бидејќи ние сме со користење Примерок.

276
00:14:07,150 --> 00:14:09,080
Тогаш сакаме да се доверат
и внесете јазол,

277
00:14:09,080 --> 00:14:12,730
па стави број, без разлика
Вал е, во јазол.

278
00:14:12,730 --> 00:14:17,310
Ние сакаме да се вметне на јазол
на почетокот на поврзани листа.

279
00:14:17,310 --> 00:14:19,619
>> Има причина што јас
сакате да го направите ова, и тоа

280
00:14:19,619 --> 00:14:21,910
би можело да биде добро да се направи втората
за да го паузирате видео тука,

281
00:14:21,910 --> 00:14:25,860
и да размислуваат за тоа зошто јас би сакал да
внесете на почетокот на поврзани

282
00:14:25,860 --> 00:14:26,589
листата.

283
00:14:26,589 --> 00:14:28,630
Повторно, што споменав порано
дека тоа не е навистина

284
00:14:28,630 --> 00:14:33,020
важно дали сме ја зачува во било
ред, па можеби тоа е поим.

285
00:14:33,020 --> 00:14:36,040
И го виде она што ќе се случи ако ние
сакаше to-- или од само една секунда

286
00:14:36,040 --> 00:14:37,360
Пред Кога одевме
преку интернет ви

287
00:14:37,360 --> 00:14:39,235
можеше да се види она што може да
се случи ако ние се обидувавме

288
00:14:39,235 --> 00:14:41,330
да се вметне на крајот на листата.

289
00:14:41,330 --> 00:14:44,750
Затоа што ние немаме
покажувачот до крајот на листата.

290
00:14:44,750 --> 00:14:47,490
>> Така од причина што јас би сакал
да се вметне на почетокот,

291
00:14:47,490 --> 00:14:49,380
е затоа што може да го направи тоа веднаш.

292
00:14:49,380 --> 00:14:52,730
Имам покажувачот на почетокот, и
ние ќе се види во овој визуелен во една секунда.

293
00:14:52,730 --> 00:14:55,605
Но ако сакам да се вметне на крајот,
Морам да започне на почетокот,

294
00:14:55,605 --> 00:14:58,760
напречни сите на патот до
крајот, а потоа го тактика на.

295
00:14:58,760 --> 00:15:01,420
Така што би значело дека
вметнување на крајот на листата

296
00:15:01,420 --> 00:15:04,140
ќе стане О на n
работењето, ќе се вратам

297
00:15:04,140 --> 00:15:06,720
за нашата дискусија на
компјутерската комплексност.

298
00:15:06,720 --> 00:15:10,140
Тоа ќе станам О од n активност, каде што
како што е на листата се поголеми и поголеми,

299
00:15:10,140 --> 00:15:13,310
и поголем, тоа ќе станува повеќе и
потешко да тактика нешто

300
00:15:13,310 --> 00:15:14,661
за на крајот.

301
00:15:14,661 --> 00:15:17,410
Но секогаш е навистина лесно да се
тактика нешто на почетокот,

302
00:15:17,410 --> 00:15:19,060
ти си секогаш во почетокот.

303
00:15:19,060 --> 00:15:21,620
>> И ќе видиме визуелна на тоа повторно.

304
00:15:21,620 --> 00:15:24,100
А потоа откако ќе завршиш, еднаш
ние сме вметнува нов јазол,

305
00:15:24,100 --> 00:15:26,880
ние сакаме да се вратат нашите покажувач на
новиот шеф на поврзани листа, која

306
00:15:26,880 --> 00:15:29,213
бидејќи ние сме вметнување на
почетокот, всушност, ќе биде

307
00:15:29,213 --> 00:15:31,060
покажувач на јазол ние само замислен.

308
00:15:31,060 --> 00:15:33,280
Ајде да се визуелизира ова,
бидејќи мислам дека тоа ќе ви помогне.

309
00:15:33,280 --> 00:15:36,661
>> Значи тука е нашата листа, таа се состои од
четири елементи, јазол кој содржи 15,

310
00:15:36,661 --> 00:15:38,410
што укажува на еден јазол
содржат 9, кое што

311
00:15:38,410 --> 00:15:41,370
укажува на еден јазол кои содржат 13,
што укажува на еден јазол содржи

312
00:15:41,370 --> 00:15:44,840
10, кој има нула
покажувачот како наредна покажувачот

313
00:15:44,840 --> 00:15:47,010
така што е на крајот на листата.

314
00:15:47,010 --> 00:15:50,200
Затоа сакаме да вметнете
нов јазол со вредност 12

315
00:15:50,200 --> 00:15:52,720
на почетокот на оваа
листа, што ќе правиме?

316
00:15:52,720 --> 00:15:58,770
Па, прво ние Примерок простор за
јазол, а потоа ќе стави 12 во таму.

317
00:15:58,770 --> 00:16:02,211
>> Така, сега сме постигнале
одлуката точка, нели?

318
00:16:02,211 --> 00:16:03,960
Имаме неколку
совети кои би можеле да

319
00:16:03,960 --> 00:16:06,770
се движи, кој треба да се движиме на прво место?

320
00:16:06,770 --> 00:16:09,250
Треба да се направи 12 точка да
новиот шеф на list--

321
00:16:09,250 --> 00:16:13,020
или, извинете, ние треба да се направи 12
укажуваат на стариот шеф на листата?

322
00:16:13,020 --> 00:16:15,319
Или ние треба да се каже дека
листа сега почнува во 12.

323
00:16:15,319 --> 00:16:17,110
Има разлика
таму, а ние ќе се погледне

324
00:16:17,110 --> 00:16:19,870
што ќе се случи со двете во една секунда.

325
00:16:19,870 --> 00:16:23,350
>> Но, ова доведува до
одлична тема за странична лента,

326
00:16:23,350 --> 00:16:26,280
кој е во тоа што еден од
најтешко работите со поврзани листи

327
00:16:26,280 --> 00:16:30,980
е да се организираме на покажувачи
во правилен ред.

328
00:16:30,980 --> 00:16:34,520
Ако ви се движат работите на ред,
можете да завршуваат случајно

329
00:16:34,520 --> 00:16:36,050
orphaning остатокот од листата.

330
00:16:36,050 --> 00:16:37,300
И еве еден пример за тоа.

331
00:16:37,300 --> 00:16:40,540
Па ајде да одиме со идејата of--
Па, ние сме го креирале 12.

332
00:16:40,540 --> 00:16:43,180
Знаеме 12 ќе биде
новиот шеф на листата,

333
00:16:43,180 --> 00:16:47,660
и така зошто не можеме само да се движат
покажувачот на листата на точка таму.

334
00:16:47,660 --> 00:16:49,070
>> Добро, па тоа е добро.

335
00:16:49,070 --> 00:16:51,560
Па сега каде што го прави 12 Следна точка?

336
00:16:51,560 --> 00:16:54,580
Мислам, визуелно може да се види
дека тоа ќе се укаже на 15,

337
00:16:54,580 --> 00:16:57,250
како луѓето, тоа е навистина очигледно за нас.

338
00:16:57,250 --> 00:17:00,300
Како го прави компјутерот знаеш?

339
00:17:00,300 --> 00:17:02,720
Ние немаме ништо
што укажува на 15 веќе, нели?

340
00:17:02,720 --> 00:17:05,869
>> Ние сме го изгубиле било способност да се однесуваат на 15.

341
00:17:05,869 --> 00:17:11,460
Не можеме да кажеме нови стрелката еднаквите
нешто, таму нема ништо.

342
00:17:11,460 --> 00:17:13,510
Всушност, ние сме сирачиња
остатокот од листата

343
00:17:13,510 --> 00:17:16,465
со тоа, ние сме
случајно скршен синџирот.

344
00:17:16,465 --> 00:17:18,089
А ние сигурно не сакате да го направите тоа.

345
00:17:18,089 --> 00:17:20,000
>> Значи, да се вратиме и да се обидат ова повторно.

346
00:17:20,000 --> 00:17:24,060
Можеби вистинската работа да се направи
е да се постават 12 следната покажувачот

347
00:17:24,060 --> 00:17:28,290
до стариот чело на листата на прво место,
тогаш можеме да се движиме на листата завршена.

348
00:17:28,290 --> 00:17:30,420
И всушност, тоа е
правилен ред дека ние

349
00:17:30,420 --> 00:17:32,836
треба да се следат кога сме
работа со одделно поврзани листа.

350
00:17:32,836 --> 00:17:36,460
Ние секогаш сакаме да го поврзете
нов елемент во листата,

351
00:17:36,460 --> 00:17:41,010
пред да се преземе тој вид на
важен чекор за промена

352
00:17:41,010 --> 00:17:43,360
во кои главата на поврзани листа е.

353
00:17:43,360 --> 00:17:46,740
Повторно, тоа е тоа темелно нешто,
ние не сакаме да се изгуби патеката на тоа.

354
00:17:46,740 --> 00:17:49,310
>> Значи, ние сакаме да се осигураме дека
сè се оковани заедно,

355
00:17:49,310 --> 00:17:52,040
пред да продолжат понатаму дека покажувачот.

356
00:17:52,040 --> 00:17:55,300
И така ова ќе биде правилен ред,
кој е да се поврзе 12 на листата,

357
00:17:55,300 --> 00:17:57,630
потоа да се каже дека на листата организира 12.

358
00:17:57,630 --> 00:18:00,860
Ако се рече листата започнува во 12 и
а потоа се обидел да се поврзете 12 на листата,

359
00:18:00,860 --> 00:18:02,193
веќе видовме што се случува.

360
00:18:02,193 --> 00:18:04,920
Ние губиме листата по грешка.

361
00:18:04,920 --> 00:18:06,740
>> Добро, па уште една работа да се зборува.

362
00:18:06,740 --> 00:18:09,750
Што ако сакаме да се ослободи од
цела поврзани листа одеднаш?

363
00:18:09,750 --> 00:18:11,750
Повторно, ние сме mallocing
сите овој простор, и така ние

364
00:18:11,750 --> 00:18:13,351
се потребни за да се ослободи кога ќе завршиш.

365
00:18:13,351 --> 00:18:15,350
Така, сега сакате да ја избришете
целата поврзани листа.

366
00:18:15,350 --> 00:18:16,850
Па, она што ние сакаме да го направи?

367
00:18:16,850 --> 00:18:20,460
>> Ако ние сме достигна нултата покажувач, ние
сакаат да престанат, инаку, само го избришете

368
00:18:20,460 --> 00:18:23,420
остатокот од списокот, а потоа ме ослободи.

369
00:18:23,420 --> 00:18:28,890
Бришење на одмор на листата,
а потоа го ослободи тековната јазол.

370
00:18:28,890 --> 00:18:32,850
Што значи тоа звучи како,
што техника има разговаравме

371
00:18:32,850 --> 00:18:35,440
во врска со претходно Дали тоа звучи како?

372
00:18:35,440 --> 00:18:39,560
Избришете сите други, тогаш
да се врати и да го избришете мене.

373
00:18:39,560 --> 00:18:42,380
>> Тоа е рекурзија, го направивме
Проблемот малку помали,

374
00:18:42,380 --> 00:18:46,910
ние сме велејќи избришете сите
друго, тогаш ќе може да ми ја избришеш.

375
00:18:46,910 --> 00:18:50,940
И во периодот кој доаѓа, тој јазол
ќе каже, да го избришете сите други.

376
00:18:50,940 --> 00:18:53,940
Но на крајот ние ќе дојдеме до
точка каде листата е нула,

377
00:18:53,940 --> 00:18:55,310
и тоа е нашиот основен случај.

378
00:18:55,310 --> 00:18:57,010
>> Па ајде да ги разгледаме во тоа,
и како тоа може да работи.

379
00:18:57,010 --> 00:18:59,759
Значи тука е нашата листа, тоа е истиот
листата бевме само зборуваме,

380
00:18:59,759 --> 00:19:00,980
и таму е чекори.

381
00:19:00,980 --> 00:19:04,200
Има многу текст тука, но
се надевам дека ќе им помогне на визуелизација.

382
00:19:04,200 --> 00:19:08,557
>> Па ние have-- и јас исто така се повлече
сочинуваат нашиот магацинот рамки илустрација

383
00:19:08,557 --> 00:19:10,890
од нашата видео на повик Купишта,
и се надевам дека сите на овој

384
00:19:10,890 --> 00:19:13,260
заедно ќе ви покаже што се случува.

385
00:19:13,260 --> 00:19:14,510
Значи тука е нашата pseudocode код.

386
00:19:14,510 --> 00:19:17,830
Ако се постигне нула
покажувач, да застане, инаку,

387
00:19:17,830 --> 00:19:21,320
бришење на одмор на листата,
тогаш слободно тековната јазол.

388
00:19:21,320 --> 00:19:25,700
Значи, токму сега, list--
покажувачот дека ние сме

389
00:19:25,700 --> 00:19:28,410
поминува во да се уништи до 12 поени.

390
00:19:28,410 --> 00:19:33,340
12 не е нулти покажувач, па ние сме
случува да ги избришете остатокот од листата.

391
00:19:33,340 --> 00:19:35,450
>> Она што се бришење на
Остатокот од нас кои се вклучени?

392
00:19:35,450 --> 00:19:37,950
Па, тоа значи правење на
јавете се да се уништи, велејќи:

393
00:19:37,950 --> 00:19:42,060
дека 15 е на почетокот на
Остатокот од листата што сакаат да го уништат.

394
00:19:42,060 --> 00:19:47,480
И така на повикот да ги уништи
12 е вид на на чекање.

395
00:19:47,480 --> 00:19:52,690
Тоа е замрзнат таму, чекајќи
јавете се да се уништи 15, за да се стави крај на својата работа.

396
00:19:52,690 --> 00:19:56,280
>> Па, 15 не е нулти покажувач, и
па затоа се случува да се каже, во ред,

397
00:19:56,280 --> 00:19:58,450
добро, бришење на одмор на листата.

398
00:19:58,450 --> 00:20:00,760
Остатокот од листата започнува
во 9, и така ние само ќе

399
00:20:00,760 --> 00:20:04,514
почекајте додека не го избришете сите кои
работи, а потоа се врати и да го избришете мене.

400
00:20:04,514 --> 00:20:06,680
И 9 се случува да се каже, добро,
Јас не сум null покажувач,

401
00:20:06,680 --> 00:20:09,020
па бришење на одмор на листата од тука.

402
00:20:09,020 --> 00:20:11,805
И така се обиде и да ги уништи 13.

403
00:20:11,805 --> 00:20:15,550
13 вели, јас не сум null покажувач,
истото, тоа поминува префрлуваат одговорноста.

404
00:20:15,550 --> 00:20:17,930
10 не е нулти покажувач, 10
содржи null покажувач,

405
00:20:17,930 --> 00:20:20,200
но 10 сама по себе не е е
ништовни покажувачот во моментов,

406
00:20:20,200 --> 00:20:22,470
и така што поминува дадените пари премногу.

407
00:20:22,470 --> 00:20:25,560
>> И сега се листа поени таму, тоа
Навистина би укажуваат some--

408
00:20:25,560 --> 00:20:28,710
ако имав повеќе простор во сликата,
тоа ќе укаже на некои случајни простор

409
00:20:28,710 --> 00:20:29,960
дека ние не знаеме што е тоа.

410
00:20:29,960 --> 00:20:34,680
Тоа е нула покажувачот иако, на листата
е буквално тоа е сега во собата null вредности.

411
00:20:34,680 --> 00:20:36,820
Тоа укажува дека право внатре црвена кутија.

412
00:20:36,820 --> 00:20:39,960
Стигнавме нулти покажувач, па
ние може да го запре, и сме подготвени.

413
00:20:39,960 --> 00:20:46,230
>> И така што рамката е виолетова now-- на
врвот на stack-- тоа е активната рамка,

414
00:20:46,230 --> 00:20:47,017
но тоа е направено.

415
00:20:47,017 --> 00:20:48,600
Ако ние сме достигна нулти покажувач, запре.

416
00:20:48,600 --> 00:20:51,290
Ние не правиме ништо, ние
не може да се ослободи нулти покажувач,

417
00:20:51,290 --> 00:20:55,070
ние не Примерок било
простор, и така сме подготвени.

418
00:20:55,070 --> 00:20:57,590
Така што функција рамка
е уништена, а ние

419
00:20:57,590 --> 00:21:00,930
resume-- ние ги собереш каде што застанавте
натпреварот со следниот највисок еден, што

420
00:21:00,930 --> 00:21:02,807
е ова темно сина рамка тука.

421
00:21:02,807 --> 00:21:04,390
Значи ние ги собереш право, каде што застанавте.

422
00:21:04,390 --> 00:21:06,598
Ние избришани останатите
листа веќе, па сега сме

423
00:21:06,598 --> 00:21:08,000
случува да се ослободи тековната јазли.

424
00:21:08,000 --> 00:21:12,920
Па сега ние може да го ослободи овој јазол, а сега
ние сте достигнавме крајот на функцијата.

425
00:21:12,920 --> 00:21:16,810
И така таа функција рамка е уништена,
и ние ги собереш во светло сина еден.

426
00:21:16,810 --> 00:21:20,650
>> Па тоа says-- Веќе done--
бришење на остатокот од листата, па

427
00:21:20,650 --> 00:21:23,140
ослободи тековната јазол.

428
00:21:23,140 --> 00:21:26,520
И сега на жолтата рамка е
повторно на врвот на магацинот.

429
00:21:26,520 --> 00:21:29,655
И така како што гледате, ние сме сега
уништување на листата од десно кон лево.

430
00:21:29,655 --> 00:21:33,710

431
00:21:33,710 --> 00:21:37,280
>> Што би се случило, иако,
ако сме ги направиле работите на погрешен начин?

432
00:21:37,280 --> 00:21:39,410
Исто како кога се обидовме
да додадете елемент.

433
00:21:39,410 --> 00:21:41,909
Ако ние збркана синџирот, ако
ние не се поврзете на покажувачи

434
00:21:41,909 --> 00:21:44,690
во правилен ред, ако ние
само ослободен првиот елемент,

435
00:21:44,690 --> 00:21:47,420
ако ние само го ослободил
врвот од листата, сега ние

436
00:21:47,420 --> 00:21:49,642
нема да имаат начин да се однесуваат на
остатокот од листата.

437
00:21:49,642 --> 00:21:51,350
И така ќе имаме
сираче сè,

438
00:21:51,350 --> 00:21:53,880
ние би имале што е
наречен меморија излегуваат во јавноста.

439
00:21:53,880 --> 00:21:56,800
Ако се сеќавате од нашата видео
на динамична алокација на меморија,

440
00:21:56,800 --> 00:21:58,650
тоа не е многу добра работа.

441
00:21:58,650 --> 00:22:00,810
>> Па како што реков, има
неколку операции

442
00:22:00,810 --> 00:22:04,010
дека ние треба да ги користите на работа
со поврзана листа ефективно.

443
00:22:04,010 --> 00:22:08,430
И може да се забележи пропуштив еден,
бришење на еден елемент од поврзани

444
00:22:08,430 --> 00:22:09,064
листата.

445
00:22:09,064 --> 00:22:10,980
Причината го сторив тоа
е тоа е всушност вид на

446
00:22:10,980 --> 00:22:14,360
незгодно да се размислува за тоа како да ги избришете
еден елемент од одделно

447
00:22:14,360 --> 00:22:15,600
поврзани листа.

448
00:22:15,600 --> 00:22:19,950
Ние треба да бидат во можност да ги прескокне
нешто во листата, која

449
00:22:19,950 --> 00:22:22,975
значи дека ние се дојде до point-- ние
сакате да го избришете овој node--

450
00:22:22,975 --> 00:22:25,350
но со цел да го направи тоа за да можеме
не губат сите информации,

451
00:22:25,350 --> 00:22:30,530
ние треба да се поврзе овој
јазол овде, овде.

452
00:22:30,530 --> 00:22:33,390
>> Па јас веројатно не дека во ред
од визуелна перспектива.

453
00:22:33,390 --> 00:22:36,830
Па ние сме на почетокот на нашата
листа, ние сме се одвива преку,

454
00:22:36,830 --> 00:22:40,510
сакаме да го избришете овој јазол.

455
00:22:40,510 --> 00:22:43,440
Ако ние само го избришете,
ние сме скршени синџирот.

456
00:22:43,440 --> 00:22:45,950
Овој јазол, токму тука
се однесува на сè друго,

457
00:22:45,950 --> 00:22:48,260
што содржи синџирот од тука надвор.

458
00:22:48,260 --> 00:22:51,190
>> Значи она што треба да се направи, всушност,
откако ќе дојде до оваа точка,

459
00:22:51,190 --> 00:22:56,670
е ние треба да се чекор назад еден, и
поврзете овој јазол во текот на овој јазол,

460
00:22:56,670 --> 00:22:58,590
па тогаш можеме да ги избришете
од една во средината.

461
00:22:58,590 --> 00:23:02,120
Но одделно поврзани листи не
ни обезбеди начин да се врати назад.

462
00:23:02,120 --> 00:23:05,160
Значи ние треба да се или да ја задржите
два покажувачи, и да се движат

463
00:23:05,160 --> 00:23:09,527
вид на надвор чекор, еден зад
други како што ние одиме, или се дојде до точка

464
00:23:09,527 --> 00:23:11,110
а потоа испрати друга покажувачот преку.

465
00:23:11,110 --> 00:23:13,150
И како што можете да видите, тоа
може да се добие малку неуредна.

466
00:23:13,150 --> 00:23:15,360
За среќа, имаме
уште еден начин да се грижи за тоа,

467
00:23:15,360 --> 00:23:17,810
кога зборуваме за двојно поврзана листи.

468
00:23:17,810 --> 00:23:20,720
>> Јас сум Даг Лојд, ова е CS50.

469
00:23:20,720 --> 00:23:22,298