1
00:00:00,000 --> 00:00:02,730
[Powered by Google Translate] [ნაწილი 6: Less კომფორტული]

2
00:00:02,730 --> 00:00:05,040
[Nate Hardison] [ჰარვარდის უნივერსიტეტის]

3
00:00:05,040 --> 00:00:07,320
[ეს არის CS50.] [CS50.TV]

4
00:00:07,320 --> 00:00:11,840
ყველა უფლება. კეთილი იყოს ნაწილი 6.

5
00:00:11,840 --> 00:00:14,690
ამ კვირაში, ჩვენ ვაპირებთ ვისაუბრებთ მონაცემები სტრუქტურების ნაწილში,

6
00:00:14,690 --> 00:00:19,780
პირველ რიგში იმიტომ, რომ ამ კვირის პრობლემა წაუკიდეს spellr

7
00:00:19,780 --> 00:00:24,410
აკეთებს მთელი bunch სხვადასხვა მონაცემები სტრუქტურა exploration.

8
00:00:24,410 --> 00:00:26,520
არსებობს რამოდენიმე განსხვავებული გზა შეგიძლიათ წავიდეთ ერთად პრობლემის კომპლექტი,

9
00:00:26,520 --> 00:00:31,570
და მეტი მონაცემები სტრუქტურების იცით, უფრო მაგარი რამ რისი გაკეთებაც შეგიძლიათ.

10
00:00:31,570 --> 00:00:34,990
>> მოდით დავიწყოთ. პირველი ჩვენ ვაპირებთ ვისაუბროთ stacks,

11
00:00:34,990 --> 00:00:37,530
დასტის და მდგომ მონაცემები სტრუქტურები, რომ ჩვენ ვაპირებთ ვისაუბროთ.

12
00:00:37,530 --> 00:00:40,560
Stacks და რიგები მართლაც გამოსადეგი, როდესაც ჩვენ ვიწყებთ საუბარს გრაფიკების,

13
00:00:40,560 --> 00:00:44,390
რაც ჩვენ არ ვაპირებთ ამის გაკეთებას დიდი ახლავე.

14
00:00:44,390 --> 00:00:52,820
მაგრამ ისინი ნამდვილად კარგი უნდა გვესმოდეს ერთი დიდი ფუნდამენტური მონაცემები სტრუქტურების CS.

15
00:00:52,820 --> 00:00:54,880
აღწერილობა პრობლემა კომპლექტი სპეციფიკაცია,

16
00:00:54,880 --> 00:00:59,260
თუ თქვენ დახევის ის საუბრობს stacks როგორც akin to

17
00:00:59,260 --> 00:01:05,239
pile of სასადილო უჯრები რომ გაქვთ cafeteria at სასადილო დარბაზები

18
00:01:05,239 --> 00:01:09,680
აქ, როდესაც სასადილო პერსონალის მოდის და აყენებს სასადილო ქაღალდის შემდეგ ისინი გაწმენდილი მათ,

19
00:01:09,680 --> 00:01:12,000
ისინი დააწყობს ერთი ყველაზე სხვა.

20
00:01:12,000 --> 00:01:15,050
და მაშინ, როდესაც ბავშვები მოდის მიიღოს საკვები,

21
00:01:15,050 --> 00:01:19,490
ისინი დახევის off ქაღალდის, პირველი დაბრუნება ერთი, მაშინ ერთი ქვემოთ, მაშინ ერთი ქვემოთ რომ.

22
00:01:19,490 --> 00:01:25,190
ასე რომ, ფაქტობრივად, პირველი უჯრა, რომ სასადილო პერსონალის ჩასახშობად არის ბოლო ერთი რომ იღებს წაიყვანეს.

23
00:01:25,190 --> 00:01:32,330
ბოლო ერთი რომ სასადილო პერსონალის ჩაიცვი არის პირველი რომ იღებს წაიყვანეს სადილად.

24
00:01:32,330 --> 00:01:38,100
პრობლემის კომპლექტი ს Spec, რომელიც შეგიძლიათ ჩამოტვირთოთ თუ არ უკვე,

25
00:01:38,100 --> 00:01:46,730
ვსაუბრობთ მოდელირებას დასტის მონაცემები სტრუქტურა გამოყენებით ამ სახის struct.

26
00:01:46,730 --> 00:01:51,070
>> რა გვაქვს აქ, ეს მსგავსია იმისა, რაც იყო წარმოდგენილი ლექცია,

27
00:01:51,070 --> 00:01:58,120
გარდა ლექცია ჩვენ წარმოდგენილი ამ ints ნაცვლად char * s.

28
00:01:58,120 --> 00:02:06,250
ეს იქნება დასტის რომ მაღაზიებში რა?

29
00:02:06,250 --> 00:02:09,009
დანიელ? რას შენახვა ამ დასტის?

30
00:02:09,009 --> 00:02:15,260
[დანიელ] სიმები? >> ჩვენ შენახვის სტრიქონები ამ დასტის, ზუსტად.

31
00:02:15,260 --> 00:02:20,950
ყველა უნდა გქონდეს, რათა შეიქმნას დასტის არის მასივი

32
00:02:20,950 --> 00:02:23,920
კონკრეტული მოცულობა, რომელიც ამ შემთხვევაში,

33
00:02:23,920 --> 00:02:28,020
სიმძლავრის იქნება ყველა caps რადგან მუდმივი.

34
00:02:28,020 --> 00:02:36,340
ხოლო შემდეგ დამატებით მასივი, ყველა ჩვენ გვჭირდება მწკრივზე არის აქტუალური ზომა მასივი.

35
00:02:36,340 --> 00:02:38,980
ერთი რამ აღვნიშნო აქ რომ სახის cool

36
00:02:38,980 --> 00:02:47,060
ის არის, რომ ჩვენ შექმნის stacked მონაცემები სტრუქტურის თავზე სხვა მონაცემები სტრუქტურა, მასივი.

37
00:02:47,060 --> 00:02:50,110
არსებობს სხვადასხვა გზა განახორციელოს stacks.

38
00:02:50,110 --> 00:02:54,250
ჩვენ არ გავაკეთეთ საკმაოდ არის, მაგრამ იმედია შემდეგ აკეთებს დაკავშირებული სიაში პრობლემები,

39
00:02:54,250 --> 00:03:00,520
თქვენ ნახავთ, თუ როგორ შეგიძლიათ ადვილად განახორციელონ დასტის თავზე უკავშირდება სიაშია.

40
00:03:00,520 --> 00:03:02,640
მაგრამ ახლა, ჩვენ ჯოხი მასივები.

41
00:03:02,640 --> 00:03:06,350
ასე რომ კიდევ ერთხელ, ყველა ჩვენ გვჭირდება მასივი და ჩვენ უბრალოდ უნდა აკონტროლოთ ზომა მასივი.

42
00:03:06,350 --> 00:03:09,850
[სემ] უკაცრავად, რატომ არის ის, რომ თქვენ განაცხადა დასტის არის თავზე სტრიქონები?

43
00:03:09,850 --> 00:03:13,440
ჩემთვის თითქოს strings შიგნით Stack.

44
00:03:13,440 --> 00:03:16,790
[Hardison] Yeah. ჩვენ ქმნის, ჩვენ აღების ჩვენი მასივი მონაცემები სტრუქტურა -

45
00:03:16,790 --> 00:03:22,130
რომ დიდი კითხვა. ასე რომ კითხვაზე ამიტომ, მათთვის, ვისაც თვალს ამ შემოსული,

46
00:03:22,130 --> 00:03:24,140
რატომ ვართ, რომ დასტის არის თავზე სიმები,

47
00:03:24,140 --> 00:03:27,990
რადგან აქ გამოიყურება სიმები არიან შიგნით დასტის?

48
00:03:27,990 --> 00:03:31,050
რომელიც მთლიანად შემთხვევაში.

49
00:03:31,050 --> 00:03:34,660
რა გულისხმობდა იყო, რომ ჩვენ მივიღეთ მასივი მონაცემები სტრუქტურა.

50
00:03:34,660 --> 00:03:39,290
გვაქვს მასივი char * s, ამ მასივი სიმები,

51
00:03:39,290 --> 00:03:45,300
და ჩვენ ვაპირებთ დავამატოთ, რომ შესაქმნელად stacked მონაცემები სტრუქტურა.

52
00:03:45,300 --> 00:03:48,620
>> ამიტომ დასტის ოდნავ უფრო რთული, ვიდრე მასივი.

53
00:03:48,620 --> 00:03:51,890
ჩვენ შეგვიძლია გამოვიყენოთ მასივი აშენება Stack.

54
00:03:51,890 --> 00:03:55,810
ასე რომ, სადაც ჩვენ ვამბობთ, რომ დასტის აგებულია ზევით მასივი.

55
00:03:55,810 --> 00:04:02,510
ანალოგიურად, როგორიც მე ვთქვი ადრე, ჩვენ შეგვიძლია ავაშენოთ დასტის თავზე უკავშირდება სიაში.

56
00:04:02,510 --> 00:04:04,960
ნაცვლად გამოყენებით მასივი გავმართოთ ელემენტები,

57
00:04:04,960 --> 00:04:10,070
ჩვენ შეგვიძლია გამოვიყენოთ დაკავშირებული სიაში გავმართოთ ელემენტები და ავაშენოთ დასტის გარშემო რომ.

58
00:04:10,070 --> 00:04:12,420
მოდით გავლა რამდენიმე მაგალითები, ეძებს რაღაც კოდი,

59
00:04:12,420 --> 00:04:14,960
რომ ნახოთ თუ რა სინამდვილეში ხდება აქ.

60
00:04:14,960 --> 00:04:23,400
მარცხნივ, მე ჩაუყარეს რა, რომ დასტის struct გამოიყურება ასე ხსოვნის

61
00:04:23,400 --> 00:04:28,330
თუ სიმძლავრის იყო # განსაზღვრული იქნება ოთხი.

62
00:04:28,330 --> 00:04:33,490
გვაქვს ჩვენი ოთხი ელემენტს char * მასივი.

63
00:04:33,490 --> 00:04:38,110
გვაქვს სტრიქონები [0], სტრიქონები [1], სტრიქონები [2], სტრიქონები [3],

64
00:04:38,110 --> 00:04:43,800
და შემდეგ რომ ბოლო სივრცეში ჩვენი ზომა რიცხვი.

65
00:04:43,800 --> 00:04:46,270
ამჯამად ამ აზრი? Okay.

66
00:04:46,270 --> 00:04:48,790
ეს არის, რა მოხდება, თუ რა გავაკეთო, მარჯვენა,

67
00:04:48,790 --> 00:04:55,790
რაც იქნება ჩემი კოდი, არის უბრალოდ განაცხადოს struct, stacked struct მოუწოდა s.

68
00:04:55,790 --> 00:05:01,270
ეს არის ის, რაც ჩვენ კიდევ. იგი აყალიბებს ამ კვალის მეხსიერებაში.

69
00:05:01,270 --> 00:05:05,590
პირველი კითხვა აქ რა შინაარსის ამ დასტის struct?

70
00:05:05,590 --> 00:05:09,250
ახლავე ისინი არაფერს, მაგრამ ისინი სრულიად არაფერი.

71
00:05:09,250 --> 00:05:13,300
ისინი ამ სახის ნაგვის. ჩვენ არ გვაქვს იდეა რა მათ.

72
00:05:13,300 --> 00:05:17,000
როდესაც ვაცხადებთ დასტის s, ჩვენ უბრალოდ სროლა, რომ ქვევით ზევით მეხსიერება.

73
00:05:17,000 --> 00:05:19,840
ეს სახის მოსწონს გამოცხადების int მე და არა ინიციალიზაციისას იგი.

74
00:05:19,840 --> 00:05:21,730
თქვენ არ ვიცი რა არის. შეგიძლიათ წაიკითხოთ რა იქ,

75
00:05:21,730 --> 00:05:27,690
მაგრამ ეს არ უნდა იყოს სუპერ გამოსადეგი.

76
00:05:27,690 --> 00:05:32,680
ერთი რამ გსურთ ყოველთვის გვახსოვს გააკეთოთ ინიციალიზაცია რასაც საჭიროებს ინიციალიზაცია.

77
00:05:32,680 --> 00:05:35,820
ამ შემთხვევაში, ჩვენ ვაპირებთ ინიციალიზაცია ზომა უნდა იყოს ნულის

78
00:05:35,820 --> 00:05:39,960
რადგან ისინი აპირებენ აღმოჩნდა ჩვენთვის ძალიან მნიშვნელოვანია.

79
00:05:39,960 --> 00:05:43,450
ჩვენ შეგვეძლო წავიდეთ წინ და ინიციალიზაცია ყველა პოინტერები, ყველა char * s,

80
00:05:43,450 --> 00:05:49,670
უნდა იყოს გარკვეული გასაგები ღირებულება, რომელიც სავარაუდოდ null.

81
00:05:49,670 --> 00:05:58,270
მაგრამ ეს არ არის ბოლომდე აუცილებელია, რომ ჩვენ გაგვაჩნია.

82
00:05:58,270 --> 00:06:04,200
>> ახლა, ორი ძირითადი ოპერაციების stacks არიან?

83
00:06:04,200 --> 00:06:07,610
ვინმეს გახსოვთ ლექცია, თუ რას აკეთებთ ერთად stacks? დიახ?

84
00:06:07,610 --> 00:06:09,700
[Stella] უბიძგებს და popping? >> ზუსტად.

85
00:06:09,700 --> 00:06:13,810
ზრდის და popping არიან ორი ძირითადი ოპერაციების stacks.

86
00:06:13,810 --> 00:06:17,060
და რა ბიძგი გავაკეთო? >> იგი აყენებს რაღაც გადატანა დაბრუნება

87
00:06:17,060 --> 00:06:19,300
საქართველოს დასტის, და შემდეგ popping იღებს ეს off.

88
00:06:19,300 --> 00:06:23,150
[Hardison] ზუსტად. ამიტომ უბიძგებს უბიძგებს რაღაც თავზე Stack.

89
00:06:23,150 --> 00:06:27,700
ეს მოსწონს სასადილო პერსონალის აყენებს სასადილო უჯრა down on მთვლელი.

90
00:06:27,700 --> 00:06:33,630
და popping ხდება სასადილო უჯრა გამორთვა Stack.

91
00:06:33,630 --> 00:06:36,460
მოდით გავლა რამდენიმე მაგალითები რა ხდება

92
00:06:36,460 --> 00:06:39,720
როდესაც ჩვენ დააყენებს რამ შევიდა Stack.

93
00:06:39,720 --> 00:06:45,110
თუ ჩვენ დააყენებს string 'მიესალმები' გადატანა ჩვენი დასტის,

94
00:06:45,110 --> 00:06:49,760
ეს არის ის, რაც ჩვენი სქემა გამოიყურება ასე არის.

95
00:06:49,760 --> 00:06:53,410
ვნახოთ, რა მოხდება?

96
00:06:53,410 --> 00:06:56,530
ჩვენ მივიღებთ შევიდა პირველი ელემენტს ჩვენი სიმები მასივი

97
00:06:56,530 --> 00:07:01,420
და ჩვენ upped ჩვენი ზომა რაოდენობა უნდა იყოს 1.

98
00:07:01,420 --> 00:07:05,340
ასე რომ, თუ დავაკვირდებით განსხვავება ორ სლაიდები, აქ იყო 0, აქ ადრე ბიძგი.

99
00:07:05,340 --> 00:07:08,690
აქ არის შემდეგ ბიძგი.

100
00:07:08,690 --> 00:07:13,460
სანამ ბიძგი, შემდეგ ბიძგი.

101
00:07:13,460 --> 00:07:16,860
და ახლა ჩვენ გვაქვს ერთი ელემენტია ჩვენი Stack.

102
00:07:16,860 --> 00:07:20,970
ეს სტრიქონი "Hello", და ამით ყველაფერი მთავრდება.

103
00:07:20,970 --> 00:07:24,440
სხვა დანარჩენი მასივი, ჩვენი სიმები მასივი, კვლავ ნაგვის.

104
00:07:24,440 --> 00:07:27,070
ჩვენ არ ინიციალიზდება იგი.

105
00:07:27,070 --> 00:07:29,410
ვთქვათ ჩვენ დააყენებს სხვა სიმებიანი გადატანა ჩვენი Stack.

106
00:07:29,410 --> 00:07:32,210
ჩვენ ვაპირებთ დააყენებს "სამყარო" ამ დროს.

107
00:07:32,210 --> 00:07:35,160
ასე რომ თქვენ შეგიძლიათ ნახოთ "world" აქ გადის თავზე "Hello",

108
00:07:35,160 --> 00:07:40,040
და ზომა რაოდენობა ღებულობენ მდე 2.

109
00:07:40,040 --> 00:07:44,520
ახლა ჩვენ შეგვიძლია დააყენებს "CS50", და რომ გექნებათ წავიდეთ თავზე კვლავ.

110
00:07:44,520 --> 00:07:51,110
თუ ჩვენ დავბრუნდებით, თქვენ ხედავთ, როგორ ჩვენ უბიძგებს რამ თავზე Stack.

111
00:07:51,110 --> 00:07:53,320
და ჩვენ მივიღებთ თემა.

112
00:07:53,320 --> 00:07:58,910
როდესაც ჩვენ popped რაღაც გამორთვა დასტის, რა მოხდა?

113
00:07:58,910 --> 00:08:01,540
ვინმეს ვხედავთ განსხვავება? ეს საკმაოდ დახვეწილი.

114
00:08:01,540 --> 00:08:05,810
[სტუდენტური] ზომა. >> Yeah, ზომა შეიცვალა.

115
00:08:05,810 --> 00:08:09,040
>> რა იქნებოდა თქვენ არ შეიცვლება?

116
00:08:09,040 --> 00:08:14,280
[სტუდენტური] სიმები, ძალიან. >> მარჯვენა. სიმები ძალიან.

117
00:08:14,280 --> 00:08:17,110
თურმე, როდესაც თქვენ ამის გაკეთება ამ გზით,

118
00:08:17,110 --> 00:08:21,960
რადგან ჩვენ არ გადაწერა ელემენტები შეიტანა ჩვენი დასტის,

119
00:08:21,960 --> 00:08:24,670
ჩვენ მართლაც არ გაქვთ არაფერს, ჩვენ უბრალოდ გამოიყენოთ ზომა

120
00:08:24,670 --> 00:08:28,630
შენარჩუნება ტრეკზე ხმების რამ ჩვენს მასივი

121
00:08:28,630 --> 00:08:33,780
ასე რომ, როცა პოპ ისევ, ისევ ჩვენ უბრალოდ decrement ჩვენი ზომა ქვემოთ 1.

122
00:08:33,780 --> 00:08:39,440
იქ არ არის საჭიროება იმისა, რომ რეალურად წავიდეს და გადავაწერო არაფერი.

123
00:08:39,440 --> 00:08:41,710
სახის ხმაურიანი.

124
00:08:41,710 --> 00:08:46,520
თურმე ჩვენ, როგორც წესი, უბრალოდ დატოვონ რამ მარტო იმიტომ რომ ნაკლები ჩვენთვის მუშაობა უნდა გააკეთოს.

125
00:08:46,520 --> 00:08:50,060
თუ ჩვენ არ უნდა დაბრუნდეს და გადავაწერო რამე, მაშინ რატომ აკეთებენ ამას?

126
00:08:50,060 --> 00:08:54,150
ასე რომ, როდესაც ჩვენ პოპ ორჯერ გამორთვა დასტის, ყველა რომ არ არის decrement ზომა რამდენჯერმე.

127
00:08:54,150 --> 00:08:59,120
ისევ და ისევ, ეს მხოლოდ იმიტომ, რომ ჩვენ არ გადაწერა რამ შევიდა ჩვენი Stack.

128
00:08:59,120 --> 00:09:01,320
დიახ? წავიდეთ წინ.

129
00:09:01,320 --> 00:09:04,460
[სტუდენტი გაუგებარია] >> და მერე რა მოხდება, როცა დააყენებს რაიმეს?

130
00:09:04,460 --> 00:09:08,570
როდესაც თქვენ დააჭირეთ რაღაც ერთხელ, სადაც იგი წავიდეთ?

131
00:09:08,570 --> 00:09:12,390
სად ეს წასვლა, ბასილ? >> Into სტრიქონები [1]? >> მარჯვენა.

132
00:09:12,390 --> 00:09:14,530
რატომ არ მას წასვლას სტრიქონები [3]?

133
00:09:14,530 --> 00:09:19,410
[ბასილ] იმიტომ, რომ დაავიწყდა, რომ იქ არაფერი სტრიქონები [1] და [2]?

134
00:09:19,410 --> 00:09:24,040
[Hardison] ზუსტად. ჩვენი დასტის, არსებითად, "დაავიწყდა", რომ ის ჩატარების შესახებ, რომ არაფერი

135
00:09:24,040 --> 00:09:29,480
in strings [1] ან სტრიქონები [2], ასე რომ, როდესაც ჩვენ დააყენებს "woot",

136
00:09:29,480 --> 00:09:36,670
უბრალოდ აყენებს რომ შევიდა ელემენტს საათზე სტრიქონები [1].

137
00:09:36,670 --> 00:09:41,590
არსებობს რაიმე კითხვები, თუ როგორ ამ სამუშაოების დროს საბაზისო დონეზე?

138
00:09:41,590 --> 00:09:45,160
[სემ] ასე რომ, ეს არ არის დინამიური არანაირად, თვალსაზრისით თანხა

139
00:09:45,160 --> 00:09:47,620
ან თვალსაზრისით ზომა დასტის?

140
00:09:47,620 --> 00:09:56,750
[Hardison] ზუსტად. ეს არის - პუნქტიანი იყო, რომ ეს არ იყო დინამიურად growning Stack.

141
00:09:56,750 --> 00:10:02,850
ეს არის დასტის, რომ შეიძლება გამართავს, უმეტეს, ოთხი char * s, უმეტეს ოთხი რამ.

142
00:10:02,850 --> 00:10:07,580
თუ ჩვენ ცდილობენ და დააყენებს მეხუთე რამ, როგორ ფიქრობთ რა უნდა მოხდეს?

143
00:10:07,580 --> 00:10:11,870
[სტუდენტები, გაუგებარია]

144
00:10:11,870 --> 00:10:14,600
[Hardison] ზუსტად. არსებობს მთელი რიგი საკითხები, რამაც შეიძლება მოხდეს.

145
00:10:14,600 --> 00:10:19,330
ეს შეიძლება seg ბრალია, იმის მიხედვით, თუ რა ვიყავით -

146
00:10:19,330 --> 00:10:22,530
როგორ ზუსტად ჩვენ განხორციელების back-end.

147
00:10:22,530 --> 00:10:31,740
ეს შეიძლება გადავაწერო. ეს შეიძლება ჰქონდეს, რომ ბუფერული overflow რომ ჩვენ ვისაუბრეთ კლასში.

148
00:10:31,740 --> 00:10:35,240
რა იქნება ყველაზე ნათელი რაც შეიძლება შეცვლილ იქნას ინსტალერის

149
00:10:35,240 --> 00:10:42,370
თუ ჩვენ შევეცადეთ დააყენებს ზედმეტი რამ ჩვენს დასტის?

150
00:10:42,370 --> 00:10:44,550
ასე, რომ თქვენ აღნიშნული ბუფერული overflow.

151
00:10:44,550 --> 00:10:47,870
რა შეიძლება იყოს, რაც დაიჭერს წერილობითი მეტი ან stomped შესახებ

152
00:10:47,870 --> 00:10:52,320
თუ ჩვენ overflowed შემთხვევით ცდილობს დააყენებს ზედმეტი რამ?

153
00:10:52,320 --> 00:10:54,730
[დანიელ, გაუგებარია] >> შესაძლებელი.

154
00:10:54,730 --> 00:10:58,440
მაგრამ თავდაპირველად, თუ რა შეიძლება მოხდეს? რა მოხდება, თუ ჩვენ შევეცადეთ დააყენებს მეოთხე რამ?

155
00:10:58,440 --> 00:11:06,220
ეს შეიძლება გადავაწერო ზომა, მინიმუმ ამ მეხსიერების დიაგრამაზე, რომ ჩვენ მივიღეთ.

156
00:11:06,220 --> 00:11:10,880
>> პრობლემის კომპლექტი სპეციფიკაცია, რაც ჩვენ უნდა განხორციელების დღეს,

157
00:11:10,880 --> 00:11:16,030
რას ვაკეთებთ ჩვენ უნდა დააბრუნებს false.

158
00:11:16,030 --> 00:11:20,030
ჩვენი ბიძგი მეთოდით დაბრუნებას აპირებს ლოგიკური ღირებულება,

159
00:11:20,030 --> 00:11:22,920
და რომ ლოგიკური ღირებულება იქნება ნამდვილი თუ ბიძგი გამოსდის

160
00:11:22,920 --> 00:11:29,730
და ცრუ თუ ჩვენ ვერ დააყენებს არაფერი რადგან დასტის სავსეა.

161
00:11:29,730 --> 00:11:33,620
მოდით გავლა ცოტა რომ კოდი ახლავე.

162
00:11:33,620 --> 00:11:36,400
აი ჩვენი ბიძგი ფუნქცია.

163
00:11:36,400 --> 00:11:40,380
ჩვენი ბიძგი ფუნქცია დასტის აპირებს მიიღოს სიმებიანი მოათავსოთ Stack.

164
00:11:40,380 --> 00:11:45,820
იგი აპირებს TRUE თუ სიმებიანი წარმატებით აიძულა

165
00:11:45,820 --> 00:11:51,820
on Stack და ცრუ სხვაგვარად.

166
00:11:51,820 --> 00:11:59,740
რაიმე შემოთავაზება, თუ რა შეიძლება იყოს კარგი პირველი, რაც უნდა გავაკეთოთ აქ?

167
00:11:59,740 --> 00:12:20,630
[სემ] თუ ზომა ტოლია სიმძლავრის შემდეგ დაბრუნდნენ ყალბი?

168
00:12:20,630 --> 00:12:23,320
[Hardison] Bingo. Nice სამუშაოს.

169
00:12:23,320 --> 00:12:26,310
თუ ზომა არის მოცულობა, ჩვენ ვაპირებთ დაბრუნებას ყალბი.

170
00:12:26,310 --> 00:12:29,270
ჩვენ ვერ დააყენა არაფერი მეტი ჩვენი Stack.

171
00:12:29,270 --> 00:12:36,900
წინააღმდეგ შემთხვევაში, ჩვენ გვინდა დააყენა რაღაც ზევით Stack.

172
00:12:36,900 --> 00:12:41,670
რა არის "ყველაზე დასტის," თავდაპირველად?

173
00:12:41,670 --> 00:12:43,650
[დანიელ] ზომა 0? >> ზომა 0.

174
00:12:43,650 --> 00:12:49,990
რა არის ზევით დასტის შემდეგ არსებობს ერთი რამ დასტის? Missy, იცით?

175
00:12:49,990 --> 00:12:52,720
[Missy] ერთი. >> ზომა არის ერთი, ზუსტად. თქვენ გაქვთ შეავსოთ ზომა,

176
00:12:52,720 --> 00:13:01,690
და ყოველ ჯერზე თქვენ აყენებს ახალ ელემენტს საათზე ინდექსი ზომის მასივი.

177
00:13:01,690 --> 00:13:05,470
ჩვენ შეგვიძლია ამის გაკეთება, რომ სახის ერთი ლაინერი, თუ ეს აზრი.

178
00:13:05,470 --> 00:13:11,910
ამიტომ, ჩვენ მივიღეთ ჩვენი სიმები მასივი, ჩვენ ვაპირებთ, რათა შეამოწმონ ის ზომა ინდექსი,

179
00:13:11,910 --> 00:13:14,780
და ჩვენ უბრალოდ აპირებს შესანახად ჩვენი char * იქ.

180
00:13:14,780 --> 00:13:19,340
შეამჩნევთ, თუ როგორ არ სიმებიანი კოპირება ხდება აქ,

181
00:13:19,340 --> 00:13:29,680
არ დინამიური გამოყოფის მეხსიერება?

182
00:13:29,680 --> 00:13:34,440
და შემდეგ მისის იზრდებიან, რაც ჩვენ ახლა უნდა გავაკეთოთ,

183
00:13:34,440 --> 00:13:40,570
რადგან ჩვენ შენახული სიმებიანი შესაბამის ადგილს მასივი,

184
00:13:40,570 --> 00:13:49,230
და მან განაცხადა, რომ მოგვიწია ნამატი ზომა ერთი ასე რომ ჩვენ მზად ვართ მომდევნო ბიძგი.

185
00:13:49,230 --> 00:13:53,950
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ, რომ s.size + +.

186
00:13:53,950 --> 00:13:59,330
ამ ეტაპზე, ჩვენ მივიღებთ ჩვენს მასივი. რა არის ბოლო რამ უნდა გავაკეთოთ?

187
00:13:59,330 --> 00:14:10,110
[სტუდენტური] დაბრუნდა TRUE. >> დაბრუნდა TRUE.

188
00:14:10,110 --> 00:14:14,690
ასე რომ საკმაოდ მარტივია, საკმაოდ მარტივია კოდი. არ არის ძალიან ბევრი.

189
00:14:14,690 --> 00:14:17,070
ერთხელ თქვენ გახვეული თქვენი უფროსი გარშემო როგორ დასტის მუშაობს,

190
00:14:17,070 --> 00:14:21,910
ეს არის საკმაოდ მარტივი განხორციელება.

191
00:14:21,910 --> 00:14:26,390
>> ახლა, მომდევნო ნაწილი ეს popping სიმებიანი გამორთვა Stack.

192
00:14:26,390 --> 00:14:29,410
მე ვაპირებ მოგცემთ ბიჭებს გარკვეული დრო მუშაობა ამ ცოტა.

193
00:14:29,410 --> 00:14:34,320
თითქმის არსებითად საპირისპირო რასაც ჩვენ გავაკეთეთ აქ ფრეა.

194
00:14:34,320 --> 00:14:38,510
რა მე ვაკეთებ ფაქტობრივად - Oops.

195
00:14:38,510 --> 00:14:48,160
მე გაიჭედოთ up ელექტრო მეტი აქ და ელექტრო მოწყობილობების,

196
00:14:48,160 --> 00:14:53,600
მე გამოყვანილია up პრობლემა მითითებული 5 სპეციფიკაცია.

197
00:14:53,600 --> 00:15:02,560
თუ ჩვენ მიუახლოვდით აქ, ვხედავთ ვარ საათზე cdn.cs50.net/2012/fall/psets/pset5.pdf.

198
00:15:02,560 --> 00:15:08,590
თქვენ ბიჭები გადმოწერილი ეს კოდი რომ აქ, section6.zip?

199
00:15:08,590 --> 00:15:15,030
ყველა უფლება. თუ არ გაკეთდა, ამას ახლავე, მართლაც სწრაფად.

200
00:15:15,030 --> 00:15:22,130
მე გავაკეთებთ ჩემი ტერმინალის ფანჯარაში.

201
00:15:22,130 --> 00:15:25,090
მე რეალურად ეს აქ. Yeah.

202
00:15:25,090 --> 00:15:34,730
დიახ, სემ? >> მაქვს შეკითხვა რატომ ამბობენ s.string 's ფრჩხილებში of size = ქ?

203
00:15:34,730 --> 00:15:42,910
რა არის ქ? ის არის, რომ განსაზღვრული სადღაც ადრე, ან - Oh, წელს char * ქ?

204
00:15:42,910 --> 00:15:47,160
[Hardison] დიახ, ზუსტად. ეს იყო არგუმენტი. >> Oh, okay. უკაცრავად.

205
00:15:47,160 --> 00:15:49,470
[Hardison] ჩვენ სასურველი სიმებიანი დააყენებს სისტემაში

206
00:15:49,470 --> 00:15:55,220
სხვა საკითხს, რომელიც შესაძლოა ამუშავება, რომ ჩვენ არ ნამდვილად ვილაპარაკოთ აქ იყო

207
00:15:55,220 --> 00:15:58,810
ავიღეთ თავისთავად, რომ ჩვენ გვქონდა ამ ცვლადში s

208
00:15:58,810 --> 00:16:02,710
რომ იყო ფარგლებს და ხელმისაწვდომი ჩვენთვის.

209
00:16:02,710 --> 00:16:06,960
ჩვენ მივიღეთ თავისთავად, რომ იყო ამ დასტის struct.

210
00:16:06,960 --> 00:16:08,930
ასე ეძებს უკან ამ ბიძგი კოდი,

211
00:16:08,930 --> 00:16:13,450
თქვენ ხედავთ, რომ ვაკეთებთ პერსონალის ამ სტრიქონს რომ გაბმულ გადავიდა

212
00:16:13,450 --> 00:16:19,210
მაგრამ შემდეგ უეცრად, ჩვენ წვდომის s.size, როგორიცაა, სად და მოდის?

213
00:16:19,210 --> 00:16:23,020
კოდექსში, რომ ჩვენ ვაპირებთ შევხედოთ განყოფილებაში არქივი

214
00:16:23,020 --> 00:16:27,100
და მაშინ პერსონალი რომ თქვენ უნდა აკეთებდა თქვენი პრობლემა ადგენს,

215
00:16:27,100 --> 00:16:32,440
ჩვენ გამოვიტანეთ ჩვენი დასტის struct გლობალური ცვლადი

216
00:16:32,440 --> 00:16:36,380
ასე, რომ ჩვენ შეგვიძლია ხელი მიუწვდება ეს ყველა ჩვენი განსხვავებული ფუნქციები

217
00:16:36,380 --> 00:16:40,630
გარეშე ხელით მსგავ გარშემო და მსგავ მიერ მინიშნება,

218
00:16:40,630 --> 00:16:44,870
ყველაფერი რომ მსგავსი საქმიანობები მას.

219
00:16:44,870 --> 00:16:52,280
ჩვენ უბრალოდ პატაშური ცოტა, თუ გნებავთ, რათა რამ გავალამაზოთ.

220
00:16:52,280 --> 00:16:57,430
და ეს რაღაც ვაკეთებთ აქ იმიტომ რომ გასართობად, უფრო ადვილია.

221
00:16:57,430 --> 00:17:02,800
ხშირად დაინახავთ ადამიანებს ამის გაკეთება, თუ მათ აქვთ ერთი დიდი მონაცემები სტრუქტურა

222
00:17:02,800 --> 00:17:07,750
რომ მიმდინარეობს ოპერაცია ფარგლებში მათი პროგრამა.

223
00:17:07,750 --> 00:17:09,560
>> მოდით დავუბრუნდეთ მეტი ელექტრო მოწყობილობების.

224
00:17:09,560 --> 00:17:15,240
ხომ ყველას წარმატებით კიდევ section6.zip?

225
00:17:15,240 --> 00:17:20,440
ყველას unzip ის გამოყენებით unzip section6.zip?

226
00:17:20,440 --> 00:17:27,200
თუ წასვლას ნაწილი 6 დირექტორია -

227
00:17:27,200 --> 00:17:29,220
aah, მთელი ადგილი -

228
00:17:29,220 --> 00:17:32,840
და თქვენ ჩასვათ რა აქ, თქვენ ხედავთ, რომ თქვენ მოხვდით სამი სხვადასხვა. გ files.

229
00:17:32,840 --> 00:17:38,350
თქვენ მოხვდით მდგომ, sll, რომელიც საგნით დაკავშირებული სიაში და დასტის.

230
00:17:38,350 --> 00:17:44,600
თუ თქვენ გახსენით stack.c,

231
00:17:44,600 --> 00:17:47,330
თქვენ ხედავთ, რომ ჩვენ მივიღეთ ეს struct განსაზღვრული ჩვენთვის,

232
00:17:47,330 --> 00:17:51,330
ზუსტი struct, რომ ჩვენ უბრალოდ ვისაუბრეთ იმ სლაიდები.

233
00:17:51,330 --> 00:17:56,340
გვაქვს ჩვენი გლობალური ცვლადი ამისთვის დასტის,

234
00:17:56,340 --> 00:18:00,110
გვაქვს ჩვენი ბიძგი ფუნქცია,

235
00:18:00,110 --> 00:18:04,230
და მაშინ ჩვენ მივიღეთ ჩვენი pop ფუნქცია.

236
00:18:04,230 --> 00:18:08,320
მე დააყენა კოდი დააყენებს back up on the slide აქ,

237
00:18:08,320 --> 00:18:10,660
მაგრამ რა მინდა შენ უნდა გააკეთოთ, მაქსიმალურად თქვენი უნარი,

238
00:18:10,660 --> 00:18:13,790
წასვლა და განხორციელება pop ფუნქცია.

239
00:18:13,790 --> 00:18:18,480
ერთხელ თქვენ განხორციელდა, შეგიძლიათ კომპილაციის ამ გააკეთოს დასტის,

240
00:18:18,480 --> 00:18:22,540
და შემდეგ აწარმოებს resultant დასტის შესრულებადი,

241
00:18:22,540 --> 00:18:28,390
და რომელიც მიიღებს ყველა ამ გამოცდას კოდი ქვემოთ აქ რომ მთავარ.

242
00:18:28,390 --> 00:18:31,060
და ძირითადი ზრუნავს რეალურად მიღების ბიძგი და საესტრადო მოუწოდებს

243
00:18:31,060 --> 00:18:33,220
და დარწმუნებულიყო, რომ ყველაფერი გადის ყველა უფლება.

244
00:18:33,220 --> 00:18:36,820
იგი ასევე ველში დასტის ზომა უფლება აქ

245
00:18:36,820 --> 00:18:39,780
ასე რომ თქვენ არ უნდა ფიქრი, რომ ინიციალიზაციისას.

246
00:18:39,780 --> 00:18:42,310
თქვენ შეიძლება ვივარაუდოთ, რომ ის სათანადოდ ინიციალიზაცია

247
00:18:42,310 --> 00:18:48,000
იმ დროისთვის, რომ თქვენ შედიხართ ის pop ფუნქცია.

248
00:18:48,000 --> 00:18:53,530
ამჯამად რომ აზრი?

249
00:18:53,530 --> 00:19:00,100
ასე რომ აქ ჩვენ მივდივართ. აქ ბიძგი კოდი.

250
00:19:00,100 --> 00:19:13,210
მე მივცემ თქვენ ბიჭები 5 ან 10 წუთი.

251
00:19:13,210 --> 00:19:15,690
და თუ თქვენ გაქვთ რაიმე კითხვები შუალედურ ხოლო თქვენ კოდირება,

252
00:19:15,690 --> 00:19:17,710
გთხოვთ ვთხოვთ მათ ხმამაღალი.

253
00:19:17,710 --> 00:19:23,080
ასე რომ, თუ თქვენ მიიღებთ sticking წერტილი, ჰკითხეთ.

254
00:19:23,080 --> 00:19:26,030
ნება მომეცით ვიცი, მოდით ყველას სხვაგან ვიცი.

255
00:19:26,030 --> 00:19:28,160
მუშაობა თქვენი მეზობელი ძალიან.

256
00:19:28,160 --> 00:19:30,360
[დანიელ] ჩვენ უბრალოდ განხორციელების pop წუთას? >> Just Pop.

257
00:19:30,360 --> 00:19:34,200
თუმცა შეგიძლიათ კოპირება განხორციელების ბიძგი თუ გსურთ

258
00:19:34,200 --> 00:19:37,780
ისე, რომ ტესტირება იმუშავებს.

259
00:19:37,780 --> 00:19:41,940
რადგან ძნელია შესამოწმებლად რამ მისაღებად შევიდა -

260
00:19:41,940 --> 00:19:49,030
ან, ძნელი გამოცდა popping ნივთების გატანას დასტის თუ არ არის არაფერი დასტის დავიწყოთ.

261
00:19:49,030 --> 00:19:55,250
>> რა არის pop უნდა დაბრუნების? ელემენტს საწყისი ზევით Stack.

262
00:19:55,250 --> 00:20:01,260
ის უნდა მიიღოს ელემენტს გამორთვა ზევით დასტის

263
00:20:01,260 --> 00:20:05,780
და შემდეგ decrement ზომა დასტის,

264
00:20:05,780 --> 00:20:07,810
და ახლა თქვენ დაკარგავთ ელემენტს ზედა.

265
00:20:07,810 --> 00:20:11,420
და მაშინ დაბრუნდებიან ელემენტს ზედა.

266
00:20:11,420 --> 00:20:20,080
[სტუდენტი გაუგებარია]

267
00:20:20,080 --> 00:20:28,810
[Hardison] მერე რა მოხდება, თუ თქვენ ამას? [სტუდენტი გაუგებარია]

268
00:20:28,810 --> 00:20:34,000
რა მთავრდება ხდება არის თქვენ ალბათ წვდომის ან

269
00:20:34,000 --> 00:20:37,350
ელემენტს, რომელიც არ ინიციალიზდება ჯერჯერობით, ასე რომ თქვენი გაანგარიშება

270
00:20:37,350 --> 00:20:39,990
სადაც ბოლო ელემენტს არის გამორთულია.

271
00:20:39,990 --> 00:20:46,260
ასე რომ აქ, თუ თქვენ შეამჩნევთ, რომ ბიძგი, ჩვენ წვდომის სიმები საათზე s.size ელემენტს

272
00:20:46,260 --> 00:20:48,560
იმიტომ რომ ახალი ინდექსი.

273
00:20:48,560 --> 00:20:51,460
ეს ახალი ზევით Stack.

274
00:20:51,460 --> 00:21:01,100
ხოლო pop, s.size იქნება შემდეგი სივრცეში,

275
00:21:01,100 --> 00:21:05,210
სივრცე რომ თავზე ყველა ელემენტების თქვენი დასტის.

276
00:21:05,210 --> 00:21:10,050
ასე რომ ყველაზე საუკეთესო ელემენტს არ არის s.size,

277
00:21:10,050 --> 00:21:14,930
არამედ, ის ქვეშ იგი.

278
00:21:14,930 --> 00:21:19,640
>> სხვა რამ უნდა გავაკეთოთ, როდესაც თქვენ - ში pop,

279
00:21:19,640 --> 00:21:22,030
არის თუ თქვენ ჩვენგან უნდა decrement ზომა.

280
00:21:22,030 --> 00:21:28,750
თუ გახსოვთ თავში ჩვენი პატარა დიაგრამაზე სწორედ აქ,

281
00:21:28,750 --> 00:21:30,980
მართლაც, ერთადერთი, რაც ჩვენ ვნახეთ მაშინ, როცა ჩვენ მოუწოდა პოპ

282
00:21:30,980 --> 00:21:36,150
იყო, რომ ეს ზომა დაეცა, პირველი და 2, შემდეგ 1.

283
00:21:36,150 --> 00:21:42,620
მაშინ, როდესაც ჩვენ მივიღებთ ახალ ელემენტს შესახებ, რომ ის გაგრძელდება დათქმულ ადგილზე.

284
00:21:42,620 --> 00:21:49,610
[ბასილ] თუ s.size არის 2, მაშინ არ ეს წასვლა ელემენტს 2,

285
00:21:49,610 --> 00:21:54,400
და მაშინ ნეტავ გსურთ პოპ რომ ელემენტს off?

286
00:21:54,400 --> 00:21:59,510
ასე რომ, თუ წავედით - >> მოდით შევხედოთ ამ ერთხელ.

287
00:21:59,510 --> 00:22:07,730
თუ ეს ჩვენი დასტის ამ ეტაპზე

288
00:22:07,730 --> 00:22:12,130
და მოვუწოდებთ pop,

289
00:22:12,130 --> 00:22:16,150
სადაც ინდექსი არის ყველაზე საუკეთესო ელემენტს?

290
00:22:16,150 --> 00:22:19,300
[ბასილ] # 2, მაგრამ აპირებს პოპ 3. >> მარჯვენა.

291
00:22:19,300 --> 00:22:24,220
ასე რომ, სადაც ჩვენი ზომა არის 3, მაგრამ ჩვენ გვინდა, რომ პოპ ელემენტს საათზე ინდექსი 2.

292
00:22:24,220 --> 00:22:29,900
ეს რომ ტიპიური სახის off ერთი, რომ თქვენ გაქვთ ერთად ნულოვანი ინდექსირებას მასივი.

293
00:22:29,900 --> 00:22:36,430
ასე რომ თქვენ გსურთ პოპ მესამე ელემენტს, მაგრამ მესამე ელემენტს არ არის ინდექსი 3.

294
00:22:36,430 --> 00:22:39,430
და მიზეზი ჩვენ არ უნდა გავაკეთოთ, რომ მინუს 1 როდესაც ჩვენ უბიძგებს

295
00:22:39,430 --> 00:22:44,120
იმიტომ ახლავე, თქვენ შეამჩნევთ რომ ყველაზე საუკეთესო ელემენტს,

296
00:22:44,120 --> 00:22:47,600
თუ ჩვენ დააყენებს რაღაც გადატანა დასტის ამ ეტაპზე,

297
00:22:47,600 --> 00:22:50,360
ჩვენ გვინდა დააყენებს მას ინდექსი 3.

298
00:22:50,360 --> 00:23:03,550
და ეს ასე მოხდება, რომ ზომა და მაჩვენებლების გამოდიან, როდესაც თქვენ დააჭერთ.

299
00:23:03,550 --> 00:23:06,960
>> ვინ მიიღო სამუშაო დასტის განხორციელება?

300
00:23:06,960 --> 00:23:09,690
თქვენ მოხვდით სამუშაო დასტის ერთ. გაქვთ pop სამუშაო ჯერ არ გაქვთ?

301
00:23:09,690 --> 00:23:11,890
[დანიელ] დიახ. ვფიქრობ ასე.

302
00:23:11,890 --> 00:23:14,610
>> პროგრამის გაშვებას და არ seg faulting, ეს დაბეჭდვისას?

303
00:23:14,610 --> 00:23:17,520
იგი ამობეჭდოთ "წარმატება" როდესაც თქვენ გაუშვით?

304
00:23:17,520 --> 00:23:22,630
Yeah. ჩადება დააწყობს, გაუშვით, თუ იგი ბეჭდავს out "წარმატება" და არ მიდის ბუმი

305
00:23:22,630 --> 00:23:26,000
მაშინ ყველა კარგია.

306
00:23:26,000 --> 00:23:34,070
ყველა უფლება. მოდით წავიდეთ მეტი ელექტრო მართლაც სწრაფად,

307
00:23:34,070 --> 00:23:46,100
და ჩვენ გავლა ამ.

308
00:23:46,100 --> 00:23:51,110
თუ დავაკვირდებით, რა ხდება აქ pop,

309
00:23:51,110 --> 00:23:55,220
დანიელ, რა იყო პირველი, რაც თქვენ გააკეთეთ?

310
00:23:55,220 --> 00:23:58,850
[დანიელ] თუ s.size მეტია 0.

311
00:23:58,850 --> 00:24:03,120
[Hardison] Okay. და რატომ ასე?

312
00:24:03,120 --> 00:24:05,610
[დანიელ], რათა დავრწმუნდეთ, რომ იყო რაღაც შიგნით Stack.

313
00:24:05,610 --> 00:24:10,950
[Hardison] მარჯვენა. გსურთ შეამოწმოთ დავრწმუნდეთ, რომ s.size მეტია 0;

314
00:24:10,950 --> 00:24:13,280
სხვაგვარად, თუ რა გსურთ არ მოხდეს?

315
00:24:13,280 --> 00:24:16,630
[დანიელ] დაბრუნება null? >> დაბრუნება null, ზუსტად.

316
00:24:16,630 --> 00:24:20,740
ასე რომ, თუ s.size მეტია 0. მაშინ რას აპირებს?

317
00:24:20,740 --> 00:24:25,890
რას ვაკეთებთ თუ დასტის არ არის ცარიელი?

318
00:24:25,890 --> 00:24:31,210
[Stella] თქვენ decrement ზომა? >> თქვენ decrement ზომა, okay.

319
00:24:31,210 --> 00:24:34,440
ასე რომ როგორ ფიქრობთ ასე? >> S.size--.

320
00:24:34,440 --> 00:24:37,030
[Hardison] დიდი. და მერე რა ვქნათ?

321
00:24:37,030 --> 00:24:44,140
[Stella] და მერე განაცხადა დაბრუნების s.string [s.size].

322
00:24:44,140 --> 00:24:48,560
[Hardison] დიდი.

323
00:24:48,560 --> 00:24:51,940
წინააღმდეგ შემთხვევაში თქვენ დაბრუნებას null. დიახ, სემ?

324
00:24:51,940 --> 00:24:55,510
[სემ] რატომ არ უნდა იყოს s.size + 1?

325
00:24:55,510 --> 00:24:58,430
[Hardison] Plus 1? >> Yeah. >> Got It.

326
00:24:58,430 --> 00:25:00,980
[სემ] მეგონა იმიტომ, რომ თქვენ იღებენ 1 out,

327
00:25:00,980 --> 00:25:04,290
მაშინ თქვენ უნდა დაბრუნების არ ერთი, რომ მათ სთხოვეს.

328
00:25:04,290 --> 00:25:09,400
[Hardison] და ეს მხოლოდ რა ჩვენ ვსაუბრობთ ამ მთელი საკითხი 0 მაჩვენებლების.

329
00:25:09,400 --> 00:25:11,380
ასე რომ, თუ ჩვენ zoom უკან მეტი აქ.

330
00:25:11,380 --> 00:25:15,650
თუ დავაკვირდებით ამ ბიჭს უფლება აქ, თქვენ ხედავთ, რომ როდესაც ჩვენ pop,

331
00:25:15,650 --> 00:25:19,340
ჩვენ popping ელემენტს საათზე ინდექსი 2.

332
00:25:19,340 --> 00:25:25,200
>> ამიტომ, ჩვენ შემცირდება ჩვენი ზომა პირველი, მაშინ ჩვენი ზომა შეესაბამება ჩვენი ინდექსი.

333
00:25:25,200 --> 00:25:39,650
თუ ჩვენ არ decrement ზომა პირველი, მაშინ ჩვენ უნდა გავაკეთოთ ზომა -1 და შემდეგ decrement.

334
00:25:39,650 --> 00:25:45,270
დიდი. ყველა კარგი?

335
00:25:45,270 --> 00:25:47,530
ნებისმიერი კითხვები ამ?

336
00:25:47,530 --> 00:25:54,050
არსებობს მთელი რიგი სხვადასხვა გზები, რათა დაეწერა ამ ისევე.

337
00:25:54,050 --> 00:26:03,290
ფაქტობრივად, ჩვენ შეგვიძლია გავაკეთოთ რაღაც კი - შეგვიძლია გავაკეთოთ ერთი ლაინერი.

338
00:26:03,290 --> 00:26:05,770
ჩვენ შეგვიძლია გავაკეთოთ ერთი ხაზის დაბრუნების.

339
00:26:05,770 --> 00:26:12,980
ასე რომ ჩვენ შეგვიძლია რეალურად decrement სანამ დაბრუნებას აკეთებს, რომ.

340
00:26:12,980 --> 00:26:18,320
ასე აყენებს - ადრე s.size.

341
00:26:18,320 --> 00:26:22,060
ხდის ხაზი მართლაც მკვრივი.

342
00:26:22,060 --> 00:26:30,940
სად სხვაობა - s. ზომა და s.size--

343
00:26:30,940 --> 00:26:40,130
ის არის, რომ ამ postfix - ისინი ეძახით postfix რადგან - უძღოდა s.size--

344
00:26:40,130 --> 00:26:47,430
იმას ნიშნავს, რომ s.size ფასდება მიზნით მოძიებაში ინდექსი

345
00:26:47,430 --> 00:26:50,410
როგორც ეს არის გაკეთებული, როდესაც ამ ხაზს ხორციელდება,

346
00:26:50,410 --> 00:26:54,290
და მაშინ ეს - ხდება შემდეგ ხაზი იღებს დასაჯეს.

347
00:26:54,290 --> 00:27:00,340
შემდეგ ელემენტს საათზე ინდექსი s.size არის შემოწმდა.

348
00:27:00,340 --> 00:27:07,260
და ეს არ არის ის, რაც ჩვენ გვინდა, იმიტომ, რომ ჩვენ გვინდა decrement მოხდეს პირველი.

349
00:27:07,260 --> 00:27:10,990
Othewise, ჩვენ ვაპირებთ იყოს წვდომის მასივი, ეფექტურად, ფარგლებს გარეთ.

350
00:27:10,990 --> 00:27:16,850
ჩვენ ვაპირებთ იყოს წვდომის ელემენტს ზემოთ ერთი, რომ ჩვენ ნამდვილად გინდათ შესვლა.

351
00:27:16,850 --> 00:27:23,840
Yeah, სემ? >> ეს სწრაფად ან გამოიყენოს ნაკლები RAM, რათა ერთ ხაზზე თუ არა?

352
00:27:23,840 --> 00:27:29,620
[Hardison] პატიოსნად, ნამდვილად არის დამოკიდებული.

353
00:27:29,620 --> 00:27:34,220
[სემ, გაუგებარია] >> Yeah, ეს დამოკიდებულია. ამის გაკეთება შეგიძლიათ შემდგენელი tricks

354
00:27:34,220 --> 00:27:41,580
მიიღოს შემდგენელი იმის აღიარება, რომ, როგორც წესი, მე წარმოვიდგენდი.

355
00:27:41,580 --> 00:27:44,840
>> ამიტომ, ჩვენ ახსენეთ ცოტა ამ შემდგენელი ოპტიმიზაციის პერსონალის

356
00:27:44,840 --> 00:27:47,400
რომ თქვენ შეგიძლიათ გავაკეთოთ შედგენა,

357
00:27:47,400 --> 00:27:50,580
და ეს სახის რამ, შემდგენელი შესაძლოა გაერკვნენ,

358
00:27:50,580 --> 00:27:54,710
მოსწონს oh, hey, იქნებ შემიძლია ამ ყველა ერთ ოპერაციას,

359
00:27:54,710 --> 00:27:59,420
როგორც ეწინააღმდეგებოდა დატვირთვისა ზომა ცვლადი in საწყისი RAM,

360
00:27:59,420 --> 00:28:03,770
decrementing ის, შენახვა უკან out, და შემდეგ ჩატვირთვის მას უკან ისევ

361
00:28:03,770 --> 00:28:08,000
დავამუშავოთ დანარჩენი ამ ოპერაციის.

362
00:28:08,000 --> 00:28:10,710
მაგრამ, როგორც წესი, არა, ეს არ არის ერთგვარი რამ

363
00:28:10,710 --> 00:28:20,770
რომ ხდება, რომ თქვენი პროგრამა მნიშვნელოვნად უფრო სწრაფად.

364
00:28:20,770 --> 00:28:26,000
აღარ შეკითხვებს stacks?

365
00:28:26,000 --> 00:28:31,360
>> ასე რომ უბიძგებს და popping. თუ ბიჭებს შევეცდები out Hacker გამოცემა,

366
00:28:31,360 --> 00:28:33,660
რაც ჩვენ გავაკეთეთ წელს Hacker გამოცემა ფაქტობრივად წასული

367
00:28:33,660 --> 00:28:37,670
და ამ დასტის იზრდება დინამიურად ვითარდება.

368
00:28:37,670 --> 00:28:43,190
გამოწვევა არსებობს, პირველ რიგში, აქ წელს ბიძგი ფუნქცია,

369
00:28:43,190 --> 00:28:48,820
გაერკვნენ, თუ როგორ უნდა მიიღოს, რომ მასივი იზრდება

370
00:28:48,820 --> 00:28:52,450
როგორც თქვენ გაქვთ უბიძგებს უფრო და უფრო ელემენტების შესახებ, რომ დასტის.

371
00:28:52,450 --> 00:28:56,000
ეს რეალურად არ არის ძალიან ბევრი დამატებითი კოდი.

372
00:28:56,000 --> 00:29:00,080
უბრალოდ ზარი - თქვენ უნდა გვახსოვდეს, მიიღოს ზარები malloc იქ სწორად,

373
00:29:00,080 --> 00:29:03,310
და შემდეგ გაერკვნენ, როდესაც თქვენ ვაპირებ მოვუწოდო realloc.

374
00:29:03,310 --> 00:29:06,090
სწორედ გართობა გამოწვევა თუ თქვენ დაინტერესებული.

375
00:29:06,090 --> 00:29:11,550
>> მაგრამ ამ დროისათვის, მოდით გადაადგილება, და ვისაუბროთ იმაზე რიგები.

376
00:29:11,550 --> 00:29:15,680
Scroll მეშვეობით აქ.

377
00:29:15,680 --> 00:29:19,340
რიგში არის მჭიდრო ძმა of Stack.

378
00:29:19,340 --> 00:29:25,380
ასე რომ, დასტის, რამ იყო უკანასკნელი

379
00:29:25,380 --> 00:29:28,810
იყო პირველი რამ მაშინ იქნება მიღებული.

380
00:29:28,810 --> 00:29:33,600
გვაქვს ამ ბოლო წელს, პირველი მათგანი, ან LIFO, შეკვეთით.

381
00:29:33,600 --> 00:29:38,390
ხოლო მდგომ, როგორც ნეტავ მოველით, როდესაც თქვენ რიგში მდგომ,

382
00:29:38,390 --> 00:29:41,980
პირველი პირი კიდევ გამოდიან, პირველი რაც შეღწევას მდგომ,

383
00:29:41,980 --> 00:29:47,630
არის პირველი რამ რომ იღებს მოძიებულია რიგიდან.

384
00:29:47,630 --> 00:29:51,490
რიგები ასევე ხშირად გამოიყენება, როდესაც ჩვენ საქმე გრაფიკების,

385
00:29:51,490 --> 00:29:55,560
როგორც ჩვენ ვისაუბრეთ მოკლედ ერთად stacks,

386
00:29:55,560 --> 00:30:00,260
და რიგები ასევე მოსახერხებელი ამისთვის bunch სხვა რამ.

387
00:30:00,260 --> 00:30:06,180
ერთი რამ, რომ მოდის up ხშირად ცდილობს შეინარჩუნოს, მაგალითად,

388
00:30:06,180 --> 00:30:12,310
დახარისხებული სიის ელემენტების.

389
00:30:12,310 --> 00:30:17,650
და ამისათვის ერთად მასივი. თქვენ შეგიძლიათ შენარჩუნება დახარისხებული ჩამონათვალი რამ მასივი,

390
00:30:17,650 --> 00:30:20,650
მაგრამ აქ რომ იღებს სახიფათო არის მაშინ ყოველთვის უნდა მოვძებნოთ

391
00:30:20,650 --> 00:30:26,160
შესაბამის ადგილზე ჩასასმელად შემდეგი რამ.

392
00:30:26,160 --> 00:30:28,250
ასე რომ, თუ თქვენ გაქვთ მასივი ნომრები, 1 მეშვეობით 10,

393
00:30:28,250 --> 00:30:31,630
და შემდეგ გსურთ გაფართოებას, რომ ყველა ციფრები 1 მეშვეობით 100,

394
00:30:31,630 --> 00:30:33,670
და თქვენ მისაღებად ამ ნომრები შემთხვევითი წესრიგისა და ცდილობს შეინარჩუნოს ყველაფერი

395
00:30:33,670 --> 00:30:40,650
დალაგებულია როგორც თქვენ გავლა, თქვენ დასრულდება მდე მქონე ბევრი გადავიდა.

396
00:30:40,650 --> 00:30:43,910
გარკვეული სახის რიგები და გარკვეული სახის ძირითადი მონაცემები სტრუქტურების,

397
00:30:43,910 --> 00:30:46,670
შეგიძლიათ პრაქტიკულად შეინახოს იგი საკმაოდ მარტივია.

398
00:30:46,670 --> 00:30:50,640
თქვენ არ უნდა დაამატოთ რაიმე და შემდეგ რეორგანიზაციის მთელი რამ ყოველ ჯერზე.

399
00:30:50,640 --> 00:30:56,770
არც თქვენ უნდა გავაკეთოთ ბევრი გადავიდა შიდა ელემენტების გარშემო.

400
00:30:56,770 --> 00:31:02,990
შევხედოთ მდგომ, ხედავთ, რომ - ასევე queue.c განყოფილებაში კოდი -

401
00:31:02,990 --> 00:31:10,950
struct რომ ჩვენ მოცემული მართლაც მსგავსი struct რომ მივეცით თქვენ დასტის.

402
00:31:10,950 --> 00:31:13,770
>> თუმცა ერთი გამონაკლისი ამ, და რომ ერთი გამონაკლისი

403
00:31:13,770 --> 00:31:21,700
არის ის, რომ ჩვენ გვაქვს ეს დამატებითი რიცხვი მოუწოდა ხელმძღვანელი,

404
00:31:21,700 --> 00:31:28,120
და უფროსი აქ არის შესანახად სიმღერა უფროსის მდგომ,

405
00:31:28,120 --> 00:31:32,160
ან პირველი ელემენტია რიგიდან.

406
00:31:32,160 --> 00:31:37,470
With დასტის, ჩვენ შეგვეძლო ტრეკზე ელემენტს, რომ ჩვენ ვიყავით დაახლოებით ვიღებ,

407
00:31:37,470 --> 00:31:40,800
ან ზევით დასტის გამოყენებით უბრალოდ ზომა,

408
00:31:40,800 --> 00:31:44,220
ხოლო ერთად მდგომ, ჩვენ მქონე გამკლავება საპირისპირო შაბათ.

409
00:31:44,220 --> 00:31:49,000
ჩვენ ვცდილობთ, რომ Tack რამ წლის მიწურულს, მაგრამ შემდეგ დაბრუნდნენ ნივთები ფრონტზე.

410
00:31:49,000 --> 00:31:54,640
იმდენად ეფექტურად, უფროსთან, ჩვენ გვაქვს მაჩვენებელი დასაწყისში მდგომ,

411
00:31:54,640 --> 00:31:58,920
და ზომა გვაძლევს ინდექსი ბოლოს მდგომ

412
00:31:58,920 --> 00:32:03,730
ასე, რომ ჩვენ შეგვიძლია მივიღოთ ნივთები ხელმძღვანელი და დაამატოთ რამ შესახებ, რომ კუდი.

413
00:32:03,730 --> 00:32:06,890
ვინაიდან ერთად დასტის, ჩვენ მხოლოდ ოდესმე საქმე ზევით Stack.

414
00:32:06,890 --> 00:32:08,900
ჩვენ არასდროს ჰქონია წვდომისათვის ბოლოში დასტის.

415
00:32:08,900 --> 00:32:12,220
ჩვენ მხოლოდ რამ დაბრუნება და აიღო რამ გამორთვა დაბრუნება

416
00:32:12,220 --> 00:32:17,470
ამიტომ ჩვენ არ გვჭირდება, რომ ზედმეტი სფეროში შიგნით ჩვენი struct.

417
00:32:17,470 --> 00:32:20,590
ამჯამად რომ ზოგადად აზრი?

418
00:32:20,590 --> 00:32:27,670
ყველა უფლება. დიახ, Charlotte? [Charlotte, გაუგებარია]

419
00:32:27,670 --> 00:32:32,660
[Hardison] სწორედ დიდი კითხვა, და რომ იყო ერთი, რომ მოვიდა ლექციების.

420
00:32:32,660 --> 00:32:36,290
იქნებ გავლით რამდენიმე მაგალითი იქნება საილუსტრაციოდ, თუ რატომ

421
00:32:36,290 --> 00:32:41,400
ჩვენ არ გვინდა, რომ გამოიყენოთ სტრიქონები [0] უფროსად რიგიდან.

422
00:32:41,400 --> 00:32:46,770
>> ასე რომ წარმოიდგინეთ, რომ ჩვენ გვაქვს ჩვენი მდგომ, ჩვენ ვაპირებთ ეძახით რიგიდან.

423
00:32:46,770 --> 00:32:49,210
თავდაპირველად, როცა ჩვენ უბრალოდ instantiated ის,

424
00:32:49,210 --> 00:32:53,330
როდესაც ჩვენ უბრალოდ გამოაცხადა, ჩვენ არ ინიციალიზდება არაფერი.

425
00:32:53,330 --> 00:32:56,790
ეს ყველაფერი ნაგავი. ასე რომ, რა თქმა უნდა ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ ინიციალიზაცია

426
00:32:56,790 --> 00:33:00,950
ორივე ზომა და ხელმძღვანელი სფეროები იქნება 0, რაღაც გონივრული.

427
00:33:00,950 --> 00:33:05,770
ჩვენ შეგვიძლია აგრეთვე წავიდეთ წინ და null out ელემენტები ჩვენს რიგიდან.

428
00:33:05,770 --> 00:33:09,930
და იმისთვის, რომ ეს სქემა მორგებული, რომ ახლა ჩვენი მდგომ შეიძლება მხოლოდ გამართავს სამი ელემენტები;

429
00:33:09,930 --> 00:33:13,150
ხოლო ჩვენი დასტის შეიძლება გამართავს ოთხი, ჩვენი მდგომ შეიძლება მხოლოდ გამართავს სამი.

430
00:33:13,150 --> 00:33:18,680
და ეს მხოლოდ იმისათვის, რომ დიაგრამაზე მორგებული.

431
00:33:18,680 --> 00:33:26,150
პირველი, რაც ხდება აქ არის ჩვენ enqueue სტრიქონი "hi".

432
00:33:26,150 --> 00:33:30,380
და მხოლოდ ისე, როგორც ერთად დასტის, არაფერი საშინლად სხვადასხვა აქ,

433
00:33:30,380 --> 00:33:39,230
ჩვენ გადაყარეთ string ზე სტრიქონები [0] და ნამატი ჩვენი ზომა მიერ 1.

434
00:33:39,230 --> 00:33:42,720
ჩვენ enqueue "bye", იგი იღებს ჩაიცვი.

435
00:33:42,720 --> 00:33:45,870
ასე რომ, ეს ჰგავს დასტის ამისთვის დიდი ნაწილი.

436
00:33:45,870 --> 00:33:53,230
ჩვენ დავიწყეთ off აქ, ახალ ელემენტს, ახალი ელემენტი, ზომა ინახავს იზრდებოდა.

437
00:33:53,230 --> 00:33:56,330
რა ხდება ამ ეტაპზე, როცა ჩვენ გვინდა dequeue რაღაც?

438
00:33:56,330 --> 00:34:01,280
როდესაც ჩვენ გვინდა dequeue, რომელიც ელემენტს, რომ ჩვენ გვინდა dequeue?

439
00:34:01,280 --> 00:34:04,110
[ბასილ] სტრიქონები [0]. >> Zero. სწორედ, ბასილ.

440
00:34:04,110 --> 00:34:10,960
ჩვენ გვინდა, რომ თავი დაეღწია პირველი სიმებიანი, ამ ერთი, "hi".

441
00:34:10,960 --> 00:34:13,170
რა იყო სხვა საქმეა, რომ შეიცვალა?

442
00:34:13,170 --> 00:34:17,010
გაითვალისწინეთ, როდესაც ჩვენ popped რაღაც გამორთვა დასტის, ჩვენ უბრალოდ შეიცვალა ზომა,

443
00:34:17,010 --> 00:34:22,080
მაგრამ აქ, გვაქვს რამდენიმე რამ, რომ ცვლილება.

444
00:34:22,080 --> 00:34:27,440
არა მარტო ზომა ცვლილება, მაგრამ ხელმძღვანელი ცვლილებები.

445
00:34:27,440 --> 00:34:31,020
ეს ბრუნდება Charlotte მოსაზრებით ადრე:

446
00:34:31,020 --> 00:34:38,699
რატომ გვყავს ამ ხელმძღვანელი ისევე?

447
00:34:38,699 --> 00:34:42,110
ამჯამად ეს აზრი არის, Charlotte? >> სახის.

448
00:34:42,110 --> 00:34:47,500
[Hardison] სახის? მერე რა მოხდა, როცა ჩვენ dequeued?

449
00:34:47,500 --> 00:34:54,340
რა ხელმძღვანელი გავაკეთოთ, რომ ახლა არის საინტერესო?

450
00:34:54,340 --> 00:34:56,449
[Charlotte] Oh, რადგან ეს შეიცვალა - okay. მე ვხედავ.

451
00:34:56,449 --> 00:35:02,090
რადგან ხელმძღვანელი - სადაც უფროსი არის მიუთითებს ცვლილებების თვალსაზრისით საიდან.

452
00:35:02,090 --> 00:35:07,200
ეს აღარ ყოველთვის ნულოვანი ინდექსი ერთი. >> ჰო, ზუსტად.

453
00:35:07,200 --> 00:35:17,660
რა მოხდა, თუ dequeueing მაღალი ელემენტს

454
00:35:17,660 --> 00:35:20,590
გაკეთდა და არ გვქონდა ამ სფეროში ხელმძღვანელი

455
00:35:20,590 --> 00:35:26,880
რადგან ჩვენ ყოველთვის მოუწოდებდა ეს კონტექსტი at 0 ინდექსი ხელმძღვანელი ჩვენი მდგომ,

456
00:35:26,880 --> 00:35:30,170
მაშინ ჩვენ ავღნიშნო უნდა გადაეტანა დანარჩენი მდგომ ქვემოთ.

457
00:35:30,170 --> 00:35:36,010
მე მინდა უნდა გადაიტანოს "bye" საწყისი საწყისი სტრიქონები [1] რათა სტრიქონები [0].

458
00:35:36,010 --> 00:35:38,760
და სიმებიანი [2] ქვემოთ სტრიქონები [1].

459
00:35:38,760 --> 00:35:43,050
და ჩვენ გვინდა უნდა გავაკეთოთ ეს მთელი სიაში ელემენტები,

460
00:35:43,050 --> 00:35:45,110
მთელი რიგი ელემენტები.

461
00:35:45,110 --> 00:35:50,490
ხოლო როდესაც ვაკეთებთ ამ მასივი, რომ იღებს მართლაც ძვირი.

462
00:35:50,490 --> 00:35:53,340
ასე რომ აქ, ეს არ დიდი გარიგება. ჩვენ მხოლოდ სამი ელემენტები ჩვენს მასივი.

463
00:35:53,340 --> 00:35:57,230
მაგრამ თუ ჩვენ გვქონდა რიგი ათასი ელემენტები ან მილიონი ელემენტები,

464
00:35:57,230 --> 00:36:00,060
და მერე უეცრად, ჩვენ ვიწყებთ მიღების bunch of dequeue მოუწოდებს ყველა მარყუჟის,

465
00:36:00,060 --> 00:36:03,930
რამ ნამდვილად აპირებს შენელდება როგორც ეს ინაცვლებს ყველაფერი ქვევით მუდმივად.

466
00:36:03,930 --> 00:36:07,320
თქვენ იცით, გადაეტანა მიერ 1, ცვლა მიერ 1, ცვლა მიერ 1, ცვლა მიერ 1.

467
00:36:07,320 --> 00:36:13,650
სამაგიეროდ, ჩვენ ვიყენებთ ამ ხელმძღვანელი, ჩვენ მას "კურსორი" მიუხედავად იმისა, რომ ეს ნამდვილად არ მომცეთ

468
00:36:13,650 --> 00:36:16,430
წელს მკაცრი გაგებით, ეს არ მომცეთ ტიპის.

469
00:36:16,430 --> 00:36:19,410
ეს არ int * ან char * ან რამე მაგდაგვარს.

470
00:36:19,410 --> 00:36:28,930
მაგრამ მიუთითებს ან მითითებით ხელმძღვანელი ჩვენი რიგიდან. ჰო?

471
00:36:28,930 --> 00:36:38,800
>> [სტუდენტური] როგორ ამჯამად dequeue ვიცი უბრალოდ პოპ off რაც სათავეში?

472
00:36:38,800 --> 00:36:43,620
[Hardison] როგორ ამჯამად dequeue ვიცი როგორ პოპ off რასაც არის სათავეში? >> მარჯვენა, yeah.

473
00:36:43,620 --> 00:36:49,050
>> რასაც ის ეძებს მხოლოდ რასაც ხელმძღვანელი სფეროში არის მითითებული.

474
00:36:49,050 --> 00:36:52,710
ამიტომ ამ პირველ შემთხვევაში, თუ გადავხედავთ უფლება აქ,

475
00:36:52,710 --> 00:36:55,690
ჩვენი ხელმძღვანელი არის 0, ინდექსი 0. >> მარჯვენა.

476
00:36:55,690 --> 00:37:00,500
[Hardison] ასე რომ უბრალოდ ამბობს okay, ისევე, ელემენტს საათზე ინდექსი 0, სტრიქონი "hi",

477
00:37:00,500 --> 00:37:03,050
არის ელემენტს სათავეში ჩვენი რიგიდან.

478
00:37:03,050 --> 00:37:05,570
ამიტომ, ჩვენ ვაპირებთ, რომ dequeue guy.

479
00:37:05,570 --> 00:37:09,800
და რომ იქნება ელემენტს რომ იღებს დაბრუნდა Caller.

480
00:37:09,800 --> 00:37:14,540
დიახ, Saad? >> ამიტომ ხელმძღვანელი ძირითადად ადგენს - სადაც თქვენ აპირებთ მაჩვენებლით იგი?

481
00:37:14,540 --> 00:37:17,750
სწორედ დაწყების ეს? >> Yeah. >> Okay.

482
00:37:17,750 --> 00:37:22,900
[Hardison] სწორედ ხდება ახალი სტარტის ჩვენი მასივი.

483
00:37:22,900 --> 00:37:28,930
ასე რომ, როდესაც თქვენ dequeue რაღაც, ყველა თქვენ უნდა გააკეთოთ შედიხართ ელემენტს საათზე ინდექსი q.head,

484
00:37:28,930 --> 00:37:32,240
და რომ იქნება ელემენტს რომ გსურთ dequeue.

485
00:37:32,240 --> 00:37:34,930
თქვენ ასევე უნდა decrement ზომა.

486
00:37:34,930 --> 00:37:39,430
ჩვენ ვხედავთ ცოტა აქ რამ კიდევ ცოტა სახიფათო ამ.

487
00:37:39,430 --> 00:37:46,520
ჩვენ dequeue, და ახლა, თუ ჩვენ enqueue ერთხელ,

488
00:37:46,520 --> 00:37:51,300
სად ჩვენ enqueue?

489
00:37:51,300 --> 00:37:55,000
სად მომდევნო ელემენტს წავიდეს ჩვენი მდგომ?

490
00:37:55,000 --> 00:37:57,980
Say გვინდა enqueue სტრიქონი "CS".

491
00:37:57,980 --> 00:38:02,240
, სადაც ინდექსი იქნება ეს წასვლა? [სტუდენტთა] სტრიქონები [2]. >> ორი.

492
00:38:02,240 --> 00:38:04,980
რატომ 2 და არა 0?

493
00:38:04,980 --> 00:38:13,570
[ბასილ] რადგან ახლა უფროსი არის 1, ასე რომ ჰგავს დაწყების სიაში?

494
00:38:13,570 --> 00:38:21,220
[Hardison] მარჯვენა. და რა ნიშნავს სიის ბოლოში?

495
00:38:21,220 --> 00:38:23,290
რა იყო ჩვენ იყენებს აღინიშნოს ბოლოს ჩვენი მდგომ?

496
00:38:23,290 --> 00:38:25,970
უფროსი არის უფროსი ჩვენი მდგომ, დასაწყისში ჩვენი რიგიდან.

497
00:38:25,970 --> 00:38:29,530
რა არის ბოლოს ჩვენი მდგომ? [სტუდენტთა] ზომა. >> ზომა, ზუსტად.

498
00:38:29,530 --> 00:38:36,360
ასე რომ ჩვენი ახალი ელემენტები წავიდეს საათზე ზომა, და ელემენტები რომ ჩვენ გამეხადა მოდის გამორთვას ხელმძღვანელი.

499
00:38:36,360 --> 00:38:45,390
როდესაც ჩვენ enqueue შემდეგი ელემენტის, ჩვენ აყენებს მას დროს ზომა.

500
00:38:45,390 --> 00:38:48,530
[სტუდენტური] სანამ დააყენა, რომ თუმცა, ზომა იყო 1, არა?

501
00:38:48,530 --> 00:38:55,690
[Hardison] მარჯვენა. ასე რომ არ საკმაოდ საათზე ზომა. ზომა +, არ +1, მაგრამ + ხელმძღვანელი.

502
00:38:55,690 --> 00:38:59,990
იმიტომ, რომ ჩვენ გადაინაცვლა ყველაფერი ხელმძღვანელის მიერ თანხა.

503
00:38:59,990 --> 00:39:14,270
ასე რომ აქ, ახლა გვაქვს რიგი ზომა 1 რომ იწყება ინდექსი 1.

504
00:39:14,270 --> 00:39:20,730
კუდი არის ინდექსი 2. დიახ?

505
00:39:20,730 --> 00:39:25,780
>> [სტუდენტური] რა ხდება, როდესაც თქვენ dequeue სტრიქონები [0], და სტრიქონები 'slots ხსოვნის

506
00:39:25,780 --> 00:39:29,420
უბრალოდ დაიცალა, ძირითადად, ან უბრალოდ დავიწყებული?

507
00:39:29,420 --> 00:39:34,700
[Hardison] Yeah. ამ თვალსაზრისით, ჩვენ უბრალოდ ივიწყებს მათ.

508
00:39:34,700 --> 00:39:42,640
თუ ჩვენ შენახვის ასლები მათ -

509
00:39:42,640 --> 00:39:46,310
ბევრი მონაცემები სტრუქტურების ხშირად შესანახად საკუთარი ასლები ელემენტები

510
00:39:46,310 --> 00:39:51,760
ისე, რომ პირი მართვის მონაცემები სტრუქტურა ამჯამად არ ინერვიულოთ

511
00:39:51,760 --> 00:39:53,650
შესახებ, სადაც ყველა იმ მითითებას ვაპირებთ.

512
00:39:53,650 --> 00:39:56,000
მონაცემები სტრუქტურა ფლობს შესახებ, რომ ყველაფერი, ფლობს შესახებ, რომ ყველა ეგზემპლარი,

513
00:39:56,000 --> 00:39:59,580
რომ დავრწმუნდეთ, რომ ყველაფერი კვლავ სათანადოდ.

514
00:39:59,580 --> 00:40:03,140
თუმცა, ამ შემთხვევაში, ეს მონაცემები სტრუქტურების უბრალოდ, სიმარტივის,

515
00:40:03,140 --> 00:40:05,580
არ მიღების ასლები არაფერი რომ ჩვენ შენახვის მათ.

516
00:40:05,580 --> 00:40:08,630
[სტუდენტური] ასე არის ეს უწყვეტი მასივი -? >> დიახ.

517
00:40:08,630 --> 00:40:14,350
თუ ჩვენ ვიხსენებთ რა განმარტება იყო ამ სტრუქტურის, ის არის.

518
00:40:14,350 --> 00:40:19,110
უბრალოდ სტანდარტული მასივი თქვენნაირი ვხედავთ,

519
00:40:19,110 --> 00:40:24,280
მასივი char * s.

520
00:40:24,280 --> 00:40:26,340
Does რომ -? >> ჰო, მე უბრალოდ მაინტერესებს

521
00:40:26,340 --> 00:40:29,130
თუ თქვენ საბოლოოდ ამოიწურა მეხსიერება, გარკვეულწილად,

522
00:40:29,130 --> 00:40:32,330
თუ თქვენ გაქვთ ყველა ამ ცარიელი ლაქების თქვენს მასივი?

523
00:40:32,330 --> 00:40:36,390
[Hardison] ჰო, კარგი წერტილი.

524
00:40:36,390 --> 00:40:41,530
>> თუ დავაკვირდებით, რა მოხდა ახლა, ამ ეტაპზე,

525
00:40:41,530 --> 00:40:46,350
ჩვენ შეივსო ჩვენი მდგომ, გამოიყურება.

526
00:40:46,350 --> 00:40:50,390
მაგრამ ჩვენ ნამდვილად არ შეივსო ჩვენი მდგომ

527
00:40:50,390 --> 00:40:57,710
იმიტომ რომ ჩვენ გვაქვს მდგომ რომ ზომა 2, მაგრამ ეს იწყება ინდექსი 1,

528
00:40:57,710 --> 00:41:02,160
რადგან ისინი, სადაც ჩვენი უფროსი კურსორი არის.

529
00:41:02,160 --> 00:41:08,400
თქვენნაირი ამბობდნენ, რომ ელემენტს საათზე სტრიქონები [0], საღამოს ინდექსი 0, არ არის ნამდვილად არსებობს.

530
00:41:08,400 --> 00:41:10,450
ეს არ არის ჩვენი მდგომ უქმნით.

531
00:41:10,450 --> 00:41:16,460
ჩვენ უბრალოდ არ გადაიტვირთოთ წავიდეთ და გადაწერა, როდესაც ჩვენ dequeued იგი.

532
00:41:16,460 --> 00:41:18,700
ასე რომ მიუხედავად იმისა, რომ ჰგავს ჩვენ ამოიწურა მეხსიერება, ჩვენ ნამდვილად არ.

533
00:41:18,700 --> 00:41:23,270
რომ ადგილზე ხელმისაწვდომია ჩვენთვის გამოიყენოს.

534
00:41:23,270 --> 00:41:29,310
შესაბამისი ქცევა, თუ ჩვენ უნდა შევეცადოთ და პირველი dequeue რაღაც

535
00:41:29,310 --> 00:41:34,420
როგორც "bye", რომელიც პოპ bye off.

536
00:41:34,420 --> 00:41:38,460
ახლა ჩვენი მდგომ იწყება ინდექსი 2 და არის ზომა 1.

537
00:41:38,460 --> 00:41:42,240
და ახლა თუ ჩვენ ვცდილობთ და enqueue რაიმეს, ვთქვათ 50,

538
00:41:42,240 --> 00:41:47,880
50 უნდა წავიდეს ამ ადგილზე დროს ინდექსი 0

539
00:41:47,880 --> 00:41:51,270
იმიტომ რომ ჯერ კიდევ არის შესაძლებელი ჩვენთვის. დიახ, Saad?

540
00:41:51,270 --> 00:41:53,630
[Saad] არა, რომ მოხდეს ავტომატურად?

541
00:41:53,630 --> 00:41:56,150
[Hardison] ეს არ მოხდება საკმაოდ ავტომატურად. ამისათვის მათემატიკის

542
00:41:56,150 --> 00:42:00,380
რათა ის იმუშავებს, მაგრამ არსებითად, რაც ჩვენ გავაკეთეთ არის ჩვენ უბრალოდ გახვეული გარშემო.

543
00:42:00,380 --> 00:42:04,070
[Saad] და ეს okay, თუ ეს ხვრელი შუა იგი?

544
00:42:04,070 --> 00:42:08,720
[Hardison] ეს თუ შეიძლება გავაკეთოთ მათემატიკის შეიმუშაოს სათანადოდ.

545
00:42:08,720 --> 00:42:15,470
>> და აღმოჩნდება, რომ სინამდვილეში არ არის, რომ ძნელია საერთო mod ოპერატორს.

546
00:42:15,470 --> 00:42:20,040
ასე რომ, ისევე, როგორც ჩვენ შემოიერთა Caesar და შიფრის პერსონალის,

547
00:42:20,040 --> 00:42:25,190
გამოყენებით mod, ჩვენ შეუძლია მიიღოს რამ გადაიტანოთ გარშემო და შეინახოს აპირებს

548
00:42:25,190 --> 00:42:28,090
გარშემო და ირგვლივ და გარშემო ჩვენს მდგომ,

549
00:42:28,090 --> 00:42:32,180
შენახვა, რომ ხელმძღვანელი მაჩვენებელი გადაადგილდებოდნენ.

550
00:42:32,180 --> 00:42:38,840
გაითვალისწინეთ, რომ ზომის ყოველთვის პატივისცემის რაოდენობის ელემენტები რეალურად ფარგლებში რიგი.

551
00:42:38,840 --> 00:42:43,110
და ეს მხოლოდ უფროსის მაჩვენებელი, ინახავს Cycling მეშვეობით.

552
00:42:43,110 --> 00:42:49,660
თუ დავაკვირდებით, თუ რა მოხდა აქ, თუ ჩვენ დავუბრუნდებით დასაწყისში,

553
00:42:49,660 --> 00:42:55,020
და უბრალოდ უყურეთ რა მოსდის ხელმძღვანელი

554
00:42:55,020 --> 00:42:58,240
როდესაც ჩვენ enqueue რაღაც, არაფერი მოხდა ხელმძღვანელი.

555
00:42:58,240 --> 00:43:00,970
როდესაც ჩვენ enqueued რაღაც, არაფერი მოხდა ხელმძღვანელი.

556
00:43:00,970 --> 00:43:04,130
მალე ჩვენ dequeued რაღაც, უფროსი მიდის up ერთი.

557
00:43:04,130 --> 00:43:06,600
ჩვენ enqueued რაღაც, არაფერი მოხდება, უფროსი.

558
00:43:06,600 --> 00:43:11,060
როდესაც ჩვენ dequeue რაღაც, უეცრად ხელმძღვანელი იღებს incremented.

559
00:43:11,060 --> 00:43:14,660
როდესაც ჩვენ enqueue რაღაც, არაფერი მოხდება, უფროსი.

560
00:43:14,660 --> 00:43:20,240
>> რა მოხდება, ამ ეტაპზე, თუ ჩვენ dequeue რაიმეს?

561
00:43:20,240 --> 00:43:23,240
ნებისმიერი აზრები? რა მოხდება რომ ხელმძღვანელი?

562
00:43:23,240 --> 00:43:27,190
რა უნდა მოხდეს, რათა უფროსმა

563
00:43:27,190 --> 00:43:32,990
თუ ჩვენ უნდა dequeue რაღაც?

564
00:43:32,990 --> 00:43:35,400
ხელმძღვანელი ახლავე არის ინდექსი 2,

565
00:43:35,400 --> 00:43:38,920
რაც იმას ნიშნავს, რომ ხელმძღვანელი მდგომ არის სტრიქონები [2].

566
00:43:38,920 --> 00:43:44,280
[სტუდენტური], რომელიც დააბრუნებს 0? >> იგი უნდა დაუბრუნდეს 0. უნდა გადაიტანოთ უკან გარშემო, ზუსტად.

567
00:43:44,280 --> 00:43:48,440
ჯერჯერობით, ყოველ ჯერზე ჩვენ მოუწოდა dequeue, ჩვენ დასძინა ერთი ხელმძღვანელი,

568
00:43:48,440 --> 00:43:50,960
დაამატოთ ერთი ხელმძღვანელი, დაამატოთ ერთი ხელმძღვანელი, დაამატოთ ერთი ხელმძღვანელი.

569
00:43:50,960 --> 00:43:58,400
როგორც კი რომ ხელმძღვანელი კურსორი იღებს ბოლო ინდექსი ჩვენს მასივი,

570
00:43:58,400 --> 00:44:05,650
მაშინ ჩვენ უნდა გადაიტანოთ უკან გარშემო დასაწყისში, დავუბრუნდეთ 0.

571
00:44:05,650 --> 00:44:09,900
[Charlotte] რა განსაზღვრავს რანგში რიგში დასტის?

572
00:44:09,900 --> 00:44:13,120
[Hardison] ამ შემთხვევაში ჩვენ უბრალოდ იყენებს # განსაზღვრული მუდმივი. >> Okay.

573
00:44:13,120 --> 00:44:19,590
[Hardison] თავად. გ ფაილის, შეგიძლიათ გადასვლა და Muck მასთან ცოტა

574
00:44:19,590 --> 00:44:21,710
და იყოს იგი, როგორც დიდი თუ როგორც პატარა, როგორც გსურთ.

575
00:44:21,710 --> 00:44:25,310
[Charlotte] ასე რომ, როდესაც თქვენ რაც მას მდგომ, როგორ გავხადოთ კომპიუტერის ვიცი

576
00:44:25,310 --> 00:44:29,120
რამდენად დიდი გსურთ დასტის იქნება?

577
00:44:29,120 --> 00:44:31,700
[Hardison] სწორედ დიდი კითხვაზე.

578
00:44:31,700 --> 00:44:34,800
არსებობს რამდენიმე გზა არსებობს. ერთი არის ის, რომ მხოლოდ განსაზღვროს ის წინა

579
00:44:34,800 --> 00:44:42,050
და ამბობენ, რომ ეს იქნება მდგომ რომ აქვს 4 ელემენტები ან 50 ელემენტები ან 10,000.

580
00:44:42,050 --> 00:44:45,430
სხვა გზა არის რა ჰაკერი გამოცემა FOLKS ვაკეთებთ

581
00:44:45,430 --> 00:44:52,310
და შექმნას ფუნქციები თქვენი მდგომ იზრდება დინამიურად როგორც რამ მისაღებად დასძინა სისტემაში

582
00:44:52,310 --> 00:44:54,740
>> [Charlotte] ასე წავიდეთ ერთად პირველი ვარიანტი, რა სინტაქსი იყენებთ

583
00:44:54,740 --> 00:44:57,830
ვუთხრა პროგრამის რა არის ზომა მდგომ?

584
00:44:57,830 --> 00:45:04,780
[Hardison] Ah. მოდით გავიდნენ ამ.

585
00:45:04,780 --> 00:45:12,650
მე ჯერ კიდევ stack.c აქ, ამიტომ მე უბრალოდ აპირებს გადახვევა მდე დაბრუნება აქ.

586
00:45:12,650 --> 00:45:17,920
აბა ნახეთ ეს უფლება აქ? ეს არის # განსაზღვრავს ტევადობა 10.

587
00:45:17,920 --> 00:45:24,600
და ეს არის თითქმის ზუსტად იგივე სინტაქსი, რომ ჩვენ გვაქვს ამისთვის რიგიდან.

588
00:45:24,600 --> 00:45:28,390
გარდა რიგში, ჩვენ მივიღეთ, რომ ზედმეტი struct სფეროში აქ.

589
00:45:28,390 --> 00:45:32,760
[Charlotte] Oh, ვიფიქრე მოცულობა ნიშნავდა ტევადობა სიმებიანი.

590
00:45:32,760 --> 00:45:36,770
[Hardison] Ah. >> რომ მაქსიმალური სიგრძე სიტყვა. >> Got It.

591
00:45:36,770 --> 00:45:41,180
Yeah. სიმძლავრე აქ - რომ დიდი წერტილი.

592
00:45:41,180 --> 00:45:44,000
და ეს არის ის, რომ სახიფათო

593
00:45:44,000 --> 00:45:49,480
რადგან ის, რაც ჩვენ განაცხადა აქ არის მასივი char * s.

594
00:45:49,480 --> 00:45:52,770
მასივი პოინტერები.

595
00:45:52,770 --> 00:45:56,690
ეს არის მასივი სიმბოლო.

596
00:45:56,690 --> 00:46:01,690
ეს არის ალბათ, რასაც თქვენ ვხედავთ, როდესაც თქვენ უკვე გამოცხადების თქვენი ბუფერი ამისთვის ფაილის I / O,

597
00:46:01,690 --> 00:46:06,840
როდესაც თქვენ უკვე შექმნა სიმები ხელით on Stack.

598
00:46:06,840 --> 00:46:09,090
თუმცა, რა გვაქვს აქ არის მასივი char * s.

599
00:46:09,090 --> 00:46:13,400
ამიტომ მასივი პოინტერები.

600
00:46:13,400 --> 00:46:18,350
სინამდვილეში, თუკი ჩვენ უკან zoom out და შევხედავთ რა ხდება აქ

601
00:46:18,350 --> 00:46:23,140
in პრეზენტაცია, ხედავთ, რომ ფაქტობრივი ელემენტები, ხასიათი მონაცემები

602
00:46:23,140 --> 00:46:26,180
არ ინახება ფარგლებში მასივი თავისთავად.

603
00:46:26,180 --> 00:46:42,690
რა ინახება შიგნით ჩვენი მასივი აქ მითითებას ხასიათი მონაცემები.

604
00:46:42,690 --> 00:46:52,560
Okay. ასე რომ, ჩვენ ვხედავთ, თუ როგორ ზომა მდგომ უბრალოდ ისევე დასტის,

605
00:46:52,560 --> 00:46:58,670
ზომა ყოველთვის პატივს სცემს რაოდენობის ელემენტები ამჟამად რიგიდან.

606
00:46:58,670 --> 00:47:02,720
შემდეგ 2 enqueues, ზომა არის 2.

607
00:47:02,720 --> 00:47:07,110
შემდეგ dequeue ზომა არის 1.

608
00:47:07,110 --> 00:47:09,330
შემდეგ კიდევ ერთი enqueue ზომა არის უკან მდე 2.

609
00:47:09,330 --> 00:47:12,340
ასე ზომა ნამდვილად პატივს სცემს რაოდენობის ელემენტების რიგში,

610
00:47:12,340 --> 00:47:15,580
და შემდეგ ხელმძღვანელი მხოლოდ ინახავს Cycling.

611
00:47:15,580 --> 00:47:20,210
იგი მიემართება 0-1-2, 0-1-2, 0-1-2.

612
00:47:20,210 --> 00:47:25,620
და ყოველ ჯერზე ჩვენ მოვუწოდებთ dequeue, უფროსი კურსორი იღებს incremented მომდევნო ინდექსი.

613
00:47:25,620 --> 00:47:29,930
და თუ ხელმძღვანელი დაახლოებით წასვლა მეტი, ის მარყუჟების უკან გარშემო 0.

614
00:47:29,930 --> 00:47:34,870
ასე რომ, ჩვენ შეგვიძლია დავწეროთ dequeue ფუნქცია.

615
00:47:34,870 --> 00:47:40,200
და ჩვენ მიემგზავრება enqueue ფუნქცია თქვენ ბიჭები განახორციელოს ნაცვლად.

616
00:47:40,200 --> 00:47:45,880
>> როდესაც ჩვენ dequeue ელემენტს ჩვენი მდგომ,

617
00:47:45,880 --> 00:47:55,490
რა იყო პირველი, რაც გააკეთა დენიელ როდესაც ჩვენ დავიწყეთ წერა pop ფუნქცია stacks?

618
00:47:55,490 --> 00:48:00,490
ნება მომეცით მოვისმინოთ ვინმეს არ გამოუთქვამს არავის გაუკეთებია.

619
00:48:00,490 --> 00:48:06,710
ვნახოთ, Saad, გახსოვთ რას დანიელ გააკეთეს როგორც პირველი, რაც მაშინ, როდესაც მან დაწერა Pop?

620
00:48:06,710 --> 00:48:08,860
[Saad] იყო, ეს იყო - >> მან ტესტირება რაღაც.

621
00:48:08,860 --> 00:48:12,140
[Saad] თუ ზომა მეტია 0. >> ზუსტად.

622
00:48:12,140 --> 00:48:14,390
და რა იყო, რომ ტესტირება?

623
00:48:14,390 --> 00:48:19,090
[Saad] ამის ტესტირების თუ არსებობს რაიმე შიგნით მასივი.

624
00:48:19,090 --> 00:48:23,210
[Hardison] Yeah. სწორედ. ასე, რომ თქვენ ვერ პოპ არაფერი გარეთ დასტის თუ ცარიელი.

625
00:48:23,210 --> 00:48:26,510
ანალოგიურად, ვერ dequeue არაფერს მდგომ თუ ცარიელი.

626
00:48:26,510 --> 00:48:30,420
რა არის პირველი რამ უნდა გავაკეთოთ ჩვენი dequeue ფუნქცია აქ, როგორ ფიქრობთ?

627
00:48:30,420 --> 00:48:33,860
[Saad] თუ ზომა მეტია 0? >> Yeah.

628
00:48:33,860 --> 00:48:37,710
ამ შემთხვევაში, მე რეალურად მხოლოდ გამოცდილი, რომ ნახოთ თუ ის არის 0.

629
00:48:37,710 --> 00:48:42,240
თუ ეს 0, შეგვიძლია დაბრუნების null.

630
00:48:42,240 --> 00:48:45,280
მაგრამ ზუსტად იგივე ლოგიკით.

631
00:48:45,280 --> 00:48:49,110
და მოდით გავაგრძელოთ ამ.

632
00:48:49,110 --> 00:48:54,600
თუ ზომა არ არის 0, სად არის ელემენტს, რომ ჩვენ გვინდა dequeue?

633
00:48:54,600 --> 00:48:58,550
[Saad] სათავეში? >> ზუსტად.

634
00:48:58,550 --> 00:49:01,720
ჩვენ შეგვიძლია მხოლოდ გაიყვანოს პირველი ელემენტია ჩვენი მდგომ

635
00:49:01,720 --> 00:49:07,040
შესვლით ელემენტს სათავეში.

636
00:49:07,040 --> 00:49:14,630
არაფერი გიჟები.

637
00:49:14,630 --> 00:49:19,620
ამის შემდეგ, რა უნდა გავაკეთოთ? რა უნდა მოხდეს?

638
00:49:19,620 --> 00:49:23,740
რა იყო სხვა რამ, რომ ჩვენ ვისაუბრეთ იმ dequeue?

639
00:49:23,740 --> 00:49:28,130
ორი რამ უნდა მოხდეს, რადგან ჩვენი მდგომ შეიცვალა.

640
00:49:28,130 --> 00:49:35,640
[დანიელ] შემცირება ზომა. >> ჩვენ უნდა შეამციროს ზომა, და გაზრდის ხელმძღვანელი? სწორედ.

641
00:49:35,640 --> 00:49:40,600
გაზრდის ხელმძღვანელი, ჩვენ შეგვიძლია არა მხოლოდ ბრმად გაზრდა ხელმძღვანელი, მახსოვს.

642
00:49:40,600 --> 00:49:45,080
ჩვენ არ შეგვიძლია უბრალოდ queue.head + +.

643
00:49:45,080 --> 00:49:51,630
ჩვენ უნდა შეიცავდეს აგრეთვე ამ mod მიერ მოცულობა.

644
00:49:51,630 --> 00:49:54,740
რატომ ჩვენ თავდაცვის სამინისტროს მიერ მოცულობა, Stella?

645
00:49:54,740 --> 00:49:58,680
[Stella] იმიტომ, რომ მან უნდა გადაიტანოთ გარშემო. >> ზუსტად.

646
00:49:58,680 --> 00:50:04,750
ჩვენ mod მიერ მოცულობა, რადგან ის უნდა გადაიტანოთ უკან გარშემო 0.

647
00:50:04,750 --> 00:50:07,400
ასე რომ ახლა, ამ ეტაპზე, ჩვენ შეგვიძლია გავაკეთოთ ის, რაც დანიელ განაცხადა.

648
00:50:07,400 --> 00:50:12,700
ჩვენ შეგვიძლია decrement ზომა.

649
00:50:12,700 --> 00:50:29,170
და მაშინ ჩვენ შეგვიძლია უბრალოდ დააბრუნოს ელემენტს რომ იყო ზედა რიგში.

650
00:50:29,170 --> 00:50:34,000
როგორც ჩანს სახის gnarly თავდაპირველად. ალბათ კითხვა. უკაცრავად?

651
00:50:34,000 --> 00:50:37,260
>> [სემ] რატომ არის პირველი ზედა რიგში? სად, რომ წავიდეთ?

652
00:50:37,260 --> 00:50:42,480
[Hardison] მოდის მეოთხე ხაზის ბოლოში.

653
00:50:42,480 --> 00:50:46,060
შემდეგ ჩვენ ვამოწმებთ დავრწმუნდეთ, რომ ჩვენი მდგომ არ არის ცარიელი,

654
00:50:46,060 --> 00:50:54,100
ჩვენ გაიყვანოს char * პირველი, ჩვენ გაიყვანოს ელემენტს რომ ზის ხელმძღვანელი ინდექსი

655
00:50:54,100 --> 00:50:58,680
ჩვენი მასივი, ჩვენი სიმები მასივი, >> და მოწოდება, რომ პირველი?

656
00:50:58,680 --> 00:51:04,500
[Hardison] და ჩვენ მას პირველი. Yeah.

657
00:51:04,500 --> 00:51:09,850
უბრალოდ თვალყური რომ, როგორ ფიქრობთ, რატომ გვქონდა ამის გაკეთება?

658
00:51:09,850 --> 00:51:18,270
[სემ] ყოველი პირველი უბრალოდ დაბრუნების q.strings [q.head]? >> Yeah.

659
00:51:18,270 --> 00:51:23,830
>> გამო ვაკეთებთ ამ ცვლილებები q.head ერთად თავდაცვის სამინისტროს ფუნქცია,

660
00:51:23,830 --> 00:51:27,810
და არ არსებობს გზა ამის, რომ ვადაში დაბრუნების ხაზი ასევე.

661
00:51:27,810 --> 00:51:31,640
[Hardison] ზუსტად. თქვენ ადგილზე. სემ სრულიად ადგილზე.

662
00:51:31,640 --> 00:51:36,800
მიზეზი გვქონდა გაიყვანოს პირველი ელემენტია ჩვენი მდგომ და ჩაწეროთ იგი შევიდა ცვლადი

663
00:51:36,800 --> 00:51:43,030
არის იმიტომ, რომ ეს ხაზი, სადაც ჩვენ უბრალოდ q.head,

664
00:51:43,030 --> 00:51:47,030
არსებობს თავდაცვის სამინისტროს ოპერატორი არ არის რაღაც, რაც ჩვენ შეგვიძლია გავაკეთოთ

665
00:51:47,030 --> 00:51:51,230
და არ ხდება გავლენას ხელმძღვანელი გარეშე - ერთ ხაზზე.

666
00:51:51,230 --> 00:51:54,480
ამიტომ, ჩვენ რეალურად უნდა გაიყვანოს პირველ ელემენტს, მაშინ შეცვალოს ხელმძღვანელი,

667
00:51:54,480 --> 00:52:00,430
შეცვალოს ზომა, ხოლო შემდეგ დაბრუნდნენ ელემენტს რომ ჩვენ გაყვანილია.

668
00:52:00,430 --> 00:52:02,680
და ეს არის ის, რომ ჩვენ დავინახავთ ამუშავება მოგვიანებით

669
00:52:02,680 --> 00:52:04,920
უკავშირდება სიები, როგორც ჩვენ თამაშობენ გარშემო მათთან.

670
00:52:04,920 --> 00:52:08,410
ხშირად, როდესაც თქვენ გამონთავისუფლების ან არსებითად დაკავშირებულია სიები

671
00:52:08,410 --> 00:52:13,500
თქვენ უნდა გვახსოვდეს შემდეგი ელემენტის, შემდეგი მაჩვენებელი საქართველოს უკავშირდება სია

672
00:52:13,500 --> 00:52:16,330
ადრე განკარგვის მიმდინარე ერთი.

673
00:52:16,330 --> 00:52:23,580
რადგან, წინააღმდეგ შემთხვევაში თქვენ გადაყარეთ ინფორმაციით, რა დარჩა სიაში.

674
00:52:23,580 --> 00:52:34,160
ახლა კი, თუ წასვლა თქვენი მოწყობილობის, თქვენ გახსენით queue.c--x ამ.

675
00:52:34,160 --> 00:52:39,390
ასე რომ, თუ მე გახსენით queue.c, ნება მომეცით მიუახლოვდით აქ,

676
00:52:39,390 --> 00:52:44,970
თქვენ ნახავთ, რომ თქვენ გაქვთ მსგავსი ორიენტირებული ფაილი.

677
00:52:44,970 --> 00:52:49,200
მსგავსი ორიენტირებული ფაილი რა გვქონდა ადრე stack.c.

678
00:52:49,200 --> 00:52:54,690
გვაქვს ჩვენი struct ამისთვის მდგომ განსაზღვრული, ისევე როგორც დავინახეთ on სლაიდები.

679
00:52:54,690 --> 00:52:59,870
>> ჩვენ გვაქვს ჩვენი enqueue ფუნქცია რომელიც თქვენთვის უნდა გააკეთოს.

680
00:52:59,870 --> 00:53:04,340
და ჩვენ გვაქვს dequeue ფუნქცია აქ.

681
00:53:04,340 --> 00:53:06,870
Dequeue ფუნქცია ფაილი unimplemented,

682
00:53:06,870 --> 00:53:13,230
მაგრამ მე ამას უკან მდე PowerPoint ასე რომ თქვენ შეგიძლიათ აკრიფოთ ის, თუ გსურთ.

683
00:53:13,230 --> 00:53:16,690
ასე რომ, მომავალი 5 წუთის ან ისე, თქვენ ბიჭები მუშაობა enqueue

684
00:53:16,690 --> 00:53:22,570
რომელიც თითქმის მხოლოდ საპირისპირო dequeue.

685
00:53:22,570 --> 00:53:29,560
თქვენ არ შეცვალოს ხელმძღვანელი როცა თქვენ enqueueing, მაგრამ რას უნდა შეცვალოს?

686
00:53:29,560 --> 00:53:38,920
ზომა. ასე რომ, როდესაც თქვენ enqueue, უფროსი რჩება ხელშეუხებელი, ზომა იღებს შეიცვალა.

687
00:53:38,920 --> 00:53:46,920
მაგრამ ეს იმას იღებენ ცოტა - თქვენ უნდა ითამაშოს გარშემო რომ mod

688
00:53:46,920 --> 00:53:57,560
გაერკვნენ, თუ რა ინდექსი ახალ ელემენტს უნდა ჩასმული დროს.

689
00:53:57,560 --> 00:54:03,080
ამიტომ მე მივცემ თქვენ ბიჭები ცოტა, დაუსვან dequeue back up on the slide,

690
00:54:03,080 --> 00:54:05,200
და როგორც თქვენ ბიჭებს აქვთ კითხვები, shout მათ, რათა შევძლოთ

691
00:54:05,200 --> 00:54:09,220
ყველა საუბარი მათ ჯგუფს.

692
00:54:09,220 --> 00:54:13,960
ასევე, ერთად ზომა თქვენ don't - როდესაც თქვენ შეცვალოს ზომა, თქვენ ყოველთვის შეგიძლიათ უბრალოდ -

693
00:54:13,960 --> 00:54:18,720
გაქვთ mod ზომა ოდესმე? [დანიელ] მდებარ >> თქვენ არ mod ზომა, სწორი.

694
00:54:18,720 --> 00:54:24,260
რადგან ზომა ყოველთვის, თუ you're - ვთქვათ, თქვენ მმართველი რამ სათანადოდ,

695
00:54:24,260 --> 00:54:30,840
ზომა ყოველთვის იყოს 0 და 3.

696
00:54:30,840 --> 00:54:38,680
სად უნდა mod როდესაც თქვენ აკეთებთ enqueue?

697
00:54:38,680 --> 00:54:41,060
[სტუდენტური] მხოლოდ ხელმძღვანელი. >> მხოლოდ ხელმძღვანელი, ზუსტად.

698
00:54:41,060 --> 00:54:44,620
რატომ უნდა mod ყველა იმ enqueue?

699
00:54:44,620 --> 00:54:48,830
როდესაც არის სიტუაცია, რომელიც ნეტავ უნდა mod?

700
00:54:48,830 --> 00:54:53,630
[სტუდენტური] თუ თქვენ გაქვთ პერსონალის at ფართები, მოსწონს ის ფართების 1 და 2

701
00:54:53,630 --> 00:54:55,950
და მაშინ საჭიროა დაამატოთ რაღაც at 0.

702
00:54:55,950 --> 00:55:02,570
[Hardison] ჰო, ზუსტად. ასე რომ, თუ თქვენი უფროსი მაჩვენებელი არის ძალიან დასასრულს,

703
00:55:02,570 --> 00:55:14,210
ან თუ თქვენი ზომა Plus თქვენი უფროსი მეტია, უფრო სწორად, აპირებს გადაიტანოთ გარშემო მდგომ.

704
00:55:14,210 --> 00:55:17,830
>> ასე რომ ამ სიტუაციაში, რომ გვაქვს აქ on the slide ახლავე,

705
00:55:17,830 --> 00:55:24,370
თუ მინდა enqueue რაღაც ახლავე,

706
00:55:24,370 --> 00:55:31,110
ჩვენ გვინდა enqueue რაღაც ეტაპზე ინდექსი 0.

707
00:55:31,110 --> 00:55:35,450
ასე რომ, თუ გადავხედავთ, სადაც 50 მიდის, და მოვუწოდებ enqueue 50,

708
00:55:35,450 --> 00:55:40,840
იგი მიდის down იქ ბოლოში. იგი მიდის ინდექსი 0.

709
00:55:40,840 --> 00:55:44,160
იგი ცვლის "hi", რაც უკვე dequeued.

710
00:55:44,160 --> 00:55:46,210
[დანიელ] ხომ არ იზრუნოს რომ dequeue უკვე?

711
00:55:46,210 --> 00:55:50,550
რატომ არაფერს ერთად მეთაურის enqueue?

712
00:55:50,550 --> 00:55:55,770
[Hardison] Oh, ამიტომ თქვენ არ შეცვლის ხელმძღვანელი, უკაცრავად.

713
00:55:55,770 --> 00:56:02,310
მაგრამ თქვენ უნდა გამოიყენოთ თავდაცვის სამინისტროს ოპერატორი როცა თქვენ წვდომის

714
00:56:02,310 --> 00:56:04,250
ელემენტს რომ გსურთ enqueue როცა თქვენ წვდომის

715
00:56:04,250 --> 00:56:06,960
შემდეგი ელემენტს თქვენს რიგიდან.

716
00:56:06,960 --> 00:56:10,960
[ბასილ] მე არ გავაკეთოთ, და მე მივიღე "წარმატება" იქ.

717
00:56:10,960 --> 00:56:13,370
[დანიელ] ოჰ, მე მესმის, თუ რას ამბობდა.

718
00:56:13,370 --> 00:56:16,240
[Hardison] ასე, რომ თქვენ didn't - უბრალოდ გააკეთეს საათზე q.size?

719
00:56:16,240 --> 00:56:20,670
[ბასილ] Yeah. უბრალოდ შეიცვალა მხარეს, მე არაფერი უფროსთან.

720
00:56:20,670 --> 00:56:24,300
[Hardison] თქვენ არ რეალურად უნდა აღადგინოთ ხელმძღვანელი უნდა იყოს არაფერი,

721
00:56:24,300 --> 00:56:31,650
მაგრამ როდესაც თქვენ ინდექსი შევიდა სიმები მასივი,

722
00:56:31,650 --> 00:56:39,500
თქვენ ნამდვილად უნდა წავიდეთ წინ და გამოვთვალოთ სადაც შემდეგი ელემენტი,

723
00:56:39,500 --> 00:56:44,230
რადგან withe დასტის, შემდეგი ელემენტს თქვენს დასტის იყო ყოველთვის

724
00:56:44,230 --> 00:56:48,740
ზე ინდექსი შესაბამისი ზომა.

725
00:56:48,740 --> 00:56:55,850
თუ ჩვენ ვიხსენებთ up ჩვენს დასტის ბიძგი ფუნქცია,

726
00:56:55,850 --> 00:57:03,100
ჩვენ შეგვიძლია ყოველთვის plunk ჩვენს ახალ ელემენტს უფლება ინდექსი ზომა.

727
00:57:03,100 --> 00:57:06,710
ვინაიდან ერთად მდგომ, ჩვენ არ შეგვიძლია გავაკეთოთ, რომ

728
00:57:06,710 --> 00:57:10,340
რადგან თუ ჩვენ ამ სიტუაციაში,

729
00:57:10,340 --> 00:57:18,130
თუ ჩვენ enqueued 50 ჩვენი ახალი სიმებიანი წავიდოდა უფლება სტრიქონები [1]

730
00:57:18,130 --> 00:57:20,540
რომელიც ჩვენ არ გვინდა, რომ გავაკეთოთ.

731
00:57:20,540 --> 00:57:41,200
ჩვენ გვინდა, რომ გვქონდეს ახალი სიმებიანი წასვლა საათზე ინდექსი 0.

732
00:57:41,200 --> 00:57:44,320
>> ვინმეს აქვს - კი? [სტუდენტური] მე მაქვს შეკითხვა, მაგრამ ნამდვილად არ უკავშირდება.

733
00:57:44,320 --> 00:57:48,160
რას ნიშნავს, როცა ვინმე მხოლოდ მოუწოდებს რაღაც pred მაჩვენებელი?

734
00:57:48,160 --> 00:57:51,260
რა არის, რომ სახელი მოკლე ამისთვის? მე ვიცი, უბრალოდ სახელი.

735
00:57:51,260 --> 00:57:59,110
[Hardison] Pred მაჩვენებელი? ვნახოთ. რა კონტექსტში?

736
00:57:59,110 --> 00:58:01,790
[სტუდენტური] სწორედ ჩანართით. შემიძლია გთხოვოთ მოგვიანებით თუ გინდათ

737
00:58:01,790 --> 00:58:03,920
იმიტომ რომ ნამდვილად არ უკავშირდება, მაგრამ მე უბრალოდ -

738
00:58:03,920 --> 00:58:07,300
[Hardison] მდებარ დავითის ჩასმა კოდი ლექცია?

739
00:58:07,300 --> 00:58:10,860
ჩვენ შეგვიძლია დახევის რომ და საუბრობენ, რომ.

740
00:58:10,860 --> 00:58:15,550
ჩვენ ვსაუბრობთ, რომ მომდევნო, კიდევ მივიღებთ, რათა დაკავშირებული სიები.

741
00:58:15,550 --> 00:58:21,440
>> მოდით ნამდვილად სწრაფად შევხედოთ რა enqueue ფუნქცია ჰგავს.

742
00:58:21,440 --> 00:58:26,530
რა იყო პირველი რაც ადამიანმა სცადა გავაკეთოთ თქვენი enqueue ხაზი? ამ რიგში?

743
00:58:26,530 --> 00:58:29,960
მსგავსია იმისა, რაც თქვენ გააკეთა დასტის უბიძგებს.

744
00:58:29,960 --> 00:58:32,080
რა გავაკეთოთ, Stella?

745
00:58:32,080 --> 00:58:35,050
[Stella, გაუგებარია]

746
00:58:35,050 --> 00:58:45,700
[Hardison] ზუსტად. თუ (q.size == სიმძლავრის) -

747
00:58:45,700 --> 00:58:54,720
მე უნდა დააყენოს ჩემი braces სწორი ადგილი - დაბრუნებას ყალბი.

748
00:58:54,720 --> 00:59:01,370
მიუახლოვდით ცოტა. Okay.

749
00:59:01,370 --> 00:59:03,800
არის რა შემდეგი რამ, რომ ჩვენ უნდა გაეკეთებინათ?

750
00:59:03,800 --> 00:59:11,370
ისევე ერთად დასტის, და ჩასმული at უფლება ადგილი.

751
00:59:11,370 --> 00:59:16,010
და მერე რა იყო სწორი ადგილი ჩასასმელად რომ?

752
00:59:16,010 --> 00:59:23,170
With დასტის ეს იყო ინდექსი ზომა, ამ ეს არ საკმაოდ რომ.

753
00:59:23,170 --> 00:59:30,210
[დანიელ] მაქვს q.head-ან - >> q.strings? >> Yeah.

754
00:59:30,210 --> 00:59:40,470
q.strings [q.head + q.size mod ტევადობა]?

755
00:59:40,470 --> 00:59:42,740
[Hardison] ჩვენ ალბათ სურთ დააყენა ფრჩხილებში გარშემო

756
00:59:42,740 --> 00:59:48,830
ასე, რომ ჩვენ ვიღებთ შესაბამისი პრეცენდენტის და ასე რომ cleart ყველას.

757
00:59:48,830 --> 00:59:55,800
და დაადგინა, რომ თანაბარი? >> To ქ? >> To ქ. დიდი.

758
00:59:55,800 --> 01:00:00,160
და ახლა რა ბოლო რამ, რომ ჩვენ უნდა გავაკეთოთ?

759
01:00:00,160 --> 01:00:06,780
უბრალოდ ისე, როგორც წელს Stack. >> ნამატი ზომა? >> ნამატი ზომა.

760
01:00:06,780 --> 01:00:13,830
Boom. და მაშინ, რადგან შემქმნელის კოდი დაბრუნებული ცრუ იყოს,

761
01:00:13,830 --> 01:00:27,460
ჩვენ გვინდა, რომ შეიცვალოს ეს ჭეშმარიტი თუ ყველა გადის და ყველაფერი კარგად.

762
01:00:27,460 --> 01:00:33,050
ყველა უფლება. სწორედ უამრავი ინფორმაცია მონაკვეთზე.

763
01:00:33,050 --> 01:00:39,480
ჩვენ არ ვართ საკმაოდ დასრულდა. ჩვენ გვინდა, რომ გაიგო ნამდვილად სწრაფად შესახებ საგნით დაკავშირებული სიები.

764
01:00:39,480 --> 01:00:44,010
მე დააყენა ამ მდე ასე შეგვიძლია დავუბრუნდეთ მოგვიანებით.

765
01:00:44,010 --> 01:00:50,850
მაგრამ მოდით დავუბრუნდეთ ჩვენი პრეზენტაცია მხოლოდ რამდენიმე სლაიდები.

766
01:00:50,850 --> 01:00:53,790
ამიტომ enqueue არის TODO, ახლა ჩვენ გავაკეთეთ.

767
01:00:53,790 --> 01:00:57,430
>> ახლა მოდით შევხედოთ საგნით დაკავშირებული სიები.

768
01:00:57,430 --> 01:01:00,040
ჩვენ ვისაუბრეთ ამ ცოტა მეტი ლექცია.

769
01:01:00,040 --> 01:01:02,540
რამდენი თქვენგანი ბიჭები დაინახა დემო სადაც ჩვენ გვქონდა ხალხი

770
01:01:02,540 --> 01:01:08,220
უხერხულად მიუთითებს ერთმანეთს და ჩატარება ნომრები? >> ვიყავი რომ.

771
01:01:08,220 --> 01:01:16,620
>> რა ბიჭები ვფიქრობ? ამით, იმედია demystify ამ ცოტა?

772
01:01:16,620 --> 01:01:25,990
With სია, აღმოჩნდება, რომ აქ საქმე გვაქვს ამ ტიპის რომ ჩვენ ვაპირებთ მოვუწოდებთ კვანძში.

773
01:01:25,990 --> 01:01:32,520
ვინაიდან ერთად მდგომ და დასტის გვქონდა structs რომ ჩვენ გვინდა მოვუწოდებთ რიგში დასტის,

774
01:01:32,520 --> 01:01:34,860
ჩვენ გვქონდა ამ ახალი რიგში დასტის ტიპის,

775
01:01:34,860 --> 01:01:39,240
აქ სიაში მართლაც მხოლოდ შედგება bunch of კვანძების.

776
01:01:39,240 --> 01:01:45,920
ანალოგიურად, რომ სტრიქონები მხოლოდ bunch of chars ყველა გაფორმებულია up შემდეგი ერთმანეთს.

777
01:01:45,920 --> 01:01:50,650
უკავშირდება სიაში მხოლოდ კვანძის და სხვა კვანძის და სხვა კვანძის და სხვა კვანძის.

778
01:01:50,650 --> 01:01:55,080
და ვიდრე Smashing ყველა კვანძების ერთად და შენახვის მათ contiguously

779
01:01:55,080 --> 01:01:58,090
ყველა უფლება მომდევნო ერთმანეთს მეხსიერება,

780
01:01:58,090 --> 01:02:04,470
მქონე ამ შემდეგი მაჩვენებელი საშუალებას გვაძლევს შესანახად კვანძების სადაც არ უნდა, შემთხვევითი.

781
01:02:04,470 --> 01:02:10,500
და შემდეგ სახის მავთული მათ ყველა ერთად აღვნიშნო ერთი შემდეგი.

782
01:02:10,500 --> 01:02:15,850
>> და რა იყო დიდი უპირატესობა, რომ ეს ყავდა მასივი?

783
01:02:15,850 --> 01:02:21,680
Over შენახვის ყველაფერი contiguously მხოლოდ დავრჩებოდით შემდეგი ერთმანეთს?

784
01:02:21,680 --> 01:02:24,190
თქვენ გახსოვთ? ჰო? >> დინამიური მეხსიერების გამოყოფის?

785
01:02:24,190 --> 01:02:27,220
>> დინამიური მეხსიერების გამოყოფის რა გრძნობა?

786
01:02:27,220 --> 01:02:31,780
[სტუდენტური] In რომ თქვენ შეგიძლიათ შეინახოთ რაც უფრო დიდი და თქვენ არ უნდა გადავიდეთ თქვენი მთელი მასივი?

787
01:02:31,780 --> 01:02:40,940
[Hardison] ზუსტად. ამრიგად მასივი, როდესაც გსურთ დააყენოს ახალი ელემენტს შუაგულში შეიჭრა იგი,

788
01:02:40,940 --> 01:02:45,320
თქვენ უნდა გადაიტანოს ყველაფერი, რათა სივრცეში.

789
01:02:45,320 --> 01:02:47,880
და როგორც ჩვენ ვისაუბრეთ ერთად მდგომ,

790
01:02:47,880 --> 01:02:50,080
ამიტომ შენარჩუნება, რომ ხელმძღვანელი მაჩვენებელი,

791
01:02:50,080 --> 01:02:52,050
ისე, რომ ჩვენ არ ვართ მუდმივად გადავიდა რამ.

792
01:02:52,050 --> 01:02:54,520
გამო რომ იღებს ძვირი თუ თქვენ მოხვდით დიდი მასივი

793
01:02:54,520 --> 01:02:57,130
და თქვენ მუდმივად აკეთებთ ამ შემთხვევითი insertions.

794
01:02:57,130 --> 01:03:00,820
ვინაიდან ერთად სიაში, ყველა თქვენ უნდა გააკეთოთ გადაყარეთ ის ახალ კვანძში,

795
01:03:00,820 --> 01:03:06,330
შეცვალოს პოინტერები, და თქვენ კეთდება.

796
01:03:06,330 --> 01:03:10,940
რა sucks ამის შესახებ?

797
01:03:10,940 --> 01:03:16,830
გარდა იმისა, რომ ეს არ არის ისეთი ადვილი მუშაობა როგორც მასივი? ჰო?

798
01:03:16,830 --> 01:03:22,980
[დანიელ] ისე, ვფიქრობ, გაცილებით უფრო რთული, რათა შეამოწმონ კონკრეტული ელემენტს უკავშირდება სიაში?

799
01:03:22,980 --> 01:03:30,470
[Hardison] თქვენ არ შეგიძლიათ უბრალოდ გადადით თვითნებური ელემენტს შუა თქვენი უკავშირდება სიაში.

800
01:03:30,470 --> 01:03:33,800
როგორ უნდა გავაკეთოთ ნაცვლად? >> თქვენ უნდა გადადგას მთელი რამ.

801
01:03:33,800 --> 01:03:35,660
[Hardison] Yeah. თქვენ უნდა გაიაროს ერთ დროს, ერთ დროს.

802
01:03:35,660 --> 01:03:38,480
ეს უზარმაზარი - ის ტკივილი.

803
01:03:38,480 --> 01:03:41,550
რა არის სხვა - არსებობს კიდევ ერთი ვარდნის ამ.

804
01:03:41,550 --> 01:03:45,340
[ბასილ] თქვენ არ შეგიძლიათ წავიდეთ წინ და უკან? თქვენ უნდა წავიდეს ერთი მიმართულებით?

805
01:03:45,340 --> 01:03:48,570
[Hardison] Yeah. ასე როგორ უნდა გადაწყვიტოს, რომ, ზოგჯერ?

806
01:03:48,570 --> 01:03:53,370
[ბასილ] ორმაგად-უკავშირდება სიები? >> ზუსტად. არსებობს ორმაგად-უკავშირდება სიები.

807
01:03:53,370 --> 01:03:55,540
ასევე არსებობს - უკაცრავად?

808
01:03:55,540 --> 01:03:57,620
>> [სემ] არის, რომ იგივე როგორც გამოყენებით pred, რაც -

809
01:03:57,620 --> 01:04:01,090
მე უბრალოდ გაიხსენა, რომელიც არ არის, რომ რა pred რამ არის?

810
01:04:01,090 --> 01:04:05,850
არ არის, რომ შორის ორმაგად და საგნით?

811
01:04:05,850 --> 01:04:10,020
[Hardison] მოდით წავიკითხოთ რას იგი აკეთებს.

812
01:04:10,020 --> 01:04:15,760
ასე რომ აქ ჩვენ მივდივართ. აი სიაში კოდი.

813
01:04:15,760 --> 01:04:25,620
აქ predptr, აქ. ეს რას ვსაუბრობთ?

814
01:04:25,620 --> 01:04:30,750
ასე რომ, ეს იყო - ის გამონთავისუფლების სიაში და ის ცდილობს შესანახად მომცეთ იგი.

815
01:04:30,750 --> 01:04:35,000
ეს არ არის ორმაგად, საგნით უკავშირდება-სიებში.

816
01:04:35,000 --> 01:04:40,090
ჩვენ შეგვიძლია გაიგო მეტი ამ მოგვიანებით რადგან ეს არის ლაპარაკი გამონთავისუფლების სია

817
01:04:40,090 --> 01:04:42,900
და მინდა ნახოთ ზოგიერთი სხვა პერსონალის პირველი.

818
01:04:42,900 --> 01:04:51,480
მაგრამ ეს მხოლოდ - ის დამახსოვრების ღირებულება ptr

819
01:04:51,480 --> 01:04:54,170
[სტუდენტური] ოჰ, ეს preceeding მაჩვენებელი? >> Yeah.

820
01:04:54,170 --> 01:05:04,070
ასე, რომ ჩვენ შეგვიძლია მაშინ ნამატი ptr თავად სანამ ჩვენ მაშინ უფასო რა predptr არის.

821
01:05:04,070 --> 01:05:09,130
რადგანაც ჩვენ არ შეგვიძლია უფასო ptr და შემდეგ მოვუწოდებთ ptr = ptr შემდეგი, არა?

822
01:05:09,130 --> 01:05:11,260
ეს იქნება ცუდი.

823
01:05:11,260 --> 01:05:20,940
ასე რომ ვნახოთ, თავში ამ ბიჭს.

824
01:05:20,940 --> 01:05:23,900
>> სხვა ცუდი რამ შესახებ სიები არის, რომ მაშინ როდესაც ერთად მასივი

825
01:05:23,900 --> 01:05:26,520
ჩვენ უბრალოდ უნდა ყველა ელემენტები თავად stacked შემდეგი ერთმანეთს,

826
01:05:26,520 --> 01:05:29,050
აქ ჩვენ ასევე გააცნო ამ მაჩვენებელმა.

827
01:05:29,050 --> 01:05:34,060
ასე რომ იქ დამატებითი ბლოკი მეხსიერება, რომ ჩვენ მქონე გამოიყენოს

828
01:05:34,060 --> 01:05:37,910
ყველა ელემენტს რომ ჩვენ შენახვის ჩვენს სიაში.

829
01:05:37,910 --> 01:05:40,030
მივიღებთ მოქნილობა, მაგრამ საქმე ზე ღირებულება.

830
01:05:40,030 --> 01:05:42,230
მას გააჩნია ამ დროის ღირებულება,

831
01:05:42,230 --> 01:05:45,270
და მას გააჩნია ამ მეხსიერების ღირებულება ძალიან.

832
01:05:45,270 --> 01:05:47,800
ახლა იმ გაგებით, რომ ჩვენ ახლა უნდა გაიაროს ყველა ელემენტს მასივი

833
01:05:47,800 --> 01:05:58,670
იპოვონ ერთი ინდექსი 10 ან რომ იქნებოდა ინდექსი 10 მასივი.

834
01:05:58,670 --> 01:06:01,230
>> უბრალოდ მართლაც სწრაფად, როდესაც ჩვენ დიაგრამაზე აღნიშნული სიები,

835
01:06:01,230 --> 01:06:05,980
ჩვეულებრივ ჩვენ გაიმართება ხელმძღვანელს სიაში ან პირველი მაჩვენებელი სიის

836
01:06:05,980 --> 01:06:08,010
და აღინიშნოს, რომ ეს არის ნამდვილი მაჩვენებელი.

837
01:06:08,010 --> 01:06:11,100
უბრალოდ 4 ბაიტი. ეს არ არის ფაქტობრივი კვანძის თავად.

838
01:06:11,100 --> 01:06:17,120
ასე რომ თქვენ ხედავთ, რომ არ გააჩნია int ღირებულების იგი, არ შემდეგი მაჩვენებელი იყო.

839
01:06:17,120 --> 01:06:20,790
ეს სიტყვასიტყვით მხოლოდ კურსორი.

840
01:06:20,790 --> 01:06:23,550
იგი აპირებს აღვნიშნო, რომ ის, რაც არის ფაქტობრივი კვანძის struct.

841
01:06:23,550 --> 01:06:28,480
[სემ] მაჩვენებელი მოუწოდა კვანძის? >> ეს არის - არ. ეს არის მაჩვენებელი რაიმე ტიპის კვანძში.

842
01:06:28,480 --> 01:06:32,540
ეს მომცეთ კვანძის struct. >> Oh, okay.

843
01:06:32,540 --> 01:06:36,870
დიაგრამა მარცხენა, კოდი მარჯვენა.

844
01:06:36,870 --> 01:06:42,190
ჩვენ შეგვიძლია ვაყენებთ მას null, რომელიც კარგი საშუალებაა დაიწყოს.

845
01:06:42,190 --> 01:06:49,850
როდესაც თქვენ დიაგრამაზე მასში თქვენ ან წერენ, როგორც null ან თქვენ დააყენა ხაზის მეშვეობით ეს იგრძნობა.

846
01:06:49,850 --> 01:06:53,910
>> ერთი იოლი გზა მუშაობა სიები

847
01:06:53,910 --> 01:06:57,430
და ჩვენ ვთხოვთ თქვენ ჩვენგან ორივე prepend და დამატება დაინახოს სხვაობა,

848
01:06:57,430 --> 01:07:01,320
მაგრამ prepending ნამდვილად ადვილია.

849
01:07:01,320 --> 01:07:05,790
როდესაც თქვენ prepend, ეს არის სადაც თქვენ - როდესაც თქვენ prepend (7),

850
01:07:05,790 --> 01:07:10,050
თქვენ წადით და შექმნას კვანძის struct

851
01:07:10,050 --> 01:07:13,870
და თქვენ პირველი აღვნიშნო მას, რადგან ახლა, რადგან ჩვენ prepended ის,

852
01:07:13,870 --> 01:07:17,240
ეს იქნება დასაწყისში სიაში.

853
01:07:17,240 --> 01:07:22,540
თუ ჩვენ prepend (3), რომელიც ქმნის მეორე კვანძის, მაგრამ ახლა 3 მოდის ადრე 7.

854
01:07:22,540 --> 01:07:31,130
ასე რომ ჩვენ არსებითად ზრდის რამ გადატანა ჩვენს სიაში.

855
01:07:31,130 --> 01:07:34,720
ახლა, თქვენ ხედავთ, რომ prepend, ზოგჯერ ადამიანებს ეძახით დააყენებს,

856
01:07:34,720 --> 01:07:39,600
იმიტომ, რომ თქვენ უბიძგებს ახალი ელემენტს გადატანა თქვენს სიაში.

857
01:07:39,600 --> 01:07:43,270
ასევე ადვილად წაშლა დროს თვალწინ სიაში.

858
01:07:43,270 --> 01:07:45,650
ამიტომ ხალხი ხშირად მოვუწოდებთ, რომ ჰოლივუდი.

859
01:07:45,650 --> 01:07:52,200
და ამ გზით, შეგიძლიათ emulate დასტის გამოყენებით უკავშირდება სიაში.

860
01:07:52,200 --> 01:07:57,880
Whoops. უკაცრავად, ახლა ჩვენ მისაღებად შევიდა დამატება. ასე რომ აქ ჩვენ prepended (7), ახლა ჩვენ prepend (3).

861
01:07:57,880 --> 01:08:02,600
თუ ჩვენ prepended რაღაც გადატანა ამ სიაში, თუ ჩვენ prepended (4),

862
01:08:02,600 --> 01:08:06,540
მაშინ ჩვენ ავღნიშნო აქვს 4 და შემდეგ 3 და შემდეგ 7.

863
01:08:06,540 --> 01:08:14,220
ასე რომ, ჩვენ შეიძლება პოპ და ამოიღონ 4, წაშალოს 3, ამოიღონ 7.

864
01:08:14,220 --> 01:08:16,500
ხშირად უფრო ინტუიციური გზა ვიფიქროთ ეს ერთად დამატება.

865
01:08:16,500 --> 01:08:20,310
ამიტომ მე diagrammed რა ეს გამოიყურება ასე ერთად დამატება აქ.

866
01:08:20,310 --> 01:08:23,380
აქ, დაერთოს (7) არ გამოიყურება ნებისმიერი სხვადასხვა

867
01:08:23,380 --> 01:08:25,160
რადგან არსებობს მხოლოდ ერთი ელემენტია სიაში.

868
01:08:25,160 --> 01:08:28,620
და appending (3) აყენებს მას დასასრულს.

869
01:08:28,620 --> 01:08:31,020
იქნებ თქვენ ხედავთ ახლავე შეასრულა ერთად დამატება

870
01:08:31,020 --> 01:08:36,600
ის არის, რომ რადგან ჩვენ მხოლოდ ვიცით, სადაც დასაწყისში სია,

871
01:08:36,600 --> 01:08:39,450
to დამატება, რათა სია გაქვთ ფეხით ყველა გზას სია

872
01:08:39,450 --> 01:08:46,500
მისაღებად ბოლომდე, შეჩერება, შემდეგ ავაშენოთ თქვენი კვანძის და plunk ყველაფერი ქვევით.

873
01:08:46,500 --> 01:08:50,590
მავთულის ყველა პერსონალის up.

874
01:08:50,590 --> 01:08:55,170
ამრიგად prepend, როგორც ჩვენ მხოლოდ ამოღებული მეშვეობით ნამდვილად სწრაფად,

875
01:08:55,170 --> 01:08:58,170
როდესაც თქვენ prepend რომ სიაში, ეს საკმაოდ მარტივია.

876
01:08:58,170 --> 01:09:02,960
>> თქვენი ახალი კვანძის, ჩავრთოთ ზოგიერთი დინამიური მეხსიერების გამოყოფის.

877
01:09:02,960 --> 01:09:09,830
ასე რომ აქ ჩვენ მიღების კვანძის struct გამოყენებით malloc.

878
01:09:09,830 --> 01:09:14,710
ამიტომ malloc ჩვენ გამოყენებით იმიტომ, რომ ყველაფერს გათვალისწინებულია მეხსიერების ჩვენთვის მოგვიანებით

879
01:09:14,710 --> 01:09:20,350
იმიტომ, რომ ჩვენ არ გვინდა ამ - ჩვენ გვინდა ამ მეხსიერების არსებობს დიდი ხანია.

880
01:09:20,350 --> 01:09:25,350
ჩვენ ლინკი მომცეთ სივრცეში მეხსიერებაში, რომ ჩვენ უბრალოდ გამოყოფილი.

881
01:09:25,350 --> 01:09:29,260
ჩვენ ვიყენებთ ზომის კვანძი, ჩვენ არ მთლიანობაში სფეროებში.

882
01:09:29,260 --> 01:09:31,899
ჩვენ არ ხელით გენერირება ბაიტების რაოდენობას,

883
01:09:31,899 --> 01:09:39,750
ნაცვლად ჩვენ ვიყენებთ sizeof ისე, რომ ჩვენ ვიცით, ჩვენ ვიღებთ შესაბამისი ბაიტების რაოდენობას.

884
01:09:39,750 --> 01:09:43,660
ჩვენ დარწმუნდით შესამოწმებლად, რომ ჩვენი malloc ზარის შედგა.

885
01:09:43,660 --> 01:09:47,939
ეს არის რაღაც თქვენ უნდა კულტურას.

886
01:09:47,939 --> 01:09:52,590
თანამედროვე მანქანები, ითმენს მეხსიერების არ არის რაღაც, რომ ადვილი

887
01:09:52,590 --> 01:09:56,610
თუ არ ხარ გამოყოფის ტონა პერსონალის და მიღების დიდი სია,

888
01:09:56,610 --> 01:10:02,220
მაგრამ თუ თქვენ მშენებლობის პერსონალის ამისთვის, ვთქვათ, როგორიცაა iPhone ან Android,

889
01:10:02,220 --> 01:10:05,230
თქვენ ჩვენგან შეზღუდული მეხსიერება რესურსების, განსაკუთრებით თუ თქვენ აკეთებთ რაღაც ინტენსიურად მიმდინარეობს.

890
01:10:05,230 --> 01:10:08,300
ასე რომ კარგი შეღწევას პრაქტიკაში.

891
01:10:08,300 --> 01:10:10,510
>> გაითვალისწინეთ, რომ მე გამოიყენება რამდენიმე განსხვავებული ფუნქციები აქ

892
01:10:10,510 --> 01:10:12,880
რომ თქვენ ვხედავთ, რომლებიც სახის ახალი.

893
01:10:12,880 --> 01:10:15,870
ამიტომ fprintf არის ისევე printf

894
01:10:15,870 --> 01:10:21,320
გარდა თავისი პირველი არგუმენტი არის ნაკადი, რომლის გსურთ ბეჭდვა.

895
01:10:21,320 --> 01:10:23,900
ამ შემთხვევაში, ჩვენ გვინდა ბეჭდვა სტანდარტული შეცდომა სიმებიანი

896
01:10:23,900 --> 01:10:29,410
რომელიც განსხვავდება სტანდარტული outstream.

897
01:10:29,410 --> 01:10:31,620
ნაგულისხმევია ის გვიჩვენებს up იმავე ადგილას.

898
01:10:31,620 --> 01:10:34,600
იგი ასევე ბეჭდავს out to ტერმინალი, მაგრამ შეგიძლიათ -

899
01:10:34,600 --> 01:10:38,790
გამოყენებით იმ ბრძანებები თქვენ შეიტყო, გადამისამართება ტექნიკას

900
01:10:38,790 --> 01:10:42,290
თქვენ შეიტყო წელს Tommy-ის ვიდეო პრობლემის კომპლექტი 4, შეგიძლიათ პირდაპირ ეს

901
01:10:42,290 --> 01:10:47,900
სხვადასხვა ადგილებში; შემდეგ გასვლა, უფლება აქ, გასასვლელების თქვენი პროგრამა.

902
01:10:47,900 --> 01:10:50,440
ეს არსებითად მოსწონს დაბრუნების ძირითად,

903
01:10:50,440 --> 01:10:53,600
გარდა ჩვენ ვიყენებთ გასასვლელში რადგან აქ სარგებელი არაფერი.

904
01:10:53,600 --> 01:10:57,140
ჩვენ არ ვართ მთავარ, ისე დაბრუნების არ გაითიშება პროგრამა, როგორიც ჩვენ გვინდა.

905
01:10:57,140 --> 01:11:03,020
ასე რომ ჩვენ ვიყენებთ გასასვლელში ფუნქცია და მისთვის შეცდომის კოდი.

906
01:11:03,020 --> 01:11:11,890
მაშინ აქ ჩვენ დავსახეთ ახალი კვანძის ღირებულების სფეროში, მისი მე სფეროში უნდა იყოს ტოლი i, და შემდეგ ჩვენ WIRE it up.

907
01:11:11,890 --> 01:11:15,530
ჩვენ დავსახეთ ახალი კვანძის მომდევნო მომცეთ აღვნიშნო, რომ პირველი,

908
01:11:15,530 --> 01:11:20,460
და მაშინ პირველად ახლა აღვნიშნავთ, რომ ახალი კვანძში.

909
01:11:20,460 --> 01:11:25,120
ეს პირველი ხაზი კოდი, ჩვენ რეალურად აშენებენ ახალ კვანძში.

910
01:11:25,120 --> 01:11:27,280
არა ბოლო ორი ხაზი ამ ფუნქციის მაგრამ პირველი მიიჩნიეს.

911
01:11:27,280 --> 01:11:30,290
თქვენ შეგიძლიათ რეალურად გაიყვანოს შევიდა ფუნქციის შევიდა დამხმარე ფუნქცია.

912
01:11:30,290 --> 01:11:32,560
რომ ხშირად რა გავაკეთო არის, მე გაიყვანოს მას out შევიდა ფუნქცია,

913
01:11:32,560 --> 01:11:36,040
მოვუწოდებ მას რაღაც Build კვანძში,

914
01:11:36,040 --> 01:11:40,410
და რომ ინახავს prepend ფუნქცია საკმაოდ მცირე, უბრალოდ 3 ხაზების შემდეგ.

915
01:11:40,410 --> 01:11:48,710
მე ზარი ჩემი build კვანძის ფუნქციას, და მერე მავთული ყველაფერი up.

916
01:11:48,710 --> 01:11:51,970
>> საბოლოო რამ მინდა გაჩვენოთ,

917
01:11:51,970 --> 01:11:54,030
და მე მოგცემთ გავაკეთოთ დამატება და ყველა რომ საკუთარ,

918
01:11:54,030 --> 01:11:57,500
არის როგორ iterate მეტი სიაში.

919
01:11:57,500 --> 01:12:00,780
არსებობს რამოდენიმე განსხვავებული გზა iterate მეტი სიაში.

920
01:12:00,780 --> 01:12:03,140
ამ შემთხვევაში, ჩვენ ვაპირებთ, რათა იპოვოს სიგრძეზე სიაში.

921
01:12:03,140 --> 01:12:06,570
ამიტომ, ჩვენ დავიწყებთ სიგრძე = 0.

922
01:12:06,570 --> 01:12:11,580
ეს არის ძალიან ჰგავს წერილობით strlen ამისთვის სიმებიანი.

923
01:12:11,580 --> 01:12:17,780
ეს არის ის, რაც მე მინდა გაჩვენოთ, ეს loop უფლება აქ.

924
01:12:17,780 --> 01:12:23,530
როგორც ჩანს kinda ხმაურიანი, ეს არ არის ჩვეულებრივი int i = 0, I <რასაც მე + +.

925
01:12:23,530 --> 01:12:34,920
ამის ნაცვლად ის ინიციალიზაციისას ჩვენი ცვლადი N უნდა იყოს დასაწყისში სიაში.

926
01:12:34,920 --> 01:12:40,620
და შემდეგ, ხოლო ჩვენი iterator ცვლადი არ არის null, ჩვენ შევინარჩუნოთ აპირებს.

927
01:12:40,620 --> 01:12:46,340
ეს იმიტომ, რომელსაც კონვენცია, ბოლომდე ჩვენს სიაში იქნება null.

928
01:12:46,340 --> 01:12:48,770
და შემდეგ წუთობრივი, ვიდრე აკეთებს + +,

929
01:12:48,770 --> 01:12:57,010
უკავშირდება სია ეკვივალენტს + + არის N = N-> მომავალი.

930
01:12:57,010 --> 01:13:00,410
>> მე მოგცემთ შეავსოთ ხარვეზები აქ იმიტომ ვართ გარეთ დრო.

931
01:13:00,410 --> 01:13:09,300
მაგრამ შენარჩუნება ამის გათვალისწინებით, როგორც თქვენ მუშაობთ თქვენს spellr psets.

932
01:13:09,300 --> 01:13:11,650
უკავშირებს სიები, თუ თქვენ განხორციელების hash მაგიდა,

933
01:13:11,650 --> 01:13:14,010
აუცილებლად მოდის ძალიან მოსახერხებელი.

934
01:13:14,010 --> 01:13:21,780
და მას შემდეგ ამ idiom ამისთვის looping მეტი რამ გახდის ცხოვრებაში ბევრი ადვილია, იმედია.

935
01:13:21,780 --> 01:13:25,910
ნებისმიერი კითხვები, სწრაფად?

936
01:13:25,910 --> 01:13:28,920
[სემ] Will თქვენ გააგზავნით out დასრულდა sll და sc?

937
01:13:28,920 --> 01:13:38,360
[Hardison] Yeah. მე გაგზავნის out დასრულდა სლაიდები და დასრულებული sll დასტის და queue.cs.

938
01:13:38,360 --> 01:13:41,360
[CS50.TV]