1
00:00:07,260 --> 00:00:10,050
[Powered by Google Translate] Во програмирање, ние често треба да претставуваат листи на вредности,

2
00:00:10,050 --> 00:00:12,840
како што се имињата на учениците во делот

3
00:00:12,840 --> 00:00:15,100
или нивните резултати на последните квиз.

4
00:00:15,100 --> 00:00:17,430
>> Во јазик C, изјави низи може да се користи

5
00:00:17,430 --> 00:00:19,160
за чување листи.

6
00:00:19,160 --> 00:00:21,200
Тоа е лесно да наведеме елементи на листа

7
00:00:21,200 --> 00:00:23,390
чуваат во низа, и ако ви треба за да пристапите

8
00:00:23,390 --> 00:00:25,050
или модифицирање на ith елемент од листа

9
00:00:25,050 --> 00:00:27,570
за некои произволни индекс јас,

10
00:00:27,570 --> 00:00:29,910
што може да се направи во постојан време,

11
00:00:29,910 --> 00:00:31,660
но низи имаат недостатоци, исто така.

12
00:00:31,660 --> 00:00:33,850
>> Кога ќе ги прогласи, ние треба да се каже

13
00:00:33,850 --> 00:00:35,900
до пред колку е голема се тие,

14
00:00:35,900 --> 00:00:38,160
што е, колку елементи ќе може да се сместат

15
00:00:38,160 --> 00:00:40,780
и колку е голема овие елементи се, што го утврдува нивниот вид.

16
00:00:40,780 --> 00:00:45,450
На пример, int arr (10)

17
00:00:45,450 --> 00:00:48,220
може да се сместат 10 предмети

18
00:00:48,220 --> 00:00:50,200
кои се со големина на инт.

19
00:00:50,200 --> 00:00:52,590
>> Ние не може да се промени големината низа по декларацијата.

20
00:00:52,590 --> 00:00:55,290
Ние треба да се направи нова низа, ако сакаме да се складираат повеќе елементи.

21
00:00:55,290 --> 00:00:57,410
Причината ова ограничување постои е дека нашата

22
00:00:57,410 --> 00:00:59,040
програма продавници целата низа

23
00:00:59,040 --> 00:01:02,310
како соседни парче на меморија.

24
00:01:02,310 --> 00:01:04,500
Велат дека ова е тампон каде што се чуваат во нашата низа.

25
00:01:04,500 --> 00:01:06,910
Може да има други променливи

26
00:01:06,910 --> 00:01:08,310
наоѓа веднаш до низа

27
00:01:08,310 --> 00:01:10,060
во меморијата, па не можеме да

28
00:01:10,060 --> 00:01:12,060
само направи низа поголем.

29
00:01:12,060 --> 00:01:15,700
>> Понекогаш ние би сакале да тргуваат брзо низа на податоци брзината на пристап

30
00:01:15,700 --> 00:01:17,650
за малку повеќе флексибилност.

31
00:01:17,650 --> 00:01:20,380
Внесете го поврзана листа, друг основни податоци структура

32
00:01:20,380 --> 00:01:22,360
Вие не може да биде запознаен со.

33
00:01:22,360 --> 00:01:24,200
На високо ниво,

34
00:01:24,200 --> 00:01:26,840
на поврзани листа продавници податоци во низа на јазли

35
00:01:26,840 --> 00:01:29,280
кои се поврзани едни со други со линкови,

36
00:01:29,280 --> 00:01:31,760
па оттука и називот "поврзани листа".

37
00:01:31,760 --> 00:01:33,840
Како што ќе видиме, оваа разлика во дизајн

38
00:01:33,840 --> 00:01:35,500
доведува до различни предности и недостатоци

39
00:01:35,500 --> 00:01:37,000
од низа.

40
00:01:37,000 --> 00:01:39,840
>> Еве некои кодот C за еден многу едноставен поврзани листа на цели броеви.

41
00:01:39,840 --> 00:01:42,190
Можете да видите дека имаме претставен секој јазол

42
00:01:42,190 --> 00:01:45,520
во списокот како struct, која содржи 2 работи,

43
00:01:45,520 --> 00:01:47,280
целобројна за чување наречена "вредност"

44
00:01:47,280 --> 00:01:50,460
и линк до следниот јазол во листата

45
00:01:50,460 --> 00:01:52,990
кои ние ги претставуваме како покажувач кој се нарекува "Следно".

46
00:01:54,120 --> 00:01:56,780
На овој начин, можеме да ги следиме целата листа

47
00:01:56,780 --> 00:01:58,790
со само еден покажувач на јазол 1,

48
00:01:58,790 --> 00:02:01,270
и потоа можеме да се следи во следните совети

49
00:02:01,270 --> 00:02:03,130
на 2 јазол,

50
00:02:03,130 --> 00:02:05,280
од 3-тиот јазол,

51
00:02:05,280 --> 00:02:07,000
до 4 јазол,

52
00:02:07,000 --> 00:02:09,889
и така натаму, се додека не стигнете до крајот на листата.

53
00:02:10,520 --> 00:02:12,210
>> Може да биде во можност да видите 1 Предноста на овој има

54
00:02:12,210 --> 00:02:14,490
во текот на статички низа структура - со поврзани листа,

55
00:02:14,490 --> 00:02:16,450
ние не треба голем дел од меморијата заедно.

56
00:02:17,400 --> 00:02:20,530
1 јазол на листа би можеле да живеат на ова место во меморијата,

57
00:02:20,530 --> 00:02:23,160
и 2 јазол може да биде целиот пат овде.

58
00:02:23,160 --> 00:02:25,780
Можеме да дојдеме до сите јазли, без разлика каде во меморијата што се,

59
00:02:25,780 --> 00:02:28,890
бидејќи со почеток во јазол 1, следната покажувачот секој јазол

60
00:02:28,890 --> 00:02:31,700
ни кажува точно каде да одиме понатаму.

61
00:02:31,700 --> 00:02:33,670
>> Покрај тоа, ние не треба да се каже однапред

62
00:02:33,670 --> 00:02:36,740
колку е голема на поврзани листа ќе биде начинот на кој ние се направи со статички низи,

63
00:02:36,740 --> 00:02:39,060
бидејќи ние може да ги задржи додавајќи јазли на листата

64
00:02:39,060 --> 00:02:42,600
додека има простор некаде во меморија за нови јазли.

65
00:02:42,600 --> 00:02:45,370
Затоа, поврзани листи се лесно да се промени големината динамично.

66
00:02:45,370 --> 00:02:47,950
Каже, подоцна во програмата ние треба да додадете повеќе лимфни јазли

67
00:02:47,950 --> 00:02:49,350
во нашата листа.

68
00:02:49,350 --> 00:02:51,480
За да внесете нов јазол во нашата листа на мува,

69
00:02:51,480 --> 00:02:53,740
сите ние треба да направите е да алоцира меморија за тој јазол,

70
00:02:53,740 --> 00:02:55,630
одеднаш во податоците вредност,

71
00:02:55,630 --> 00:02:59,070
и тогаш тоа место каде што сакаме со прилагодување на соодветни совети.

72
00:02:59,070 --> 00:03:02,310
>> На пример, ако сакаме да поставите јазол помеѓу

73
00:03:02,310 --> 00:03:04,020
2 и 3 јазли на листата,

74
00:03:04,020 --> 00:03:06,800
 ние не ќе мора да се преселат на 2ра или 3та јазли на сите.

75
00:03:06,800 --> 00:03:09,190
Велат ние сме вметнување овој црвено јазол.

76
00:03:09,190 --> 00:03:12,890
Сите ние ќе треба да направите е да поставите следниот покажувачот новиот јазол

77
00:03:12,890 --> 00:03:14,870
да се укаже на 3 јазол

78
00:03:14,870 --> 00:03:18,580
а потоа rewire следната покажувачот на 2 јазол

79
00:03:18,580 --> 00:03:20,980
да се укаже на нашата нова јазол.

80
00:03:22,340 --> 00:03:24,370
Значи, можеме да ја промените големината нашите листи во лет

81
00:03:24,370 --> 00:03:26,090
Од нашиот компјутер не се потпира на индексирање,

82
00:03:26,090 --> 00:03:28,990
туку за поврзување со користење совети како да ги чува.

83
00:03:29,120 --> 00:03:31,600
>> Сепак, недостаток на поврзани листи

84
00:03:31,600 --> 00:03:33,370
е дека, за разлика од статична низа,

85
00:03:33,370 --> 00:03:36,690
компјутерот не само да скокнете до средината на листата.

86
00:03:38,040 --> 00:03:40,780
Од компјутер мора да ја посетите секој јазол во поврзани листа

87
00:03:40,780 --> 00:03:42,330
да се дојде до следното едно,

88
00:03:42,330 --> 00:03:44,770
тоа нема да потрае подолго за да најдете одреден јазол

89
00:03:44,770 --> 00:03:46,400
отколку што би во низа.

90
00:03:46,400 --> 00:03:48,660
Да напречни целата листа е потребно време пропорционална

91
00:03:48,660 --> 00:03:50,580
должината на листата,

92
00:03:50,580 --> 00:03:54,630
или О (n) во асимптотска нотација.

93
00:03:54,630 --> 00:03:56,510
Во просек, достигнувајќи било кој јазол

94
00:03:56,510 --> 00:03:58,800
Исто така е потребно време пропорционална на n.

95
00:03:58,800 --> 00:04:00,700
>> Сега, ајде да всушност пишува некаков код

96
00:04:00,700 --> 00:04:02,000
која работи со поврзани листи.

97
00:04:02,000 --> 00:04:04,220
Да речеме дека сакаме поврзани листа на цели броеви.

98
00:04:04,220 --> 00:04:06,140
Ние може да претставува еден јазол во нашата листа повторно

99
00:04:06,140 --> 00:04:08,340
како struct со 2 области,

100
00:04:08,340 --> 00:04:10,750
целобројна вредност наречена "вредност"

101
00:04:10,750 --> 00:04:13,490
и следната покажувач кон следниот јазол на листа.

102
00:04:13,490 --> 00:04:15,660
Па, се чини едноставна.

103
00:04:15,660 --> 00:04:17,220
>> Да речеме дека сакаме да напише функција

104
00:04:17,220 --> 00:04:19,329
кој преминува листата и отпечатоци од

105
00:04:19,329 --> 00:04:22,150
вредност се чуваат во последните јазол на листа.

106
00:04:22,150 --> 00:04:24,850
Па, тоа значи дека ние ќе треба да напречни сите јазли во листата

107
00:04:24,850 --> 00:04:27,310
да се најде на последната, но бидејќи ние не сме додавање на

108
00:04:27,310 --> 00:04:29,250
или бришење на ништо, ние не сакаме да се промени

109
00:04:29,250 --> 00:04:32,210
внатрешната структура на следниот совети во листата.

110
00:04:32,210 --> 00:04:34,790
>> Значи, ние ќе треба покажувач специјално за traversal

111
00:04:34,790 --> 00:04:36,940
кој ќе го наречеме "Роботот".

112
00:04:36,940 --> 00:04:38,870
Тоа ќе ползи преку сите елементи на листата

113
00:04:38,870 --> 00:04:41,190
со следење на синџирот на следната совети.

114
00:04:41,190 --> 00:04:43,750
Сите ние се чуваат е покажувач на јазол 1,

115
00:04:43,750 --> 00:04:45,730
или 'глава' на листата.

116
00:04:45,730 --> 00:04:47,370
Раководител поени 1 јазол.

117
00:04:47,370 --> 00:04:49,120
Тоа е од тип покажувач до-јазол.

118
00:04:49,120 --> 00:04:51,280
>> Да го добиете вистинскиот 1 јазол во листата,

119
00:04:51,280 --> 00:04:53,250
ние треба да Dereference овој покажувач,

120
00:04:53,250 --> 00:04:55,100
но пред да можеме да го Dereference, ние треба да се провери

121
00:04:55,100 --> 00:04:57,180
ако покажувачот е нула во прв план.

122
00:04:57,180 --> 00:04:59,190
Ако тоа е нула, на листата е празна,

123
00:04:59,190 --> 00:05:01,320
и ние треба да испечатите на пораката што, бидејќи на листата е празна,

124
00:05:01,320 --> 00:05:03,250
не постои последен јазол.

125
00:05:03,250 --> 00:05:05,190
Но, да речеме, на листата не е празна.

126
00:05:05,190 --> 00:05:08,340
Ако не е, тогаш треба да ползи преку целата листа

127
00:05:08,340 --> 00:05:10,440
додека не стигнете до последниот јазол на листа,

128
00:05:10,440 --> 00:05:13,030
и како можеме да ти кажам, ако ние сме во потрага на последниот јазол во листата?

129
00:05:13,670 --> 00:05:16,660
>> Па, ако следниот покажувачот еден јазол е нула,

130
00:05:16,660 --> 00:05:18,320
знаеме дека сме на крајот

131
00:05:18,320 --> 00:05:22,390
од последната следната покажувачот нема да има следниот јазол во листата да се укаже.

132
00:05:22,390 --> 00:05:26,590
Тоа е добра практика да се држи секогаш следната покажувачот последните јазол иницијализира на нула

133
00:05:26,590 --> 00:05:30,800
да имаат стандардизиран имот кој не предупредува кога сте достигнавме крајот на листата.

134
00:05:30,800 --> 00:05:33,510
>> Значи, ако Роботот → следната е нула,

135
00:05:34,120 --> 00:05:38,270
се сеќавам дека стрелките на синтаксата е кратенка за dereferencing

136
00:05:38,270 --> 00:05:40,010
покажувач на struct, тогаш пристап

137
00:05:40,010 --> 00:05:42,510
својот следен областа еквивалентни на непријатна:

138
00:05:42,510 --> 00:05:48,750
(* Роботот). Следната.

139
00:05:49,820 --> 00:05:51,260
Откако ќе го најде последниот јазол,

140
00:05:51,260 --> 00:05:53,830
ние сакаме да се печати Роботот → вредност,

141
00:05:53,830 --> 00:05:55,000
вредност во тековниот јазол

142
00:05:55,000 --> 00:05:57,130
кои знаеме е последен.

143
00:05:57,130 --> 00:05:59,740
Инаку, ако ние не сме уште во последниот јазол во листата,

144
00:05:59,740 --> 00:06:02,340
ние треба да се движи кон следниот јазол во листата

145
00:06:02,340 --> 00:06:04,750
и проверете дали тоа е последен.

146
00:06:04,750 --> 00:06:07,010
Да го направите ова, ние само го постави нашиот Роботот покажувачот

147
00:06:07,010 --> 00:06:09,840
да се укаже следната вредност тековната јазол,

148
00:06:09,840 --> 00:06:11,680
што е, следниот јазол во листата.

149
00:06:11,680 --> 00:06:13,030
Ова е направено со поставување

150
00:06:13,030 --> 00:06:15,280
Роботот = Роботот → следната.

151
00:06:16,050 --> 00:06:18,960
Тогаш ние го повтори овој процес, со еден циклус на пример,

152
00:06:18,960 --> 00:06:20,960
додека не се најде на последната јазол.

153
00:06:20,960 --> 00:06:23,150
Така, на пример, ако Роботот беше укажува на главата,

154
00:06:24,050 --> 00:06:27,710
ние во собата Роботот да се укаже Роботот → следната,

155
00:06:27,710 --> 00:06:30,960
кој е ист како на следната област на 1 јазол.

156
00:06:30,960 --> 00:06:33,620
Значи, сега нашите Роботот е да се покажува на 2 јазол,

157
00:06:33,620 --> 00:06:35,480
и, повторно, се повторува со еден циклус,

158
00:06:37,220 --> 00:06:40,610
додека ние Наидовме на последниот јазол, што е,

159
00:06:40,610 --> 00:06:43,640
каде следната покажувачот на јазол е да се покажува на нула.

160
00:06:43,640 --> 00:06:45,070
И таму го имаме,

161
00:06:45,070 --> 00:06:47,620
ние Наидовме на последниот јазол во листата, и да се печати својата вредност,

162
00:06:47,620 --> 00:06:50,800
ние само користење пребарувач → вредност.

163
00:06:50,800 --> 00:06:53,130
>> Traversing не е толку лошо, но она што за вметнување?

164
00:06:53,130 --> 00:06:56,290
Да речеме ние сакаме да вметнете број во 4-то место

165
00:06:56,290 --> 00:06:58,040
во целобројна листа.

166
00:06:58,040 --> 00:07:01,280
Тоа е меѓу сегашните 3 и 4 јазли.

167
00:07:01,280 --> 00:07:03,760
Повторно, ние треба да напречни листата само за да

168
00:07:03,760 --> 00:07:06,520
стигнете до 3 елемент, еден ние сме вметнување после.

169
00:07:06,520 --> 00:07:09,300
Значи, ние создаваме Роботот покажувачот повторно да напречни листата,

170
00:07:09,300 --> 00:07:11,400
проверете дали нашата глава покажувачот е нула,

171
00:07:11,400 --> 00:07:14,810
а ако не е, посочуваат нашите Роботот покажувачот на чело јазол.

172
00:07:16,880 --> 00:07:18,060
Значи, ние сме на 1 елемент.

173
00:07:18,060 --> 00:07:21,020
Ние треба да одиме напред уште 2 елементи пред да можеме да вметнете,

174
00:07:21,020 --> 00:07:23,390
па ние да го користите за телефонска линија

175
00:07:23,390 --> 00:07:26,430
int i = 1; i <3; i + +

176
00:07:26,430 --> 00:07:28,590
и во секоја повторување на јамка,

177
00:07:28,590 --> 00:07:31,540
унапредиме нашите Роботот покажувачот нанапред со 1 јазол

178
00:07:31,540 --> 00:07:34,570
со проверка дали наредното поле тековната јазол е нула,

179
00:07:34,570 --> 00:07:37,550
а ако не е, се движи нашиот Роботот покажувач кон следниот јазол

180
00:07:37,550 --> 00:07:41,810
со поставување еднаква на следниот покажувач на тековната јазол.

181
00:07:41,810 --> 00:07:45,210
Значи, бидејќи нашите за јамка вели да го направите тоа

182
00:07:45,210 --> 00:07:47,550
двапати,

183
00:07:49,610 --> 00:07:51,190
Дојдовме до 3 јазол,

184
00:07:51,190 --> 00:07:53,110
и еднаш нашите Роботот покажувачот достигна јазол по

185
00:07:53,110 --> 00:07:55,270
која сакате да вметнете нашиот нов број,

186
00:07:55,270 --> 00:07:57,050
како ние всушност направиме вметнување?

187
00:07:57,050 --> 00:07:59,440
>> Па, нашата нова цел број мора да биде вметната во листата

188
00:07:59,440 --> 00:08:01,250
како дел од своите јазол struct,

189
00:08:01,250 --> 00:08:03,140
бидејќи ова е навистина низа на јазли.

190
00:08:03,140 --> 00:08:05,690
Значи, ајде да се направи нов покажувач на јазол

191
00:08:05,690 --> 00:08:08,910
се вика 'new_node "

192
00:08:08,910 --> 00:08:11,800
и го постави на точка за меморија што ние сега се распредели

193
00:08:11,800 --> 00:08:14,270
на грамада за јазол себе,

194
00:08:14,270 --> 00:08:16,000
и колку меморија не ни треба да ги распредели?

195
00:08:16,000 --> 00:08:18,250
Па, големината на еден јазол,

196
00:08:20,450 --> 00:08:23,410
и ние сакаме да се постави вредност областа на цел број кој сакаме да го внесете.

197
00:08:23,410 --> 00:08:25,590
Да речеме, 6.

198
00:08:25,590 --> 00:08:27,710
Сега, на јазол содржи нашите целобројна вредност.

199
00:08:27,710 --> 00:08:30,650
Тоа е исто така добра пракса да се иницијализира следната областа на новиот јазол

200
00:08:30,650 --> 00:08:33,690
да се укаже на нула,

201
00:08:33,690 --> 00:08:35,080
но сега што?

202
00:08:35,080 --> 00:08:37,179
>> Ние мора да се промени на внатрешната структура на листата

203
00:08:37,179 --> 00:08:40,409
а следниот совети содржани во постојните на листата

204
00:08:40,409 --> 00:08:42,950
3 и 4 јазли.

205
00:08:42,950 --> 00:08:46,560
Од следната совети утврди редоследот на листата,

206
00:08:46,560 --> 00:08:48,650
и бидејќи ние сме вметнување нашиот нов јазол

207
00:08:48,650 --> 00:08:50,510
право во средината на листата,

208
00:08:50,510 --> 00:08:52,010
тоа може да биде малку незгодно.

209
00:08:52,010 --> 00:08:54,250
Тоа е затоа што, се сеќавам, нашиот компјутер

210
00:08:54,250 --> 00:08:56,250
само знае локацијата на јазли во листата

211
00:08:56,250 --> 00:09:00,400
бидејќи на следната совети чуваат во претходниот јазли.

212
00:09:00,400 --> 00:09:03,940
Значи, ако некогаш се губеше на било кој од овие локации,

213
00:09:03,940 --> 00:09:06,860
каже со промена на еден од следните совети во нашата листа,

214
00:09:06,860 --> 00:09:09,880
На пример, да речеме ние го променивме

215
00:09:09,880 --> 00:09:12,920
3 јазол следната област

216
00:09:12,920 --> 00:09:15,610
да се укаже на некои јазол овде.

217
00:09:15,610 --> 00:09:17,920
Ние ќе биде надвор од среќа, бидејќи ние не би

218
00:09:17,920 --> 00:09:20,940
имате идеја каде да ја најдат на остатокот од листата,

219
00:09:20,940 --> 00:09:23,070
и тоа е очигледно навистина лошо.

220
00:09:23,070 --> 00:09:25,080
Значи, ние треба да биде навистина внимателен за цел

221
00:09:25,080 --> 00:09:28,360
во која манипулира со нашиот следен совети при самото внесување.

222
00:09:28,360 --> 00:09:30,540
>> Значи, да се поедностави тоа, да речеме дека

223
00:09:30,540 --> 00:09:32,220
нашата прва 4 јазли

224
00:09:32,220 --> 00:09:36,200
се нарекуваат А, Б, Ц и Д, со стрели претставуваат синџир на покажувачи

225
00:09:36,200 --> 00:09:38,070
кои ги поврзуваат јазли.

226
00:09:38,070 --> 00:09:40,050
Значи, ние треба да го вметнете нашиот нов јазол

227
00:09:40,050 --> 00:09:42,070
помеѓу јазли C и D.

228
00:09:42,070 --> 00:09:45,060
Тоа е критичко да го стори тоа во вистинската цел, а јас ќе ви покажеме зошто.

229
00:09:45,060 --> 00:09:47,500
>> Да ги погледнеме на погрешен начин да го направи тоа во прв план.

230
00:09:47,500 --> 00:09:49,490
Еј, знаеме нов јазол мора да дојде веднаш по Ц,

231
00:09:49,490 --> 00:09:51,910
па ајде постави следната покажувачот на C

232
00:09:51,910 --> 00:09:54,700
да се укаже new_node.

233
00:09:56,530 --> 00:09:59,180
Добро, се чини во ред, ние само треба да завршам сега со

234
00:09:59,180 --> 00:10:01,580
правење следната новиот јазол покажувачот точка за развој,

235
00:10:01,580 --> 00:10:03,250
Но чекајте, како можеме да го направите тоа?

236
00:10:03,250 --> 00:10:05,170
Единственото нешто што може да ни каже каде d е,

237
00:10:05,170 --> 00:10:07,630
беше следниот покажувачот претходно зачувани во C,

238
00:10:07,630 --> 00:10:09,870
но ние едноставно rewrote дека покажувачот

239
00:10:09,870 --> 00:10:11,170
да укаже на нов јазол,

240
00:10:11,170 --> 00:10:14,230
па ние веќе немаш поим од каде D е во меморијата,

241
00:10:14,230 --> 00:10:17,020
и ние сме изгубени остатокот на листата.

242
00:10:17,020 --> 00:10:19,000
Не е добро на сите.

243
00:10:19,000 --> 00:10:21,090
>> Значи, како ние да го направите ова, нели?

244
00:10:22,360 --> 00:10:25,090
Прво, точка следната покажувачот новиот јазол на Д

245
00:10:26,170 --> 00:10:28,990
Сега, двете нови јазол и C следната совети

246
00:10:28,990 --> 00:10:30,660
се укажува на истиот јазол, Д,

247
00:10:30,660 --> 00:10:32,290
но тоа е во ред.

248
00:10:32,290 --> 00:10:35,680
Сега можеме да укаже следната покажувачот на C на нов јазол.

249
00:10:37,450 --> 00:10:39,670
Значи, ние го направиле тоа без губење на сите податоци.

250
00:10:39,670 --> 00:10:42,280
Во код, C е тековната јазол

251
00:10:42,280 --> 00:10:45,540
дека traversal покажувачот Роботот е да се покажува,

252
00:10:45,540 --> 00:10:50,400
и Д се претставени од страна на јазол посочи до следната областа на тековната јазол,

253
00:10:50,400 --> 00:10:52,600
или Роботот → следната.

254
00:10:52,600 --> 00:10:55,460
Значи, ние првиот сет следната покажувачот новиот јазол

255
00:10:55,460 --> 00:10:57,370
да се укаже Роботот → следната,

256
00:10:57,370 --> 00:11:00,880
На ист начин можеме рече следната покажувачот new_node треба

257
00:11:00,880 --> 00:11:02,780
точка до D на илустрацијата.

258
00:11:02,780 --> 00:11:04,540
Потоа, ние може да се постави следното покажувач на тековната јазол

259
00:11:04,540 --> 00:11:06,330
на нашиот нов јазол,

260
00:11:06,330 --> 00:11:10,980
како што моравме да чекаме да се укаже C до new_node во цртежот.

261
00:11:10,980 --> 00:11:12,250
Сега сè е во ред, и ние не ја загубивме

262
00:11:12,250 --> 00:11:14,490
ги пратите на сите податоци, а ние бевме во можност да само

263
00:11:14,490 --> 00:11:16,200
држи нашиот нов јазол во средината на листата

264
00:11:16,200 --> 00:11:19,330
без обновата на целата работа, па дури и менувањето на било какви елементи

265
00:11:19,330 --> 00:11:22,490
начинот на кој ние би требало да со фиксна должина низа.

266
00:11:22,490 --> 00:11:26,020
>> Значи, поврзани листи се основни, но важно, динамична структура на податоци

267
00:11:26,020 --> 00:11:29,080
кои имаат и предности и недостатоци

268
00:11:29,080 --> 00:11:31,260
во споредба со низи и други структури на податоци,

269
00:11:31,260 --> 00:11:33,350
и како што е често случај во компјутерски науки,

270
00:11:33,350 --> 00:11:35,640
тоа е важно да се знае кога да се користи секоја алатка,

271
00:11:35,640 --> 00:11:37,960
па можете да ги собереш на правото алатка за вистинската работа.

272
00:11:37,960 --> 00:11:40,060
>> За повеќе пракса, обидете се да пишувате функции

273
00:11:40,060 --> 00:11:42,080
избришете јазли од поврзани листа -

274
00:11:42,080 --> 00:11:44,050
не заборавајте да се биде внимателен во врска со редоследот по кој ќе ги преуредите

275
00:11:44,050 --> 00:11:47,430
вашиот следен совети како да се осигура дека вие не губат парче на вашата листа -

276
00:11:47,430 --> 00:11:50,200
или функција да смета на јазли во поврзани листа,

277
00:11:50,200 --> 00:11:53,280
или забавно, да се јават на цел на сите јазли во поврзани листа.

278
00:11:53,280 --> 00:11:56,090
>> Моето име е Џексон Steinkamp, ​​ова е CS50.