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
>> DOUG LLOYD：OK、そうで
もちろんこの点、

4
00:00:08,560 --> 00:00:15,300
我々は、Cの基礎をたくさん紹介してきました
私たちは、変数、配列について多くのことを知っています

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
>> そしてそれでは始めましょう、のはそれをやらせます
Cは私たちを与えるもののうち分岐します、

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
私たちは、配列を宣言すると、
我々はそれに1つのショットを取得。

32
00:01:47,150 --> 00:01:49,790
私たちは、私が欲しい、と言ってもらいます
この多くの要素。

33
00:01:49,790 --> 00:01:51,940
それは、100かもしれないかもしれません
それは、千場合がございます

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
>> しかし、私たちはそれだけで1ショットを取得、我々
その後、私は実際に、ああ言うために得ることはありません

37
00:01:59,905 --> 00:02:04,360
101を必要とするか、私は、xプラス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
malloc関数で割り当て、我々
一緒にこれらの作品を置くことができます

47
00:02:36,180 --> 00:02:40,960
新しいデータstructure-- Aを作成します
我々は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--このそれを呼び出すに行きます
ノードが二つの部材、または2つのフィールドがあります。

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
含まれている第2のノードに
データ、および第3のノードへのポインタ。

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
構造体sllist tyepdef、その後、私は
任意に、ここでワード値を使用して

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
日Iの終わりに
明らかにそれを呼び出したいです

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
そのために一時的に与えます
構造体sllistの名前

91
00:05:14,910 --> 00:05:18,540
私は、私がしたいと言うことができます
別の構造体へのポインタsllist、

92
00:05:18,540 --> 00:05:24,690
構造体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は構造体を言います
中かっこを開き、それを定義します。

100
00:05:43,040 --> 00:05:45,620
あなたがしている場合でも、構造体は、自己があります
これは、そのまま、参考

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
そして、私たちは、削除できるようにする必要があります
急襲の失敗1で全体のリンクリスト。

123
00:06:44,627 --> 00:06:46,460
それでは、通さ
これらの操作の一部

124
00:06:46,460 --> 00:06:51,192
私たちはそれらを視覚化する方法、
特に擬似コードコードで話し。

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ノード星、作成し、私が渡しています
1引数に、いくつかの任意のデータ

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
繰り返しますが、我々は薄いからそれを作成しています
空気ので、我々はそれのためのmallocスペースにする必要があります。

137
00:07:26,689 --> 00:07:28,480
そしてもちろん、すぐに
私たちはをmallocした後、

138
00:07:28,480 --> 00:07:31,692
我々は常にことを確認するためにチェックする私たちの
pointer--我々は戻ってnullを取得できませんでした。

139
00:07:31,692 --> 00:07:33,650
そのため、私たちがしようとする場合
NULLポインタを服従、

140
00:07:33,650 --> 00:07:36,190
我々は苦しむことになるだろう
セグメンテーションフォールトと我々はそれを望んでいません。

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
画像は持っていません
それがnullの場合、最大示し、

151
00:08:04,840 --> 00:08:07,298
我々は、メモリが不足しているだろう
私たちはそこに行ってもいいです。

152
00:08:07,298 --> 00:08:10,200
だから今、私たちは、ステップCににしています
ノードの値フィールドを初期化します。

153
00:08:10,200 --> 00:08:12,280
さて、この関数に基づいて
私はここで使用している呼び出し、

154
00:08:12,280 --> 00:08:16,700
私は6に渡したいように見えます、
私はvalueフィールドの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
そして、我々は起こっている機能が欲しいです
応じて、trueまたはfalseを返します

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
見つけるBOOL this--のように見える、と可能性があります
その後、我々は二つの引数を渡したいです。

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
あなただけの最初のトラックを保持する必要があります
1これらはすべて一緒に連鎖している場合。

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
なぜ私たちは周りのその1を移動しませんか？

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
だから、作成する方が良いでしょう
私たちが移動するために使用する第1。

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
この1の構成は
5つのノード、我々は持っています

212
00:11:00,043 --> 00:11:04,330
の先頭へのポインタ
リストと呼ばれるリスト。

213
00:11:04,330 --> 00:11:07,385
私たちがやりたい最初のものです
再び、そのトラバースポインタを作成します。

214
00:11:07,385 --> 00:11:09,760
つまり、2つのポインタを持っています
同じことをポイント。

215
00:11:09,760 --> 00:11:15,025
>> さて、ここにも気づく、私はしませんでした
TRAVのための任意の領域ををmallocする必要があります。

216
00:11:15,025 --> 00:11:18,970
私はTRAVはmalloc関数に等しいと言っていませんでした
何かが、そのノードが既に存在して

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
>> そして、それは、我々1取引の一種です
アレイの詩リンクリストを持っています、

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番目の要素、または第六の要素、

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を含む、6がそこにはありません。

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次、
そこに赤いボックスは、nullです。

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
そして、それが返されます
この場合にはfalse。

255
00:13:10,980 --> 00:13:14,540
>> [OK]を、どのように我々は新しいを挿入します
リンクリストにノード？

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
私たちは、1つのリストを持ってしたいこと
その内のノードの束を持って、

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
我々はmalloc関数を使用しているため。

276
00:14:07,150 --> 00:14:09,080
その後、我々は移入したいです
ノードを挿入し、

277
00:14:09,080 --> 00:14:12,730
そう番号を入れて、どんな
valがノードに、あります。

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個のOになります
操作は、戻って

297
00:15:04,140 --> 00:15:06,720
私たちの議論に
計算の複雑さ。

298
00:15:06,720 --> 00:15:10,140
これは、n個の動作のOになるだろう
リストが大きく、そして大きくなったように、

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
>> だからここに私たちのリストだ、それはで構成されてい
4つの要素が、ノードは、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
さて、最初に我々はのためのスペースををmalloc
ノード、その後、我々はそこに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
リストの残りの部分を孤立。

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
>> [OK]を、ので、それは良いことです。

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
>> [OK]を、について話をするので、もう一つ。

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
>> 私たちは、NULLポインタに達した場合は、我々
それ以外の場合は、停止したい、ただ削除

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
しかし、最終的に我々はに取得します
リストがnullである点、

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
だからここに私達の擬似コードコードです。

386
00:19:14,510 --> 00:19:17,830
我々はNULLに達した場合
ポインタが、そうでない場合、停止します

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は、NULLポインタでないので、我々はしています
リストの残りの部分を削除しようとして。

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は、NULLポインタではなく、
それは、すべての権利を言うために起こっています

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ポインタではありません
NULLポインタが含まれています、

405
00:20:17,930 --> 00:20:20,200
しかし10は、それ自体ではありません
今NULLポインタ、

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ポインタです
文字通り、今ではNULL値です設定されています。

411
00:20:34,680 --> 00:20:36,820
それは、その赤いボックス内を右向いています。

412
00:20:36,820 --> 00:20:39,960
私たちはそのように、NULLポインタに達しました
私たちは停止することができ、我々は完了です。

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
我々はNULLポインタに達した場合は、停止します。

416
00:20:48,600 --> 00:20:51,290
我々は、我々が何もしません
nullポインタを解放することはできません、

417
00:20:51,290 --> 00:20:55,070
我々は、いずれかををmallocしませんでした
スペースは、と私たちは完了です。

418
00:20:55,070 --> 00:20:57,590
だから、関数フレーム
破壊され、私たちさ

419
00:20:57,590 --> 00:21:00,930
我々は左のどこが拾いますresume--
次に高い1、でオフします

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
だから、その関数のフレームが破壊され、
我々は水色1で拾います。

426
00:21:16,810 --> 00:21:20,650
>> だから、私はすでにdone--ましsays--
そう、リストの残りの部分を削除します

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
そして、あなたは、私は1つを省略して気づいたかもしれません
リンクから単一の要素を削除します

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
我々は1つ前のステップに必要であり、
このノードにこのノードを介して接続、

460
00:22:56,670 --> 00:22:58,590
私たちはその後、削除することができます
真ん中の1。

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