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
или изменить го элемента списка

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
Например, внутр обр (10)

17
00:00:45,450 --> 00:00:48,220
может хранить 10 пунктов

18
00:00:48,220 --> 00:00:50,200
, которые являются размер Int.

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
В списке, как структура, которая содержит 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
Первый узел списка могли бы жить на этом месте в памяти,

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
потому что, начиная с первого узла, следующего указателя каждого узла

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
Руководитель указывает на первый узел.

117
00:04:47,370 --> 00:04:49,120
Это типа указатель-на-узла.

118
00:04:49,120 --> 00:04:51,280
>> Чтобы получить фактический первый узел в списке,

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

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
Итак, теперь наш сканер указывает на втором узле,

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
Мы должны идти вперед еще 2 элемента прежде чем мы сможем вставить,

174
00:07:21,020 --> 00:07:23,390
поэтому мы можем использовать для цикла

175
00:07:23,390 --> 00:07:26,430
Int я = 1; I <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
наши первые 4 узлов

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
так что давайте установить следующий указатель Си

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
В коде С текущего узла

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
так же, как мы должны были ждать до точки С, чтобы 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.