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
またはi番目のリスト要素を変更する

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
例えば、int型ARR（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
'val'の呼ばれる格納する整数

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
第一のノードへのただ一つのポインタを使用して、

48
00:01:58,790 --> 00:02:01,270
それから私達は次のポインタをたどることができ

49
00:02:01,270 --> 00:02:03,130
第二のノードに、

50
00:02:03,130 --> 00:02:05,280
第三のノードに、

51
00:02:05,280 --> 00:02:07,000
第四ノードに、

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
そして第二ノードはこっちすべての方法かもしれない。

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
 我々はすべてで2nd、3rdのノードを移動する必要はありません。

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
第三のノードを指すように

78
00:03:14,870 --> 00:03:18,580
その後第二のノードの次のポインタを配線し直す

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
また、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
2つのフィールドを持つ構造体として、

100
00:04:08,340 --> 00:04:10,750
'val'の呼ばれる整数値

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
>> Let 'sは、我々は関数を書きたいと言う

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
我々が保存されていたすべては、第一のノードへのポインタです。

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
我々は、間接参照するthisポインタを持っている

120
00:04:53,250 --> 00:04:55,100
我々はそれを間接参照することができます前に、しかし、我々は確認する必要があります

121
00:04:55,100 --> 00:04:57,180
ポインタは最初のnullである場合。

122
00:04:57,180 --> 00:04:59,190
それがnullである場合は、リストは空です

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
>> さて、ノードの次のポインタがnullである場合、

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
それは、常にnullに初期化された最後のノードの次のポインタを保持すると良いでしょう

133
00:05:26,590 --> 00:05:30,800
我々はリストの最後に到達したときに私たちに警告を標準化されたプロパティを持っています。

134
00:05:30,800 --> 00:05:33,510
>> だから、クローラー→次がnullである場合、

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
我々は、クローラー→valを印刷したい

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
これは、第一のノードの次のフィールドと同じです。

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
どこのノードの次のポインタはnullに向いています。

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
私達はちょうどクローラー→valを使用しています。

163
00:06:50,800 --> 00:06:53,130
>> トラバースはそれほど悪くはありませんが、挿入はどうでしょうか？

164
00:06:53,130 --> 00:06:56,290
貸し付けは、我々は第四の位置に整数値を挿入したいと言う

165
00:06:56,290 --> 00:06:58,040
整数のリストに表示されます。

166
00:06:58,040 --> 00:07:01,280
つまり、現在の第三と第四のノードとの間にある。

167
00:07:01,280 --> 00:07:03,760
再び、我々はちょうどにリストを横断しなければならない

168
00:07:03,760 --> 00:07:06,520
第三要素は、我々は後に挿入しているものを取得する。

169
00:07:06,520 --> 00:07:09,300
そこで、我々は、リストをトラバースするには、もう一度クローラのポインタを作成する

170
00:07:09,300 --> 00:07:11,400
私たちの頭のポインタがnullであるかどうかを確認してください

171
00:07:11,400 --> 00:07:14,810
それがない場合には、ヘッドノードでクローラポインタを指す。

172
00:07:16,880 --> 00:07:18,060
そこで、我々は第一要素にいる。

173
00:07:18,060 --> 00:07:21,020
私たちは、挿入する前に、2以上の要素を前方に行かなければならない

174
00:07:21,020 --> 00:07:23,390
ので、我々は、forループを使用することができます

175
00:07:23,390 --> 00:07:26,430
int型私= 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
現在のノードの次のフィールドがnullかどうかをチェックすることによって、

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
私たちは、第三のノードに到達しました

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
我々は、我々は挿入する整数へのvalフィールドを設定したい。

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
NULLを指している場合は、

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
第三ノードの横にあるフィールド

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
それでは、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
同じノードA、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
図のA〜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ためにCを指すように待たなければならなかったのと同じである。

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
リンクされたリスト内のすべてのノードの順序を逆にしたり、楽しい1、。

278
00:11:53,280 --> 00:11:56,090
>> 私の名前はジャクソンSteinkampですが、これはCS50です。