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
თუ გავიხსენებთ ჩვენი ვიდეო
on Insertion დალაგების,

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
როდესაც ვაცხადებთ მასივი,
ჩვენ კიდევ ერთი ესროლეს.

32
00:01:47,150 --> 00:01:49,790
ჩვენ კიდევ უნდა ვთქვა, მე მინდა
ეს ბევრი ელემენტები.

33
00:01:49,790 --> 00:01:51,940
შეიძლება 100, შესაძლოა,
1,000, შესაძლოა,

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
>> მაგრამ ჩვენ მხოლოდ ერთი გასროლით ის, რომ ჩვენ
არ მიიღოთ, მაშინ ამბობენ oh, რეალურად მე

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
ასე რომ, ისინი ძალიან მოუქნელი
ამისთვის resizing ჩვენი მონაცემებით,

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
რათა შეიქმნას ახალი მონაცემები სტრუქტურა
ცალკე უკავშირდება სიაში ჩვენ შეიძლება ვთქვათ

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
უბრალოდ აპირებს ეძახით კვანძის და ეს
კვანძის აქვს ორი წევრი, ან ორი სფეროებში.

58
00:03:16,190 --> 00:03:20,300
მას აქვს მონაცემები, როგორც წესი,
რიცხვი, ხასიათი float,

59
00:03:20,300 --> 00:03:23,790
ან შეიძლება იყოს ზოგიერთი სხვა მონაცემები ტიპი
რომ თქვენ განსაზღვრული ტიპის Def.

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
მეორე კვანძი, რომელიც შეიცავს
მონაცემები და მომცეთ მესამე კვანძის.

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
ისე, თუ გახსოვთ, ჩვენი ვიდეო
განსაზღვრის საბაჟო ტიპის, ტიპის Def,

70
00:04:01,120 --> 00:04:05,400
ჩვენ შეგვიძლია განვსაზღვროთ სტრუქტურა და
ტიპი განსაზღვრავს სტრუქტურა მოსწონს ეს.

71
00:04:05,400 --> 00:04:11,240
tyepdef struct sllist, და მაშინ მე
გამოყენებით სიტყვა მნიშვნელობა აქ თვითნებურად

72
00:04:11,240 --> 00:04:13,891
მიუთითოს მონაცემები ტიპის ნამდვილად.

73
00:04:13,891 --> 00:04:16,890
თქვენ შეიძლება გაიაროს მთელი რიცხვი ან float,
თქვენ შეიძლება ჰქონდეს, რაც გაგიხარდებათ.

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
ბოლოს დღეს მე
ნათლად გვინდა, რომ მას

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
მიზეზი ისაა, რომ მე არ
ის ტიპის მოუწოდა კვლავ კვანძის

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
ეს; s მონაცემთა ტიპის
სტრუქტურა, რომელიც შეიცავს მონაცემებს,

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
ასე რომ, რაც მას დროებითი
სახელი struct sllist

91
00:05:14,910 --> 00:05:18,540
საშუალებას აძლევს ჩემთვის, მაშინ ამბობენ მე მინდა
მომცეთ კიდევ ერთი struct sllist,

92
00:05:18,540 --> 00:05:24,690
არის struct 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
არ აქვს specifier სახელი აქ.

99
00:05:39,390 --> 00:05:43,040
ეს, უბრალოდ, ვამბობთ typedef struct,
ღია Curly გაუწიოს და შემდეგ განსაზღვრავს მას.

100
00:05:43,040 --> 00:05:45,620
მაგრამ თუ თქვენ struct თვითმმართველობის
რეფერენტული, როგორც ეს ერთი არის,

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
ასე რომ, ჩვენ უნდა შეეძლოს წაშლა
მთელი უკავშირდება სიაში ერთ ვერ swoop.

123
00:06:44,627 --> 00:06:46,460
მოდით გავლა
ზოგიერთი ოპერაციების

124
00:06:46,460 --> 00:06:51,192
და როგორ შეიძლება ვიზუალურად მათ,
საუბარი pseudocode კოდი კონკრეტულად.

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 კვანძის ვარსკვლავი, შექმნა, და მე გავლით
ერთი არგუმენტი, ზოგიერთი თვითნებური მონაცემები

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
ჩვენ ყოველთვის შემოწმება, რათა დავრწმუნდეთ, რომ ჩვენი
მაჩვენებელი ჩვენ არ დაუბრუნდება null.

139
00:07:31,692 --> 00:07:33,650
იმიტომ, რომ თუ ჩვენ ვცდილობთ და
პარადიგმები, ტერმინოლოგიური null მაჩვენებელი,

140
00:07:33,650 --> 00:07:36,190
ჩვენ ვაპირებთ, რომ განიცდიან
segfault და ჩვენ არ გვინდა, რომ.

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
და შემდეგ ჩვენ გვინდა, რომელთა მიზანია, საბოლოო ჯამში, როგორც
ფუნქციის პროტოტიპი 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,
ასე რომ, მე 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
და მე წარმოადგენს null
მაჩვენებელი, როგორც მხოლოდ წითელი ყუთი,

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
მაგრამ როდესაც თქვენ მოხვდა
წითელი ყუთი, რომ null,

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
ასე რომ, ჩვენ მოვუწოდებთ მას ახალი,
და დაბრუნდება new

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
და ჩვენ გვინდა, ფუნქცია, რომ აპირებს
დაბრუნდეს ჭეშმარიტი ან მცდარი, დამოკიდებულია

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 იპოვოს და
მაშინ ჩვენ გვინდა გავლა ორი არგუმენტები.

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
თქვენ მხოლოდ უნდა შევინარჩუნოთ სიმღერა პირველი
ერთ-ერთი, თუ ისინი ყველა მიჯაჭვული ერთად.

188
00:09:50,920 --> 00:09:52,460
>> და მერე მეორე, რაც
ჩვენ გავლის ერთხელ

189
00:09:52,460 --> 00:09:54,376
არის თვითნებურად, რაღაც
რასაც მონაცემები ტიპის ჩვენ

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
რატომ არ გვაქვს უბრალოდ გადაადგილება, რომ ერთი გარშემო?

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
ასე რომ, უმჯობესია, რათა შეიქმნას
მეორე, რომ ჩვენ ვიყენებთ გადაადგილება.

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
ეს ერთი შედგება
ხუთ კვანძების, და ჩვენ გვაქვს

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
ასე რომ, ახლა ჩვენ გვაქვს ორი პოინტერები
რომ წერტილი იგივე.

215
00:11:09,760 --> 00:11:15,025
>> ახლა, აქ, ასევე, მე არ
უნდა malloc ნებისმიერი ფართი trav.

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
>> და ეს არის ერთგვარი ერთი სავაჭრო, რომ ჩვენ
აქვს უკავშირდება სია ლექსები მასივები,

236
00:12:13,150 --> 00:12:15,300
არის ის, რომ ჩვენ არ გვაქვს
წვდომის აღარ.

237
00:12:15,300 --> 00:12:18,150
ჩვენ ვერ ვიტყვით, მინდა
წასვლა 0th ელემენტს,

238
00:12:18,150 --> 00:12:21,410
ან მე -6 ელემენტის ჩემი მასივი,
რაც შემიძლია მასივი.

239
00:12:21,410 --> 00:12:25,080
მე ვერ ვიტყვი, მინდა წასვლა
0th ელემენტი, ან მე -6 ელემენტს,

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, და ექვსი არ არსებობს.

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
და ეს იქნება დაბრუნდა
ცრუ ამ შემთხვევაში.

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
შექმნა bunch of მკაფიო სიები.

259
00:13:22,620 --> 00:13:25,700
ჩვენ გვინდა, რომ ერთ-ერთი სია, რომელიც
აქვს რამოდენიმე კვანძების ის,

260
00:13:25,700 --> 00:13:28,040
არ არის bunch of სიები ერთი კვანძის.

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
და დაინახა, რა მოხდება, თუ ჩვენ
მინდოდა, რომელთა მიზანია ან უბრალოდ მეორე

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
traverse ყველა გზა
ბოლოს და ბოლოს, და მაშინ დაყენება იგი.

295
00:14:58,760 --> 00:15:01,420
ასე რომ, ეს ნიშნავს იმას, რომ
ჩასმა ბოლოს სია

296
00:15:01,420 --> 00:15:04,140
გახდება o ო
ოპერაცია, ბრუნდება

297
00:15:04,140 --> 00:15:06,720
ჩვენი განხილვის
გამოთვლითი სირთულის.

298
00:15:06,720 --> 00:15:10,140
ეს მინდა გახდეს o ო ოპერაცია, სადაც
როგორც სიაში მიიღო დიდი და უფრო დიდი,

299
00:15:10,140 --> 00:15:13,310
და დიდი, ეს კიდე უფრო და
უფრო რთული Tack რაღაც

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
>> ასე რომ, აქ ჩვენს სიაში, იგი შედგება
ოთხი ელემენტები, კვანძის შემცველი 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, რომელსაც აქვს null
მაჩვენებელი, როგორც მისი მომავალი მაჩვენებელი

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
>> მაგრამ ეს იწვევს
კარგი თემა sidebar,

326
00:16:23,350 --> 00:16:26,280
რაც არის, რომ ერთ-ერთი
trickiest რამ უკავშირდება სიები

327
00:16:26,280 --> 00:16:30,980
არის მოწყობა პოინტერები
სწორი მიზნით.

328
00:16:30,980 --> 00:16:34,520
თუ თქვენ გადატანა რამ მწყობრიდან,
თქვენ შეგიძლიათ დასრულდება up შემთხვევით

329
00:16:34,520 --> 00:16:36,050
orphaning დანარჩენი სიაში.

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
ჩვენ არ შეგვიძლია ვთქვათ, ახალი arrow შემდეგი ტოლობის
რაღაც, იქ არაფერი არ არსებობს.

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
>> ასე რომ, ჩვენ ჰქონდეს და მე ასევე გამოყვანილია
ჩვენი დასტის ფარგლებში ილუსტრაცია

383
00:19:08,557 --> 00:19:10,890
ჩვენი ვიდეო ზარის stacks,
და იმედია ეს ყველაფერი

384
00:19:10,890 --> 00:19:13,260
ერთად გამოჩნდება, თუ რა ხდება.

385
00:19:13,260 --> 00:19:14,510
ასე რომ, აქ არის ჩვენი pseudocode კოდი.

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 არ არის null მაჩვენებელი, 10
შეიცავს 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
>> და ახლა ჩამოვთვალოთ რაოდენობა არსებობს, ეს
მართლაც აღვნიშნო, რომ, რაღაც

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
>> ასე რომ, purple ჩარჩო, ახლა დროს
ზევით დასტის, რომ აქტიური ჩარჩო,

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-- ჩვენ შეარჩიო, სადაც დავტოვეთ
off ერთად მომდევნო უმაღლესი ერთი, რომელიც

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
და ისე, რომ ფუნქცია ფარგლებში განადგურებულია,
და ჩვენ შეარჩიო ცისფერს.

426
00:21:16,810 --> 00:21:20,650
>> ასე რომ, ეს says-- მე უკვე done--
წაშლის დანარჩენი სიაში, ასე

427
00:21:20,650 --> 00:21:23,140
გასათავისუფლებლად მიმდინარე კვანძში.

428
00:21:23,140 --> 00:21:26,520
ახლა ყვითელი ჩარჩო
უკან ზევით Stack.

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
თქვენ შეიძლება არ შეამჩნია, მე გამოტოვებული ერთი,
წაშლის ერთ ელემენტს უკავშირდება

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-- ჩვენ
გსურთ წაშალოთ ეს კვანძის

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
ის შეიცავს ჯაჭვის აქ out.

458
00:22:48,260 --> 00:22:51,190
>> ასე რომ, ის, რაც ჩვენ უნდა გავაკეთოთ რეალურად
შემდეგ მივიღებთ, რომ ამ ეტაპზე,

459
00:22:51,190 --> 00:22:56,670
არის, რომ ჩვენ უნდა უკან დახევას ერთი, და
დაკავშირება ამ კვანძის მეტი ამ კვანძის,

460
00:22:56,670 --> 00:22:58,590
ასე რომ ჩვენ შეგვიძლია შემდეგ წაშლა
ერთი შუა.

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
ერთგვარი off ნაბიჯი, ერთი უკან
სხვა, როგორც ჩვენ წავიდეთ და მისაღებად,

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
>> მე Doug Lloyd, ეს არის CS50.

469
00:23:20,720 --> 00:23:22,298