1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [კვირა 6]

2
00:00:02,000 --> 00:00:04,000
[დევიდ ჯ Malan] [ჰარვარდის უნივერსიტეტის]

3
00:00:04,000 --> 00:00:08,000
[ეს არის CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> ეს არის CS50, და ეს არის დაწყების კვირა 6,

5
00:00:12,000 --> 00:00:16,000
ასე რამდენიმე ახალი იარაღები უკვე შესაძლებელია თქვენ ისარგებლოს,

6
00:00:16,000 --> 00:00:19,000
პირველ რომელსაც CS50 სტილი.

7
00:00:19,000 --> 00:00:22,000
შანსი, თუ თქვენ ჩემნაირი ან სწავლების პრაქტიკის,

8
00:00:22,000 --> 00:00:26,000
თქვენ ალბათ ჩანს პროგრამა, რომლის სტილი გამოიყურება პატარა რაღაც მსგავსი.

9
00:00:26,000 --> 00:00:30,000
იქნებ დაიწყოს ჭრის ზოგიერთი კუთხეები, გვიან ღამით, ან თქვენ გაუმკლავდეთ მას შემდეგ,

10
00:00:30,000 --> 00:00:32,000
და შემდეგ TF ან CA მოდის მეტი დროს საათებში.

11
00:00:32,000 --> 00:00:34,000
მაშინ რთულია ჩვენთვის წაიკითხოს.

12
00:00:34,000 --> 00:00:38,000
ისე, ამ კოდექსით არის syntactically სწორი იქნება, და ეს კომპილაციის იქნება, და ეს რეალურად აწარმოებს.

13
00:00:38,000 --> 00:00:40,000
მაგრამ ეს ნამდვილად არ 5 ამისთვის სტილი.

14
00:00:40,000 --> 00:00:45,000
>> მაგრამ ახლა, თუ ჩვენ წასვლას ამ დირექტორიაში აქ-

15
00:00:45,000 --> 00:00:48,000
და შენიშნავს, რომ მაქვს conditions2.c-

16
00:00:48,000 --> 00:00:55,000
მე და აწარმოებს ამ ახალი ბრძანება, style50, ამ ფაილის conditions2.c, მიუთითოთ,

17
00:00:55,000 --> 00:00:57,000
შეამჩნია, რომ ის მაცნობა, რომ უკვე სტილიზებული.

18
00:00:57,000 --> 00:01:00,000
Gedit შეამჩნია, რომ ფაილი შეიცვალა დისკზე,

19
00:01:00,000 --> 00:01:08,000
და თუ მე დააჭირეთ განაახლეთ, ყველა თქვენი პრობლემები ავტომატიზირებულია.

20
00:01:08,000 --> 00:01:15,000
[ტაში]

21
00:01:15,000 --> 00:01:17,000
სწორედ ერთი რამ გავაკეთეთ ამ კვირას.

22
00:01:17,000 --> 00:01:20,000
გააცნობიეროს, რომ ეს არის არასრულყოფილი, რადგან არსებობს კოდი

23
00:01:20,000 --> 00:01:23,000
რომ ეს უბრალოდ ვერ შეძლებს, რათა stylize კარგად,

24
00:01:23,000 --> 00:01:26,000
მაგრამ გააცნობიეროს ეს არის ინსტრუმენტი შეგიძლიათ ისარგებლოს

25
00:01:26,000 --> 00:01:33,000
თუ მხოლოდ Tidy up ზოგიერთი უფრო errantly განთავსებული Curly braces და ასე შემდეგ.

26
00:01:33,000 --> 00:01:36,000
>> მაგრამ უფრო მყარი ახლა არის CS50 ქვითარი.

27
00:01:36,000 --> 00:01:39,000
With CS50 შემოწმება, შეგიძლიათ რეალურად შეასრულოს იგივე სისწორის ტესტები

28
00:01:39,000 --> 00:01:42,000
საკუთარ კოდი, რომელიც სწავლების პრაქტიკის შეუძლიათ.

29
00:01:42,000 --> 00:01:44,000
ეს არის command line პროგრამა, რომელიც მოდის ახლა ელექტრო მოწყობილობების

30
00:01:44,000 --> 00:01:46,000
როგორც კი თქვენ ამის გაკეთება update50 როგორც პოსტი

31
00:01:46,000 --> 00:01:49,000
pset 4 სპეციფიკაციები და გამოიყენოს იგი არსებითად მოსწონს ეს.

32
00:01:49,000 --> 00:01:51,000
თქვენ აწარმოებს ბრძანება check50.

33
00:01:51,000 --> 00:01:56,000
მაშინ კორიდორი ბრძანების არგუმენტი, ან მეტი საყოველთაოდ ცნობილია, როგორც შეცვლა ან დროშას.

34
00:01:56,000 --> 00:01:58,000
საერთოდ, რამ აქვს დეფისის უწოდებენ შეცვლა

35
00:01:58,000 --> 00:02:02,000
to command line პროგრამა, ე.წ. გ განსაზღვრავს

36
00:02:02,000 --> 00:02:04,000
ამოწმებს, რომ გსურთ აწარმოებს.

37
00:02:04,000 --> 00:02:07,000
>> ტესტები რომ გსურთ აწარმოებს იდენტიფიცირებულია ცალსახად ამ სტრიქონს,

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
სხვა სიტყვებით, ეს მხოლოდ თვითნებური მაგრამ უნიკალური სიმებიანი

40
00:02:13,000 --> 00:02:18,000
ჩვენ ვიყენებთ, რათა ცალსახად იდენტიფიცირება pset 4 ს სისწორის ტესტები.

41
00:02:18,000 --> 00:02:21,000
და მაშინ დააკონკრეტა ჰარით გამოყოფილი ჩამონათვალი ფაილი, რომელიც ასატვირთად

42
00:02:21,000 --> 00:02:24,000
to CS50 შემოწმება ანალიზი.

43
00:02:24,000 --> 00:02:29,000
მაგალითად, თუ მე წასვლას ჩემი გამოსავალი აქ resize.c-

44
00:02:29,000 --> 00:02:31,000
ნება მომეცით ქმნის უფრო დიდი ტერმინალი ფანჯარა-

45
00:02:31,000 --> 00:02:42,000
მე და წავიდეთ წინ და აწარმოებს ვთქვათ check50-C 2012/pset4/resize,

46
00:02:42,000 --> 00:02:46,000
და მერე წავიდეთ წინ და მიუთითეთ სახელები ფაილი

47
00:02:46,000 --> 00:02:49,000
resize.c და შემდეგ დააჭიროთ, ეს კომპრესები,

48
00:02:49,000 --> 00:02:53,000
ეს ატვირთვები, ის ამოწმებს, და მე უბრალოდ ვერ მოხერხდა მთელი bunch of ტესტები.

49
00:02:53,000 --> 00:02:59,000
ერთი წითელი ზედა მარცხენა ნათქვამია, რომ resize.c და BMP არსებობს.

50
00:02:59,000 --> 00:03:01,000
ეს იყო ტესტი. ეს იყო კითხვა ვთხოვეთ.

51
00:03:01,000 --> 00:03:04,000
და ეს უბედური, რადგან პასუხი იყო ყალბი.

52
00:03:04,000 --> 00:03:08,000
თეთრი ქვემოთ ტექსტი ნათქვამია მოსალოდნელია bmp.h არსებობს, და ეს უბრალოდ ჩემი ბრალია.

53
00:03:08,000 --> 00:03:11,000
დამავიწყდა ატვირთვა, ასე რომ მე უნდა ატვირთოთ ორივე ფაილი

54
00:03:11,000 --> 00:03:14,000
resize.c და bmp.h.

55
00:03:14,000 --> 00:03:17,000
მაგრამ ახლა შეამჩნია ყველა სხვა ტესტები არიან ყვითელი რადგან მათ არ აწარმოებს,

56
00:03:17,000 --> 00:03:21,000
და ასე smiley face არის ვერტიკალური, რადგან ის არც ბედნიერი და არც სამწუხარო,

57
00:03:21,000 --> 00:03:25,000
მაგრამ უნდა შეცვალოს სიტუაცია, რომ საკითხი წითელი ადრე იმ სხვა ამოწმებს მიიღებს.

58
00:03:25,000 --> 00:03:27,000
>> ნება მომეცით დაფიქსირება ამ.

59
00:03:27,000 --> 00:03:30,000
ნება მომეცით დააშორებს და გამეორება ამ, ამ დროის bmp.h ასევე

60
00:03:30,000 --> 00:03:34,000
ბრძანების სტრიქონში, შეიყვანეთ და ახლა თუ ყველა კარგად იქნება,

61
00:03:34,000 --> 00:03:38,000
ეს ხდება შემოწმება და მერე დაბრუნების შედეგად-გამართავს თქვენი სუნთქვა-

62
00:03:38,000 --> 00:03:42,000
ყველა მწვანე, რაც იმას ნიშნავს, მე ვაკეთებ ნამდვილად კარგად pset 4 ჯერჯერობით.

63
00:03:42,000 --> 00:03:44,000
თქვენ შეგიძლიათ ნახოთ და infer საწყისი აღწერითი ტექსტი აქ

64
00:03:44,000 --> 00:03:47,000
ზუსტად რა არის ჩვენ ტესტირება.

65
00:03:47,000 --> 00:03:49,000
ჩვენ გამოცდილი პირველი არ არსებობს ფაილი?

66
00:03:49,000 --> 00:03:51,000
ჩვენ მაშინ ტესტირება არ resize.c კომპილირების?

67
00:03:51,000 --> 00:03:58,000
მაშინ ჩვენ ტესტირება იგი არ შეცვლის 1x1-pixel BMP, როდესაც N, Resize ფაქტორი, არის 1.

68
00:03:58,000 --> 00:04:01,000
ახლა კი, თუ არ ვიცი, რა N არის, თქვენ კიდევ თქვენ ჩაყვინთვის შევიდა pset 4,

69
00:04:01,000 --> 00:04:04,000
მაგრამ, რომ უბრალოდ არის საღი აზრის შეამოწმეთ დარწმუნდით, რომ თქვენ არ resizing

70
00:04:04,000 --> 00:04:08,000
გამოსახულება ყველა თუ Resize ფაქტორი 1.

71
00:04:08,000 --> 00:04:14,000
თუ, პირიქით, ეს უცვლის ზომას 1x1 pixel to 1x1 pixel BMP to 2x2 სწორად

72
00:04:14,000 --> 00:04:19,000
როდესაც N არის 2, მაშინ ანალოგიურად, მაღაროს აყალიბებს შესაბამისად.

73
00:04:19,000 --> 00:04:22,000
>> მოკლედ, ეს იმას ნიშნავდა, რომ, ერთი, მიიღოს გადაკვეთის თითების

74
00:04:22,000 --> 00:04:25,000
გარეთ განტოლება უფლება სანამ თქვენი pset.

75
00:04:25,000 --> 00:04:28,000
თქვენ იცით ზუსტად რა თქვენი TF მალე ვიცი

76
00:04:28,000 --> 00:04:30,000
როდესაც მიდიხარ შესახებ წარდგენის ზოგიერთი ამ პრობლემის კომპლექტი,

77
00:04:30,000 --> 00:04:34,000
და ასევე პედაგოგიური მოტივაცია მართლაც დააყენოს

78
00:04:34,000 --> 00:04:37,000
შესაძლებლობა თქვენს წინაშე, ისე რომ, როდესაც თქვენ იცით აპრიორი

79
00:04:37,000 --> 00:04:39,000
რომ არსებობს შეცდომები თქვენს კოდი და ტესტები რომ მის მიმართ არ ხორციელდება გავიდა,

80
00:04:39,000 --> 00:04:43,000
თქვენ შეგიძლიათ განათავსოთ უფრო ეფექტური დრო up წინა ხალხს პრობლემების ოპერატიულ მოგვარებას

81
00:04:43,000 --> 00:04:45,000
ვიდრე დაკარგავს ქულა, მიიღოთ კავშირი თქვენი TF,

82
00:04:45,000 --> 00:04:48,000
და მერე, "Ahh," როგორც მე უნდა figured რომ.

83
00:04:48,000 --> 00:04:50,000
ეხლა მაინც არსებობს ინსტრუმენტი, რათა დაგეხმაროთ თქვენ მოვძებნოთ რომ.

84
00:04:50,000 --> 00:04:52,000
ეს არ აღვნიშნო, სადაც შეცდომა, მაგრამ ეს გითხრათ

85
00:04:52,000 --> 00:04:54,000
რა არის სიმპტომატური იგი.

86
00:04:54,000 --> 00:04:57,000
>> ახლა აცნობიერებენ ტესტები არ არის აუცილებლად ამომწურავი.

87
00:04:57,000 --> 00:04:59,000
მხოლოდ იმიტომ, რომ თქვენ გაქვთ ეკრანზე სავსე მწვანე smiley სახეები

88
00:04:59,000 --> 00:05:02,000
არ ნიშნავს თქვენი კოდი არის სრულყოფილი, მაგრამ ეს იმას ნიშნავს,

89
00:05:02,000 --> 00:05:06,000
რომ მან გაიარა გარკვეული ტესტების დადგენილი სპეც.

90
00:05:06,000 --> 00:05:08,000
ზოგჯერ ჩვენ არ გაათავისუფლებს ამოწმებს.

91
00:05:08,000 --> 00:05:10,000
მაგალითად, whodunit, ერთ ასპექტს pset 4,

92
00:05:10,000 --> 00:05:15,000
არის სახის გულდასაწყვეტია თუ ჩვენ მოგაწვდით

93
00:05:15,000 --> 00:05:18,000
პასუხი, თუ რა არის ეს, და იქ ხმების გზები გამოსავლენად

94
00:05:18,000 --> 00:05:21,000
ვინც პირის არის, რომ წითელი ხმაური.

95
00:05:21,000 --> 00:05:24,000
სპეც ყოველთვის დააზუსტეთ მომავალი pset 5 Onward

96
00:05:24,000 --> 00:05:26,000
რა ამოწმებს არსებობს თქვენთვის.

97
00:05:26,000 --> 00:05:28,000
თქვენ შეამჩნევთ არსებობს ამ თეთრი URL ბოლოში.

98
00:05:28,000 --> 00:05:30,000
ახლა, ეს მხოლოდ დიაგნოსტიკური გამომუშავება.

99
00:05:30,000 --> 00:05:33,000
თუ თქვენ ესტუმრებით, რომ URL, თქვენ შეძლებთ მთელი bunch of გიჟები, cryptic შეტყობინებები

100
00:05:33,000 --> 00:05:36,000
რომ მობრძანდით, გაეცნონ, მაგრამ ძირითადად თანამშრომლებისათვის

101
00:05:36,000 --> 00:05:41,000
ასე, რომ ჩვენ შეგვიძლია დიაგნოსტიკა და გამართვის შეცდომებს check50 თავად.

102
00:05:41,000 --> 00:05:46,000
>> გარეშე ado, მოდით გადაადგილება სად ვიქნებით შეჩერდით.

103
00:05:46,000 --> 00:05:48,000
CS50 ბიბლიოთეკა ავიღეთ თავისთავად რამოდენიმე კვირაა,

104
00:05:48,000 --> 00:05:52,000
მაგრამ შემდეგ, გასულ კვირას დავიწყეთ peeling უკან ერთი ფენების იგი.

105
00:05:52,000 --> 00:05:55,000
ჩვენ დავიწყეთ აყენებს განზე სიმებიანი სასარგებლოდ რა ნაცვლად?

106
00:05:55,000 --> 00:05:57,000
[სტუდენტთა] ჩარ.

107
00:05:57,000 --> 00:05:59,000
ჩარ *, რომელსაც უკვე char * ყველა ამ დროს,

108
00:05:59,000 --> 00:06:03,000
მაგრამ ახლა ჩვენ არ ვიტყვი, რომ ეს ფაქტობრივი მონაცემების ტიპის სიმებიანი.

109
00:06:03,000 --> 00:06:06,000
უფრო მეტიც, უკვე სინონიმი ჯიშები ამისთვის char *,

110
00:06:06,000 --> 00:06:09,000
და სიმებიანი არის თანმიმდევრობა გმირები,

111
00:06:09,000 --> 00:06:14,000
ასე რატომ ხდება აზრი წარმოადგენენ სიმები როგორც char * s?

112
00:06:14,000 --> 00:06:20,000
რას char * წარმოადგენენ კონტექსტი კონცეფცია სიმებიანი?

113
00:06:20,000 --> 00:06:23,000
Yeah. >> [სტუდენტური] პირველ სიმბოლოს.

114
00:06:23,000 --> 00:06:25,000
კარგი, პირველ სიმბოლოს, მაგრამ არა საკმაოდ პირველი ხასიათი.

115
00:06:25,000 --> 00:06:27,000
ეს-[სტუდენტთა] მისამართი.

116
00:06:27,000 --> 00:06:29,000
კარგი, მისამართი პირველი ხასიათი.

117
00:06:29,000 --> 00:06:33,000
ყველა რომ აუცილებელია წარმოადგენენ string in კომპიუტერის მეხსიერების

118
00:06:33,000 --> 00:06:36,000
მხოლოდ უნიკალური მისამართი მისი პირველივე byte.

119
00:06:36,000 --> 00:06:38,000
თქვენ კი არ უნდა ვიცოდეთ რამდენი ხანი არის

120
00:06:38,000 --> 00:06:42,000
რადგან როგორ შეიძლება გაერკვნენ, რომ დინამიურად?

121
00:06:42,000 --> 00:06:44,000
[სტუდენტური] სიმებიანი სიგრძე.

122
00:06:44,000 --> 00:06:48,000
შეგიძლიათ დარეკოთ სიმებიანი სიგრძე, კარგი, მაგრამ რამდენად შეესაბამება სიმებიანი სიგრძე მუშაობს?

123
00:06:48,000 --> 00:06:50,000
რას აკეთებთ? Yeah.

124
00:06:50,000 --> 00:06:52,000
[სტუდენტური] Keep აპირებს სანამ არ მიიღებთ null ხასიათი.

125
00:06:52,000 --> 00:06:54,000
ჰო, ზუსტად, უბრალოდ iterates ერთად ამისთვის მარყუჟის, ხოლო მარყუჟის,

126
00:06:54,000 --> 00:06:57,000
რასაც საწყისი * ბოლომდე, და ბოლოს არის წარმოდგენილი

127
00:06:57,000 --> 00:07:01,000
მიერ \ 0, ე.წ. nul ხასიათი, nul,

128
00:07:01,000 --> 00:07:05,000
არ იყოს დაბნეული და null, რომელიც მაჩვენებელი,

129
00:07:05,000 --> 00:07:07,000
რაც ამუშავება საუბარში კიდევ ერთხელ დღეს.

130
00:07:07,000 --> 00:07:11,000
>> ჩვენ peeled უკან ფენით GetInt და შემდეგ მივიღეთ შევხედოთ GetString,

131
00:07:11,000 --> 00:07:14,000
და გავიხსენოთ, რომ ორივე ამ ფუნქციების, ან მართლაც,

132
00:07:14,000 --> 00:07:18,000
GetString, იყო გამოყენებით გარკვეული ფუნქცია

133
00:07:18,000 --> 00:07:21,000
რეალურად გარჩევის, რომ წაიკითხა ან ანალიზი, მომხმარებლის შეყვანის.

134
00:07:21,000 --> 00:07:25,000
და რა იყო, რომ ახალი ფუნქცია?

135
00:07:25,000 --> 00:07:27,000
Scanf ან sscanf. ეს ფაქტიურად მოდის რამდენიმე სხვადასხვა არომატის.

136
00:07:27,000 --> 00:07:31,000
არსებობს scanf, არსებობს sscanf, არსებობს fscanf.

137
00:07:31,000 --> 00:07:35,000
ახლა, თუმცა, მოდით ფოკუსირება ერთი ყველაზე ადვილად ილუსტრირებული,

138
00:07:35,000 --> 00:07:38,000
და ნება მომეცით წავიდეთ წინ და ქმნის in ელექტრო მოწყობილობების

139
00:07:38,000 --> 00:07:41,000
შემდეგის მსგავსად, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
ეს არის სუპერ მარტივი პროგრამა,

141
00:07:43,000 --> 00:07:46,000
მაგრამ, რომ არ ის, რაც ჩვენ არასოდეს კეთდება

142
00:07:46,000 --> 00:07:48,000
დახმარების გარეშე CS50 ბიბლიოთეკაში.

143
00:07:48,000 --> 00:07:51,000
ეს იღებს int საწყისი მომხმარებელს. როგორ მუშაობს იგი?

144
00:07:51,000 --> 00:07:53,000
კარგად, შეესაბამება 16 იქ,

145
00:07:53,000 --> 00:07:56,000
შეამჩნევთ, რომ ვაცხადებთ int მოუწოდა x, და ამ დროისთვის ამბავი,

146
00:07:56,000 --> 00:07:58,000
რა არის ღირებულება x?

147
00:07:58,000 --> 00:08:00,000
[Inaudible სტუდენტი საპასუხოდ]

148
00:08:00,000 --> 00:08:02,000
[დავით მ] მარჯვენა, ვინ იცის, ზოგიერთი ნაგვის ღირებულება პოტენციურად, ასევე 17, ჩვენ უბრალოდ ვუთხრა მომხმარებლის

149
00:08:02,000 --> 00:08:06,000
მომეცი ნომერი, გთხოვთ, და ნაბიჯი 18 არის სადაც იგი იღებს საინტერესო.

150
00:08:06,000 --> 00:08:11,000
Scanf ჩანს სესხება იდეა საწყისი printf, რომ ის იყენებს ამ ფორმატის კოდების შეთავაზებები.

151
00:08:11,000 --> 00:08:13,000
% D არ არის, რა თქმა უნდა ათობითი რიცხვი.

152
00:08:13,000 --> 00:08:21,000
მაგრამ რატომ ვარ მე გადადის & x ნაცვლად მხოლოდ x?

153
00:08:21,000 --> 00:08:24,000
ყოფილი სწორია. Yeah.

154
00:08:24,000 --> 00:08:26,000
[Inaudible სტუდენტი საპასუხოდ]

155
00:08:26,000 --> 00:08:31,000
სწორედ, თუ მიზანი ამ პროგრამის, როგორიცაა ფუნქციის GetInt თავად,

156
00:08:31,000 --> 00:08:34,000
მისაღებად int საწყისი მომხმარებლის შემიძლია გაივლის ფუნქციები

157
00:08:34,000 --> 00:08:38,000
ყველა ცვლადები მინდა, მაგრამ თუ არ გაივლის მათ მიერ მინიშნება

158
00:08:38,000 --> 00:08:41,000
ან მისამართი ან კურსორი, ყველა სინონიმი დღევანდელი მიზნებისათვის,

159
00:08:41,000 --> 00:08:46,000
მაშინ ეს ფუნქცია არ აქვს უნარი შეცვალოს შინაარსი რომ ცვლადი.

160
00:08:46,000 --> 00:08:49,000
ეს კორიდორი ასლი ისევე buggy ვერსია swap

161
00:08:49,000 --> 00:08:51,000
რომ ჩვენ ვისაუბრეთ რამდენიმეჯერ არის.

162
00:08:51,000 --> 00:08:54,000
>> მაგრამ ამის ნაცვლად, ამით და x, მე სიტყვასიტყვით ავლით რა?

163
00:08:54,000 --> 00:08:57,000
[სტუდენტური] მისამართზე. >> მისამართი x.

164
00:08:57,000 --> 00:09:01,000
ეს მოსწონს ხატვის რუკა ფუნქცია მოუწოდა scanf და ამბობდა აქ,

165
00:09:01,000 --> 00:09:04,000
ეს მითითებებს ბლოკი მეხსიერება კომპიუტერის

166
00:09:04,000 --> 00:09:07,000
რომ შეგიძლიათ შეინახოთ რამდენიმე რიცხვი სისტემაში

167
00:09:07,000 --> 00:09:10,000
იმისათვის sscanf აქამდე ასე

168
00:09:10,000 --> 00:09:13,000
რა ოპერატორი, რა ნაჭერი სინტაქსისიც იგი აპირებს უნდა გამოვიყენოთ

169
00:09:13,000 --> 00:09:19,000
მიუხედავად იმისა, რომ ჩვენ ვერ ვხედავ, რადგან სხვისი დაწერა ეს ფუნქცია?

170
00:09:19,000 --> 00:09:21,000
სხვა სიტყვებით - რა რომ?

171
00:09:21,000 --> 00:09:23,000
[სტუდენტური] X წაიკითხა.

172
00:09:23,000 --> 00:09:27,000
არსებობს იქნება ზოგიერთი მოსმენით, მაგრამ მხოლოდ დაკავშირებით x აქ.

173
00:09:27,000 --> 00:09:30,000
თუ scanf მიმდინარეობს გავიდა მისამართი X,

174
00:09:30,000 --> 00:09:35,000
syntactically, რა ოპერატორი ვალდებულია არსებობს სადმე

175
00:09:35,000 --> 00:09:38,000
შიგნით scanf განხორციელების ისე, რომ scanf

176
00:09:38,000 --> 00:09:42,000
შეიძლება რეალურად დაწეროს რიცხვი 2 რომ მისამართი?

177
00:09:42,000 --> 00:09:44,000
ჰო, ასე *.

178
00:09:44,000 --> 00:09:47,000
შეგახსენებთ, რომ * ჩვენი dereference ოპერატორი, რომელიც არსებითად ნიშნავს იქ.

179
00:09:47,000 --> 00:09:50,000
>> ერთხელ თქვენ გადაეცა მისამართი, როგორც ეს აქ,

180
00:09:50,000 --> 00:09:53,000
scanf ალბათ თუ ჩვენ რეალურად დაათვალიერეს მისი კოდის-

181
00:09:53,000 --> 00:09:59,000
აკეთებს * x ან ექვივალენტი ფაქტიურად წასვლა რომ მისამართი და დააყენა გარკვეული მნიშვნელობა არსებობს.

182
00:09:59,000 --> 00:10:02,000
ახლა, რაც შეეხება როგორ scanf იღებს შეიტანენ კლავიატურა,

183
00:10:02,000 --> 00:10:04,000
ჩვენ ტალღა ჩვენს ხელში გარეთ დღეს.

184
00:10:04,000 --> 00:10:07,000
უბრალოდ ვივარაუდოთ, რომ ოპერაციული სისტემა საშუალებას sscanf გაიგო

185
00:10:07,000 --> 00:10:11,000
to მომხმარებლის კლავიატურის, მაგრამ ამ ეტაპზე ახლა ხაზი 19,

186
00:10:11,000 --> 00:10:14,000
როცა ჩვენ უბრალოდ ამობეჭდოთ x, აშკარად ჩანს, რომ საქმე

187
00:10:14,000 --> 00:10:17,000
რომ scanf დააყენა int in x.

188
00:10:17,000 --> 00:10:19,000
სწორედ როგორ scanf მუშაობს, და გავიხსენოთ გასულ კვირას

189
00:10:19,000 --> 00:10:25,000
სწორედ როგორ GetString და GetInt და მისი ოჯახის სხვა ფუნქციების

190
00:10:25,000 --> 00:10:28,000
საბოლოოდ მუშაობს, თუმცა უმნიშვნელო ეწინააღმდეგება მოსწონს sscanf,

191
00:10:28,000 --> 00:10:31,000
რაც იმას ნიშნავს, სკანირების სიმებიანი ნაცვლად კლავიატურაზე.

192
00:10:31,000 --> 00:10:33,000
მაგრამ მოდით შევხედოთ პატარა ეწინააღმდეგება ამ.

193
00:10:33,000 --> 00:10:37,000
In scanf2, მე რეალურად ბრალია.

194
00:10:37,000 --> 00:10:42,000
რა არის არასწორი და მე დასამალი კომენტარი რომ განმარტავს, იმდენი-

195
00:10:42,000 --> 00:10:47,000
რა არის არასწორი ამ პროგრამით, ვერსია 2?

196
00:10:47,000 --> 00:10:55,000
იყოს, როგორც ტექნიკური, რაც შეიძლება ამ დროს.

197
00:10:55,000 --> 00:10:57,000
იგი გამოიყურება საკმაოდ კარგი.

198
00:10:57,000 --> 00:11:03,000
ეს ლამაზად indented, მაგრამ-

199
00:11:03,000 --> 00:11:07,000
Okay, რა მოდით prune იგი ქვემოთ მოკლე კითხვები?

200
00:11:07,000 --> 00:11:17,000
ხაზი 16. რა არის ხაზზე 16 აკეთებდა ზუსტი მაგრამ ტექნიკური ინგლისურ?

201
00:11:17,000 --> 00:11:20,000
შესმენილ პატარა უხერხულ. დიახ, მაიკლ.

202
00:11:20,000 --> 00:11:25,000
[სტუდენტური] ეს მიუთითებს პირველი წერილი სიმებიანი.

203
00:11:25,000 --> 00:11:27,000
>> Okay, ახლოს. ნება მომეცით tweak, რომ ცოტა.

204
00:11:27,000 --> 00:11:33,000
მიმანიშნებელი პირველი წერილი სიმებიანი, თქვენ ვაცხადებთ ცვლადში ბუფერული

205
00:11:33,000 --> 00:11:36,000
რომელიც აღვნიშნო, რომ პირველი მისამართი სიმებიანი,

206
00:11:36,000 --> 00:11:39,000
უფრო სწორად, რომელიც აღვნიშნო უფრო კონკრეტულად, რათა char.

207
00:11:39,000 --> 00:11:42,000
გაითვალისწინეთ ის რეალურად არ მიუთითებს სადმე რადგან იქ არ არის დავალება ოპერატორი.

208
00:11:42,000 --> 00:11:46,000
იქ არ არის თანაბარი ნიშანი, ასე რომ ყველა ვაკეთებთ არის გამოყოფის ცვლადში ბუფერული.

209
00:11:46,000 --> 00:11:49,000
ეს ხდება, რომ იყოს 32 ბიტი იმიტომ რომ მომცეთ,

210
00:11:49,000 --> 00:11:52,000
და შინაარსი ბუფერული სავარაუდოდ საბოლოოდ

211
00:11:52,000 --> 00:11:57,000
შეიცავს მისამართი char, მაგრამ ახლა, რა ბუფერული შეიცავდეს?

212
00:11:57,000 --> 00:11:59,000
რამოდენიმე გაყალბებულად, ვინ იცის, ზოგიერთი ნაგვის ღირებულება,

213
00:11:59,000 --> 00:12:03,000
იმიტომ, რომ ჩვენ არ არის მკაფიოდ ინიციალიზაცია, ასე რომ ჩვენ არ უნდა ვივარაუდოთ, არაფერი.

214
00:12:03,000 --> 00:12:06,000
Okay, ასე არის ხაზზე 17 IS-რას ხაზი 17 გავაკეთო?

215
00:12:06,000 --> 00:12:08,000
იქნებ, რომელიც თბილი ამ მდე.

216
00:12:08,000 --> 00:12:10,000
იგი ბეჭდავს სტრინგს, არა?

217
00:12:10,000 --> 00:12:12,000
იგი ბეჭდავს სიმებიანი გთხოვთ.

218
00:12:12,000 --> 00:12:15,000
>> Line 18 არის სახის ნაცნობი ახლა, რომ ჩვენ უბრალოდ დაინახა ეწინააღმდეგება ამ

219
00:12:15,000 --> 00:12:18,000
მაგრამ სხვადასხვა ფორმატში კოდი, ასევე ხაზი 18,

220
00:12:18,000 --> 00:12:23,000
ჩვენ ვეუბნებით scanf აქ მისამართი ბლოკი მეხსიერება.

221
00:12:23,000 --> 00:12:27,000
მინდა ბეჭედი წელს სიმებიანი, როგორც ითვალისწინებს% s,

222
00:12:27,000 --> 00:12:32,000
მაგრამ პრობლემა ის არის, რომ ჩვენ არ კეთდება რამდენიმე რამ აქ.

223
00:12:32,000 --> 00:12:35,000
რა არის ერთი პრობლემა?

224
00:12:35,000 --> 00:12:38,000
[სტუდენტური] ეს ცდილობს dereference null მაჩვენებელი.

225
00:12:38,000 --> 00:12:41,000
კარგი, null ან უბრალოდ სხვაგვარად უცნობია პოინტერები.

226
00:12:41,000 --> 00:12:45,000
თქვენ გადაცემის scanf მისამართი, მაგრამ თქვენ მხოლოდ განაცხადა მომენტში წინ

227
00:12:45,000 --> 00:12:49,000
რომ მისამართია ზოგიერთი ნაგვის ღირებულების რადგან ჩვენ ვერ რეალურად მივანიჭოთ მას არაფერი,

228
00:12:49,000 --> 00:12:53,000
და ა.შ. თქვენ ვეუბნებოდი scanf ეფექტურად წასვლა დააყენა სიმებიანი აქ,

229
00:12:53,000 --> 00:12:56,000
მაგრამ ჩვენ არ ვიცით, სად აქ ჯერ კიდევ არის,

230
00:12:56,000 --> 00:12:59,000
ამიტომ ჩვენ არ რეალურად გამოყოფილი მეხსიერების ბუფერი.

231
00:12:59,000 --> 00:13:03,000
უფრო მეტიც, რას ასევე კი არ ვეუბნებოდი scanf?

232
00:13:03,000 --> 00:13:06,000
დავუშვათ, რომ ეს იყო ბლოკი მეხსიერება, და ეს არ იყო ნაგვის ღირებულება,

233
00:13:06,000 --> 00:13:09,000
მაგრამ თქვენ მაინც არ ვეუბნებოდი scanf რაღაც მნიშვნელოვანია.

234
00:13:09,000 --> 00:13:12,000
[სტუდენტური] სად ის რეალურად არის, ampersand.

235
00:13:12,000 --> 00:13:15,000
Ampersand, ამიტომ ამ შემთხვევაში, ეს okay.

236
00:13:15,000 --> 00:13:18,000
იმის გამო, რომ ბუფერული უკვე გამოცხადდა მაჩვენებელი

237
00:13:18,000 --> 00:13:22,000
ერთად * ნაჭერი სინტაქსი, ჩვენ არ უნდა გამოვიყენოთ ampersand

238
00:13:22,000 --> 00:13:25,000
იმიტომ რომ უკვე მისამართი, მაგრამ ვფიქრობ, გავიგე აქ.

239
00:13:25,000 --> 00:13:27,000
[სტუდენტური] როგორ დიდი არის ეს?

240
00:13:27,000 --> 00:13:29,000
კარგი, ჩვენ არა ვართ ვეუბნებოდი scanf რამდენად დიდი ეს ბუფერული არის,

241
00:13:29,000 --> 00:13:32,000
რაც იმას ნიშნავს, მაშინაც კი, თუ ბუფერული იყო მაჩვენებელი,

242
00:13:32,000 --> 00:13:35,000
ჩვენ ვამბობთ, scanf, დაუსვან სიმებიანი აქ,

243
00:13:35,000 --> 00:13:38,000
მაგრამ აქ შეიძლება იყოს 2 ბაიტი, შეიძლება იყოს 10 ბაიტი, შეიძლება იყოს megabyte.

244
00:13:38,000 --> 00:13:41,000
Scanf ვიზიტორების იდეა, და რადგან ეს ბლოკი მეხსიერება

245
00:13:41,000 --> 00:13:43,000
სავარაუდოდ, ეს არ სიმებიანი ამჟამად.

246
00:13:43,000 --> 00:13:48,000
ეს მხოლოდ სიმებიანი ერთხელ წერთ გმირები და \ 0 რომ ბლოკი მეხსიერება.

247
00:13:48,000 --> 00:13:51,000
ახლა კი რამოდენიმე ბლოკი მეხსიერება.

248
00:13:51,000 --> 00:13:55,000
Scanf არ ვიცი, როდის უნდა შეწყვიტოს წერილობით, რომ მისამართზე.

249
00:13:55,000 --> 00:13:59,000
>> თუ გავიხსენებთ მაგალითები წარსულში სადაც მე შემთხვევით აკრეფილი წლის კლავიატურაზე

250
00:13:59,000 --> 00:14:03,000
ცდილობს overflow ბუფერულ, და ჩვენ ვისაუბრეთ პარასკევს შესახებ ზუსტად რომ.

251
00:14:03,000 --> 00:14:07,000
თუ მოწინააღმდეგის როგორღაც injects თქვენი პროგრამის ბევრად უფრო დიდი სიტყვა

252
00:14:07,000 --> 00:14:10,000
ან სასჯელს ან ფრაზა მაშინ ელოდნენ შეგიძლიათ overrun

253
00:14:10,000 --> 00:14:13,000
ბლოკი მეხსიერება, რომელიც შეიძლება ცუდი შედეგები,

254
00:14:13,000 --> 00:14:15,000
მოსწონს აღების მთელ პროგრამა თავისთავად.

255
00:14:15,000 --> 00:14:17,000
ჩვენ გვჭირდება დაფიქსირება ამ როგორღაც.

256
00:14:17,000 --> 00:14:20,000
ნება მომეცით დააშორებს და წასვლას ვერსია 3 ამ პროგრამის.

257
00:14:20,000 --> 00:14:22,000
სწორედ ცოტა უკეთესი.

258
00:14:22,000 --> 00:14:24,000
ამ ვერსიაში, შეამჩნევთ სხვაობა.

259
00:14:24,000 --> 00:14:27,000
სტრიქონში 16, მე კიდევ ერთხელ ვაცხადებთ ცვლადში ბუფერული,

260
00:14:27,000 --> 00:14:29,000
მაგრამ რა არის ეს ახლა?

261
00:14:29,000 --> 00:14:33,000
ეს მასივი 16 სიმბოლო.

262
00:14:33,000 --> 00:14:36,000
ეს არის კარგი, რადგან ეს იმას ნიშნავს, მე შემიძლია გითხრათ არის scanf

263
00:14:36,000 --> 00:14:39,000
აქ არის ფაქტობრივი ბლოკი მეხსიერება.

264
00:14:39,000 --> 00:14:42,000
თქვენ შეგიძლიათ თითქმის ვფიქრობ მასივი როგორც პოინტერები ახლა,

265
00:14:42,000 --> 00:14:44,000
მიუხედავად იმისა, რომ ისინი რეალურად არ ექვივალენტს.

266
00:14:44,000 --> 00:14:47,000
ისინი ყველაფერს სხვაგვარად იქცევიან სხვადასხვა კონტექსტში.

267
00:14:47,000 --> 00:14:50,000
მაგრამ ეს, რა თქმა უნდა იმ შემთხვევაში, რომ ბუფერული არის referencing

268
00:14:50,000 --> 00:14:53,000
16 მომიჯნავე chars რადგან სწორედ მასივი

269
00:14:53,000 --> 00:14:55,000
და უკვე რამოდენიმე კვირაა.

270
00:14:55,000 --> 00:14:59,000
>> აქ, მე ვამბობ scanf აქ ბლოკი მეხსიერება.

271
00:14:59,000 --> 00:15:01,000
ამჯერად, ეს რეალურად ბლოკი მეხსიერება,

272
00:15:01,000 --> 00:15:07,000
მაგრამ რატომ არის ეს პროგრამა ჯერ კიდევ exploitable?

273
00:15:07,000 --> 00:15:11,000
რა არის არასწორი კვლავ?

274
00:15:11,000 --> 00:15:14,000
მე განაცხადა მომეცი 16 ბაიტი, მაგრამ-

275
00:15:14,000 --> 00:15:16,000
[სტუდენტური] რა თუ ისინი აკრიფოთ ზე მეტ 16?

276
00:15:16,000 --> 00:15:20,000
სწორედ, რა, თუ მომხმარებლის ტიპები 17 ასო, ან 1700 გმირები?

277
00:15:20,000 --> 00:15:23,000
ფაქტობრივად, ვნახოთ, შევძლებთ თუ არა მოგზაურობა ამ შეცდომას ახლა.

278
00:15:23,000 --> 00:15:25,000
სჯობს, მაგრამ არ არის სრულყოფილი.

279
00:15:25,000 --> 00:15:28,000
ნება მომეცით წავიდეთ წინ და აწარმოებს მიიღოს scanf3 შედგენა ამ პროგრამის.

280
00:15:28,000 --> 00:15:34,000
ნება მომეცით აწარმოებს scanf3, სიმებიანი გთხოვთ: Hello, და ჩვენ, როგორც ჩანს, იქნება.

281
00:15:34,000 --> 00:15:37,000
ნება მომეცით ვცდილობთ ოდნავ აღარ ერთი, გამარჯობა.

282
00:15:37,000 --> 00:15:42,000
Okay, მოდით გამარჯობა როგორ ხარ დღეს, შეიყვანეთ.

283
00:15:42,000 --> 00:15:54,000
შესმენილ სახის გაუმართლა აქ, ვთქვათ გამარჯობა, როგორ ხარ.

284
00:15:54,000 --> 00:15:56,000
Damn it.

285
00:15:56,000 --> 00:16:03,000
Okay, ასე მივიღეთ გაუმართლა. ვნახოთ, შევძლებთ თუ არა დაფიქსირება ამ.

286
00:16:03,000 --> 00:16:06,000
არა, ეს არ აპირებს ნება მომეცით ასლი.

287
00:16:06,000 --> 00:16:09,000
მოდით ვეცადოთ ეს კიდევ ერთხელ.

288
00:16:09,000 --> 00:16:12,000
ყველა უფლება დგას.

289
00:16:12,000 --> 00:16:20,000
ჩვენ დავინახავთ, თუ ხანგრძლივი შემიძლია პრეტენზია ფოკუსირება მიუხედავად აკეთებენ.

290
00:16:20,000 --> 00:16:23,000
Damn it. სწორედ საკმაოდ შესაბამისი, რეალურად.

291
00:16:23,000 --> 00:16:26,000
იქ ჩვენ წავიდეთ.

292
00:16:26,000 --> 00:16:30,000
ქულა გააკეთა.

293
00:16:30,000 --> 00:16:34,000
>> ეს, მუცელზე თუმცა ეს ასევე არის, ეს არის ერთერთი წყაროების დიდი დაბნეულობა

294
00:16:34,000 --> 00:16:38,000
როდესაც წერა პროგრამებს, აქვს შეცდომები, რადგან ისინი მანიფესტი თავად

295
00:16:38,000 --> 00:16:40,000
მხოლოდ ერთხელ, ხოლო ზოგჯერ.

296
00:16:40,000 --> 00:16:43,000
რეალობაა ის, რომ მაშინაც კი, თუ თქვენი კოდი მთლიანად გატეხილი,

297
00:16:43,000 --> 00:16:46,000
ეს შესაძლოა მხოლოდ მთლიანად გატეხილი ერთხელ ხოლო

298
00:16:46,000 --> 00:16:49,000
რადგან ზოგჯერ, არსებითად რა ხდება არის ოპერაციული სისტემა გამოყოფს

299
00:16:49,000 --> 00:16:52,000
ცოტა მეტი მეხსიერების ვიდრე რეალურად სჭირდება სხვადსხვა მიზეზის გამო,

300
00:16:52,000 --> 00:16:57,000
და ასე არავინ იყენებს მეხსიერების შემდეგ თქვენი ბლოკი 16 გმირები,

301
00:16:57,000 --> 00:17:01,000
ასე რომ, თუ მიდიხარ 17, 18, 19, რასაც, ეს არ ასეთი დიდი გარიგება.

302
00:17:01,000 --> 00:17:04,000
ახლა, კომპიუტერი, მაშინაც კი, თუ ის არ ავარიული იმ ეტაპზე,

303
00:17:04,000 --> 00:17:09,000
შესაძლოა საბოლოოდ გამოიყენოთ byte ხმების 17 ან 18 ან 19 რაღაც სხვას,

304
00:17:09,000 --> 00:17:14,000
სადაც აღვნიშნო თქვენი მონაცემები, რომ თქვენ დააყენა იქ, თუმცა ზედმეტად ხანგრძლივი,

305
00:17:14,000 --> 00:17:18,000
აპირებს მიიღოს ინსტალერის პოტენციურად ზოგიერთი სხვა ფუნქცია.

306
00:17:18,000 --> 00:17:21,000
ეს აუცილებლად არ აპირებს დარჩეს უცვლელი,

307
00:17:21,000 --> 00:17:23,000
მაგრამ ეს აუცილებლად არ იწვევს seg ბრალია.

308
00:17:23,000 --> 00:17:26,000
მაგრამ ამ შემთხვევაში, მე საბოლოოდ გათვალისწინებული საკმარისი გმირები

309
00:17:26,000 --> 00:17:29,000
რომ მე არსებითად გადააჭარბა ჩემი სეგმენტი მეხსიერება, და bam,

310
00:17:29,000 --> 00:17:33,000
ოპერაციული სისტემა განაცხადა, "ბოდიში, რომ არ არის კარგი, სეგმენტაცია ბრალია."

311
00:17:33,000 --> 00:17:38,000
>> და ვნახოთ ახლა თუ რა რჩება აქ ჩემი დირექტორია-

312
00:17:38,000 --> 00:17:40,000
შეამჩნია, რომ მე ამ ფაილის აქ, ძირითადი.

313
00:17:40,000 --> 00:17:42,000
გაითვალისწინეთ, რომ ეს კიდევ ერთხელ მოუწოდა ძირითადი ნაგავსაყრელი.

314
00:17:42,000 --> 00:17:46,000
ეს არსებითად ფაილი, რომელიც შეიცავს შინაარსი თქვენი პროგრამის მეხსიერებაში

315
00:17:46,000 --> 00:17:48,000
მომენტი, რომლის დროსაც იგი შეეჯახა,

316
00:17:48,000 --> 00:17:51,000
და უბრალოდ ცდილობენ პატარა მაგალითი აქ ნება მომეცით წავიდეს აქ

317
00:17:51,000 --> 00:17:57,000
და აწარმოებს GDB on scanf3 და შემდეგ მიუთითე მესამე არგუმენტი ეწოდება core,

318
00:17:57,000 --> 00:18:01,000
და შენიშნავს, აქ რომ თუ სიაში კოდი,

319
00:18:01,000 --> 00:18:06,000
ჩვენ შევძლებთ, როგორც ყოველთვის ერთად GDB დაიწყოს გავლით ამ პროგრამის

320
00:18:06,000 --> 00:18:10,000
და შემიძლია გაუშვით და როგორც კი მოხვდა, როგორც ერთად ნაბიჯი სარდლობის GDB-

321
00:18:10,000 --> 00:18:13,000
როგორც კი მოხვდა პოტენციურად buggy ხაზის შემდეგ აკრეფით უზარმაზარი ტექსტი,

322
00:18:13,000 --> 00:18:16,000
მე შევძლებთ რეალურად იდენტიფიცირება აქ.

323
00:18:16,000 --> 00:18:19,000
გაძლიერებული ამ, თუმცა, ნაწილში თვალსაზრისით ძირითადი dumps

324
00:18:19,000 --> 00:18:22,000
და მინდა ასე რომ თქვენ შეგიძლიათ რეალურად poke გარშემო შიგნით ძირითადი ნაგავსაყრელი

325
00:18:22,000 --> 00:18:27,000
და ნახე რა ხაზის პროგრამის ჩაიშალა თქვენ.

326
00:18:27,000 --> 00:18:32,000
ნებისმიერი კითხვები შემდეგ პოინტერები და მისამართები?

327
00:18:32,000 --> 00:18:36,000
იმის გამო, რომ დღეს, ჩვენ ვაპირებთ დავიწყოთ აღების თავისთავად, რომ ეს ყველაფერი არსებობს

328
00:18:36,000 --> 00:18:40,000
და ჩვენ ვიცით, ზუსტად რა ისინი.

329
00:18:40,000 --> 00:18:42,000
დიახ.

330
00:18:42,000 --> 00:18:46,000
>> [სტუდენტური] როგორ, შენ არ უნდა დააყენოს ampersand შემდეგი ნაწილს-

331
00:18:46,000 --> 00:18:48,000
კარგი კითხვაა.

332
00:18:48,000 --> 00:18:51,000
როგორ მოვიდა მე არ უნდა დააყენოს ampersand შემდეგ ხასიათი მასივს როგორც მე ადრე

333
00:18:51,000 --> 00:18:53,000
უმეტესობა ჩვენი მაგალითები?

334
00:18:53,000 --> 00:18:55,000
მოკლე პასუხი არის კოლექტორები ხართ პატარა სპეციალური.

335
00:18:55,000 --> 00:18:59,000
თქვენ შეგიძლიათ თითქმის ვფიქრობ ბუფერული როგორც მართლაც მისამართი,

336
00:18:59,000 --> 00:19:03,000
და ეს ასე მოხდება, რომ იყოს საქმე, რომ კვადრატული ფრჩხილი ნოტაცია

337
00:19:03,000 --> 00:19:06,000
არის კომფორტული ასე, რომ ჩვენ შეგვიძლია წასვლას bracket 0, bracket 1,

338
00:19:06,000 --> 00:19:10,000
bracket 2, გარეშე გამოყენება * ნოტაცია.

339
00:19:10,000 --> 00:19:13,000
სწორედ ცოტა თეთრი ტყუილი, რადგან მასივები და პოინტერები

340
00:19:13,000 --> 00:19:17,000
არიან, ფაქტობრივად, ცოტა განსხვავებული, მაგრამ ხშირად, მაგრამ არა ყოველთვის იქნება გამოყენებული interchangeably.

341
00:19:17,000 --> 00:19:21,000
მოკლედ, როდესაც ფუნქციის ელოდება მომცეთ ბლოკი მეხსიერება,

342
00:19:21,000 --> 00:19:24,000
თქვენ შეგიძლიათ ან გაიაროს ეს მისამართი, რომელიც დაბრუნდა მიერ malloc,

343
00:19:24,000 --> 00:19:29,000
და ვნახავთ malloc კიდევ ხანგრძლივი, ან შეგიძლიათ გაიაროს ეს სახელწოდება მასივი.

344
00:19:29,000 --> 00:19:32,000
თქვენ არ უნდა გავაკეთოთ ampersand ერთად კოლექტორები რადგან ისინი უკვე

345
00:19:32,000 --> 00:19:34,000
არსებითად like მისამართები.

346
00:19:34,000 --> 00:19:36,000
სწორედ ერთი გამონაკლისი.

347
00:19:36,000 --> 00:19:39,000
კვადრატულ ფრჩხილებში მათი სპეციალური.

348
00:19:39,000 --> 00:19:41,000
>> იქნებ დააყენა ampersand შემდეგ ბუფერული?

349
00:19:41,000 --> 00:19:43,000
არ ამ შემთხვევაში.

350
00:19:43,000 --> 00:19:46,000
რომ არ იმუშავებს, ვინაიდან, კიდევ ერთხელ, ამ კუთხეში შემთხვევაში

351
00:19:46,000 --> 00:19:49,000
სად კოლექტორები არ არიან საკმაოდ რეალურად მისამართები.

352
00:19:49,000 --> 00:19:54,000
მაგრამ ჩვენ ალბათ დაბრუნდება, რომ ხანგრძლივი სხვა მაგალითები.

353
00:19:54,000 --> 00:19:56,000
მოდით ცდილობენ გადაჭრის პრობლემა აქ.

354
00:19:56,000 --> 00:20:00,000
ჩვენ გვყავს მონაცემები სტრუქტურა, რომელიც ჩვენ გამოყენებით, გარკვეული დროის ცნობილი როგორც მასივი.

355
00:20:00,000 --> 00:20:02,000
მაგალითია ის, რაც ჩვენ უბრალოდ ჰქონდა.

356
00:20:02,000 --> 00:20:04,000
მაგრამ კოლექტორები აქვს გარკვეული upsides და downsides.

357
00:20:04,000 --> 00:20:06,000
კოლექტორები კი კარგია, თუ რატომ?

358
00:20:06,000 --> 00:20:11,000
რა არის ერთი რამ, რომ გსურთ-იმდენად, რამდენადაც ეს მოგწონთ კოლექტორები-ს შესახებ კოლექტორები?

359
00:20:11,000 --> 00:20:13,000
რა არის მოსახერხებელი მათ შესახებ? რა არის მყარი?

360
00:20:13,000 --> 00:20:18,000
რატომ გააცნოს მათ პირველ რიგში?

361
00:20:18,000 --> 00:20:20,000
Yeah.

362
00:20:20,000 --> 00:20:27,000
[სტუდენტური] მათ შეუძლიათ შესანახად ბევრი მონაცემები, და თქვენ არ უნდა გამოვიყენოთ მთელი რამ.

363
00:20:27,000 --> 00:20:29,000
თქვენ შეგიძლიათ გამოიყენოთ მონაკვეთზე.

364
00:20:29,000 --> 00:20:32,000
კარგი, ერთად მასივების შენახვა შეუძლია მრავალი მონაცემები,

365
00:20:32,000 --> 00:20:35,000
და თქვენ არ აუცილებლად უნდა გამოვიყენოთ ყველა ის, ასე რომ თქვენ შეგიძლიათ overallocate,

366
00:20:35,000 --> 00:20:39,000
რაც შესაძლოა მოსახერხებელი თუ თქვენ არ იცით, წინასწარ რამდენი რამე უნდა ველოდოთ.

367
00:20:39,000 --> 00:20:41,000
>> GetString არის მაგალითი.

368
00:20:41,000 --> 00:20:44,000
GetString, წერილობითი ჩვენს მიერ ვიზიტორების იდეა რამდენი სიმბოლო უნდა ველოდოთ,

369
00:20:44,000 --> 00:20:48,000
ასე რომ ჩვენ შეგვიძლია გამოყოფს მოცულობით მიმდებარე მეხსიერების არის კარგი.

370
00:20:48,000 --> 00:20:51,000
კოლექტორები ასევე გადაწყვიტოს პრობლემა დავინახეთ რამდენიმე კვირის წინ არის

371
00:20:51,000 --> 00:20:54,000
სადაც თქვენი კოდი იწყებს გადაეცემა შევიდა რაღაც ძალიან ცუდად დაპროექტებული.

372
00:20:54,000 --> 00:20:57,000
შეგახსენებთ, რომ მე შექმნილი სტუდენტი სტრუქტურა მოუწოდა დავით,

373
00:20:57,000 --> 00:21:00,000
და მაშინ ეს იყო რეალურად ალტერნატიული, თუმცა,

374
00:21:00,000 --> 00:21:04,000
to მქონე ცვლადში სახელი და სხვა ცვლადში, ვფიქრობ, კერძო სახლი,

375
00:21:04,000 --> 00:21:08,000
და სხვა ცვლადში ID რადგან ამბავი მე მაშინ სურდა შემოიღონ რაღაც

376
00:21:08,000 --> 00:21:11,000
მინდა რობ იქნება პროგრამაში, ასე შემდეგ გადავწყვიტე დაველოდოთ წუთში,

377
00:21:11,000 --> 00:21:13,000
მე უნდა გადაარქვათ ამ ცვლადებს.

378
00:21:13,000 --> 00:21:16,000
მოდით მოვუწოდებთ მაღაროს name1, ID1, house1.

379
00:21:16,000 --> 00:21:20,000
მოდით მოვუწოდებთ რობ ს name2, house2, ID2.

380
00:21:20,000 --> 00:21:22,000
მაგრამ შემდეგ დაველოდოთ წუთში, რაც შეეხება Tommy?

381
00:21:22,000 --> 00:21:24,000
მაშინ ჩვენ გვქონდა სამი ცვლადი.

382
00:21:24,000 --> 00:21:27,000
ჩვენ გააცნო ვინმე, ოთხი კომპლექტი ცვლადები.

383
00:21:27,000 --> 00:21:30,000
მსოფლიოში დაიწყო მისაღებად ბინძურ ძალიან სწრაფად,

384
00:21:30,000 --> 00:21:33,000
ამიტომ ჩვენ გააცნო structs, და რაც მყარი შესახებ struct?

385
00:21:33,000 --> 00:21:39,000
რას C struct მოგცემთ გავაკეთოთ?

386
00:21:39,000 --> 00:21:42,000
მართლაც უხერხულია დღეს.

387
00:21:42,000 --> 00:21:44,000
რა? >> [Inaudible სტუდენტი საპასუხოდ]

388
00:21:44,000 --> 00:21:47,000
ჰო, კონკრეტულად, typedef გაძლევთ საშუალებას შექმნათ ახალი მონაცემები ტიპის,

389
00:21:47,000 --> 00:21:51,000
და struct, struct სიტყვით, გაძლევთ საშუალებას encapsulate

390
00:21:51,000 --> 00:21:54,000
კონცეპტუალურად დაკავშირებული დარტყმები მონაცემთა ერთად

391
00:21:54,000 --> 00:21:56,000
და ამის შემდგომ მოვუწოდებთ მათ რაღაც სტუდენტი.

392
00:21:56,000 --> 00:21:58,000
>> ეს იყო კარგი, რადგან ახლა ჩვენ შეგვიძლია მოდელირებისა

393
00:21:58,000 --> 00:22:03,000
ბევრად უფრო სახის კონცეპტუალურად თანმიმდევრული ცნება სტუდენტი ცვლადი

394
00:22:03,000 --> 00:22:07,000
ვიდრე თვითნებურად მქონე ერთი ტექსტი, ერთი ID, და სხვ.

395
00:22:07,000 --> 00:22:10,000
კოლექტორები კი კარგია, რადგან ისინი საშუალებას მოგვცემს დავიწყოთ გაწმენდის ჩვენი კოდი.

396
00:22:10,000 --> 00:22:13,000
მაგრამ რა არის downside ახლა მასივი?

397
00:22:13,000 --> 00:22:15,000
რა შეგიძლიათ არ გააკეთებს? Yeah.

398
00:22:15,000 --> 00:22:17,000
[სტუდენტური] თქვენ უნდა იცოდეს, რამდენად დიდი ეს არის.

399
00:22:17,000 --> 00:22:19,000
თქვენ უნდა იცოდეს, რამდენად დიდი ეს არის, ამიტომ სახის ტკივილი.

400
00:22:19,000 --> 00:22:21,000
იმ თქვენ წინასწარი პროგრამირების გამოცდილება ვიცი, რომ ბევრი ენების,

401
00:22:21,000 --> 00:22:24,000
მოსწონს ჯავის, შეგიძლიათ ბლოკი მეხსიერება, კონკრეტულად მასივი,

402
00:22:24,000 --> 00:22:28,000
რამდენად დიდი ხარ, ერთად სიგრძე, ქონება, ასე ვთქვათ, და ეს მართლაც მოსახერხებელია.

403
00:22:28,000 --> 00:22:32,000
In C, თქვენ კი ვერ ვუწოდებთ strlen on generic მასივი

404
00:22:32,000 --> 00:22:35,000
რადგან strlen, როგორც სიტყვა გულისხმობს, არის მხოლოდ სიმები,

405
00:22:35,000 --> 00:22:39,000
და შეგიძლიათ გაერკვნენ სიგრძეზე string რადგან ამ ადამიანის კონვენცია

406
00:22:39,000 --> 00:22:43,000
მქონე \ 0, მაგრამ მასივი, უფრო generically, მხოლოდ ბლოკი მეხსიერება.

407
00:22:43,000 --> 00:22:46,000
თუ ეს მასივი ints, იქ არ იქნება ზოგიერთი სპეციალური ხასიათის

408
00:22:46,000 --> 00:22:48,000
დასასრულს გელოდებათ.

409
00:22:48,000 --> 00:22:50,000
თქვენ უნდა გვახსოვდეს, სიგრძით მასივი.

410
00:22:50,000 --> 00:22:54,000
კიდევ ერთი downside of მასივი reared მისი მეთაურის GetString თავად.

411
00:22:54,000 --> 00:22:59,000
რა არის კიდევ ერთი downside of მასივი?

412
00:22:59,000 --> 00:23:01,000
სერ, უბრალოდ მე და შენ დღეს.

413
00:23:01,000 --> 00:23:04,000
[Inaudible სტუდენტი საპასუხოდ] >> ეს რა?

414
00:23:04,000 --> 00:23:06,000
ეს განაცხადა Stack.

415
00:23:06,000 --> 00:23:09,000
Okay, განაცხადა Stack. რატომ არ მოგწონთ, რომ?

416
00:23:09,000 --> 00:23:13,000
[სტუდენტური] გამო იგი იღებს reused.

417
00:23:13,000 --> 00:23:15,000
იგი იღებს reused.

418
00:23:15,000 --> 00:23:18,000
Okay, თუ თქვენ იყენებთ მასივი გამოყოს მეხსიერება,

419
00:23:18,000 --> 00:23:21,000
თქვენ არ შეგიძლიათ, მაგალითად, მისი დაბრუნება, რადგან ეს on Stack.

420
00:23:21,000 --> 00:23:23,000
Okay, რომ მინუსი.

421
00:23:23,000 --> 00:23:25,000
და როგორ დაახლოებით ერთი მეორე მასივი?

422
00:23:25,000 --> 00:23:28,000
ერთხელ თქვენ გამოყოფს იგი, თქვენ სახის ბრალია თუ გჭირდებათ მეტი სივრცე

423
00:23:28,000 --> 00:23:30,000
ვიდრე, რომ მასივი აქვს.

424
00:23:30,000 --> 00:23:34,000
>> შემდეგ ჩვენ გააცნო, გაწვევას, malloc, რომელიც მოგვცა უნარი დინამიურად გამოყოფს მეხსიერება.

425
00:23:34,000 --> 00:23:37,000
მაგრამ რა, თუ ჩვენ შევეცადეთ სხვადასხვა სამყაროში საერთოდ?

426
00:23:37,000 --> 00:23:40,000
რა მოხდება, თუ გვინდოდა მოსაგვარებლად რამდენიმე იმ პრობლემებზე

427
00:23:40,000 --> 00:23:45,000
ამიტომ ჩვენ ნაცვლად-ჩემი კალამი დაეცა ეძინა აქ-

428
00:23:45,000 --> 00:23:51,000
რა თუ ჩვენ ნაცვლად სურდა არსებითად შექმნა მსოფლიოს რომ აღარ მოსწონს?

429
00:23:51,000 --> 00:23:56,000
ეს არის მასივი, და, რა თქმა უნდა, ასეთი უარესდება ერთხელ ჩვენ მოხვდა ბოლოს მასივი,

430
00:23:56,000 --> 00:24:00,000
და მე ახლა აღარ აქვს სივრცეში კიდევ ერთი მთელი რიცხვი ან სხვა ხასიათის.

431
00:24:00,000 --> 00:24:03,000
რა მოხდება, თუ ჩვენ სახის preemptively ამბობენ კარგად, რატომ არ გვაქვს მოდუნების

432
00:24:03,000 --> 00:24:07,000
ეს მოთხოვნა, რომ ყველა ეს მოცულობით მეხსიერების იყოს მომიჯნავე თავში უკან,

433
00:24:07,000 --> 00:24:10,000
და რატომ არ, როცა მჭირდება int ან char,

434
00:24:10,000 --> 00:24:12,000
უბრალოდ მომეცი სივრცეში ერთი მათგანი?

435
00:24:12,000 --> 00:24:14,000
და როცა გვჭირდება სხვა, მომეცი კიდევ ერთი სივრცის,

436
00:24:14,000 --> 00:24:16,000
და როცა გვჭირდება სხვა, მომეცი კიდევ ერთი ფართი.

437
00:24:16,000 --> 00:24:19,000
უპირატესობა რომელიც ახლა ის არის, რომ თუ ვინმეს

438
00:24:19,000 --> 00:24:21,000
იღებს მეხსიერების მეტი აქ, არ დიდი გარიგება.

439
00:24:21,000 --> 00:24:25,000
მე მიიღოს ამ დამატებითი ბლოკი მეხსიერება აქ და შემდეგ ამ ერთი.

440
00:24:25,000 --> 00:24:28,000
>> ახლა, მხოლოდ დაჭერა აქ არის ის, რომ ამ თითქმის იგრძნობა მაქვს

441
00:24:28,000 --> 00:24:30,000
მთელი bunch სხვადასხვა ცვლადები.

442
00:24:30,000 --> 00:24:33,000
ეს იგრძნობა ხუთი ცვლადის სხვადასხვა პოტენციურად.

443
00:24:33,000 --> 00:24:36,000
მაგრამ რა, თუ ჩვენ მოიპაროს იდეა საწყისი სტრიქონები

444
00:24:36,000 --> 00:24:41,000
რომლითაც ჩვენ როგორღაც დაუკავშირონ ეს ყველაფერი ერთად კონცეპტუალურად, და რა მე რომ ამ?

445
00:24:41,000 --> 00:24:44,000
ეს არის ჩემი ძალიან ცუდად შედგენილი arrow.

446
00:24:44,000 --> 00:24:46,000
მაგრამ ვარაუდობენ, რომ თითოეულ ამ მოცულობით მეხსიერება

447
00:24:46,000 --> 00:24:52,000
აღნიშნა, რომ სხვა, და ამ ბიჭს, რომელმაც არ აქვს ძმა მისი უფლება,

448
00:24:52,000 --> 00:24:54,000
ვიზიტორების ასეთი arrow.

449
00:24:54,000 --> 00:24:56,000
ეს არის, ფაქტობრივად, რასაც დაკავშირებული სიაში.

450
00:24:56,000 --> 00:25:00,000
ეს არის ახალი მონაცემები სტრუქტურა, რომელიც საშუალებას გვაძლევს გამოყოფს ბლოკი მეხსიერება,

451
00:25:00,000 --> 00:25:03,000
მაშინ კიდევ, მაშინ მეორე, მაშინ კიდევ, ნებისმიერ დროს ჩვენ გვინდა

452
00:25:03,000 --> 00:25:07,000
დროს პროგრამა, და ჩვენ გვახსოვს, რომ ისინი ყველა როგორღაც დაკავშირებული

453
00:25:07,000 --> 00:25:11,000
მიერ სიტყვასიტყვით chaining მათი ერთად, და გავაკეთეთ, რომ pictorially აქ arrow.

454
00:25:11,000 --> 00:25:15,000
მაგრამ კოდი, რა იქნება მექანიზმი მეშვეობით რომელიც თქვენ შეიძლება რაღაცნაირად დააკავშირებს,

455
00:25:15,000 --> 00:25:20,000
თითქმის მოსწონს Scratch, ერთი ბლოკი მეორეში ბლოკი?

456
00:25:20,000 --> 00:25:22,000
ჩვენ შეგვეძლო გამოიყენოთ მომცეთ, არა?

457
00:25:22,000 --> 00:25:25,000
რადგან მართლაც arrow რომ ხდება საწყისი ზედა მარცხენა მოედანზე,

458
00:25:25,000 --> 00:25:31,000
ამ ბიჭს აქ ამ ერთი, შეიძლება შეიცავდეს შიგნით ამ მოედანზე

459
00:25:31,000 --> 00:25:34,000
არა მხოლოდ რამდენიმე ints, არა მხოლოდ ზოგიერთი char, მაგრამ მე ვფიქრობ რეალურად გამოყოფილი

460
00:25:34,000 --> 00:25:37,000
ცოტა ზედმეტი სივრცე ისე, რომ ახლა,

461
00:25:37,000 --> 00:25:41,000
თითოეული ჩემი მოცულობით მეხსიერება, მიუხედავად იმისა, რომ ამ აპირებს ეღირება ჩემთვის,

462
00:25:41,000 --> 00:25:45,000
ახლა გამოიყურება უფრო მართკუთხა სადაც ერთ მოცულობით მეხსიერება

463
00:25:45,000 --> 00:25:47,000
გამოიყენება ნომერი, როგორიც ნომერი 1,

464
00:25:47,000 --> 00:25:50,000
და თუ ამ ბიჭს ინახავს რიცხვი 2,

465
00:25:50,000 --> 00:25:52,000
ამ სხვა ბლოკი მეხსიერება გამოიყენება arrow,

466
00:25:52,000 --> 00:25:54,000
ან უფრო კონკრეტულად, მაჩვენებელი.

467
00:25:54,000 --> 00:25:59,000
და ვარაუდობენ მე შესანახად ნომერი 3 ზე აქ მე გამოიყენოს ეს აღვნიშნო, რომ ბიჭს,

468
00:25:59,000 --> 00:26:02,000
და ახლა ამ ბიჭს, დავუშვათ მე მხოლოდ მინდა სამი ასეთი მოცულობით მეხსიერება.

469
00:26:02,000 --> 00:26:05,000
მე დახაზოთ ხაზი მეშვეობით რომ მითითებით null.

470
00:26:05,000 --> 00:26:07,000
არ არსებობს დამატებითი ხასიათი.

471
00:26:07,000 --> 00:26:10,000
>> მართლაც, ეს როგორ შეგვიძლია წავიდეთ შესახებ ახორციელებს

472
00:26:10,000 --> 00:26:12,000
რაღაც რომ ე.წ. დაკავშირებული სიაში.

473
00:26:12,000 --> 00:26:18,000
უკავშირდება სია ახალი მონაცემები სტრუქტურას, და ეს სტეპინგზე ქვის მიმართ

474
00:26:18,000 --> 00:26:21,000
გაცილებით fancier მონაცემები სტრუქტურები, რომლებიც იწყებენ პრობლემების გადასაჭრელად

475
00:26:21,000 --> 00:26:23,000
გასწვრივ ხაზი Facebook ტიპის პრობლემების და Google-ის ტიპის პრობლემები

476
00:26:23,000 --> 00:26:26,000
სადაც თქვენ უზარმაზარი მონაცემები კომპლექტი, და ეს აღარ წყვეტს იგი

477
00:26:26,000 --> 00:26:29,000
შესანახად ყველაფერი contiguously და გამოიყენოს მსგავსი რამ ხაზოვანი ძებნა

478
00:26:29,000 --> 00:26:31,000
ან თუნდაც რაღაც ორობითი ძებნა.

479
00:26:31,000 --> 00:26:33,000
გსურთ კიდევ უფრო უკეთესი გაშვებული ჯერ.

480
00:26:33,000 --> 00:26:37,000
ფაქტობრივად, ერთი წმიდა Grails ჩვენ ვსაუბრობთ ამ კვირის ბოლოს ან შემდეგი

481
00:26:37,000 --> 00:26:41,000
არის ალგორითმი, რომლის ქრონომეტრაჟი არის მუდმივი.

482
00:26:41,000 --> 00:26:44,000
სხვა სიტყვებით, იგი ყოველთვის იღებს იმავე დროის არ აქვს მნიშვნელობა

483
00:26:44,000 --> 00:26:47,000
რამდენად დიდი შეყვანის არის, და რომ მართლაც იყოს მყარი,

484
00:26:47,000 --> 00:26:49,000
კიდევ უფრო მეტი, ვიდრე ისე რაღაც ლოგარითმული.

485
00:26:49,000 --> 00:26:51,000
რა არის ეს ეკრანზე აქ?

486
00:26:51,000 --> 00:26:55,000
თითოეული მართკუთხედების არის ზუსტად ის, რაც მე უბრალოდ გაამახვილა ხელით.

487
00:26:55,000 --> 00:26:59,000
მაგრამ რამ ყველა გზა მარცხენა არის სპეციალური ცვლადი.

488
00:26:59,000 --> 00:27:02,000
ეს იქნება ერთი მაჩვენებელი, რადგან ერთი GOTCHA

489
00:27:02,000 --> 00:27:04,000
ერთად უკავშირდება სიაში, როგორც ამას უწოდებენ,

490
00:27:04,000 --> 00:27:09,000
ის არის, რომ თქვენ უნდა გათიშეთ გადატანა ერთი ბოლოს უკავშირდება სიაში.

491
00:27:09,000 --> 00:27:13,000
>> ისევე ერთად სიმებიანი, თქვენ უნდა იცოდეს, მისამართი პირველი ჩარ.

492
00:27:13,000 --> 00:27:15,000
იგივე გარიგება ამისთვის დაკავშირებული სიები.

493
00:27:15,000 --> 00:27:19,000
თქვენ უნდა იცოდეს, მისამართი პირველი ბლოკი მეხსიერება

494
00:27:19,000 --> 00:27:25,000
რადგან იქ, შეგიძლიათ მიღწევა ყოველ მეორე.

495
00:27:25,000 --> 00:27:27,000
Downside.

496
00:27:27,000 --> 00:27:30,000
რა ფასი ჩვენ გადამხდელი ამ versatility მქონე დინამიურად

497
00:27:30,000 --> 00:27:34,000
მნიშვნელოვანი მონაცემები სტრუქტურის, რომ თუ ჩვენ ოდესმე გვჭირდება მეტი მეხსიერების, ჯარიმა,

498
00:27:34,000 --> 00:27:37,000
უბრალოდ გამოყოფს კიდევ ერთი ბლოკი და დავხატოთ კურსორი საწყისი

499
00:27:37,000 --> 00:27:39,000
ძველიდან ახალ კუდი სიის?

500
00:27:39,000 --> 00:27:41,000
Yeah.

501
00:27:41,000 --> 00:27:43,000
[სტუდენტური] ეს დაახლოებით ორჯერ იმდენი ფართი.

502
00:27:43,000 --> 00:27:45,000
იგი იღებს ორჯერ იმდენი სივრცეში, ასე რომ აუცილებლად downside, და ჩვენ ვნახეთ ამ

503
00:27:45,000 --> 00:27:48,000
tradeoff ადრე შორის დრო და სივრცე და მოქნილობა

504
00:27:48,000 --> 00:27:51,000
იმ შემთხვევაში, როდესაც ახლა, ჩვენ გვჭირდება არა 32 ბიტი თითოეული ამ ნომრებზე.

505
00:27:51,000 --> 00:27:57,000
ჩვენ ნამდვილად გვჭირდება 64, 32 ნომერი და 32 კურსორი.

506
00:27:57,000 --> 00:27:59,000
მაგრამ hey, მაქვს 2 გბ ოპერატიული მეხსიერება.

507
00:27:59,000 --> 00:28:02,000
დამატება სხვა 32 ბიტი აქ და აქ არ ჩანს, რომ დიდი გარიგება.

508
00:28:02,000 --> 00:28:05,000
მაგრამ დიდი მონაცემები კომპლექტი, იგი აუცილებლად დასძენს მდე სიტყვასიტყვით ორჯერ იმდენი.

509
00:28:05,000 --> 00:28:09,000
რა არის კიდევ ერთი downside არის, ან რა ფუნქცია ჩვენ დავთმობთ,

510
00:28:09,000 --> 00:28:12,000
თუ ჩვენ წარმოვადგენთ სიები რამ ერთად უკავშირდება სიაში და არ მასივი?

511
00:28:12,000 --> 00:28:14,000
[სტუდენტური] თქვენ არ შეგიძლიათ traverse მას უკან.

512
00:28:14,000 --> 00:28:16,000
თქვენ არ შეგიძლიათ traverse მას უკან, ასე რომ თქვენ ტიპის ბრალია თუ თქვენ ფეხით

513
00:28:16,000 --> 00:28:19,000
მარცხნიდან მარჯვნივ გამოყენებით ამისთვის მარყუჟი ან ხოლო loop

514
00:28:19,000 --> 00:28:21,000
და მაშინ ხვდები, "ოჰ, მე მინდა დავუბრუნდეთ დასაწყისში სიაში."

515
00:28:21,000 --> 00:28:26,000
თქვენ არ შეგიძლიათ, რადგან ამ მითითებას მხოლოდ იქ მარცხნიდან მარჯვნივ, როგორც ისრებით მიუთითოს.

516
00:28:26,000 --> 00:28:29,000
>> ახლა, თქვენ შეიძლება გახსოვთ დაწყების სიაში სხვა ცვლადი,

517
00:28:29,000 --> 00:28:31,000
მაგრამ ეს სირთულის გვახსოვდეს.

518
00:28:31,000 --> 00:28:35,000
Array, არ აქვს მნიშვნელობა, თუ რამდენად შორს წახვალ, შეგიძლიათ ყოველთვის მინუსია, მინუს, მინუს, მინუს

519
00:28:35,000 --> 00:28:37,000
და წავიდეთ უკან საიდანაც თქვენ მოვიდა.

520
00:28:37,000 --> 00:28:40,000
რა არის კიდევ ერთი downside აქ? Yeah.

521
00:28:40,000 --> 00:28:43,000
[Inaudible სტუდენტი კითხვა]

522
00:28:43,000 --> 00:28:47,000
თქვენ შეიძლება, ასე რომ თქვენ რეალურად მხოლოდ შემოთავაზებული მონაცემები სტრუქტურა მოუწოდა ორმაგად უკავშირდება სია,

523
00:28:47,000 --> 00:28:50,000
და მართლაც, თქვენ რომ დაამატოთ კიდევ ერთი მაჩვენებელი თითოეულ ამ მართკუთხედების

524
00:28:50,000 --> 00:28:53,000
რომ მიდის სხვა მიმართულებით, Upside, რომლის

525
00:28:53,000 --> 00:28:55,000
არის შეგიძლიათ traverse უკან და მეოთხე,

526
00:28:55,000 --> 00:28:59,000
downside რომლის არის თქვენ იყენებთ სამჯერ იმდენი მეხსიერება როგორც ჩვენ გამოიყენება

527
00:28:59,000 --> 00:29:04,000
და ასევე დასძინა, სირთულის თვალსაზრისით კოდი თქვენ უნდა დაწეროს მიიღოს ეს უფლება.

528
00:29:04,000 --> 00:29:08,000
მაგრამ ეს მხოლოდ ყველა ალბათ ძალიან გონივრული tradeoffs, თუ შეცვლის უფრო მნიშვნელოვანია.

529
00:29:08,000 --> 00:29:10,000
Yeah.

530
00:29:10,000 --> 00:29:12,000
[სტუდენტური] თქვენ ასევე შეგიძლიათ არ აქვს 2D დაკავშირებული სიაში.

531
00:29:12,000 --> 00:29:16,000
კარგი, შეგიძლიათ ნამდვილად არ აქვს 2D უკავშირდება სიაში.

532
00:29:16,000 --> 00:29:18,000
თქვენ შეიძლება. ეს არ არის თითქმის მარტივი როგორც მასივი.

533
00:29:18,000 --> 00:29:21,000
Like მასივი, თქვენ ღია bracket, დახურული ფრჩხილი, ღია bracket, დახურული ფრჩხილი,

534
00:29:21,000 --> 00:29:23,000
და თქვენ მიიღეთ რაიმე 2 განზომილებიანი სტრუქტურა.

535
00:29:23,000 --> 00:29:26,000
თქვენ შეიძლება განახორციელოს 2 განზომილებიანი უკავშირდება სია

536
00:29:26,000 --> 00:29:29,000
თუ add-როგორც თქვენ შემოთავაზებული-მესამე მომცეთ თითოეული ეს ყველაფერი,

537
00:29:29,000 --> 00:29:34,000
და თუ ფიქრობთ ამის შესახებ კიდევ ერთი სია მოდის at თქვენ 3D სტილი

538
00:29:34,000 --> 00:29:40,000
საწყისი ეკრანის ყველა ჩვენგანისთვის, რომელიც არის კიდევ ერთი ჯაჭვის გარკვეული.

539
00:29:40,000 --> 00:29:45,000
ჩვენ შეგვეძლო ამის გაკეთება, მაგრამ არ იმდენად მარტივია, აკრეფით ღია bracket, სკვერი bracket. Yeah.

540
00:29:45,000 --> 00:29:48,000
[Inaudible სტუდენტი კითხვა]

541
00:29:48,000 --> 00:29:50,000
კარგი, ასე რომ ეს არის რეალური kicker.

542
00:29:50,000 --> 00:29:54,000
>> ეს ალგორითმები, რომ ჩვენ pined მეტი, როგორიცაა OH, ორობითი ძებნა,

543
00:29:54,000 --> 00:29:57,000
თქვენ შეგიძლიათ მოძებნოთ მასივი ნომრები ფორუმში

544
00:29:57,000 --> 00:30:01,000
ან სატელეფონო წიგნი იმდენად უფრო სწრაფად, თუ თქვენ იყენებთ გათიშე და დაიპყროთ

545
00:30:01,000 --> 00:30:05,000
და ბინარული ძებნის ალგორითმი, მაგრამ ბინარული ძებნა საჭირო ორი ვარაუდები.

546
00:30:05,000 --> 00:30:09,000
ერთი, რომ მონაცემები იყო დახარისხებული.

547
00:30:09,000 --> 00:30:11,000
ახლა შეგვიძლია, სავარაუდოდ რომ ეს დახარისხებული,

548
00:30:11,000 --> 00:30:14,000
იქნებ ეს არ არის შეშფოთება, მაგრამ ბინარული ძებნის ასევე აიღო

549
00:30:14,000 --> 00:30:18,000
რომ თქვენ გქონდათ შემთხვევითი ხელმისაწვდომობის სიაში ნომრები,

550
00:30:18,000 --> 00:30:21,000
და array საშუალებას გაძლევთ შემთხვევითი წვდომის და შემთხვევითი წვდომის,

551
00:30:21,000 --> 00:30:24,000
ვგულისხმობ თუ თქვენ მოცემული მასივი, რამდენი დრო სჭირდება თქვენ

552
00:30:24,000 --> 00:30:26,000
მისაღებად bracket 0?

553
00:30:26,000 --> 00:30:29,000
ერთი ოპერაცია, უბრალოდ გამოიყენოთ [0] და თქვენ უფლება არსებობს.

554
00:30:29,000 --> 00:30:33,000
რამდენი ნაბიჯები სჭირდება მოხვედრა საიდან 10?

555
00:30:33,000 --> 00:30:36,000
ერთი ნაბიჯი, თქვენ უბრალოდ წასვლა [10] და თქვენ იქ.

556
00:30:36,000 --> 00:30:40,000
ამის საპირისპიროდ, თუ როგორ იღებთ მე -10 რიცხვი წელს უკავშირდება სიაში?

557
00:30:40,000 --> 00:30:42,000
თქვენ უნდა დაიწყოს დასაწყისში რადგან თქვენ მხოლოდ დამახსოვრების

558
00:30:42,000 --> 00:30:45,000
დასაწყისში უკავშირდება სია, ისევე, როგორც სიმებიანი ხდება გაიხსენა

559
00:30:45,000 --> 00:30:48,000
მისი მისამართია მისი პირველი char, და იპოვოს, რომ მე -10 int

560
00:30:48,000 --> 00:30:53,000
ან რომ მე -10 პერსონაჟი სიმებიანი, თქვენ უნდა მოძებნოთ მთელი Damn რამ.

561
00:30:53,000 --> 00:30:55,000
>> ისევ და ისევ, ჩვენ არ გადაჭრის ყველა ჩვენი პრობლემები.

562
00:30:55,000 --> 00:31:00,000
ჩვენ ახალი პირობა, მაგრამ ეს ნამდვილად არის დამოკიდებული, თუ რა თქვენ ცდილობთ დიზაინი.

563
00:31:00,000 --> 00:31:04,000
განხორციელების თვალსაზრისით, ჩვენ შეგვიძლია სესხება იდეა, რომ სტუდენტი სტრუქტურა.

564
00:31:04,000 --> 00:31:07,000
სინტაქსი ძალიან ჰგავს, გარდა ახლა, იდეა არის ცოტა უფრო აბსტრაქტული

565
00:31:07,000 --> 00:31:09,000
ვიდრე სახლში და სახელი და ID.

566
00:31:09,000 --> 00:31:13,000
მაგრამ მე ვთავაზობ, რომ ჩვენ შეგვეძლო მონაცემები სტრუქტურა C

567
00:31:13,000 --> 00:31:17,000
რომ ჰქვია კვანძში, როგორც ბოლო სიტყვა on the slide ვარაუდობს,

568
00:31:17,000 --> 00:31:21,000
შიგნით კვანძი, და კვანძის მხოლოდ generic კონტეინერის კომპიუტერულ მეცნიერებათა.

569
00:31:21,000 --> 00:31:25,000
ეს, როგორც წესი, შედგენილია, როგორც წრის ან კვადრატული ან მართკუთხედი, როგორც ჩვენ გავაკეთეთ.

570
00:31:25,000 --> 00:31:27,000
და ამ მონაცემების სტრუქტურას, ჩვენ გვაქვს int, N,

571
00:31:27,000 --> 00:31:29,000
ასე რომ ნომერი მინდა შესანახად.

572
00:31:29,000 --> 00:31:36,000
მაგრამ რა არის ეს მეორე ხაზი, struct კვანძის * შემდეგი?

573
00:31:36,000 --> 00:31:40,000
რატომ არის ეს სწორი, ან რა როლი აქვს ამ რამ პიესა,

574
00:31:40,000 --> 00:31:42,000
მიუხედავად იმისა, რომ ეს პატარა cryptic ერთი შეხედვით?

575
00:31:42,000 --> 00:31:44,000
Yeah.

576
00:31:44,000 --> 00:31:46,000
[Inaudible სტუდენტი საპასუხოდ]

577
00:31:46,000 --> 00:31:50,000
სწორედ, ამიტომ * სახის გაფუჭდა, რომ მომცეთ რაიმე სახის.

578
00:31:50,000 --> 00:31:53,000
სახელი ამ მაჩვენებელმა არის თვითნებურად შემდეგი,

579
00:31:53,000 --> 00:32:00,000
მაგრამ ჩვენ შეეძლო მას არაფერი გვინდა, მაგრამ რას უნდა მომცეთ წერტილი?

580
00:32:00,000 --> 00:32:03,000
[სტუდენტური] კიდევ ერთი კვანძის. >> სწორედ ეს მიუთითებს სხვა ასეთი კვანძის.

581
00:32:03,000 --> 00:32:05,000
>> ახლა, ეს არის ერთგვარი ცნობისმოყვარეობა C.

582
00:32:05,000 --> 00:32:09,000
შეგახსენებთ, რომ C წაკითხვის მიერ შემდგენელი ყველაზე ქვედა, მარცხნიდან მარჯვნივ,

583
00:32:09,000 --> 00:32:13,000
რაც იმას ნიშნავს, თუ-ეს არის პატარა განსხვავდება, რაც ჩვენ გავაკეთეთ ერთად სტუდენტი.

584
00:32:13,000 --> 00:32:16,000
როდესაც ჩვენ განსაზღვრული სტუდენტი, ჩვენ რეალურად არ დააყენა სიტყვა არსებობს.

585
00:32:16,000 --> 00:32:18,000
ეს უბრალოდ განაცხადა typedef.

586
00:32:18,000 --> 00:32:20,000
მაშინ ჩვენ გვქონდა int id, string სახელი, string სახლი,

587
00:32:20,000 --> 00:32:23,000
და მაშინ სტუდენტი ბოლოში struct.

588
00:32:23,000 --> 00:32:26,000
ეს დეკლარაცია ცოტა განსხვავებული იმიტომ,

589
00:32:26,000 --> 00:32:28,000
ერთხელ, C კომპილატორი არის პატარა მუნჯი.

590
00:32:28,000 --> 00:32:30,000
ეს მხოლოდ აპირებს წაიკითხა ზედა ქვედა,

591
00:32:30,000 --> 00:32:33,000
ასე რომ, თუ იგი აღწევს მე -2 ხაზი აქ

592
00:32:33,000 --> 00:32:37,000
აქ შემდეგი ცხადდება და მას ხედავს, OH, აქ ცვლადში შემდეგი.

593
00:32:37,000 --> 00:32:39,000
ეს მომცეთ struct კვანძში.

594
00:32:39,000 --> 00:32:42,000
შემდგენელი აპირებს გააცნობიეროს, რა არის struct კვანძის?

595
00:32:42,000 --> 00:32:44,000
მე არასდროს მსმენია ამ რამ ადრე,

596
00:32:44,000 --> 00:32:47,000
რადგან სიტყვა კვანძის შეიძლება არ სხვაგვარად გამოჩნდება

597
00:32:47,000 --> 00:32:49,000
სანამ ბოლოში, ასე რომ, ამ redundancy.

598
00:32:49,000 --> 00:32:53,000
თქვენ უნდა ვთქვა struct კვანძის აქ, რომელიც შეგიძლიათ შემდეგ shorten მოგვიანებით

599
00:32:53,000 --> 00:32:56,000
წყალობით typedef ქვემოთ აქ, მაგრამ ეს იმიტომ

600
00:32:56,000 --> 00:33:02,000
ჩვენ referencing სტრუქტურა თავად შიგნით სტრუქტურა.

601
00:33:02,000 --> 00:33:05,000
სწორედ ერთ GOTCHA არსებობს.

602
00:33:05,000 --> 00:33:07,000
>> რამდენიმე საინტერესო პრობლემების ვაპირებთ წარმოიქმნება.

603
00:33:07,000 --> 00:33:09,000
გვაქვს სიაში ნომრები. როგორ უნდა ჩადოთ მივანიჭო?

604
00:33:09,000 --> 00:33:11,000
როგორ უნდა ვეძებოთ იგი? როგორ უნდა წაშალოთ მისგან?

605
00:33:11,000 --> 00:33:13,000
ახლა მით უმეტეს, რომ ჩვენ უნდა მართოს ყველა ამ მითითებას.

606
00:33:13,000 --> 00:33:15,000
თქვენ ეგონა პოინტერები იყო ერთგვარი გონება-bending

607
00:33:15,000 --> 00:33:17,000
როდესაც თქვენ ერთი მათგანი მხოლოდ წაკითხვის მცდელობისას int მას.

608
00:33:17,000 --> 00:33:20,000
ახლა ჩვენ გვაქვს მანიპულირება სრული სია მისი შესაბამისი ფასეულობით.

609
00:33:20,000 --> 00:33:22,000
რატომ არ ვიღებთ ჩვენი 5 წუთიანი შესვენება აქ, და შემდეგ ჩვენ მოუტანს

610
00:33:22,000 --> 00:33:34,000
ზოგიერთი FOLKS up სცენაზე უნდა გავაკეთოთ ზუსტად რომ.

611
00:33:34,000 --> 00:33:36,000
>> C არის ბევრად უფრო გართობა როცა ეს მოქმედებდა გარეთ.

612
00:33:36,000 --> 00:33:39,000
ვის სიტყვასიტყვით მინდა იყოს პირველი?

613
00:33:39,000 --> 00:33:41,000
Okay, მოდის up. თქვენ ხართ პირველი.

614
00:33:41,000 --> 00:33:44,000
ვინ მინდა იყოს 9? Okay, 9.

615
00:33:44,000 --> 00:33:46,000
როგორ დაახლოებით 9? 17?

616
00:33:46,000 --> 00:33:51,000
პატარა clique აქ. 22 და 26 წლის, რომ წინა რიგის.

617
00:33:51,000 --> 00:33:53,000
და მაშინ როგორ შესახებ ვინმე იქ მიმდინარეობს მიუთითა.

618
00:33:53,000 --> 00:33:57,000
თქვენ ხართ 34. Okay, 34, მოდის up.

619
00:33:57,000 --> 00:33:59,000
პირველი არის იქ. Okay, ოთხივე თქვენგანს ბიჭები.

620
00:33:59,000 --> 00:34:01,000
არიან და არ ვამბობთ, 9?

621
00:34:01,000 --> 00:34:04,000
ვინ არის ჩვენი 9?

622
00:34:04,000 --> 00:34:07,000
ვინ ნამდვილად სურს იყოს 9? ყველა უფლება ერთი, იყოს 9.

623
00:34:07,000 --> 00:34:10,000
Here We Go.

624
00:34:10,000 --> 00:34:13,000
34, ჩვენ შეგხვდებით იქ.

625
00:34:13,000 --> 00:34:17,000
პირველი ნაწილი არის მიიღოს თქუენგან ჰგავს, რომ.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, კარგი.

627
00:34:21,000 --> 00:34:25,000
თუ თქვენ დავდგეთ off იმ მხარეს, რადგან ჩვენ ვაპირებთ malloc თქვენ მომენტში.

628
00:34:25,000 --> 00:34:29,000
>> კარგი, კარგი.

629
00:34:29,000 --> 00:34:32,000
Okay, კარგი, მოდით ვკითხოთ რამდენიმე კითხვები აქ.

630
00:34:32,000 --> 00:34:34,000
და ფაქტობრივად, რა გქვია? >> Anita.

631
00:34:34,000 --> 00:34:37,000
ანიტა, okay, მოდის, მეტი აქ.

632
00:34:37,000 --> 00:34:41,000
Anita აპირებს დაგვეხმარება სახის გადაჭრას ერთი საკმაოდ მარტივი კითხვა პირველი,

633
00:34:41,000 --> 00:34:44,000
რომელიც როგორ მოვძებნოთ თუ არა მნიშვნელობა არის სიაში?

634
00:34:44,000 --> 00:34:48,000
ახლა, რომ პირველი, წარმოდგენილია აქ ლუკასი

635
00:34:48,000 --> 00:34:52,000
არის ცოტა განსხვავებული და ამიტომ მისი ნაჭერი ქაღალდი განზრახ sideways

636
00:34:52,000 --> 00:34:55,000
რადგან ეს არ საკმაოდ როგორც მაღალი და არ იღებს, როგორც ბევრი ბიტი,

637
00:34:55,000 --> 00:34:58,000
მიუხედავად იმისა, რომ ტექნიკურად მას იგივე ზომის ქაღალდი მხოლოდ გარდამავალია.

638
00:34:58,000 --> 00:35:01,000
მაგრამ ის ცოტა განსხვავებული, რომ ის მხოლოდ 32 ბიტი ამისთვის მაჩვენებელი,

639
00:35:01,000 --> 00:35:05,000
და ყველა ეს ბიჭები არიან 64 ბიტი, ნახევარი, რომელიც ნომერი, ნახევარი, რომელიც მაჩვენებელმა.

640
00:35:05,000 --> 00:35:08,000
მაგრამ მაჩვენებელი არ არის გამოსახული, ასე რომ, თუ თქვენ ბიჭები შეეძლო გარკვეულწილად უხერხულად

641
00:35:08,000 --> 00:35:12,000
გამოიყენოთ თქვენი მარცხენა ხელის აღვნიშნო დროს პირი შემდეგი თქვენ.

642
00:35:12,000 --> 00:35:14,000
და თქვენ ნომერი 34. რა არის შენი სახელი?

643
00:35:14,000 --> 00:35:16,000
Ari.

644
00:35:16,000 --> 00:35:19,000
Ari, ისე რეალურად, გამართავს ქაღალდის თქვენს მარჯვენა ხელი, და მარცხენა ხელის მიდის სწორი ქვემოთ.

645
00:35:19,000 --> 00:35:21,000
თქვენ წარმოადგენთ null მარცხენა.

646
00:35:21,000 --> 00:35:24,000
>> ახლა ჩვენი ადამიანის სურათს ძალიან თანმიმდევრული.

647
00:35:24,000 --> 00:35:26,000
ეს არის რეალურად როგორ პოინტერები მუშაობა.

648
00:35:26,000 --> 00:35:29,000
და თუ შეგიძლიათ scrunch ცოტა ამ გზით, ასე რომ მე არ ვარ თქვენი გზა.

649
00:35:29,000 --> 00:35:34,000
Anita აქ, იპოვეთ ჩემთვის ნომერი 22,

650
00:35:34,000 --> 00:35:40,000
მაგრამ ვივარაუდოთ შეზღუდვა არა ადამიანები ჩატარების up ცალი ქაღალდის,

651
00:35:40,000 --> 00:35:43,000
მაგრამ ეს სია, და თქვენ მხოლოდ ლუკას დავიწყოთ

652
00:35:43,000 --> 00:35:46,000
იმიტომ, რომ ის არის სიტყვასიტყვით პირველი მაჩვენებელი.

653
00:35:46,000 --> 00:35:51,000
დავუშვათ, რომ თავად არიან მაჩვენებელი, და ასე რომ თქვენ ძალიან აქვს უნარი ადგილამდე რაღაც.

654
00:35:51,000 --> 00:35:56,000
რატომ არ იწყება მიუთითებს ზუსტად რა Lucas არის მიუთითებს?

655
00:35:56,000 --> 00:35:58,000
კარგი, და ნება მომეცით მიიღოს ამ გარეთ მეტი აქ.

656
00:35:58,000 --> 00:36:04,000
მხოლოდ გულისთვის დისკუსია, ნება მომეცით დახევის up ცარიელი გვერდი აქ.

657
00:36:04,000 --> 00:36:06,000
როგორ მართლწერის თქვენი სახელი? >> Anita.

658
00:36:06,000 --> 00:36:08,000
Okay, ანიტა.

659
00:36:08,000 --> 00:36:18,000
ვთქვათ კვანძის * anita = ლუკასი.

660
00:36:18,000 --> 00:36:22,000
ასევე, ჩვენ არ უნდა მოვუწოდებთ თქვენ ლუკასი. ჩვენ უნდა მოვუწოდებთ თქვენ პირველი.

661
00:36:22,000 --> 00:36:25,000
რატომ არის ეს რეალურად შეესაბამება რეალობას?

662
00:36:25,000 --> 00:36:27,000
ერთი, პირველი უკვე არსებობს.

663
00:36:27,000 --> 00:36:30,000
პირველი გამოყოფილი სავარაუდოდ სადღაც აქ.

664
00:36:30,000 --> 00:36:35,000
Node * პირველი და ეს გამოყოფილი სიაში რატომღაც.

665
00:36:35,000 --> 00:36:37,000
არ ვიცი როგორ მოხდა, რომ. რაც მოხდა ადრე კლასის დაიწყო.

666
00:36:37,000 --> 00:36:40,000
ეს დაკავშირებულია სია ადამიანისა შეიქმნა.

667
00:36:40,000 --> 00:36:44,000
და ახლა ამ დროისთვის ამბავი ეს ყველაფერი ხდება Facebook სავარაუდოდ მოგვიანებით-

668
00:36:44,000 --> 00:36:49,000
ამ დროისთვის ამბავი, ანიტა უკვე ინიციალიზაცია იყოს თანაბარი პირველ,

669
00:36:49,000 --> 00:36:51,000
რაც არ ნიშნავს, რომ ანიტა ქულა Lucas.

670
00:36:51,000 --> 00:36:53,000
უფრო მეტიც, მან ქულა, თუ რას ქულა

671
00:36:53,000 --> 00:36:57,000
რადგან იგივე მისამართზე რომ შიგნით Lucas-ს 32 ბიტი - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
არის ასევე შიგნით ანიტა ს 32 ბიტი - 1, 2, 3.

673
00:37:01,000 --> 00:37:05,000
>> ახლა იპოვოს 22. როგორ წავიდეთ შესახებ ამით?

674
00:37:05,000 --> 00:37:07,000
რა არის ეს? >> წერტილი რასაც.

675
00:37:07,000 --> 00:37:11,000
წერტილი რასაც, ასე წავიდეთ წინ და იმოქმედოს ის, როგორც საუკეთესო შეგიძლიათ აქ.

676
00:37:11,000 --> 00:37:15,000
კარგი, კარგი, და ახლა თქვენ მიუთითებს რა არის თქვენი სახელი 22?

677
00:37:15,000 --> 00:37:18,000
რამონ. >> Ramon, ასე რამონ მართავს up 22.

678
00:37:18,000 --> 00:37:20,000
თქვენ ახლა კეთდება ქვითარი.

679
00:37:20,000 --> 00:37:24,000
ამჯამად რამონ == 22, და თუ ასეა, მაგალითად, ჩვენ შეგვიძლია იქნება TRUE.

680
00:37:24,000 --> 00:37:26,000
ნება მომეცით-ხოლო ეს ბიჭები დგანან აქ გარკვეულწილად უხერხულად-

681
00:37:26,000 --> 00:37:32,000
ნება მომეცით რაღაც სწრაფად მოსწონს bool იპოვოს.

682
00:37:32,000 --> 00:37:37,000
მე ვაპირებ წავიდეთ წინ და ვთქვათ (კვანძის * სიაში, int N).

683
00:37:37,000 --> 00:37:39,000
მე უფლებას უკან თქვენ ბიჭები. მე უბრალოდ უნდა დაეწერა რაღაც კოდი.

684
00:37:39,000 --> 00:37:45,000
და ახლა მე ვაპირებ წავიდეთ წინ და ამის გაკეთება, node * anita = სიაში.

685
00:37:45,000 --> 00:37:51,000
და მე ვაპირებ წავიდეთ წინ და აცხადებენ, ხოლო (anita = NULL).

686
00:37:51,000 --> 00:37:57,000
>> მეტაფორა აქ დღითიდღე პატარა გადაჭიმული, მაგრამ (anita = NULL), რა გსურთ?

687
00:37:57,000 --> 00:38:03,000
მჭირდება რამდენიმე გზა referencing

688
00:38:03,000 --> 00:38:05,000
მთელი რიცხვი, რომ ანიტა არის მიუთითებს.

689
00:38:05,000 --> 00:38:08,000
წარსულში, როდესაც ჩვენ გვქონდა სტრუქტურებში, რომლებიც კვანძში არის,

690
00:38:08,000 --> 00:38:11,000
ჩვენ გამოიყენება dot ნოტაცია და ჩვენ ვიტყოდი რაღაც

691
00:38:11,000 --> 00:38:15,000
anita.n, მაგრამ პრობლემა აქ ის არის, რომ ანიტა არ არის struct თავისთავად.

692
00:38:15,000 --> 00:38:17,000
რა არის იგი?

693
00:38:17,000 --> 00:38:21,000
შიზი მაჩვენებელი, ასე ნამდვილად, თუ ჩვენ გვინდა გამოვიყენოთ ეს dot ნოტაცია-

694
00:38:21,000 --> 00:38:23,000
და ამ აპირებს გამოიყურებოდეს განზრახ პატარა cryptic-

695
00:38:23,000 --> 00:38:28,000
ჩვენ უნდა გავაკეთოთ მსგავსი რამ წასვლა რასაც ანიტა მარცხენა ხელის მიუთითებს

696
00:38:28,000 --> 00:38:31,000
და შემდეგ კიდევ სფეროში მოუწოდა n.

697
00:38:31,000 --> 00:38:35,000
ანიტა არის კურსორი, მაგრამ რა არის * anita?

698
00:38:35,000 --> 00:38:38,000
რას პოულობენ, როდესაც მიდიხარ რა ანიტა არის მიუთითებს?

699
00:38:38,000 --> 00:38:42,000
Struct, კვანძში, და კვანძის, გაწვევას, აქვს სფეროში მოუწოდა N

700
00:38:42,000 --> 00:38:47,000
იმიტომ, რომ მან, გავიხსენოთ, ამ 2 სფეროებში, შემდეგი და n,

701
00:38:47,000 --> 00:38:50,000
რომ დავინახეთ მომენტში წინ სწორედ აქ.

702
00:38:50,000 --> 00:38:53,000
>> რეალურად იმიტაცია ამ კოდის,

703
00:38:53,000 --> 00:39:02,000
ჩვენ შეგვიძლია ამის გაკეთება და ვთქვათ თუ ((* anita). N == N), n, რომ ვეძებ.

704
00:39:02,000 --> 00:39:04,000
გაითვალისწინეთ, რომ ფუნქცია იყო მიღებული ხმების მე აღელვებთ.

705
00:39:04,000 --> 00:39:10,000
მაშინ შემიძლია წავიდეთ წინ და რაღაც მოსწონს დაბრუნების ჭეშმარიტი.

706
00:39:10,000 --> 00:39:12,000
სხვაგან, თუ ეს ასე არ არის საქმე, რა გსურთ?

707
00:39:12,000 --> 00:39:19,000
როგორ შემიძლია თარგმნა ენაზე კოდი რა ანიტა გააკეთა ინტუიციურად გავლით სიაში?

708
00:39:19,000 --> 00:39:26,000
რა უნდა გავაკეთოთ, აქ სიმულაცია ანიტა აღების, რომ ნაბიჯი მარცხნივ, რომ ნაბიჯი მარცხნივ?

709
00:39:26,000 --> 00:39:28,000
[Inaudible სტუდენტი საპასუხოდ] >> რა არის რომ?

710
00:39:28,000 --> 00:39:30,000
[Inaudible სტუდენტი საპასუხოდ]

711
00:39:30,000 --> 00:39:34,000
კარგი, არ არის ცუდი იდეა, მაგრამ წარსულში, როდესაც ჩვენ გავაკეთეთ, ჩვენ გავაკეთეთ anita + +

712
00:39:34,000 --> 00:39:37,000
იმიტომ, რომ დაამატოთ ნომერი 1 დან ანიტა,

713
00:39:37,000 --> 00:39:40,000
რომელმაც შესაძლოა ტიპიურად აღვნიშნო მომდევნო პირი, ისევე როგორც Ramon,

714
00:39:40,000 --> 00:39:44,000
ან პირის შემდეგი თქმით, თუ მომდევნო მას პირი ქვემოთ ხაზი.

715
00:39:44,000 --> 00:39:49,000
მაგრამ ეს არ არის საკმაოდ კარგი აქ იმიტომ რას რამ ჰგავს მეხსიერებაში?

716
00:39:49,000 --> 00:39:54,000
არა. ჩვენ უნდა გამორთოთ, რომ.

717
00:39:54,000 --> 00:40:00,000
როგორც ჩანს ეს მეხსიერებაში და მიუხედავად იმისა, რომ მე შედგენილი 1 და 2 და 3 ახლოს ერთმანეთთან,

718
00:40:00,000 --> 00:40:03,000
თუ ჩვენ ნამდვილად სიმულაცია ამ-შეგიძლიათ ბიჭები, მიუხედავად მიუთითებს იგივე ადამიანები,

719
00:40:03,000 --> 00:40:07,000
შეიძლება ზოგიერთ თქვენგანს მიიღოს შემთხვევითი ნაბიჯი უკან, ზოგიერთი თქვენგანი შემთხვევითი წინგადადგმული ნაბიჯი?

720
00:40:07,000 --> 00:40:10,000
>> ეს სასადილო ჯერ კიდევ დაკავშირებული სიაში,

721
00:40:10,000 --> 00:40:13,000
მაგრამ ეს ბიჭები შეიძლება სადმე მეხსიერება,

722
00:40:13,000 --> 00:40:15,000
ასე anita + + არ იმუშავებს, თუ რატომ?

723
00:40:15,000 --> 00:40:19,000
რა დროს საიდან anita + +?

724
00:40:19,000 --> 00:40:21,000
ვინ იცის.

725
00:40:21,000 --> 00:40:24,000
ეს რაღაც სხვა მნიშვნელობა, რომელიც მხოლოდ ასე ხდება უნდა interposed

726
00:40:24,000 --> 00:40:28,000
შორის ყველა ამ კვანძების მიერ შანსი, რადგან ჩვენ არ იყენებს მასივი.

727
00:40:28,000 --> 00:40:30,000
ჩვენ გამოყოფილი თითოეული ამ კვანძების ინდივიდუალურად.

728
00:40:30,000 --> 00:40:32,000
Okay, თუ ბიჭები შეიძლება გაწმენდა თქუენგან უკან მდე.

729
00:40:32,000 --> 00:40:37,000
ნება მომეცით ინიციატივით კი, ნაცვლად anita + +, ჩვენ ნაცვლად გააკეთოს anita იღებს-

730
00:40:37,000 --> 00:40:42,000
ასევე, რატომ არ გვაქვს წასვლა რასაც ანიტა არის მიუთითებს და მერე გავაკეთოთ. შემდეგი?

731
00:40:42,000 --> 00:40:45,000
სხვა სიტყვებით, ჩვენ წასვლა Ramon, რომელიც ჩატარების ნომერი 22,

732
00:40:45,000 --> 00:40:51,000
და შემდეგ. შემდეგი არის თითქოს ანიტა იქნება კოპირება მისი მარცხენა ხელის მაჩვენებელი.

733
00:40:51,000 --> 00:40:54,000
მაგრამ მან წასვლა არ შემდგომი ვიდრე რამონ რადგან აღმოვაჩინეთ 22.

734
00:40:54,000 --> 00:40:56,000
მაგრამ ეს იქნება იდეა. ახლა, ეს არის ღვთის საშინელი ხმაური.

735
00:40:56,000 --> 00:40:59,000
პატიოსნად, ვერავინ გახსოვთ ეს სინტაქსი და ა.შ. საბედნიეროდ,

736
00:40:59,000 --> 00:41:04,000
სინამდვილეში პატარა მიზანმიმართული-oh, თქვენ არ რეალურად ვხედავ რა დავწერე.

737
00:41:04,000 --> 00:41:08,000
ეს იქნება უფრო მყარი, თუ თქვენ შეიძლება. Voila!

738
00:41:08,000 --> 00:41:10,000
>> კულისებში, მე პრობლემის გადაჭრის ამ გზით.

739
00:41:10,000 --> 00:41:14,000
ანიტა, მიიღოს ეს ნაბიჯი მარცხნივ,

740
00:41:14,000 --> 00:41:18,000
პირველი, ჩვენ გადადით მისამართზე, რომელიც ანიტა არის მიუთითებს

741
00:41:18,000 --> 00:41:23,000
და სადაც იგი იპოვის არა მხოლოდ N, რომელიც ჩვენ მხოლოდ შემოწმდება შედარებით ის გულისთვის,

742
00:41:23,000 --> 00:41:25,000
მაგრამ თქვენ ასევე მოვძებნოთ შემდეგი - ამ შემთხვევაში,

743
00:41:25,000 --> 00:41:28,000
რამონ მარცხენა მხრივ მიუთითებს შემდეგი კვანძის სიაში.

744
00:41:28,000 --> 00:41:32,000
მაგრამ ეს ღვთის საშინელი ხმაური, რომლის მე მოხსენიებული ადრე,

745
00:41:32,000 --> 00:41:34,000
მაგრამ აღმოჩნდება, C საშუალებას გვაძლევს გავამარტივოთ ამ.

746
00:41:34,000 --> 00:41:40,000
ნაცვლად წერა (* anita), ჩვენ შეგვიძლია ნაცვლად მხოლოდ წერენ anita-> n,

747
00:41:40,000 --> 00:41:45,000
და ეს ზუსტად იმავეს ფუნქციურად, მაგრამ ბევრად უფრო ინტუიტიური,

748
00:41:45,000 --> 00:41:48,000
და ეს ბევრად უფრო შეესაბამება სურათზე რომ ჩვენ ხატვის

749
00:41:48,000 --> 00:41:50,000
მთელი ამ ხნის გამოყენებით ისრებით.

750
00:41:50,000 --> 00:41:57,000
>> და ბოლოს, რას უნდა გავაკეთოთ დასასრულს ამ პროგრამის?

751
00:41:57,000 --> 00:42:00,000
თუმცა ერთი ხაზი კოდი დარჩენილი.

752
00:42:00,000 --> 00:42:02,000
დაბრუნება რა?

753
00:42:02,000 --> 00:42:05,000
ყალბი, რადგან თუ არ მივიღებთ მთელ ხოლო loop

754
00:42:05,000 --> 00:42:10,000
და ანიტა არის, ფაქტობრივად, null, რაც იმას ნიშნავს, მან ყველა გზა ბოლომდე სია

755
00:42:10,000 --> 00:42:12,000
სადაც ის მიუთითებს რა არის თქვენი სახელი კვლავ?

756
00:42:12,000 --> 00:42:15,000
Ari. >> Ari მარცხენა მხრივ, რომელიც null.

757
00:42:15,000 --> 00:42:18,000
ანიტა არის null, და ვხვდები, თქვენ მხოლოდ ვდგავართ აქ უხერხულად წელს ჰაერშია გამოკიდებული

758
00:42:18,000 --> 00:42:21,000
რადგან მე ვაპირებ off on მონოლოგი აქ,

759
00:42:21,000 --> 00:42:23,000
მაგრამ ჩვენ ჩართვას კიდევ ერთხელ რაღაც მომენტში.

760
00:42:23,000 --> 00:42:27,000
ანიტა არის null იმ მომენტში ამბავი, ასე ხოლო loop წყვეტს,

761
00:42:27,000 --> 00:42:30,000
და ჩვენ გვაქვს დასაბრუნებელი ცრუ, რადგან თუ მან შეიძინა ყველა გზა Ari ს null მაჩვენებელი

762
00:42:30,000 --> 00:42:34,000
მაშინ არ იყო ნომერი, რომელიც მან ვეძებოთ სიაში.

763
00:42:34,000 --> 00:42:39,000
ჩვენ შეგვიძლია გაწმენდა ამ up ძალიან, მაგრამ ეს არის საკმაოდ კარგი განხორციელების შემდეგ

764
00:42:39,000 --> 00:42:43,000
საქართველოს გასვლის ფუნქცია, იპოვოს ფუნქცია უკავშირდება სიაში.

765
00:42:43,000 --> 00:42:48,000
ეს ჯერ კიდევ ხაზოვანი ძებნა, მაგრამ არ იმდენად მარტივია, + + კურსორი

766
00:42:48,000 --> 00:42:52,000
ან + + მე ცვლადი რადგან ახლა ჩვენ ვერ ვხვდები,

767
00:42:52,000 --> 00:42:54,000
სადაც თითოეულ ამ კვანძების არიან მეხსიერებაში.

768
00:42:54,000 --> 00:42:57,000
ჩვენ უნდა დაიცვას სიტყვასიტყვით ბილიკი breadcrumbs ან, უფრო კონკრეტულად,

769
00:42:57,000 --> 00:43:00,000
პოინტერები, მიიღოს ერთი კვანძის სხვა.

770
00:43:00,000 --> 00:43:02,000
>> ახლა მოდით შევეცადოთ კიდევ ერთი. ანიტა, გსურთ დავბრუნდებით აქ?

771
00:43:02,000 --> 00:43:06,000
რატომ არ ვართ წავიდეთ წინ და გამოყოფს ერთ სხვა პირს აუდიტორიის?

772
00:43:06,000 --> 00:43:08,000
Malloc-რა გქვია? >> რებეკა.

773
00:43:08,000 --> 00:43:10,000
რებეკა. რებეკა უკვე malloced საწყისი აუდიტორიას,

774
00:43:10,000 --> 00:43:13,000
და ქალი არის შენახვის ნომერი 55.

775
00:43:13,000 --> 00:43:17,000
და მიზანი ხელთ არის არის ანიტა ჩასასმელად

776
00:43:17,000 --> 00:43:22,000
რებეკა შევიდა უკავშირდება სია აქ თავის შესაბამის ადგილზე.

777
00:43:22,000 --> 00:43:24,000
Come on მეტი აქ ერთი მომენტი.

778
00:43:24,000 --> 00:43:28,000
მე არ კეთდება მსგავსი რამ.

779
00:43:28,000 --> 00:43:32,000
მე არ კეთდება კვანძის *. და რაც თქვენი სახელი კვლავ?

780
00:43:32,000 --> 00:43:34,000
რებეკა. >> რებეკა, okay.

781
00:43:34,000 --> 00:43:41,000
რებეკა იღებს malloc (sizeof (კვანძის)).

782
00:43:41,000 --> 00:43:44,000
ისევე, როგორც ჩვენ გამოყოფილი რამ, როგორიცაა სტუდენტებისა და whatnot წარსულში,

783
00:43:44,000 --> 00:43:46,000
ჩვენ გვჭირდება ზომის კვანძი, ამიტომ ახლა რებეკა

784
00:43:46,000 --> 00:43:49,000
არის მიუთითებს რა?

785
00:43:49,000 --> 00:43:52,000
რებეკა აქვს ორი სფეროებში შიგნით მისი, რომელთაგან ერთი 55.

786
00:43:52,000 --> 00:43:55,000
მოდით რა, რებეკა-> = 55.

787
00:43:55,000 --> 00:44:00,000
მაგრამ შემდეგ რებეკა-> მომავალი უნდა მსგავსი ახლავე, თავის მხრივ არის ერთგვარი ვინ იცის?

788
00:44:00,000 --> 00:44:03,000
ეს მიუთითებს ზოგიერთი ნაგვის ღირებულება, ასე რომ რატომ არ კარგი ღონისძიება

789
00:44:03,000 --> 00:44:07,000
ჩვენ მინიმუმ ამის გაკეთება ისე, რომ მარცხენა ხელის არის მის მხარეს.

790
00:44:07,000 --> 00:44:09,000
ახლა ანიტა, მას აქედან.

791
00:44:09,000 --> 00:44:11,000
თქვენ გაქვთ რებეკა რომელმაც გამოიყო.

792
00:44:11,000 --> 00:44:20,000
წავიდეთ წინ და იპოვოს, სადაც ჩვენ უნდა დააყენოს რებეკა.

793
00:44:20,000 --> 00:44:25,000
კარგი, ძალიან კარგი.

794
00:44:25,000 --> 00:44:28,000
Okay, კარგი, და ახლა ჩვენ თქვენ გვჭირდებით, რომ უზრუნველყოს ცოტა მიმართულებით,

795
00:44:28,000 --> 00:44:30,000
ასე თქვენ მიაღწია Ari.

796
00:44:30,000 --> 00:44:33,000
მისი მარცხენა ხელი null, მაგრამ რებეკა ნათლად ეკუთვნის უფლება,

797
00:44:33,000 --> 00:44:36,000
ასე როგორ უნდა უნდა შეცვალოს ამ ბმის სია

798
00:44:36,000 --> 00:44:38,000
რათა ჩადეთ რებეკა შევიდა შესაბამის ადგილზე?

799
00:44:38,000 --> 00:44:42,000
თუ შეიძლება სიტყვასიტყვით გადავა ხალხის ხელში მარცხენა გარშემო როგორც საჭიროა,

800
00:44:42,000 --> 00:44:48,000
ჩვენ დაფიქსირება პრობლემა რომ გზა.

801
00:44:48,000 --> 00:44:52,000
Okay, კარგი, და იმავდროულად, რებეკა მარცხენა ხელით არის მისი მხრიდან.

802
00:44:52,000 --> 00:44:54,000
>> ეს იყო ძალიან ადვილი.

803
00:44:54,000 --> 00:44:57,000
მოდით ვეცადოთ გამოყოფის-we're თითქმის გაკეთდეს, 20.

804
00:44:57,000 --> 00:44:59,000
Okay, მოდის up.

805
00:44:59,000 --> 00:45:04,000
20 გამოეყო, ნება მომეცით, წავიდეთ წინ და ვთქვათ ერთხელ აქ

806
00:45:04,000 --> 00:45:07,000
ჩვენ უბრალოდ გაკეთდეს კვანძის * saad.

807
00:45:07,000 --> 00:45:11,000
ჩვენ გვყავს malloc (sizeof (კვანძის)).

808
00:45:11,000 --> 00:45:16,000
ჩვენ მაშინ იგივე ზუსტი სინტაქსი როგორც გავაკეთეთ ადრე, 20,

809
00:45:16,000 --> 00:45:20,000
და მე გავაკეთებ შემდეგი = NULL, და ახლა ეს მდე ანიტა

810
00:45:20,000 --> 00:45:23,000
ჩასასმელად თქვენ შევიდა უკავშირდება სია, თუ შეუძლიათ, რომ ზუსტად იგივე როლი.

811
00:45:23,000 --> 00:45:30,000
შეასრულოს.

812
00:45:30,000 --> 00:45:32,000
Okay, კარგი.

813
00:45:32,000 --> 00:45:38,000
ახლა ყურადღებით იფიქრეთ თქვენს წინაშე დაიწყება მოძრავი მარცხენა ხელში გარშემო.

814
00:45:38,000 --> 00:45:46,000
თქვენ ბევრად მიიღო საუკეთესო უხერხულ როლი დღეს.

815
00:45:46,000 --> 00:45:59,000
ვისი ხელით უნდა გადავიდნენ პირველი?

816
00:45:59,000 --> 00:46:02,000
Okay, დაველოდოთ, მე მოსმენის გარკვეული არ იყო.

817
00:46:02,000 --> 00:46:07,000
თუ FOLKS რომ თავაზიანად მინდა დაეხმარება გადაჭრას უხერხულ მდგომარეობაში აქ.

818
00:46:07,000 --> 00:46:11,000
ვისი მარცხენა ხელის უნდა განახლდეს პირველი ალბათ? Yeah.

819
00:46:11,000 --> 00:46:13,000
[სტუდენტური] Saad-ს.

820
00:46:13,000 --> 00:46:15,000
Okay, Saad-ს, თუ რატომ, თუმცა?

821
00:46:15,000 --> 00:46:17,000
[Inaudible სტუდენტი საპასუხოდ]

822
00:46:17,000 --> 00:46:19,000
კარგი, რადგან თუ ჩვენ გადაადგილება-რა გქვია? >> მარშალის.

823
00:46:19,000 --> 00:46:22,000
მარშალის, თუ ჩვენ გადაადგილება თავისი ხელით პირველ ქვემოთ null,

824
00:46:22,000 --> 00:46:25,000
ახლა ჩვენ სიტყვასიტყვით ობოლი ოთხი ადამიანი ამ სიაში

825
00:46:25,000 --> 00:46:29,000
რადგან იგი ერთადერთი მიუთითებს რამონ და ყველას მარცხენა

826
00:46:29,000 --> 00:46:31,000
ასე განახლებას რომ კურსორი პირველი იყო ცუდი.

827
00:46:31,000 --> 00:46:33,000
მოდით გაუქმება, რომ.

828
00:46:33,000 --> 00:46:37,000
კარგი, ახლა წავიდეთ წინ და გადატანა შესაბამისი მარცხენა მიუთითებს რამონ.

829
00:46:37,000 --> 00:46:39,000
ეს გრძნობს პატარა გადაჭარბებული.

830
00:46:39,000 --> 00:46:41,000
ახლა ორი ადამიანი მიუთითებს Ramon, მაგრამ ეს ჯარიმა

831
00:46:41,000 --> 00:46:43,000
რადგან ახლა როგორ სხვაგან უნდა განახლდეს სიაში?

832
00:46:43,000 --> 00:46:48,000
რა მხრივ უნდა გადავიდეს?

833
00:46:48,000 --> 00:46:53,000
შესანიშნავი, ახლა ჩვენ დავკარგეთ ნებისმიერი მეხსიერების?

834
00:46:53,000 --> 00:46:57,000
არა, იმდენად კარგი, ვნახოთ, შევძლებთ თუ არა დაარღვიოს ამ კიდევ ერთხელ.

835
00:46:57,000 --> 00:47:00,000
>> Mallocing ერთი ბოლო დროს, ნომერი 5.

836
00:47:00,000 --> 00:47:04,000
ყველა გზა უკან, მოდის ქვემოთ.

837
00:47:04,000 --> 00:47:08,000
ძალიან საინტერესო.

838
00:47:08,000 --> 00:47:15,000
[ტაში]

839
00:47:15,000 --> 00:47:17,000
რა არის შენი სახელი? >> რონ.

840
00:47:17,000 --> 00:47:19,000
რონ, okay, თქვენ malloced როგორც ნომერი 5.

841
00:47:19,000 --> 00:47:23,000
ჩვენ უბრალოდ დახვრიტეს კოდი, რომელიც თითქმის იდენტურია ამ

842
00:47:23,000 --> 00:47:26,000
მხოლოდ სხვა სახელი.

843
00:47:26,000 --> 00:47:28,000
შესანიშნავი.

844
00:47:28,000 --> 00:47:38,000
ახლა, ანიტა, წარმატებას გისურვებთ ჩასმა ხმების 5 შევიდა სიაში ახლა.

845
00:47:38,000 --> 00:47:43,000
კარგი, და?

846
00:47:43,000 --> 00:47:47,000
შესანიშნავი, ასე რომ, ეს ნამდვილად მესამე სამი სულ შემთხვევებში.

847
00:47:47,000 --> 00:47:49,000
ჩვენ პირველი ჰქონდა ვიღაცას დასასრულს, რებეკა.

848
00:47:49,000 --> 00:47:51,000
ჩვენ მაშინ ჰქონდა ვიღაცას შუა.

849
00:47:51,000 --> 00:47:53,000
ახლა ჩვენ გვაქვს ვინმე დასაწყისში, და ამ მაგალითად,

850
00:47:53,000 --> 00:47:56,000
ჩვენ ახლა განაახლოთ Lucas პირველად

851
00:47:56,000 --> 00:48:00,000
რადგან პირველ ელემენტს სიაში ახლა აღვნიშნო ახალ კვანძში,

852
00:48:00,000 --> 00:48:03,000
ვინც, თავის მხრივ, არის მიუთითებს კვანძის ნომერი 9.

853
00:48:03,000 --> 00:48:06,000
>> ეს იყო უკიდურესად უხერხულ დემონსტრირება, დარწმუნებული ვარ,

854
00:48:06,000 --> 00:48:08,000
ასე დიდი რაუნდი ტაში ამ ბიჭებს თუ თქვენ შეიძლება.

855
00:48:08,000 --> 00:48:11,000
ლამაზად კეთდება.

856
00:48:11,000 --> 00:48:17,000
ეს იყო. თქვენ შესაძლებელია ჩაწეროთ ცალი ქაღალდის, როგორც პატარა მეხსიერება.

857
00:48:17,000 --> 00:48:22,000
თურმე ამით კოდის

858
00:48:22,000 --> 00:48:26,000
დიდი ხნის არ არის იმდენად მარტივია, უბრალოდ მოძრავი ხელში გარშემო

859
00:48:26,000 --> 00:48:28,000
და მიუთითებს პოინტერები სხვადასხვა ნივთები.

860
00:48:28,000 --> 00:48:31,000
მაგრამ ვაცნობიერებთ, რომ როდესაც საქმე დროის განახორციელოს მსგავსი რამ

861
00:48:31,000 --> 00:48:34,000
უკავშირდება სიაში ან ვარიანტი, თუ ფოკუსირება ნამდვილად

862
00:48:34,000 --> 00:48:38,000
ამ ძირითადი საფუძვლები, bite ზომის პრობლემები უნდა გაერკვნენ,

863
00:48:38,000 --> 00:48:43,000
არის ამ მხრივ ან ამ მხრივ, გვესმოდეს, რომ ის არის სხვაგვარად საკმაოდ კომპლექსური პროგრამა

864
00:48:43,000 --> 00:48:47,000
შეიძლება, ფაქტობრივად, მცირდება საკმაოდ მარტივია შენობის ბლოკების მოსწონს ეს.

865
00:48:47,000 --> 00:48:51,000
>> ავიღოთ რამ უფრო დახვეწილი მიმართულება მაინც.

866
00:48:51,000 --> 00:48:53,000
ჩვენ ახლა აქვს ცნება დაკავშირებულია სიაში.

867
00:48:53,000 --> 00:48:57,000
ჩვენ ასევე გვაქვს-წყალობით წინადადება თავში იქ-ორმაგად უკავშირდება სია,

868
00:48:57,000 --> 00:49:01,000
რომელიც გამოიყურება თითქმის იგივე, მაგრამ ახლა ჩვენ ორი პოინტერები შიგნით struct

869
00:49:01,000 --> 00:49:05,000
ერთის ნაცვლად, და ჩვენ შეგვიძლია ალბათ მოვუწოდებთ მათ მითითებას წინა და შემდეგი

870
00:49:05,000 --> 00:49:08,000
ან მარცხნივ ან მარჯვნივ, მაგრამ ჩვენ, ფაქტობრივად, გვჭირდება ორი მათგანი.

871
00:49:08,000 --> 00:49:10,000
კოდი იქნებოდა ცოტა მეტი ჩართული.

872
00:49:10,000 --> 00:49:12,000
Anita ექნებოდა უფრო მეტი მუშაობა აქ სცენაზე.

873
00:49:12,000 --> 00:49:15,000
მაგრამ ჩვენ ნამდვილად განახორციელოს ისეთი სტრუქტურა.

874
00:49:15,000 --> 00:49:19,000
თვალსაზრისით გაშვებული დრო, თუმცა, რა იქნება გაშვებული დრო

875
00:49:19,000 --> 00:49:24,000
ამისთვის ანიტა მოძიების ნომერი N ში დაუკავშირა სია არის?

876
00:49:24,000 --> 00:49:27,000
ჯერ კიდევ დიდი O of n, ამიტომ არ უკეთესად ხაზოვანი ძებნა.

877
00:49:27,000 --> 00:49:29,000
ჩვენ არ შეგვიძლია გავაკეთოთ ორობითი ძებნა, თუმცა, კიდევ ერთხელ.

878
00:49:29,000 --> 00:49:34,000
რატომ იყო, რომ საქმე? თქვენ არ შეგიძლიათ ხტომა გარშემო.

879
00:49:34,000 --> 00:49:36,000
მიუხედავად იმისა, რომ ჩვენ აშკარად ყველა ადამიანისა სცენაზე,

880
00:49:36,000 --> 00:49:39,000
და ანიტა შეეძლო eyeballed იგი და თქვა: "აქ არის შუა სია"

881
00:49:39,000 --> 00:49:42,000
იგი აღარ იციან, რომ თუ ის იყო კომპიუტერული პროგრამა

882
00:49:42,000 --> 00:49:47,000
რადგან ერთადერთი, რაც მას უნდა latch შესახებ, რომ დაწყების სცენარი

883
00:49:47,000 --> 00:49:50,000
იყო ლუკას, რომელიც იყო პირველი მაჩვენებელი.

884
00:49:50,000 --> 00:49:53,000
მან აუცილებლად უნდა დაიცვას ეს კავშირები,

885
00:49:53,000 --> 00:49:56,000
დათვლის მიმავალი სანამ ნაპოვნია უხეშად შუა,

886
00:49:56,000 --> 00:49:58,000
და მაშინაც, იგი არ აპირებს იცით, როდესაც მან მიაღწია შუა

887
00:49:58,000 --> 00:50:01,000
მოხდება მისი მიდის ყველა გზა ბოლომდე უნდა გაერკვნენ, თუ რამდენი არსებობს,

888
00:50:01,000 --> 00:50:05,000
მაშინ backtracks, და რომ ძალიან იქნება რთული, თუ არ გქონდათ

889
00:50:05,000 --> 00:50:07,000
ორმაგად უკავშირდება სიაში გარკვეული.

890
00:50:07,000 --> 00:50:10,000
>> გადაჭრის გარკვეული პრობლემები, თუმცა შემოღების სხვები.

891
00:50:10,000 --> 00:50:12,000
რაც შეეხება სხვადასხვა მონაცემები სტრუქტურა საერთოდ?

892
00:50:12,000 --> 00:50:15,000
ეს არის ფოტოსურათი ქაღალდის წელს Mather სახლი,

893
00:50:15,000 --> 00:50:19,000
და ამ შემთხვევაში, ჩვენ გვაქვს მონაცემები სტრუქტურა ჩვენ ასევე სახის უკვე საუბარი.

894
00:50:19,000 --> 00:50:22,000
ჩვენ ვისაუბრეთ დასტის კონტექსტში მეხსიერება,

895
00:50:22,000 --> 00:50:26,000
და ეს ერთგვარი განზრახ დაასახელა, რადგან დასტის წელს თვალსაზრისით მეხსიერების

896
00:50:26,000 --> 00:50:31,000
არის ეფექტურად მონაცემები სტრუქტურა, რომელსაც აქვს უფრო და უფრო პერსონალის ფენიანი თავზე მას.

897
00:50:31,000 --> 00:50:35,000
მაგრამ საინტერესო ის დასტის, როგორც ეს სინამდვილეში,

898
00:50:35,000 --> 00:50:38,000
ის არის, რომ ეს არის განსაკუთრებული სახის მონაცემები სტრუქტურა.

899
00:50:38,000 --> 00:50:42,000
ეს მონაცემები სტრუქტურა, რომლის დროსაც პირველი ელემენტია

900
00:50:42,000 --> 00:50:46,000
არის ბოლო ელემენტს გარეთ.

901
00:50:46,000 --> 00:50:50,000
თუ თქვენ ხართ პირველი უჯრა უნდა დააყენოს გადატანა დასტის,

902
00:50:50,000 --> 00:50:53,000
თქვენ იქნება სამწუხაროდ ბოლო უჯრა იქნას off დასტის,

903
00:50:53,000 --> 00:50:55,000
და ეს არ არის აუცილებლად კარგია.

904
00:50:55,000 --> 00:50:58,000
პირიქით, შეგიძლიათ დაფიქრდით პირიქით,

905
00:50:58,000 --> 00:51:02,000
ბოლო წელს არის პირველი გარეთ.

906
00:51:02,000 --> 00:51:05,000
>> ახლა რაიმე სცენარი მოვიდა იბადება სადაც მქონე დასტის

907
00:51:05,000 --> 00:51:08,000
მონაცემები სტრუქტურა, სადაც თქვენ, რომ საკუთრების

908
00:51:08,000 --> 00:51:13,000
უკანასკნელი წელს, პირველი გარეთ, ფაქტობრივად აიძულებს?

909
00:51:13,000 --> 00:51:16,000
ის არის, რომ კარგია? ის არის, რომ ცუდი რამ?

910
00:51:16,000 --> 00:51:19,000
ეს ნამდვილად ცუდი რამ თუ უჯრები არ იყო ყველა იდენტური

911
00:51:19,000 --> 00:51:21,000
და ისინი ყველა სპეციალური სხვადასხვა ფერის ან whatnot,

912
00:51:21,000 --> 00:51:24,000
და ფერი გნებავთ არის ყველა გზა ბოლოში.

913
00:51:24,000 --> 00:51:26,000
რა თქმა უნდა, თქვენ ვერ იღებს გარეშე დიდი ძალისხმევა.

914
00:51:26,000 --> 00:51:28,000
თქვენ უნდა დაიწყოს ზემოდან და მუშაობა თქვენი გზა down.

915
00:51:28,000 --> 00:51:31,000
ანალოგიურად, რა თუ იყო ერთი ამ გულშემატკივართა ბიჭები

916
00:51:31,000 --> 00:51:34,000
ვინც ელოდება Up All Night ცდილობს iPhone და ხაზების up

917
00:51:34,000 --> 00:51:36,000
ადგილზე ასე?

918
00:51:36,000 --> 00:51:40,000
არ იქნება ლამაზი თუ Apple მაღაზია

919
00:51:40,000 --> 00:51:42,000
იყო დასტის მონაცემები სტრუქტურა?

920
00:51:42,000 --> 00:51:44,000
YAY? Nay?

921
00:51:44,000 --> 00:51:47,000
ეს მხოლოდ კარგი ადამიანები, რომლებიც გამოჩნდება უკანასკნელ შესაძლო წუთი

922
00:51:47,000 --> 00:51:50,000
და შემდეგ მიიღოს plucked off რიგიდან.

923
00:51:50,000 --> 00:51:52,000
და რეალურად, ის ფაქტი, რომ მე ასე ვაპირებთ ამბობენ მდგომ

924
00:51:52,000 --> 00:51:56,000
ფაქტიურად შეესაბამება რასაც ჩვენ მოვუწოდებთ ამ სახის მონაცემები სტრუქტურის,

925
00:51:56,000 --> 00:51:59,000
ერთი რეალურად სადაც წესრიგი არ აქვს მნიშვნელობა,

926
00:51:59,000 --> 00:52:02,000
და გსურთ პირველი ერთი იქნება პირველი გარეთ

927
00:52:02,000 --> 00:52:04,000
თუ მხოლოდ გულისთვის ადამიანის სამართლიანობისა.

928
00:52:04,000 --> 00:52:07,000
ჩვენ ზოგადად მოვუწოდებთ, რომ რიგი მონაცემები სტრუქტურა.

929
00:52:07,000 --> 00:52:11,000
>> თურმე გარდა უკავშირდება სიები, ჩვენ შეგვიძლია დავიწყოთ გამოყენებით ამ საერთო ძირითადი იდეები

930
00:52:11,000 --> 00:52:15,000
და დაიწყოს შეიქმნას ახალი და სხვადასხვა სახის იმ პრობლემების გადასაჭრელად.

931
00:52:15,000 --> 00:52:19,000
მაგალითად, იმ შემთხვევაში, დასტის, შეიძლება წარმოადგენდეს დასტის

932
00:52:19,000 --> 00:52:22,000
გამოყენებით მონაცემების სტრუქტურას ასე, მინდა შესთავაზოს.

933
00:52:22,000 --> 00:52:26,000
ამ შემთხვევაში, მე განაცხადა struct, და მე განაცხადა შიგნით ამ სტრუქტურის

934
00:52:26,000 --> 00:52:30,000
არის მასივი ნომრები და შემდეგ ცვლადში ზომა,

935
00:52:30,000 --> 00:52:33,000
და ვაპირებ მოვუწოდო ამ რამ Stack.

936
00:52:33,000 --> 00:52:35,000
ახლა, რატომ ამ რეალურად მუშაობს?

937
00:52:35,000 --> 00:52:43,000
იმ შემთხვევაში, დასტის, მე ვერ მიაპყროს ამ ეფექტურად ეკრანზე როგორც მასივი.

938
00:52:43,000 --> 00:52:47,000
აქ არის ჩემი Stack. ეს ის ჩემი ნომრები.

939
00:52:47,000 --> 00:52:50,000
და ჩვენ დავხატოთ მათ ამ, ამ, ამ, ამ, ამ.

940
00:52:50,000 --> 00:52:53,000
და მერე გარკვეული სხვა მონაცემები წევრი აქ,

941
00:52:53,000 --> 00:52:58,000
რომელსაც ზომა, ასე რომ, ეს ზომა, და ეს ნომრები,

942
00:52:58,000 --> 00:53:02,000
და ერთობლივად, მთელი iPad აქ წარმოადგენს ერთ დასტის სტრუქტურა.

943
00:53:02,000 --> 00:53:07,000
ახლა, ცხადია, ზომა სავარაუდოდ რაღაც უნდა იყოს ინიციალიზაცია 0,

944
00:53:07,000 --> 00:53:11,000
და რაც შიგნით მასივი ნომრები თავდაპირველად

945
00:53:11,000 --> 00:53:14,000
როდესაც მე პირველად გამოყოფს მასივი?

946
00:53:14,000 --> 00:53:16,000
Garbage. ვინ იცის? და ეს ფაქტობრივად არ აქვს.

947
00:53:16,000 --> 00:53:20,000
არ აქვს მნიშვნელობა, თუ ეს 1, 2, 3, 4, 5, სრულიად შემთხვევით

948
00:53:20,000 --> 00:53:25,000
ცუდი იღბალი შენახული ჩემი სტრუქტურა, რადგან, თუ ვიცი, რომ ზომის დასტის

949
00:53:25,000 --> 00:53:29,000
არის 0, მაშინ მე ვიცი, პროგრამულად, არ შევხედოთ ნებისმიერი ელემენტების მასივი.

950
00:53:29,000 --> 00:53:31,000
არ აქვს მნიშვნელობა, რა იქ.

951
00:53:31,000 --> 00:53:34,000
ნუ შეხედავს მათ, როგორც იქნებოდა გავლენა საქართველოს ზომის 0.

952
00:53:34,000 --> 00:53:38,000
>> მაგრამ ვარაუდობენ, ახლა წავიდეთ წინ და ჩადეთ რამე შევიდა Stack.

953
00:53:38,000 --> 00:53:42,000
მინდა ჩადეთ ნომერი 5, ამიტომ დააყენა ნომერი 5 აქ,

954
00:53:42,000 --> 00:53:45,000
და მერე რა ჩასახშობად აქ?

955
00:53:45,000 --> 00:53:48,000
ახლა მინდა რეალურად ჩასახშობად 1 ამისთვის ზომა,

956
00:53:48,000 --> 00:53:50,000
და ახლა დასტის არის ზომა 1.

957
00:53:50,000 --> 00:53:53,000
რა მოხდება, თუ წავიდეთ წინ და ჩადეთ ნომერი, ვთქვათ, 7 შემდეგი?

958
00:53:53,000 --> 00:53:57,000
ეს მაშინ იღებს განახლებული 2, და შემდეგ ჩვენ გავაკეთებთ 9,

959
00:53:57,000 --> 00:54:02,000
და მაშინ ეს იღებს განახლებული 3.

960
00:54:02,000 --> 00:54:05,000
მაგრამ საინტერესო ფუნქცია, ახლა ამ დასტის არის, რომ

961
00:54:05,000 --> 00:54:09,000
მე უნდა ამოიღონ, რომელიც ელემენტს თუ მინდა პოპ

962
00:54:09,000 --> 00:54:12,000
რაღაც გამორთვა დასტის, ასე ვთქვათ?

963
00:54:12,000 --> 00:54:14,000
9 იქნება პირველი, რაც წასვლა.

964
00:54:14,000 --> 00:54:18,000
როგორ უნდა სურათზე შეიცვალოს თუ მინდა პოპ ელემენტს off დასტის,

965
00:54:18,000 --> 00:54:20,000
ჰგავს უჯრა წელს Mather?

966
00:54:20,000 --> 00:54:22,000
Yeah. >> [სტუდენტური] Set ზომა, რათა 2.

967
00:54:22,000 --> 00:54:27,000
სწორედ ყველა გავაკეთო არის მითითებული ზომა: 2, და რა ვუყოთ მასივი?

968
00:54:27,000 --> 00:54:29,000
მე არ მაქვს არაფრის.

969
00:54:29,000 --> 00:54:32,000
შემეძლო, უბრალოდ უნდა იყოს anal, დაუსვან 0 იქ ან -1 ან რაიმე ნიშნავდეს

970
00:54:32,000 --> 00:54:34,000
რომ ეს არ არის legit ღირებულება, მაგრამ ეს არაფერს ნიშნავს, რადგან

971
00:54:34,000 --> 00:54:37,000
შემიძლია ჩაწერას გარეთ მასივი თავად რამდენი ხანი არის

972
00:54:37,000 --> 00:54:41,000
ასე რომ ვიცი, მხოლოდ შევხედოთ პირველი ორი ელემენტები ამ მასივი.

973
00:54:41,000 --> 00:54:47,000
ახლა, თუ წავიდე და დაამატოთ ხმების 8 ამ მასივი, როგორ სურათზე შეცვლის შემდეგ?

974
00:54:47,000 --> 00:54:50,000
ეს ხდება 8, და ეს ხდება 3.

975
00:54:50,000 --> 00:54:52,000
მე ჭრის რამდენიმე კუთხეების აქ.

976
00:54:52,000 --> 00:54:56,000
ახლა ჩვენ გვაქვს 5, 7, 8, და ჩვენ თავში ზომა 3.

977
00:54:56,000 --> 00:54:58,000
ეს არის საკმაოდ მარტივი განხორციელება,

978
00:54:58,000 --> 00:55:06,000
მაგრამ როდესაც ჩვენ ვაპირებთ ვნანობ ამ დიზაინის გადაწყვეტილება?

979
00:55:06,000 --> 00:55:09,000
როდის რამ დაიწყება წასვლა ძალიან, ძალიან არასწორი? Yeah.

980
00:55:09,000 --> 00:55:11,000
[Inaudible სტუდენტი საპასუხოდ]

981
00:55:11,000 --> 00:55:13,000
როდესაც გსურთ უკან და კიდევ პირველი ელემენტს თქვენ დააყენა სისტემაში

982
00:55:13,000 --> 00:55:18,000
>> თურმე აქ მიუხედავად იმისა დასტის არის მასივი ქვეშ hood,

983
00:55:18,000 --> 00:55:21,000
ამ მონაცემების სტრუქტურები დავიწყეთ ლაპარაკი ასევე საყოველთაოდ ცნობილია, როგორც

984
00:55:21,000 --> 00:55:25,000
აბსტრაქტული მონაცემები სტრუქტურების რომლითაც როგორ ისინი განხორციელდა

985
00:55:25,000 --> 00:55:27,000
სრულიად გარდა წერტილი.

986
00:55:27,000 --> 00:55:31,000
მონაცემები სტრუქტურის მსგავსად დასტის უნდა დაამატოთ მხარდაჭერა

987
00:55:31,000 --> 00:55:35,000
ოპერაციების მოსწონს ბიძგი, რომელიც უბიძგებს უჯრა გადატანა დასტის,

988
00:55:35,000 --> 00:55:39,000
და საესტრადო, რომელიც შლის ელემენტს საწყისი დასტის, და ამით ყველაფერი მთავრდება.

989
00:55:39,000 --> 00:55:43,000
თუ იყო ჩამოტვირთოთ სხვისი კოდი რომელმაც უკვე განახორციელა

990
00:55:43,000 --> 00:55:46,000
ამ რამ მოუწოდა დასტის, რომ პირი იქნებოდა დაწერილი

991
00:55:46,000 --> 00:55:49,000
მხოლოდ ორი ფუნქცია თქვენთვის, დააყენებს და საესტრადო, რომლის ერთადერთი მიზანი ცხოვრებაში

992
00:55:49,000 --> 00:55:51,000
იქნებოდა გავაკეთოთ ზუსტად რომ.

993
00:55:51,000 --> 00:55:54,000
თქვენ ან მას ვინც განახორციელა, რომ პროგრამა

994
00:55:54,000 --> 00:55:58,000
იქნებოდა მთლიანად ერთი გადასაწყვეტია როგორ განახორციელებენ

995
00:55:58,000 --> 00:56:00,000
სემანტიკა უბიძგებს და popping ქვეშ hood

996
00:56:00,000 --> 00:56:03,000
ან ფუნქციონალური ზრდის და popping.

997
00:56:03,000 --> 00:56:07,000
და მე მივიღე გარკვეულწილად shortsighted გადაწყვეტილება აქ

998
00:56:07,000 --> 00:56:10,000
განხორციელებით ჩემი დასტის ამ მარტივი მონაცემთა სტრუქტურა რატომ?

999
00:56:10,000 --> 00:56:12,000
როდის ამ მონაცემთა სტრუქტურა შესვენების?

1000
00:56:12,000 --> 00:56:18,000
რა წერტილი უნდა დაბრუნდეს შეცდომა, როდესაც მომხმარებლის მოუწოდებს ბიძგი, მაგალითად?

1001
00:56:18,000 --> 00:56:20,000
[სტუდენტური] თუ არ მეტი სივრცე.

1002
00:56:20,000 --> 00:56:23,000
სწორედ, თუ არ მეტი სივრცე, თუ მე გადააჭარბა მოცულობა,

1003
00:56:23,000 --> 00:56:27,000
რაც ყველა caps რადგან იგი ვარაუდობს, რომ ეს რაღაც გლობალური მუდმივი.

1004
00:56:27,000 --> 00:56:30,000
კარგად, მაშინ მე უბრალოდ აპირებს უნდა ვთქვა, "ბოდიში, მე ვერ დააყენებს სხვა ღირებულება

1005
00:56:30,000 --> 00:56:32,000
გადატანა დასტის, "ჰგავს, რომელიც Mather.

1006
00:56:32,000 --> 00:56:36,000
>> რაღაც მომენტში, ისინი აპირებენ მოხვდა ზედა ნაწილს, რომ პატარა კაბინეტი.

1007
00:56:36,000 --> 00:56:39,000
არ არსებობს უფრო მეტი სივრცე ან შესაძლებლობები დასტის, სადაც წერტილი არსებობს გარკვეული სახის შეცდომა.

1008
00:56:39,000 --> 00:56:42,000
ისინი უნდა დააყენოს ელემენტს სხვაგან, უჯრა სხვაგან,

1009
00:56:42,000 --> 00:56:44,000
ან არსად ყველა.

1010
00:56:44,000 --> 00:56:47,000
ახლა, რიგში, ჩვენ შეგვიძლია განვახორციელოთ ეს პატარა განსხვავებულად.

1011
00:56:47,000 --> 00:56:50,000
რიგში არის ცოტა განსხვავებული რომ ქვეშ Hood, ეს შეიძლება განხორციელდეს

1012
00:56:50,000 --> 00:56:54,000
როგორც მასივი, მაგრამ რატომ, ამ შემთხვევაში, მე ვერ სთავაზობს

1013
00:56:54,000 --> 00:56:59,000
ასევე აქვს ხელმძღვანელი ელემენტს წარმოადგენს ხელმძღვანელი სია,

1014
00:56:59,000 --> 00:57:06,000
თვალწინ სიაში, პირველი პირი ხაზს Apple შენახვის, გარდა ზომა?

1015
00:57:06,000 --> 00:57:14,000
რატომაა დამატებითი ნაჭერი მონაცემები აქ?

1016
00:57:14,000 --> 00:57:16,000
იფიქრეთ თავში რა ნომრები არის

1017
00:57:16,000 --> 00:57:18,000
თუ მე შედგენილი შემდეგი რედაქციით.

1018
00:57:18,000 --> 00:57:21,000
დავუშვათ, რომ ეს არის მდგომ ნაცვლად დასტის,

1019
00:57:21,000 --> 00:57:24,000
განსხვავებით,-ისევე Apple მაღაზია-მდგომ არის სამართლიანი.

1020
00:57:24,000 --> 00:57:27,000
პირველი პირი ხაზს დაწყების სია, ხმების 5 ამ შემთხვევაში,

1021
00:57:27,000 --> 00:57:30,000
იგი აპირებს, მიეცეთ საშუალება შეაღწიონ მაღაზიის პირველი.

1022
00:57:30,000 --> 00:57:32,000
მოდით, რომ.

1023
00:57:32,000 --> 00:57:35,000
დავუშვათ, რომ ეს არის სახელმწიფო, ჩემი მდგომ ამ ეტაპზე დროულად და ახლა Apple მაღაზია

1024
00:57:35,000 --> 00:57:39,000
ხსნის და პირველი პირი, ნომერი 5, ხელმძღვანელობს შევიდა მაღაზიაში.

1025
00:57:39,000 --> 00:57:43,000
როგორ შევცვალო სურათზე არის, რომ მე არ დე რიგშია პირველი პირი

1026
00:57:43,000 --> 00:57:47,000
ფრონტის ხაზის?

1027
00:57:47,000 --> 00:57:50,000
რა არის ეს? >> [სტუდენტური] შეცვლა რიგიდან.

1028
00:57:50,000 --> 00:57:52,000
შეცვლა ხელმძღვანელმა, ასე 5 ქრება.

1029
00:57:52,000 --> 00:57:56,000
სინამდვილეში, ეს თითქოს-თუ როგორ გავაკეთოთ ეს?

1030
00:57:56,000 --> 00:58:00,000
სინამდვილეში, ეს თითქოს ამ ბიჭს ქრება.

1031
00:58:00,000 --> 00:58:03,000
რა რაოდენობის 7 გავაკეთოთ ფაქტობრივი მაღაზიაში?

1032
00:58:03,000 --> 00:58:05,000
ისინი მიიღებენ დიდი წინ გადადგმული ნაბიჯია.

1033
00:58:05,000 --> 00:58:08,000
>> მაგრამ რა გვაქვს მოვიდა ვაფასებთ როდესაც საქმე კოლექტორები

1034
00:58:08,000 --> 00:58:10,000
და მოძრავი რამ გარშემო?

1035
00:58:10,000 --> 00:58:12,000
სწორედ სახის ნარჩენები თქვენი დრო, არა?

1036
00:58:12,000 --> 00:58:16,000
რატომ უნდა იყოს ასე anal როგორც აქვს პირველი პირი

1037
00:58:16,000 --> 00:58:21,000
დაწყების ხაზს ფიზიკურად დაწყების ბლოკი მეხსიერება?

1038
00:58:21,000 --> 00:58:23,000
სწორედ სრულიად არასაჭირო. რატომ?

1039
00:58:23,000 --> 00:58:26,000
რა შეიძლება მე უბრალოდ გვახსოვდეს ნაცვლად? >> [Inaudible სტუდენტი საპასუხოდ]

1040
00:58:26,000 --> 00:58:30,000
სწორედ, მე ვერ უბრალოდ გვახსოვდეს, ამ დამატებითი მონაცემები წევრი ხელმძღვანელი

1041
00:58:30,000 --> 00:58:34,000
რომ ახლა ხელმძღვანელი სიაში აღარ არის 0, რომელიც იყო მომენტი წინ.

1042
00:58:34,000 --> 00:58:39,000
ახლა კი რეალურად ხმების 1. ამ გზით, მივიღებ უმნიშვნელო ოპტიმიზაცია.

1043
00:58:39,000 --> 00:58:44,000
მხოლოდ იმიტომ, რომ მე დე რიგშია ვინმე ხაზს დაწყების ხაზს Apple მაღაზია

1044
00:58:44,000 --> 00:58:47,000
არ ნიშნავს, ყველას აქვს გადაეტანა, რომელიც გაწვევას არის წრფივი ოპერაცია.

1045
00:58:47,000 --> 00:58:50,000
შემიძლია ნაცვლად დახარჯოს მუდმივი ახლა მხოლოდ

1046
00:58:50,000 --> 00:58:53,000
და მივაღწიოთ მაშინ ბევრად უფრო სწრაფად საპასუხოდ.

1047
00:58:53,000 --> 00:58:56,000
მაგრამ ფასი მე გადამხდელი არის რა მოსაპოვებლად, რომ დამატებით შესრულება

1048
00:58:56,000 --> 00:58:58,000
და არ მქონე გადაეტანა ყველას?

1049
00:58:58,000 --> 00:59:01,000
Yeah. >> [Inaudible სტუდენტი საპასუხოდ]

1050
00:59:01,000 --> 00:59:04,000
შეგიძლიათ დაამატოთ მეტი ადამიანი, ისევე, რომ პრობლემა არის orthogonal

1051
00:59:04,000 --> 00:59:07,000
ის ფაქტი, რომ ჩვენ არ გადავიდა გარშემო.

1052
00:59:07,000 --> 00:59:11,000
ეს ჯერ კიდევ მასივი, ასე თუ არა ჩვენ გადაეტანა ყველას თუ არა-

1053
00:59:11,000 --> 00:59:13,000
OH, ვხედავ, რაც თქვენ ნიშნავს, okay.

1054
00:59:13,000 --> 00:59:16,000
სინამდვილეში, მე ვეთანხმები თუ რას ამბობდა, რომ ის თითქმის თითქოს

1055
00:59:16,000 --> 00:59:19,000
ჩვენ ახლა არასდროს გამოიყენოთ დაწყება ამ მასივი უქმნით

1056
00:59:19,000 --> 00:59:22,000
რადგან თუ მოვხსნა 5, მერე ამოიღონ 7.

1057
00:59:22,000 --> 00:59:24,000
მაგრამ მე მხოლოდ დააყენა ხალხის უფლება.

1058
00:59:24,000 --> 00:59:28,000
>> ეს იგრძნობა მე გაყვანაა სივრცეში, და საბოლოოდ ჩემი მდგომ disintegrates შევიდა არაფერი ყველა,

1059
00:59:28,000 --> 00:59:31,000
ამიტომ ვერ უბრალოდ ადამიანი wraparound,

1060
00:59:31,000 --> 00:59:35,000
და ჩვენ შეგვიძლია ვიფიქროთ, ეს მასივი მართლაც როგორც გარკვეული სახის ცირკულარული სტრუქტურა,

1061
00:59:35,000 --> 00:59:38,000
მაგრამ ჩვენ ვიყენებთ რა ოპერატორს C გავაკეთოთ, რომ სახის wraparound?

1062
00:59:38,000 --> 00:59:40,000
[Inaudible სტუდენტი საპასუხოდ] >> modulo ოპერატორს.

1063
00:59:40,000 --> 00:59:43,000
კარგი იქნებოდა, ცოტა შემაშფოთებელი ვიფიქროთ მეშვეობით როგორ გავაკეთოთ wraparound,

1064
00:59:43,000 --> 00:59:46,000
მაგრამ ჩვენ შეგვიძლია ამის გაკეთება, და ჩვენ შეგვიძლია დავიწყოთ ხალხის რა გამოყენებული იქნება წინა ხაზის,

1065
00:59:46,000 --> 00:59:52,000
მაგრამ ჩვენ უბრალოდ გვახსოვდეს ამ ხელმძღვანელი ცვლადი ვინც ფაქტობრივი ხელმძღვანელი ხაზის ფაქტობრივად.

1066
00:59:52,000 --> 00:59:57,000
რა მოხდება, თუ, ნაცვლად, ჩვენი მიზანი საბოლოოდ, თუმცა,

1067
00:59:57,000 --> 01:00:00,000
იყო ეძებოთ ნომრები, როგორც გავაკეთეთ აქ სცენაზე ერთად ანიტა,

1068
01:00:00,000 --> 01:00:02,000
მაგრამ ჩვენ ნამდვილად გვინდა საუკეთესო ყველა ამ სამყაროებს?

1069
01:00:02,000 --> 01:00:05,000
ჩვენ გვინდა უფრო დახვეწილობის, ვიდრე მასივი საშუალებას

1070
01:00:05,000 --> 01:00:09,000
იმიტომ, რომ ჩვენ გვინდა უნარი დინამიურად იზრდება მონაცემები სტრუქტურა.

1071
01:00:09,000 --> 01:00:12,000
მაგრამ ჩვენ არ გვინდა, რომ გვქონდეს მიმართო ის, რასაც ჩვენ აღნიშნა

1072
01:00:12,000 --> 01:00:15,000
პირველ ლექციას არ იყო ოპტიმალური ალგორითმის,

1073
01:00:15,000 --> 01:00:17,000
რომ წრფივი ძებნა.

1074
01:00:17,000 --> 01:00:21,000
თურმე შეგიძლიათ, ფაქტობრივად, მივაღწიოთ

1075
01:00:21,000 --> 01:00:24,000
ან თუნდაც ახლოს მუდმივი დროს, რომლის დროსაც ვიღაცას მოსწონს ანიტა,

1076
01:00:24,000 --> 01:00:27,000
თუ ის configures მისი მონაცემები სტრუქტურა არ უნდა იყოს დაკავშირებული სიაში,

1077
01:00:27,000 --> 01:00:30,000
არ უნდა დასტის, არ იყოს რიგში, შეიძლება, ფაქტობრივად,

1078
01:00:30,000 --> 01:00:33,000
ამუშავება მონაცემები სტრუქტურა, რომელიც საშუალებას აძლევს მას ეძებოთ ნივთები,

1079
01:00:33,000 --> 01:00:37,000
თუნდაც სიტყვა, არა მხოლოდ ციფრები, რა ჩვენ მოვუწოდებთ მუდმივი დრო.

1080
01:00:37,000 --> 01:00:40,000
>> ფაქტია, ვეძებ წინ, ერთ psets ამ კლასში თითქმის ყოველთვის

1081
01:00:40,000 --> 01:00:43,000
განხორციელების ეცნობით, რომლის დროსაც

1082
01:00:43,000 --> 01:00:46,000
ჩვენ გაძლევთ კვლავ ზოგიერთ 150,000 ინგლისური სიტყვა და მიზანია

1083
01:00:46,000 --> 01:00:51,000
ჩატვირთვა იმ მეხსიერებაში და სწრაფად შეძლებს უპასუხოს კითხვებს ფორმა

1084
01:00:51,000 --> 01:00:54,000
არის ამ სიტყვის მართლწერაში?

1085
01:00:54,000 --> 01:00:58,000
და ეს მართლაც suck თუ მოუხდა iterate მთელი 150,000 სიტყვა უპასუხოს, რომ.

1086
01:00:58,000 --> 01:01:02,000
მაგრამ, სინამდვილეში, ჩვენ დავინახავთ, რომ ჩვენ შეგვიძლია გავაკეთოთ ეს ძალიან, ძალიან სწრაფი დრო.

1087
01:01:02,000 --> 01:01:06,000
და ეს აპირებს ჩართვას ახორციელებს რაღაც მოუწოდა hash მაგიდა,

1088
01:01:06,000 --> 01:01:09,000
და მიუხედავად იმისა, რომ ერთი შეხედვით ეს რამ მოუწოდა hash table აპირებს

1089
01:01:09,000 --> 01:01:12,000
მოდით მივაღწიოთ ამ სუპერ სწრაფი რეაგირების ჯერ,

1090
01:01:12,000 --> 01:01:18,000
აღმოჩნდება, რომ არსებობს რეალურად პრობლემა.

1091
01:01:18,000 --> 01:01:23,000
როდესაც საქმე დროის განხორციელების რამ მოუწოდა-ისევ, მე ამის გაკეთება კიდევ ერთხელ.

1092
01:01:23,000 --> 01:01:25,000
მე მხოლოდ ერთი აქ.

1093
01:01:25,000 --> 01:01:28,000
როდესაც საქმე დროის შეასრულოს ამ რამ მოუწოდა hash მაგიდა,

1094
01:01:28,000 --> 01:01:30,000
ჩვენ ვაპირებთ აქვს მიიღოს გადაწყვეტილება.

1095
01:01:30,000 --> 01:01:32,000
რამდენად დიდი უნდა ამ რამ რეალურად იყოს?

1096
01:01:32,000 --> 01:01:36,000
და როდესაც ჩვენ დავიწყებთ ჩასმა ციფრები ამ hash მაგიდა,

1097
01:01:36,000 --> 01:01:38,000
როგორ მივდივართ შესანახად მათ ასეთი გზა

1098
01:01:38,000 --> 01:01:42,000
რომ ჩვენ შეგვიძლია მიიღონ მათ უკან, როგორც სწრაფად, როგორც მივიღეთ მათ?

1099
01:01:42,000 --> 01:01:45,000
მაგრამ ჩვენ დავინახავთ ადრე ხანგრძლივი, რომ ეს საკითხი

1100
01:01:45,000 --> 01:01:48,000
როდესაც ყველას დაბადების დღე არის კლასის იქნება საკმაოდ გერმანე.

1101
01:01:48,000 --> 01:01:51,000
თურმე ამ ოთახში, გვაქვს რამდენიმე ასეული ადამიანი,

1102
01:01:51,000 --> 01:01:56,000
ასე რომ შანსები ორი უნდა გვქონდეს იგივე დღე ალბათ საკმაოდ მაღალია.

1103
01:01:56,000 --> 01:01:58,000
რა მოხდება, თუ იქ მხოლოდ 40 ჩვენგანს ამ ოთახში?

1104
01:01:58,000 --> 01:02:02,000
რა შანსები ორი მქონე ადამიანები იგივე დაბადების დღე?

1105
01:02:02,000 --> 01:02:04,000
[სტუდენტთა] 50%.

1106
01:02:04,000 --> 01:02:06,000
ჰო, მეტი 50%. რეალურად, მე კი მოუტანა ჩარტში.

1107
01:02:06,000 --> 01:02:08,000
თურმე, და ამ მართლაც მხოლოდ Sneak გადახედვისას-

1108
01:02:08,000 --> 01:02:12,000
თუ მხოლოდ 58 ჩვენგანს ამ ოთახში, ალბათობა 2 ჩვენგანი

1109
01:02:12,000 --> 01:02:16,000
იგივე დღე არის უკიდურესად მაღალია, თითქმის 100%,

1110
01:02:16,000 --> 01:02:20,000
და რომ აპირებს გამოიწვევს მთელი bunch of ავნებს ჩვენთვის ოთხშაბათს.

1111
01:02:20,000 --> 01:02:24,000
>> აღნიშნულის გათვალისწინებით, მოდით adjourn აქ. ჩვენ დავინახავთ, თქვენ ოთხშაბათს.

1112
01:02:24,000 --> 01:02:28,000
[ტაში]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]