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
за някои произволно индекс I,

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
Например, вътр 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
в списъка като структура, която съдържа две неща,

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
и след това Повторното свързване следващия показалеца на 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
или O (N) в асимптотичната бройна система.

93
00:03:54,630 --> 00:03:56,510
Като цяло, достигайки всеки възел

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

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
като структура с 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
>> Така че, ние ще трябва показалеца специално за преодоляване

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
Head пункта до 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
ние трябва да сочен този указател,

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

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
указател на структура, а след това достъп до

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
>> Преминаващи не е толкова лошо, но какво да кажем за поставяне?

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
Ние трябва да вървим напред, две повече елементи, преди да могат да се монтират,

174
00:07:21,020 --> 00:07:23,390
така че можем да използваме за цикъл

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

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
като част от структурата на своя възел,

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
първите четири възли

224
00:09:32,220 --> 00:09:36,200
се наричат ​​A, B, C и D, със стрелките, представляващи веригата от указатели

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
Хей, ние знаем, нов възел трябва да дойде веднага след C,

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
следващия показалеца на нов възел точка за D,

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
но ние просто пренаписа че показалеца

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
Първо, насочете следващата показалеца на нов възел в D.

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

246
00:10:28,990 --> 00:10:30,660
са насочени към същия възел, D,

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
че прекосява показалеца верижен сочат,

252
00:10:45,540 --> 00:10:50,400
и D се представлява от възела, посочи следващото поле на текущия възел,

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.