1
00:00:00,000 --> 00:00:02,770
[Powered by Google Translate] [ნაწილი 7: უფრო კომფორტული]

2
00:00:02,770 --> 00:00:05,090
[Rob Bowden] [ჰარვარდის უნივერსიტეტის]

3
00:00:05,090 --> 00:00:07,930
[ეს არის CS50] [CS50.TV]

4
00:00:07,930 --> 00:00:10,110
ყველა უფლება. ასე რომ მე განაცხადა ჩემი ელ,

5
00:00:10,110 --> 00:00:14,060
ეს იქნება ორობითი ხე ინტენსიური მონაკვეთზე.

6
00:00:14,060 --> 00:00:16,820
მაგრამ არ არსებობს, რომ ბევრ კითხვას.

7
00:00:16,820 --> 00:00:18,920
ამიტომ, ჩვენ ვაპირებთ შევეცადოთ და შესამუშაევბლად თითოეული კითხვა

8
00:00:18,920 --> 00:00:25,430
და წასვლას მტკივნეული დეტალი ყველა საუკეთესო გზები საქმეს აკეთებენ.

9
00:00:25,430 --> 00:00:31,200
ასე რომ უფლება დასაწყისში, ჩვენ გაიაროს ნიმუში ნახატების ორობითი ხეები და პერსონალი.

10
00:00:31,200 --> 00:00:35,970
ასე რომ აქ ", გახსოვდეთ, რომ ორობითი ხე აქვს კვანძების ანალოგიურია უკავშირდება სია,

11
00:00:35,970 --> 00:00:38,150
გარდა ერთის ნაცვლად მაჩვენებელი არსებობს ორი: ერთი მარცხნივ ბავშვის

12
00:00:38,150 --> 00:00:41,950
და ერთი უფლება 'ბავშვი'. "

13
00:00:41,950 --> 00:00:45,630
ასე რომ ორობითი ხე არის, ისევე, როგორც დაკავშირებული სიაში,

14
00:00:45,630 --> 00:00:47,910
გარდა struct აპირებს აქვს ორი პოინტერები.

15
00:00:47,910 --> 00:00:51,390
არსებობს trinary ხეები, რომლებიც აპირებენ სამი პოინტერები,

16
00:00:51,390 --> 00:00:56,540
არსებობს N-მარტისათვის ხეები, რომელიც უბრალოდ უნდა generic მაჩვენებელი

17
00:00:56,540 --> 00:01:00,320
რომ თქვენ მაშინ უნდა malloc იყოს დიდი საკმარისი აქვს

18
00:01:00,320 --> 00:01:04,840
საკმარისი მითითებას ყველა შესაძლო შვილი.

19
00:01:04,840 --> 00:01:08,200
ასე რომ ორობითი ხე რაღაც ჰქონდეს მუდმივი ხმების ორი.

20
00:01:08,200 --> 00:01:11,260
თუ გსურთ, თქვენ შეგიძლიათ მისცეს დაკავშირებული სიაში როგორც unary ხე,

21
00:01:11,260 --> 00:01:15,360
მაგრამ არა მგონია, ვინმეს მოუწოდებს, რომ.

22
00:01:15,360 --> 00:01:18,060
"დახაზეთ ყუთები და ისრებით დიაგრამის ორობითი ხე კვანძში

23
00:01:18,060 --> 00:01:24,110
შემცველი Nate ფავორიტი ნომერი, 7, სადაც თითოეულ ბავშვს მაჩვენებელი არის null. "

24
00:01:24,110 --> 00:01:27,780
ასე რომ iPad რეჟიმში.

25
00:01:27,780 --> 00:01:30,280
>> ეს იქნება საკმაოდ მარტივია.

26
00:01:30,280 --> 00:01:36,150
ჩვენ უბრალოდ აპირებს კვანძში, მე მიაპყროს, როგორც მოედანზე.

27
00:01:36,150 --> 00:01:38,730
მე კი მიაპყროს ფასეულობების აქ.

28
00:01:38,730 --> 00:01:41,090
ამიტომ ღირებულების წავა აქ,

29
00:01:41,090 --> 00:01:44,770
და შემდეგ ქვევით აქ გვექნება მარცხენა კურსორი მარცხნივ და მარჯვნივ კურსორი მარჯვნივ.

30
00:01:44,770 --> 00:01:50,430
და ეს არის ძალიან ისე კონვენციით ეძახით მარცხენა და მარჯვენა, რომელიც მაჩვენებელმა სახელები.

31
00:01:50,430 --> 00:01:52,460
ორივე ვაპირებთ იყოს null.

32
00:01:52,460 --> 00:01:57,870
ეს ხელს მხოლოდ null, და რომელიც მხოლოდ null.

33
00:01:57,870 --> 00:02:03,630
Okay. ასე რომ თავში აქ.

34
00:02:03,630 --> 00:02:05,700
"ერთად უკავშირდება სია, ჩვენ მხოლოდ შესანახად მაჩვენებელი

35
00:02:05,700 --> 00:02:09,639
პირველი კვანძის სიაში, რათა გვახსოვდეს, რომ მთელი უკავშირდება სიაში, ან მთელი სია.

36
00:02:09,639 --> 00:02:11,650
ანალოგიურად, ხეებით, ჩვენ მხოლოდ უნდა შესანახად მაჩვენებელი

37
00:02:11,650 --> 00:02:13,420
ერთ კვანძში, რათა გვახსოვდეს, რომ მთელი ხე.

38
00:02:13,420 --> 00:02:15,980
ეს კვანძი არის Calle კი "root 'ხე.

39
00:02:15,980 --> 00:02:18,320
ქმნით თქვენს დიაგრამაზე საწყისი დაწყებამდე ან დავხატოთ ახალი

40
00:02:18,320 --> 00:02:21,690
ისეთი, რომ თქვენ გაქვთ ყუთები და ისრებით გამოსახვა ორობითი ხე

41
00:02:21,690 --> 00:02:25,730
ერთად ღირებულება 7, შემდეგ 3 წლის მარცხენა

42
00:02:25,730 --> 00:02:32,760
მაშინ 9 მარჯვენა, შემდეგ კი 6 წლის უფლება 3. "

43
00:02:32,760 --> 00:02:34,810
ვნახოთ, თუ მე მახსოვს ყველა, რომ ჩემი უფროსი.

44
00:02:34,810 --> 00:02:37,670
ასე რომ, ეს იქნება ჩვენი ფესვი აქ.

45
00:02:37,670 --> 00:02:41,600
ჩვენ გვექნება ზოგიერთი მაჩვენებელი სადღაც, რაღაც, რაც ჩვენ მოვუწოდებთ ფესვი,

46
00:02:41,600 --> 00:02:45,140
და ეს მიუთითებს ამ ბიჭს.

47
00:02:45,140 --> 00:02:48,490
ახლა, რათა ახალი კვანძის,

48
00:02:48,490 --> 00:02:52,870
რა გვაქვს, 3 მარცხენა?

49
00:02:52,870 --> 00:02:57,140
ასე რომ ახალი კვანძის ერთად 3, და ეს თავდაპირველად მიუთითებს null.

50
00:02:57,140 --> 00:02:59,190
მე უბრალოდ დააყენა ნ

51
00:02:59,190 --> 00:03:02,250
ახლა ჩვენ გვსურს, რომ გადადით მარცხნივ 7.

52
00:03:02,250 --> 00:03:06,840
ამიტომ, ჩვენ შეცვალოთ ეს მომცეთ არის პასუხისმგებელი ამ ბიჭს.

53
00:03:06,840 --> 00:03:12,420
და ჩვენ იგივე. ჩვენ გვინდა 9 ზე აქ

54
00:03:12,420 --> 00:03:14,620
რომელიც თავდაპირველად მხოლოდ ამბობს null.

55
00:03:14,620 --> 00:03:19,600
ჩვენ ვაპირებთ, რომ შეიცვალოს ეს მაჩვენებელი, წერტილი 9,

56
00:03:19,600 --> 00:03:23,310
და ახლა ჩვენ გვინდა დააყენა 6 მარჯვნივ 3.

57
00:03:23,310 --> 00:03:32,170
ამიტომ აპირებს - მიიღოს 6.

58
00:03:32,170 --> 00:03:34,310
და რომ ბიჭი იქნება აღვნიშნო.

59
00:03:34,310 --> 00:03:38,320
Okay. ასე რომ ყველა ის გვთხოვს უნდა გააკეთოს.

60
00:03:38,320 --> 00:03:42,770
>> ახლა მოდით წავიდეთ მეტი რამდენიმე ტერმინოლოგიას.

61
00:03:42,770 --> 00:03:46,690
ჩვენ უკვე ვისაუბრეთ იმაზე, თუ როგორ root ხე არის ყველაზე საუკეთესო კვანძში, რომელიც ხე.

62
00:03:46,690 --> 00:03:54,720
ერთი შემცველი 7. კვანძების ბოლოში ხე ეწოდება ფოთლები.

63
00:03:54,720 --> 00:04:01,240
ნებისმიერი კვანძის რომელიც მხოლოდ აქვს null როგორც თავისი ბავშვების ფოთოლი.

64
00:04:01,240 --> 00:04:03,680
ასე რომ, შესაძლებელია, თუ ჩვენი ორობითი ხე არის მხოლოდ ერთი კვანძის,

65
00:04:03,680 --> 00:04:10,130
რომ ხე არის ფოთოლი, და ამით ყველაფერი მთავრდება.

66
00:04:10,130 --> 00:04:12,060
"The 'სიმაღლე' ხე არის ხმების hops თქვენ უნდა გააკეთოთ

67
00:04:12,060 --> 00:04:16,620
მიიღოს ზემოდან რომ ფოთოლი. "

68
00:04:16,620 --> 00:04:18,640
ჩვენ შეღწევას, წელს მეორე, განსხვავება

69
00:04:18,640 --> 00:04:21,940
შორის დაბალანსებული და გაუწონასწორებელ ბინარული ხეები,

70
00:04:21,940 --> 00:04:29,470
მაგრამ ახლა, საერთო სიმაღლე ამ ხე

71
00:04:29,470 --> 00:04:34,520
მე ვიტყოდი, არის 3, თუმცა, თუ თქვენ ითვლიან რაოდენობის hops

72
00:04:34,520 --> 00:04:39,710
თქვენ უნდა გააკეთოთ, რათა ხელი 9, მაშინ ეს მართლაც მხოლოდ სიმაღლე 2.

73
00:04:39,710 --> 00:04:43,340
ახლავე ეს გაუწონასწორებელ ორობითი ხე,

74
00:04:43,340 --> 00:04:49,840
მაგრამ ჩვენ ვისაუბრეთ დაბალანსებული, როდესაც იგი იღებს უნდა იყოს შესაბამისი.

75
00:04:49,840 --> 00:04:52,040
ახლა ჩვენ შეგვიძლია ვისაუბროთ კვანძების ხე თვალსაზრისით

76
00:04:52,040 --> 00:04:54,700
შედარებით სხვა კვანძების ხე.

77
00:04:54,700 --> 00:04:59,730
ახლა ჩვენ გვაქვს მშობლები, შვილები, და, ძმა, წინაპრების და შთამომავლების.

78
00:04:59,730 --> 00:05:05,650
ისინი საკმაოდ საღი აზრი, რას გულისხმობენ.

79
00:05:05,650 --> 00:05:09,610
თუ ჩვენ ვთხოვთ - ის მშობლები.

80
00:05:09,610 --> 00:05:12,830
რა არის მშობელი 3?

81
00:05:12,830 --> 00:05:16,090
[სტუდენტთა] 7. >> Yeah. მშობელს მხოლოდ იქნება რა მიუთითებს თქვენ.

82
00:05:16,090 --> 00:05:20,510
მაშინ რა შვილები 7?

83
00:05:20,510 --> 00:05:23,860
[სტუდენტთა] 3 და 9. >> Yeah.

84
00:05:23,860 --> 00:05:26,460
გაითვალისწინეთ, რომ "ბავშვები" სიტყვასიტყვით ნიშნავს შვილი,

85
00:05:26,460 --> 00:05:31,010
ასე რომ, 6 არ ვრცელდება, რადგან მოსწონს შვილიშვილი.

86
00:05:31,010 --> 00:05:35,540
მაგრამ შემდეგ, თუ ჩვენ შთამომავლები, რადგან ყველანი შთამომავლები 7?

87
00:05:35,540 --> 00:05:37,500
[სტუდენტთა] 3, 6 და 9. >> Yeah.

88
00:05:37,500 --> 00:05:42,330
შთამომავლები root node იქნება ყველაფერი ხე,

89
00:05:42,330 --> 00:05:47,950
გარდა იქნებ root node თავად, თუ არ გვინდა, რომ თვლიან, რომ შთამომავალი.

90
00:05:47,950 --> 00:05:50,750
და ბოლოს, წინაპრები, ამიტომ საპირისპირო მიმართულებით.

91
00:05:50,750 --> 00:05:55,740
ასე რომ რა წინაპრები 6?

92
00:05:55,740 --> 00:05:58,920
[სტუდენტთა] 3 და 7. >> Yeah. 9 არ შედის.

93
00:05:58,920 --> 00:06:02,520
უბრალოდ პირდაპირი lineage დაბრუნება root

94
00:06:02,520 --> 00:06:13,230
იქნება თქვენი წინაპრების.

95
00:06:13,230 --> 00:06:16,300
>> "ჩვენ ვამბობთ, რომ ორობითი ხის 'შეუკვეთა' თუ თითოეული კვანძის in ხე,

96
00:06:16,300 --> 00:06:19,530
ყველა მისი შთამომავლები მარცხენა აქვს ნაკლები ღირებულებების

97
00:06:19,530 --> 00:06:22,890
და ყველა, ვინც მარჯვენა აქვს უფრო დიდი ღირებულებები.

98
00:06:22,890 --> 00:06:27,060
მაგალითად, ხე ზემოთ უკვეთავს მაგრამ ეს არ არის მხოლოდ შესაძლებელი უბრძანა მოწყობა. "

99
00:06:27,060 --> 00:06:30,180
სანამ არ მივიღებთ რომ,

100
00:06:30,180 --> 00:06:36,420
უბრძანა ორობითი ხე ასევე ცნობილია როგორც ორობითი ძებნა ხე.

101
00:06:36,420 --> 00:06:38,660
აქ ჩვენ არ უნდა იყოს უწოდა უბრძანა ორობითი ხე,

102
00:06:38,660 --> 00:06:41,850
მაგრამ არასდროს არ მსმენია ეს მოუწოდა უბრძანა ორობითი ხე ადრე,

103
00:06:41,850 --> 00:06:46,650
და ინტელექტუალური ჩვენ ბევრად უფრო დააყენა ორობითი ძებნა ხე.

104
00:06:46,650 --> 00:06:49,250
ისინი ერთი და იგივე,

105
00:06:49,250 --> 00:06:54,580
და მნიშვნელოვანია თქვენ აღიარებს განსხვავება შორის ორობითი ხე და ბინარული ძებნა ხე.

106
00:06:54,580 --> 00:06:58,830
ორობითი ხე მხოლოდ ხე, რომელიც მიუთითებს ორ რამეს.

107
00:06:58,830 --> 00:07:02,120
თითოეული კვანძის მიუთითებს ორ რამეს.

108
00:07:02,120 --> 00:07:06,310
არ არსებობს მიზეზის შესახებ ღირებულებებს, რომ ეს მიუთითებს.

109
00:07:06,310 --> 00:07:11,370
ამიტომ მინდა აქ, რადგან ბინარული ძებნა ხე,

110
00:07:11,370 --> 00:07:14,030
ჩვენ ვიცით, რომ თუ ჩვენ მივდივართ მარცხნივ 7,

111
00:07:14,030 --> 00:07:16,670
მაშინ ყველა ღირებულებებს, რომ ჩვენ შესაძლოა მიაღწიოს

112
00:07:16,670 --> 00:07:19,310
მიერ მიმდინარეობს დარჩა 7 უნდა იყოს არანაკლებ 7.

113
00:07:19,310 --> 00:07:24,070
გაითვალისწინეთ, რომ ყველა ღირებულებების არანაკლებ 7 არიან 3 და 6.

114
00:07:24,070 --> 00:07:26,040
იმ ყველა მარცხნივ 7.

115
00:07:26,040 --> 00:07:29,020
თუ ჩვენ წასვლა უფლება 7, ყველაფერი უნდა იყოს მეტი 7,

116
00:07:29,020 --> 00:07:33,220
ასე 9 არის მარჯვნივ 7, ასე რომ ჩვენ კარგები.

117
00:07:33,220 --> 00:07:36,150
ეს არ არის საქმე ორობითი ხე,

118
00:07:36,150 --> 00:07:40,020
ამისთვის რეგულარული ორობითი ხე შეგვიძლია უბრალოდ 3 ზედა, 7 მარცხნივ,

119
00:07:40,020 --> 00:07:47,630
9 მარცხნივ 7; არ შეკვეთით ფასეულობათა განაწილებაზე.

120
00:07:47,630 --> 00:07:56,140
ახლა ჩვენ რეალურად არ ვაკეთებთ, რადგან ეს რუტინული და არასაჭირო,

121
00:07:56,140 --> 00:07:59,400
მაგრამ "ცდილობენ მიაპყროს როგორც ბევრი უბრძანა ხეები, როგორც თქვენ შეგიძლიათ ვფიქრობ

122
00:07:59,400 --> 00:08:01,900
გამოყენებით ნომრები 7, 3, 9, და 6.

123
00:08:01,900 --> 00:08:06,800
რამდენი განსხვავებული ფორმატი არის იქ? რა არის სიმაღლე ყოველი ერთი? "

124
00:08:06,800 --> 00:08:10,480
>> ჩვენ ყველაფერს გავაკეთებთ წყვილი, მაგრამ მთავარი იდეა ისაა,

125
00:08:10,480 --> 00:08:16,530
ეს არანაირად არ უნიკალური წარმომადგენლობა ორობითი ხე შემცველი ამ ღირებულებებს.

126
00:08:16,530 --> 00:08:22,760
ყველა ჩვენ გვჭირდება გარკვეული ორობითი ხე, რომელიც შეიცავს 7, 3, 6, და 9.

127
00:08:22,760 --> 00:08:25,960
კიდევ ერთი შესაძლო მართებული იქნებოდა root არის 3,

128
00:08:25,960 --> 00:08:30,260
გადადით მარცხნივ და ეს 6, გადადით მარცხნივ და ეს 7,

129
00:08:30,260 --> 00:08:32,730
გადადით მარცხნივ და ეს 9.

130
00:08:32,730 --> 00:08:36,169
სწორედ შესანიშნავად მოქმედებს ორობითი ძებნა ხე.

131
00:08:36,169 --> 00:08:39,570
ეს არ არის ძალიან გამოსადეგი, რადგან ეს ისევე უკავშირდება სია

132
00:08:39,570 --> 00:08:43,750
და ყველა ეს მითითებები მხოლოდ null.

133
00:08:43,750 --> 00:08:48,900
მაგრამ ეს სწორი ხე. ჰო?

134
00:08:48,900 --> 00:08:51,310
[სტუდენტური] ნუ ღირებულებები უნდა იყოს უფრო მეტი მარჯვენა?

135
00:08:51,310 --> 00:08:56,700
ან ეს -? >> ეს ვგულისხმობდი წასვლა სხვა გზით.

136
00:08:56,700 --> 00:09:00,960
არის კიდევ - ჰო, მოდით გადართოთ რომ.

137
00:09:00,960 --> 00:09:07,770
9, 7, 6, 3. კარგი დაჭერა.

138
00:09:07,770 --> 00:09:11,730
ეს ჯერ არ ემორჩილებიან რა ორობითი ხე ძებნა უნდა გავაკეთოთ.

139
00:09:11,730 --> 00:09:15,650
ასე რომ ყველაფერი მარცხნივ უნდა იყოს ნაკლები ნებისმიერ მოცემულ კვანძში.

140
00:09:15,650 --> 00:09:23,180
ჩვენ შეგვეძლო უბრალოდ გადაადგილება, ვთქვათ, ამ 6 და განათავსოთ აქ.

141
00:09:23,180 --> 00:09:26,880
არა, ჩვენ არ შეგვიძლია. რატომაა აკეთეთ, რომ?

142
00:09:26,880 --> 00:09:35,350
მოდით - აქ არის 6, აქ არის 7, 6 ქულა 3.

143
00:09:35,350 --> 00:09:39,290
ეს არის ჯერ კიდევ მოქმედებს ორობითი ძებნა ხე.

144
00:09:39,290 --> 00:09:49,260
რა არის არასწორი თუ - ვნახოთ, თუ შემიძლია ამუშავება მოწყობა.

145
00:09:49,260 --> 00:09:52,280
Yeah, okay. რა არის ცუდი ამ ხეს?

146
00:09:52,280 --> 00:10:08,920
ვფიქრობ მე უკვე მოცემული მინიშნება, რომ არსებობს რაღაც არის.

147
00:10:08,920 --> 00:10:14,430
რატომაა აკეთეთ, რომ?

148
00:10:14,430 --> 00:10:18,510
Okay. ეს გამოიყურება გონივრული.

149
00:10:18,510 --> 00:10:22,590
თუ დავაკვირდებით თითოეული კვანძის, როგორიცაა 7, შემდეგ მარცხნივ 7 არის 3.

150
00:10:22,590 --> 00:10:24,960
ასე რომ, ჩვენ გვაქვს 3, რამ უფლება 3 არის 6.

151
00:10:24,960 --> 00:10:27,750
და თუ თქვენ შეხედეთ 6, რამ უფლება 6 არის 9.

152
00:10:27,750 --> 00:10:30,910
მაშ რატომ არის ეს არ მოქმედებს ორობითი ძებნა ხე?

153
00:10:30,910 --> 00:10:36,330
[სტუდენტთა] 9 მაინც მარცხნივ 7. >> Yeah.

154
00:10:36,330 --> 00:10:43,710
ეს უნდა იყოს ჭეშმარიტი, რომ ყველა მნიშვნელობა თქვენ შესაძლოა მიაღწიოს მიერ აპირებს მარცხნივ 7 ნაკლებია 7.

155
00:10:43,710 --> 00:10:49,120
თუ ჩვენ მივდივართ მარცხნივ 7, მივიღებთ დან 3 და ჩვენ შეგვიძლია მაინც დან 6,

156
00:10:49,120 --> 00:10:52,520
ჩვენ შეგვიძლია მაინც დან 9, არამედ რომელმაც წავიდა არანაკლებ 7,

157
00:10:52,520 --> 00:10:55,070
ჩვენ არ უნდა შეუძლია მიიღოს რიგი რომ აღემატება 7.

158
00:10:55,070 --> 00:10:59,830
ასე რომ ეს არ არის სწორი ორობითი ძებნა ხე.

159
00:10:59,830 --> 00:11:02,330
>> ჩემი ძმა რეალურად ჰქონდა ინტერვიუში კითხვაზე

160
00:11:02,330 --> 00:11:07,760
რომ იყო ძირითადად ეს, უბრალოდ კოდი up რაღაც, რათა შეამოწმოს

161
00:11:07,760 --> 00:11:10,500
თუ არა ხე არის ორობითი ძებნა ხე,

162
00:11:10,500 --> 00:11:13,580
და ა.შ. პირველი რაც მან გააკეთა იყო მხოლოდ შეამოწმეთ

163
00:11:13,580 --> 00:11:17,020
თუ მარცხენა და მარჯვენა სწორია, ხოლო შემდეგ iterate დახვდა.

164
00:11:17,020 --> 00:11:19,700
მაგრამ თქვენ არ შეგიძლიათ უბრალოდ რომ, თქვენ უნდა ტრეკზე

165
00:11:19,700 --> 00:11:22,550
იმისა, რომ ახლა, რომ მე წასული მარცხნივ 7,

166
00:11:22,550 --> 00:11:26,340
ყველაფერი ამ subtree უნდა იყოს არანაკლებ 7.

167
00:11:26,340 --> 00:11:28,430
სწორი ალგორითმი სჭირდება ტრეკზე

168
00:11:28,430 --> 00:11:35,970
საქართველოს ფარგლებს გარეთ, რომ ღირებულებების შესაძლოა ხარობს სისტემაში

169
00:11:35,970 --> 00:11:38,360
ჩვენ არ გავლა ყველა მათგანი.

170
00:11:38,360 --> 00:11:41,630
არსებობს ლამაზი რეციდივის მიზეზი,

171
00:11:41,630 --> 00:11:44,810
თუმცა ჩვენ არ მიღებული იმ, ან ჩვენ ვერ მიიღებენ მათ,

172
00:11:44,810 --> 00:11:47,030
განსაზღვრის რამდენი იქ სინამდვილეში.

173
00:11:47,030 --> 00:11:53,180
ასე რომ 14 მათგანი.

174
00:11:53,180 --> 00:11:56,020
იდეა, როგორ გავაკეთებთ მათემატიკურად ჰგავს,

175
00:11:56,020 --> 00:11:59,770
შეგიძლიათ აირჩიოთ ნებისმიერი ერთი უნდა იყოს root node,

176
00:11:59,770 --> 00:12:03,160
და მაშინ თუ მე აირჩიოთ 7 იყოს root node,

177
00:12:03,160 --> 00:12:08,150
მაშინ არსებობს, ვთქვათ, ზოგიერთი ნომრები, რომ შეიძლება იყოს ჩემი მარცხენა კვანძში,

178
00:12:08,150 --> 00:12:10,440
და არსებობს ციფრები, რომ შეიძლება ჩემი უფლება კვანძში,

179
00:12:10,440 --> 00:12:15,090
მაგრამ თუ მე n სულ ციფრები, მაშინ თანხა, რომელიც შეიძლება წავიდეს მარცხენა

180
00:12:15,090 --> 00:12:18,820
პლუს თანხა, რომელიც შეიძლება წავიდეს უფლება N - 1.

181
00:12:18,820 --> 00:12:26,130
ასე დარჩენილი ციფრები, რომ მათ უნდა მიეცეთ საშუალება წასვლა ან მარცხნივ ან მარჯვნივ.

182
00:12:26,130 --> 00:12:31,580
როგორც ჩანს რთული, რომ თუ მე ზუსტად 3 პირველი მაშინ ყველაფერს აქვს წასვლა მარცხენა

183
00:12:31,580 --> 00:12:35,080
მაგრამ თუ მე ზუსტად 7, მაშინ ზოგი რამ შეიძლება მარცხენა და ზოგი რამ შეიძლება გადადით მარჯვნივ.

184
00:12:35,080 --> 00:12:39,570
და '3 პირველი "მე ყოფილა ყველაფერი შეუძლია უფლება.

185
00:12:39,570 --> 00:12:42,350
მართლაც, თქვენ უბრალოდ უნდა ვიფიქროთ, როგორც,

186
00:12:42,350 --> 00:12:47,980
რამდენი რამ შეიძლება ადამიანმა შემდეგ ეტაპზე ხე.

187
00:12:47,980 --> 00:12:50,420
და საქმე აღმოჩნდება 14; ან თქვენ შეგიძლიათ დახაზოთ ყველა მათგანი,

188
00:12:50,420 --> 00:12:54,650
და შემდეგ თქვენ მიიღებთ 14.

189
00:12:54,650 --> 00:13:01,120
>> უკან აქ,

190
00:13:01,120 --> 00:13:03,510
"წესრიგიანი ბინარული ხეები გრილი რადგან ჩვენ შეგიძლიათ მოძებნოთ მეშვეობით მათ

191
00:13:03,510 --> 00:13:06,910
ძალიან მსგავსი გზა ძებნას მეტი დახარისხებული მასივი.

192
00:13:06,910 --> 00:13:10,120
ამისათვის ჩვენ იწყება root და მუშაობა ჩვენი გზა ქვემოთ ხე

193
00:13:10,120 --> 00:13:13,440
მიმართ ფოთლები, შემოწმების თითოეული კვანძის ღირებულებების წინააღმდეგ ღირებულებები ჩვენ ეძებს.

194
00:13:13,440 --> 00:13:15,810
თუ მიმდინარე კვანძის ს მნიშვნელობა ნაკლებია ღირებულების ჩვენ ვეძებთ,

195
00:13:15,810 --> 00:13:18,050
თქვენ გადასვლა შემდეგ კვანძის უფლება შვილი.

196
00:13:18,050 --> 00:13:20,030
წინააღმდეგ შემთხვევაში თქვენ გადადით კვანძის მარცხენა შვილი.

197
00:13:20,030 --> 00:13:22,800
რაღაც მომენტში, თქვენ ან იპოვოს ღირებულება თქვენ ვეძებთ, ან თქვენ გადაეყარონ null,

198
00:13:22,800 --> 00:13:28,520
მითითებით ღირებულება არ in ხე. "

199
00:13:28,520 --> 00:13:32,450
მე უნდა მეთოდით გადასინჯვის ხე გვქონდა ადრე, რომ ყველაფერს იღებენ მეორე.

200
00:13:32,450 --> 00:13:38,280
მაგრამ ჩვენ გვინდა, რომ ეძებოთ თუ არა 6, 10 და 1 არიან ხე.

201
00:13:38,280 --> 00:13:49,180
ასე რომ, რაც იყო, 7, 9, 3, 6. Okay.

202
00:13:49,180 --> 00:13:52,730
ნომრები გსურთ ეძებოთ, ჩვენ გვინდა გამოიყურებოდეს up 6.

203
00:13:52,730 --> 00:13:55,440
როგორ აკეთებს ამას ალგორითმი მუშაობს?

204
00:13:55,440 --> 00:14:03,040
ასევე, ჩვენ ასევე გვაქვს ძირეული მომცეთ ჩვენი ხე.

205
00:14:03,040 --> 00:14:12,460
და ჩვენ გვინდა წასვლა root და აცხადებენ, ეს ღირებულება ტოლია ღირებულების ჩვენ ეძებს?

206
00:14:12,460 --> 00:14:15,000
ამიტომ, ჩვენ ვეძებთ 6, ამიტომ არ ემთხვევიან.

207
00:14:15,000 --> 00:14:20,140
ამიტომ, ჩვენ ვაპირებთ შენარჩუნება, და ახლა ჩვენ ვამბობთ, okay, ასე 6 ნაკლებია, ვიდრე 7.

208
00:14:20,140 --> 00:14:23,940
ნიშნავს ეს გვინდა წასვლა მარცხენა ან არ გვინდა წასვლა უფლება?

209
00:14:23,940 --> 00:14:27,340
[სტუდენტური] მარცხნივ. >> Yeah.

210
00:14:27,340 --> 00:14:33,340
ეს მნიშვნელოვნად ადვილია, ყველა თქვენ უნდა გააკეთოთ გავამახვილო ერთ შესაძლო კვანძის ხე

211
00:14:33,340 --> 00:14:37,760
და მაშინ don't - ის ნაცვლად ცდილობს ვფიქრობ თქვენს ხელმძღვანელი,

212
00:14:37,760 --> 00:14:40,020
okay, თუ ნაკლები, შემიძლია წასვლა მარცხენა ან მარჯვენა

213
00:14:40,020 --> 00:14:43,030
უბრალოდ ეძებს ამ სურათს, ძალიან ნათელია, რომ მე წასვლა მარცხენა

214
00:14:43,030 --> 00:14:47,700
თუ ამ კვანძის მეტია ღირებულება რომ ვეძებ.

215
00:14:47,700 --> 00:14:52,600
ასე, რომ თქვენ გადადით მარცხნივ, ახლა მე ღამის 3.

216
00:14:52,600 --> 00:14:57,770
მინდა - 3 ნაკლებია, ვიდრე ღირებულება ვეძებ, რომელიც 6.

217
00:14:57,770 --> 00:15:03,420
ამიტომ, ჩვენ გადადით უფლება, და ახლა დასრულდება up at 6,

218
00:15:03,420 --> 00:15:07,380
რაც ღირებულება ვეძებ, ამიტომ იქნება TRUE.

219
00:15:07,380 --> 00:15:15,760
შემდეგი ღირებულება მე ვაპირებ ვეძებოთ არის 10.

220
00:15:15,760 --> 00:15:23,230
Okay. ასე 10, ახლა, აპირებს - შეწყვიტა, რომ - აპირებს დაიცვას root.

221
00:15:23,230 --> 00:15:27,670
ახლა, 10 იქნება მეტი 7, ამიტომ მინდა გამოიყურებოდეს მარჯვნივ.

222
00:15:27,670 --> 00:15:31,660
მე ვაპირებ გადმოდიოდნენ აქ, 10 იქნება მეტი 9,

223
00:15:31,660 --> 00:15:34,520
ამიტომ მე ვაპირებ მინდა თვალი მარჯვნივ.

224
00:15:34,520 --> 00:15:42,100
მე მეტი აქ, მაგრამ აქ ახლა მე ზე null.

225
00:15:42,100 --> 00:15:44,170
რა გავაკეთო, თუ მე მოხვდა null?

226
00:15:44,170 --> 00:15:47,440
[სტუდენტური] დაბრუნება ყალბი? >> Yeah. მე ვერ 10.

227
00:15:47,440 --> 00:15:49,800
1 იქნება თითქმის იდენტურია შემთხვევაში,

228
00:15:49,800 --> 00:15:51,950
გარდა უბრალოდ უნდა flipped; ნაცვლად ეძებს

229
00:15:51,950 --> 00:15:56,540
ქვემოთ მარჯვენა მხარეს, მე ვაპირებ თვალი ქვევით მარცხენა მხარეს.

230
00:15:56,540 --> 00:16:00,430
>> ახლა ვფიქრობ, რეალურად მისაღებად კოდი.

231
00:16:00,430 --> 00:16:04,070
აი აქ - გახსენით CS50 ელექტრო და ნავიგაცია თქვენი გზა არსებობს,

232
00:16:04,070 --> 00:16:07,010
მაგრამ თქვენ შეგიძლიათ უბრალოდ ის სივრცეში.

233
00:16:07,010 --> 00:16:09,170
ალბათ იდეალური ამას სივრცეში,

234
00:16:09,170 --> 00:16:13,760
იმიტომ, რომ ჩვენ შეგვიძლია მუშაობა სივრცეში.

235
00:16:13,760 --> 00:16:19,170
"პირველი, ჩვენ გვჭირდება ახალი ტიპის განმარტება ორობითი ხე კვანძის შემცველი int ღირებულებებს.

236
00:16:19,170 --> 00:16:21,400
გამოყენება boilerplate typedef ქვემოთ

237
00:16:21,400 --> 00:16:24,510
შექმნა ახალი ტიპის განმარტება node in ორობითი ხე.

238
00:16:24,510 --> 00:16:27,930
თუ თქვენ გაქვთ დავრჩებოდით. . . "Blah, blah, blah. Okay.

239
00:16:27,930 --> 00:16:30,380
მოდით დააყენა boilerplate აქ,

240
00:16:30,380 --> 00:16:41,630
typedef struct კვანძის და კვანძის. Yeah, okay.

241
00:16:41,630 --> 00:16:44,270
ასე რომ რა სფეროებში ჩვენ ვაპირებთ გვინდა ჩვენს კვანძის?

242
00:16:44,270 --> 00:16:46,520
[სტუდენტური] Int და შემდეგ ორი პოინტერები?

243
00:16:46,520 --> 00:16:49,700
>> Int ღირებულება, ორი პოინტერები? როგორ შემიძლია წერენ პოინტერები?

244
00:16:49,700 --> 00:16:58,440
[სტუდენტური] Struct. >> მე უნდა zoom შემოსული ჰო, ისე struct კვანძის * დაუტოვებიათ,

245
00:16:58,440 --> 00:17:01,320
და struct კვანძის * უფლება.

246
00:17:01,320 --> 00:17:03,460
და მახსოვს, განხილვის ბოლო დროს,

247
00:17:03,460 --> 00:17:15,290
რომ ეს აზრი არ აქვს, ეს აზრი არ აქვს,

248
00:17:15,290 --> 00:17:18,270
ამ აზრი არა აქვს.

249
00:17:18,270 --> 00:17:25,000
თქვენ უნდა ყველაფერს, რათა განისაზღვროს ამ რეკურსიული struct.

250
00:17:25,000 --> 00:17:27,970
Okay, ასე რომ რა ჩვენი ხე აპირებს გამოიყურებოდეს.

251
00:17:27,970 --> 00:17:37,670
თითქოს ჩვენ აქ trinary ხე, მაშინ კვანძის შეიძლება გამოიყურებოდეს B1, B2, struct კვანძის * B3,

252
00:17:37,670 --> 00:17:43,470
სადაც B არის ფილიალი - ფაქტობრივად, მე მეტი გაიგეს იგი დაუტოვებიათ, შუა, მარჯვენა, მაგრამ რასაც.

253
00:17:43,470 --> 00:17:55,610
ჩვენ მხოლოდ აინტერესებს ორობითი, ამიტომ უფლება, დაუტოვებიათ.

254
00:17:55,610 --> 00:17:59,110
"ახლა განაცხადოს გლობალური კვანძის * ცვლადი ამისთვის ფესვი ხე."

255
00:17:59,110 --> 00:18:01,510
ამიტომ ჩვენ არ ვაპირებთ გავაკეთოთ, რომ.

256
00:18:01,510 --> 00:18:08,950
იმისათვის, რომ რამ ოდნავ უფრო რთული და უფრო განზოგადებული,

257
00:18:08,950 --> 00:18:11,570
არ გვექნება გლობალური კვანძის ცვლადი.

258
00:18:11,570 --> 00:18:16,710
ამის ნაცვლად, მთავარ ჩვენ ვაცხადებთ ჩვენი ყველა კვანძის რამ,

259
00:18:16,710 --> 00:18:20,500
და ეს იმას ნიშნავს რომ ქვემოთ, როდესაც ჩვენ ვიწყებთ გაშვებული

260
00:18:20,500 --> 00:18:23,130
ჩვენი შეიცავს ფუნქცია და ჩვენი ჩანართით ფუნქცია,

261
00:18:23,130 --> 00:18:27,410
ნაცვლად ჩვენი შეიცავს ფუნქციის გამოყენებით ამ გლობალურ კვანძის ცვლადი,

262
00:18:27,410 --> 00:18:34,280
ჩვენ ვაპირებთ აქვს მიიღოს როგორც არგუმენტი ხე რომ ჩვენ გვსურს პროცესში.

263
00:18:34,280 --> 00:18:36,650
მქონე გლობალური ცვლადი უნდა მიიღოს რამ ადვილია.

264
00:18:36,650 --> 00:18:42,310
ჩვენ ვაპირებთ, რათა რამ ჩვენზე მეტი.

265
00:18:42,310 --> 00:18:51,210
ახლა მიიღოს წუთი ან ასე უბრალოდ ასეთი რამ,

266
00:18:51,210 --> 00:18:57,690
აქ შიგნით ძირითადი გსურთ მისი შექმნა ამ ხეს, და რომ ყველა გსურთ.

267
00:18:57,690 --> 00:19:04,530
სცადეთ და მშენებლობა ხე თქვენს მთავარ ფუნქციას.

268
00:19:42,760 --> 00:19:47,610
>> Okay. ასე, რომ თქვენ არც კი უნდა არ აშენდა ხის მთელი გზა არ არის.

269
00:19:47,610 --> 00:19:49,840
მაგრამ არავის აქვს რაღაც შემეძლო დახევის up

270
00:19:49,840 --> 00:20:03,130
რათა ნახოთ, თუ როგორ შეიძლება დავიწყოთ აშენებს ასეთი ხე?

271
00:20:03,130 --> 00:20:08,080
[სტუდენტური] ვინმეს banging, ცდილობდა.

272
00:20:08,080 --> 00:20:13,100
[Bowden] Anyone კომფორტულად იგრძნონ იმ ხის სამშენებლო?

273
00:20:13,100 --> 00:20:15,520
[სტუდენტური] რა თქმა უნდა. ეს არ გაკეთებულა. >> ეს ჯარიმა. ჩვენ შეგვიძლია მხოლოდ დასრულდება -

274
00:20:15,520 --> 00:20:26,860
OH, შეგიძლიათ შეინახოთ? Hooray.

275
00:20:26,860 --> 00:20:32,020
ასე რომ აქ გვაქვს - Oh, მე ოდნავ შეწყვიტა.

276
00:20:32,020 --> 00:20:34,770
ვარ zoomed წელს?

277
00:20:34,770 --> 00:20:37,730
მიუახლოვდით, გადახვევა გარეთ. >> მე მაქვს შეკითხვა. >> Yeah?

278
00:20:37,730 --> 00:20:44,410
[სტუდენტური] როდესაც თქვენ განსაზღვროს struct, რომლებიც რამ, როგორიცაა ინიციალიზაცია არაფრის?

279
00:20:44,410 --> 00:20:47,160
[Bowden] მდებარ >> Okay. ასე, რომ თქვენ უნდა ინიციალიზაცია -

280
00:20:47,160 --> 00:20:50,450
[Bowden] მდებარ როდესაც განსაზღვრავენ, ან როდესაც თქვენ გამოაცხადოს struct,

281
00:20:50,450 --> 00:20:55,600
იგი არ არის ინიციალიზაცია მიერ default; უბრალოდ მინდა თუ განაცხადოს int.

282
00:20:55,600 --> 00:20:59,020
ეს ზუსტად იგივე. ეს იგივეა, თითქოს თითოეულ ინდივიდუალური სფეროები

283
00:20:59,020 --> 00:21:04,460
შეიძლება ჰქონდეს ნაგვის ღირებულების იგი. >> და შეიძლება განისაზღვროს - ან განაცხადოს struct

284
00:21:04,460 --> 00:21:07,740
ისე, რომ ის არ ვრთავ მათ?

285
00:21:07,740 --> 00:21:13,200
[Bowden] დიახ. ასე რომ, მალსახმობი ინიციალიზაციისას სინტაქსი

286
00:21:13,200 --> 00:21:18,660
აპირებს ჰგავს -

287
00:21:18,660 --> 00:21:22,200
არსებობს ორი გზა, ჩვენ შეგვიძლია ამის გაკეთება. მიმაჩნია, რომ უნდა კომპილირება

288
00:21:22,200 --> 00:21:25,840
რომ დავრწმუნდეთ Clang ასევე აკეთებს ამას.

289
00:21:25,840 --> 00:21:28,510
ბრძანებით არგუმენტები, რომ მოდის struct,

290
00:21:28,510 --> 00:21:32,170
თქვენ დააყენა როგორც ბრძანებით არგუმენტები შიგნით ამ Curly braces.

291
00:21:32,170 --> 00:21:35,690
ასე რომ, თუ გსურთ ინიციალიზაცია მას 9 დატოვა იყოს null და შემდეგ სწორი იყოს null,

292
00:21:35,690 --> 00:21:41,570
ეს იქნება 9, null, null.

293
00:21:41,570 --> 00:21:47,890
ალტერნატიული არის, და რედაქტორი არ მოსწონს ეს სინტაქსი,

294
00:21:47,890 --> 00:21:50,300
და ეს ფიქრობს მინდა ახალი ბლოკი,

295
00:21:50,300 --> 00:22:01,800
მაგრამ ალტერნატიული არის რაღაც მსგავსი -

296
00:22:01,800 --> 00:22:04,190
აქ, მე ამას ახალ ხაზზე.

297
00:22:04,190 --> 00:22:09,140
შეგიძლიათ პირდაპირ ვთქვა, მე დაგვავიწყდეს ზუსტი სინტაქსი.

298
00:22:09,140 --> 00:22:13,110
ასე რომ შეგიძლიათ პირდაპირ მიმართოს მათ სახელი და აცხადებენ,

299
00:22:13,110 --> 00:22:21,570
. გ, ან. ღირებულება = 9. მარცხენა = null.

300
00:22:21,570 --> 00:22:24,540
მე გამოცნობა ამ საჭიროებს მძიმეები.

301
00:22:24,540 --> 00:22:29,110
. უფლება = NULL, ამიტომ ამ გზით თქვენ არ

302
00:22:29,110 --> 00:22:33,780
რეალურად უნდა იცოდეთ ბრძანებით struct,

303
00:22:33,780 --> 00:22:36,650
და როდესაც თქვენ კითხულობთ ამ, გაცილებით უფრო ზუსტად რომ ვთქვათ

304
00:22:36,650 --> 00:22:41,920
იმაზე, თუ რა ღირებულების ის მიმდინარეობს ინიციალიზაცია to.

305
00:22:41,920 --> 00:22:44,080
>> ეს ხდება, რომ ერთი რამ, რომ -

306
00:22:44,080 --> 00:22:49,100
ასე რომ, ყველაზე ნაწილი, C + + არის superset of C.

307
00:22:49,100 --> 00:22:54,160
შეგიძლიათ მიიღოს C კოდი, გადატანა მეტი C + +, უნდა შეადგინოს.

308
00:22:54,160 --> 00:22:59,570
ეს არის ერთი რამ, რომ C + + არ უჭერს მხარს, ასე რომ, ადამიანებს ტენდენცია არ უნდა გაეკეთებინათ ეს.

309
00:22:59,570 --> 00:23:01,850
არ ვიცი თუ ეს ერთადერთი მიზეზი ხალხი ტენდენცია არ უნდა გააკეთოს ის,

310
00:23:01,850 --> 00:23:10,540
მაგრამ შემთხვევაში სადაც მე გამოყენება დასჭირდა საჭიროა მუშაობა C + + და ა.შ. მე ვერ გამოიყენოს ეს.

311
00:23:10,540 --> 00:23:14,000
კიდევ ერთი მაგალითი, რომ რაღაც არ მუშაობს ერთად C + + არის

312
00:23:14,000 --> 00:23:16,940
როგორ malloc დააბრუნებს "ბათილად *," ტექნიკურად,

313
00:23:16,940 --> 00:23:20,200
მაგრამ თქვენ შეიძლება უბრალოდ, ვამბობთ char * x = malloc რასაც,

314
00:23:20,200 --> 00:23:22,840
და ეს ავტომატურად იქნება მიცემული რომ char *.

315
00:23:22,840 --> 00:23:25,450
რომ ავტომატური მსახიობი არ ხდება C + +.

316
00:23:25,450 --> 00:23:28,150
რომ არ კომპილირდება, და თქვენ ამას მკაფიოდ უნდა ითქვას,

317
00:23:28,150 --> 00:23:34,510
char *, malloc, რასაც, რომ მიიღო ის, რომ char *.

318
00:23:34,510 --> 00:23:37,270
არ არსებობს ბევრი რამ, რომ C და C + + ვერ შეთანხმებულან,

319
00:23:37,270 --> 00:23:40,620
მაგრამ იმ ორი.

320
00:23:40,620 --> 00:23:43,120
ასე რომ ჩვენ წავიდეთ ერთად ამ სინტაქსს.

321
00:23:43,120 --> 00:23:46,150
მაგრამ მაშინაც კი, თუ ჩვენ არ წავიდეთ ერთად, რომ სინტაქსი,

322
00:23:46,150 --> 00:23:49,470
რა არის - შეიძლება იყოს ცუდი ეს?

323
00:23:49,470 --> 00:23:52,170
[სტუდენტური] მე არ უნდა dereference ეს? >> Yeah.

324
00:23:52,170 --> 00:23:55,110
გახსოვდეთ, რომ arrow აქვს დაფარული dereference,

325
00:23:55,110 --> 00:23:58,230
და ასე, როცა ჩვენ უბრალოდ საქმე struct,

326
00:23:58,230 --> 00:24:04,300
ჩვენ გვინდა გამოვიყენოთ. მიიღოს საათზე სფეროში შიგნით struct.

327
00:24:04,300 --> 00:24:07,200
და მხოლოდ ახლა ვიყენებთ arrow არის, როცა ჩვენ გვსურს რომ -

328
00:24:07,200 --> 00:24:13,450
ასევე, arrow უდრის -

329
00:24:13,450 --> 00:24:17,020
არის ის, რაც მას იმის მანიშნებელი, თუ გამოიყენება arrow.

330
00:24:17,020 --> 00:24:24,600
ყველა arrow საშუალებებზე, dereference ამ, ახლა მე ზე struct, და შემიძლია კიდევ სფეროში.

331
00:24:24,600 --> 00:24:28,040
ან კიდევ სფეროში პირდაპირ ან dereference და მიიღეთ სფეროში -

332
00:24:28,040 --> 00:24:30,380
ვფიქრობ ეს უნდა იყოს მნიშვნელობა.

333
00:24:30,380 --> 00:24:33,910
მაგრამ აქ მე საქმე მხოლოდ struct, არ მომცეთ struct,

334
00:24:33,910 --> 00:24:38,780
და ამიტომ მე ვერ გამოიყენებს arrow.

335
00:24:38,780 --> 00:24:47,510
მაგრამ ამ სახის რამ შეგვიძლია გავაკეთოთ ყველა კვანძების.

336
00:24:47,510 --> 00:24:55,790
Oh ღმერთი ჩემი.

337
00:24:55,790 --> 00:25:09,540
ეს არის 6, 7, და 3.

338
00:25:09,540 --> 00:25:16,470
მაშინ ჩვენ შეგვიძლია შექმნას ფილიალები ჩვენი ხე, რომ შეგვიძლია 7 -

339
00:25:16,470 --> 00:25:21,650
ჩვენ შეგვიძლია არ, მისი მარცხენა უნდა აღვნიშნო, რომ 3.

340
00:25:21,650 --> 00:25:25,130
ასე როგორ უნდა გავაკეთოთ, რომ?

341
00:25:25,130 --> 00:25:29,320
[სტუდენტები, გაუგებარია] >> Yeah. მისამართი node3,

342
00:25:29,320 --> 00:25:34,170
და თუ არ აქვს მისამართი, მაშინ უბრალოდ არ შეადგინოს.

343
00:25:34,170 --> 00:25:38,190
მაგრამ გვახსოვდეს, რომ ეს არის მითითებას შემდეგი კვანძების.

344
00:25:38,190 --> 00:25:44,930
უფლება უნდა აღვნიშნო, რომ 9,

345
00:25:44,930 --> 00:25:53,330
და 3 უნდა აღვნიშნო უფლება 6.

346
00:25:53,330 --> 00:25:58,480
ვფიქრობ, ეს არის სრულ მზადყოფნაში. ნებისმიერი კომენტარი ან კითხვები?

347
00:25:58,480 --> 00:26:02,060
[სტუდენტი გაუგებარია] root იქნება 7.

348
00:26:02,060 --> 00:26:08,210
ჩვენ შეგვიძლია უბრალოდ, ვამბობთ კვანძის * ptr =

349
00:26:08,210 --> 00:26:14,160
ან ფესვი, = & node7.

350
00:26:14,160 --> 00:26:20,730
>> ჩვენი მიზნებისათვის, ჩვენ ვაპირებთ იყოს საქმე ჩანართით,

351
00:26:20,730 --> 00:26:25,490
ამიტომ ჩვენ ვაპირებთ მინდა დაწერა ფუნქციის ჩასასმელად ამ ორობითი ხე

352
00:26:25,490 --> 00:26:34,230
და ჩადეთ არის აუცილებლად ვაპირებ მოვუწოდო malloc შექმნა ახალი კვანძის ამ ხეს.

353
00:26:34,230 --> 00:26:36,590
ასე რამ ვაპირებთ მისაღებად ბინძურ იმ ფაქტით, რომ ზოგიერთი კვანძების

354
00:26:36,590 --> 00:26:38,590
ამჟამად on დასტის

355
00:26:38,590 --> 00:26:43,680
და სხვა კვანძების ვაპირებთ დასრულდება მდე შესახებ ბევრი როდესაც ჩვენ ჩადეთ მათ.

356
00:26:43,680 --> 00:26:47,640
ეს არის შესანიშნავად მოქმედებს, მაგრამ ერთადერთი მიზეზი

357
00:26:47,640 --> 00:26:49,600
ჩვენ ვერ გააკეთებს ამ თემაზე დასტის

358
00:26:49,600 --> 00:26:51,840
არის იმიტომ რომ ასეთი contrived მაგალითია იმისა, რომ ჩვენ ვიცით,

359
00:26:51,840 --> 00:26:56,360
ხე უნდა აშენდეს როგორც 7, 3, 6, 9.

360
00:26:56,360 --> 00:27:02,970
თუ არ გვქონდა, მაშინ ჩვენ არ უნდა malloc პირველ რიგში.

361
00:27:02,970 --> 00:27:06,160
როგორც ვნახავთ, მოგვიანებით, ჩვენ უნდა malloc'ing.

362
00:27:06,160 --> 00:27:08,570
ახლავე ეს შესანიშნავად გონივრული მოათავსოთ დასტის,

363
00:27:08,570 --> 00:27:14,750
მაგრამ მოდით შეცვალოთ ეს უნდა malloc განხორციელება.

364
00:27:14,750 --> 00:27:17,160
ასე რომ თითოეული ეს არის იქნება რაღაც მსგავსი

365
00:27:17,160 --> 00:27:24,240
კვანძის * node9 = malloc (sizeof (კვანძის)).

366
00:27:24,240 --> 00:27:28,040
და ახლა ჩვენ ვაპირებთ უნდა გავაკეთოთ ჩვენი ქვითარი.

367
00:27:28,040 --> 00:27:34,010
თუ (node9 == NULL) - მე არ მინდოდა, რომ -

368
00:27:34,010 --> 00:27:40,950
დააბრუნოს 1, და შემდეგ შეგვიძლია გავაკეთოთ node9-> რადგან ახლა ეს მაჩვენებელი,

369
00:27:40,950 --> 00:27:45,300
ღირებულების = 6, node9-> დაუტოვებიათ = NULL,

370
00:27:45,300 --> 00:27:48,930
node9-> უფლება = NULL,

371
00:27:48,930 --> 00:27:51,410
და ჩვენ ვაპირებთ უნდა გავაკეთოთ, რომ თითოეული იმ კვანძების.

372
00:27:51,410 --> 00:27:57,490
ასე რომ ნაცვლად, მოდით ვთქვათ შიგნით ცალკე ფუნქცია.

373
00:27:57,490 --> 00:28:00,620
მოდით ეძახით კვანძის * build_node,

374
00:28:00,620 --> 00:28:09,050
და ეს გარკვეულწილად მსგავსი APIs ჩვენ უზრუნველყოფს Huffman კოდირებას.

375
00:28:09,050 --> 00:28:12,730
ჩვენ გაძლევთ initializer ფუნქციების ხე

376
00:28:12,730 --> 00:28:20,520
და deconstructor "ფუნქციები" მათთვის, ხეები და იგივე ტყეებში.

377
00:28:20,520 --> 00:28:22,570
>> ასე რომ აქ ჩვენ ვაპირებთ აქვს initializer ფუნქცია

378
00:28:22,570 --> 00:28:25,170
უბრალოდ აშენება კვანძის ჩვენთვის.

379
00:28:25,170 --> 00:28:29,320
და ეს აპირებს გამოიყურებოდეს საკმაოდ ბევრი ზუსტად მოსწონს ეს.

380
00:28:29,320 --> 00:28:32,230
და მე კი იქნება ზარმაცი და არ შეიცვლება სახელით ცვლადი,

381
00:28:32,230 --> 00:28:34,380
მიუხედავად იმისა, რომ node9 აზრი არ აქვს უქმნით.

382
00:28:34,380 --> 00:28:38,610
ოჰ, ვფიქრობ node9 ღირებულების არ უნდა ყოფილიყო 6.

383
00:28:38,610 --> 00:28:42,800
ახლა ჩვენ შეგვიძლია დაბრუნების node9.

384
00:28:42,800 --> 00:28:49,550
და აქ ჩვენ უნდა დაუბრუნდეს null.

385
00:28:49,550 --> 00:28:52,690
ყველამ შეთანხმდნენ, რომ ზრდა-კვანძის ფუნქციას?

386
00:28:52,690 --> 00:28:59,780
ახლა ჩვენ შეგვიძლია უბრალოდ მოვუწოდებთ, რომ ავაშენოთ ნებისმიერი კვანძის ერთად მოცემული მნიშვნელობა და null პოინტერები.

387
00:28:59,780 --> 00:29:09,750
ახლა ჩვენ შეგვიძლია მოვუწოდებთ, რომ ჩვენ შეგვიძლია გავაკეთოთ კვანძი * node9 = build_node (9).

388
00:29:09,750 --> 00:29:25,810
და მოდით. . .

389
00:29:25,810 --> 00:29:33,980
6, 3, 7, 6, 3, 7.

390
00:29:33,980 --> 00:29:39,330
და ახლა ჩვენ გვინდა შეიქმნა იგივე მითითებას,

391
00:29:39,330 --> 00:29:42,470
გარდა ახლა ყველაფერი უკვე თვალსაზრისით პოინტერები

392
00:29:42,470 --> 00:29:48,480
ასე აღარ მისამართი.

393
00:29:48,480 --> 00:29:56,300
Okay. რა არის ბოლო რამ მინდა გავაკეთო?

394
00:29:56,300 --> 00:30:03,850
არსებობს შეცდომის შემოწმება, რომ მე არ აკეთებს.

395
00:30:03,850 --> 00:30:06,800
რას ააშენებს კვანძის დაბრუნების?

396
00:30:06,800 --> 00:30:11,660
[სტუდენტი გაუგებარია] >> Yeah. თუ malloc ვერ მოხერხდა, ის ყველაფერს დაბრუნების null.

397
00:30:11,660 --> 00:30:16,460
ამიტომ მე ვაპირებ lazily დააყენა მისი დანგრევა აქ ნაცვლად აკეთებს მდგომარეობა თითოეული.

398
00:30:16,460 --> 00:30:22,320
თუ (node9 == NULL, ან - კი მარტივი,

399
00:30:22,320 --> 00:30:28,020
ამ უდრის მხოლოდ იმ შემთხვევაში, თუ არ node9.

400
00:30:28,020 --> 00:30:38,310
ასე რომ, თუ არ node9, ან არ node6, ან არ node3, ან არ node7, დაბრუნდნენ 1.

401
00:30:38,310 --> 00:30:42,850
იქნებ ჩვენ უნდა ბეჭდვა malloc ვერ მოხერხდა, ან რაღაც.

402
00:30:42,850 --> 00:30:46,680
[სტუდენტური] სიცრუეა ტოლია null ისევე?

403
00:30:46,680 --> 00:30:51,290
[Bowden] ნებისმიერი ნულოვანი ღირებულება არის ყალბი.

404
00:30:51,290 --> 00:30:53,920
ასე რომ null არის ნულოვანი ღირებულება.

405
00:30:53,920 --> 00:30:56,780
ნულოვანი არის ნულოვანი ღირებულება. ცრუ არის ნულოვანი ღირებულება.

406
00:30:56,780 --> 00:31:02,130
ნებისმიერი - საკმაოდ ბევრი მხოლოდ 2 ნულოვანი ღირებულებები null და ნულის

407
00:31:02,130 --> 00:31:07,900
ყალბი მხოლოდ hash განისაზღვრება, როგორც ნულოვანი.

408
00:31:07,900 --> 00:31:13,030
რომელიც ასევე ვრცელდება თუ ჩვენ ვაცხადებთ გლობალური ცვლადი.

409
00:31:13,030 --> 00:31:17,890
თუ ჩავატარეთ კვანძის * root აქ,

410
00:31:17,890 --> 00:31:24,150
მაშინ - ლამაზი რამ შესახებ გლობალური ცვლადები არის, რომ ისინი ყოველთვის საწყის ღირებულებას.

411
00:31:24,150 --> 00:31:27,500
ეს არ არის ნამდვილი ფუნქციების, როგორ შიგნით აქ,

412
00:31:27,500 --> 00:31:34,870
თუ ჩვენ გვაქვს, ისევე, node * ან კვანძის x.

413
00:31:34,870 --> 00:31:37,380
ჩვენ არ გვაქვს, როგორია x.value, x.whatever,

414
00:31:37,380 --> 00:31:40,700
ან ჩვენ შეგვიძლია ბეჭდვა მათ და ისინი შეიძლება თვითნებური.

415
00:31:40,700 --> 00:31:44,980
ეს არ არის ნამდვილი გლობალური ცვლადები.

416
00:31:44,980 --> 00:31:47,450
ასე რომ კვანძის root ან კვანძის x.

417
00:31:47,450 --> 00:31:53,410
ჩვეულებრივ, ყველაფერი, რაც გლობალურ, თუ პირდაპირ არ ინიციალიზაცია ზოგიერთ ღირებულება,

418
00:31:53,410 --> 00:31:57,390
აქვს ნულოვანი ღირებულება, როგორც მისი ღირებულება.

419
00:31:57,390 --> 00:32:01,150
ასე რომ აქ, node * root, ჩვენ არ არის მკაფიოდ ინიციალიზაცია მას არაფერი,

420
00:32:01,150 --> 00:32:06,350
ამიტომ მისი საწყისი მნიშვნელობა იქნება null, რომელიც ნულოვანი ღირებულება პოინტერები.

421
00:32:06,350 --> 00:32:11,870
ნაგულისხმევი მნიშვნელობა x აპირებს ნიშნავს, რომ x.value არის ნულოვანი,

422
00:32:11,870 --> 00:32:14,260
x.left არის null, და x.right არის null.

423
00:32:14,260 --> 00:32:21,070
, რადგან ეს struct, ყველა სფეროებში struct იქნება ნულოვანი ღირებულებები.

424
00:32:21,070 --> 00:32:24,410
ჩვენ არ უნდა გამოვიყენოთ, რომ აქ, თუმცა.

425
00:32:24,410 --> 00:32:27,320
[სტუდენტური] structs განსხვავებულია, ვიდრე სხვა ცვლადები, და სხვა ცვლადები არის

426
00:32:27,320 --> 00:32:31,400
ნაგვის ფასეულობები; ეს zeros?

427
00:32:31,400 --> 00:32:36,220
[Bowden] სხვა ღირებულებები ძალიან. ასე რომ, x, x იქნება ნულოვანი.

428
00:32:36,220 --> 00:32:40,070
თუ ეს გლობალურ ფარგლებს, მას თავდაპირველი ღირებულება. >> Okay.

429
00:32:40,070 --> 00:32:48,950
[Bowden] ან პირველადი მნიშვნელობა მისცა ან ნულოვანი.

430
00:32:48,950 --> 00:32:53,260
მე ვფიქრობ, რომ ზრუნავს ყველა ამ.

431
00:32:53,260 --> 00:32:58,390
>> Okay. ასე რომ შემდეგი ნაწილი კითხვაზე სთხოვს,

432
00:32:58,390 --> 00:33:01,260
"ახლა ჩვენ გვინდა დავწეროთ ფუნქცია მოუწოდა შეიცავს

433
00:33:01,260 --> 00:33:04,930
ერთად პროტოტიპი bool შეიცავს int ღირებულება. "

434
00:33:04,930 --> 00:33:08,340
ჩვენ არ ვაპირებთ ამის გაკეთებას bool შეიცავს int ღირებულება.

435
00:33:08,340 --> 00:33:15,110
ჩვენი პროტოტიპი აპირებს გამოიყურებოდეს

436
00:33:15,110 --> 00:33:22,380
bool შეიცავს (int ღირებულება.

437
00:33:22,380 --> 00:33:24,490
და მაშინ ჩვენ ასევე ვაპირებთ უნდა გაიაროს ეს ხე

438
00:33:24,490 --> 00:33:28,870
რომ ეს უნდა იყოს შემოწმების დაინახოს, თუ მას, რომ ღირებულება.

439
00:33:28,870 --> 00:33:38,290
ასე რომ კვანძის * ხე). Okay.

440
00:33:38,290 --> 00:33:44,440
და მაშინ ჩვენ შეგვიძლია ეძახით რაღაც მოსწონს,

441
00:33:44,440 --> 00:33:46,090
იქნებ ჩვენ გვინდა printf ან რამე.

442
00:33:46,090 --> 00:33:51,040
შეიცავს 6, ჩვენი ძირეული.

443
00:33:51,040 --> 00:33:54,300
რომ უნდა დაუბრუნდეს ერთი, ან ნამდვილი,

444
00:33:54,300 --> 00:33:59,390
ხოლო შეიცავს 5 root უნდა დაუბრუნდეს ყალბი.

445
00:33:59,390 --> 00:34:02,690
ასე რომ მიიღოს მეორე განხორციელების.

446
00:34:02,690 --> 00:34:06,780
თქვენ შეგიძლიათ ეს გააკეთოთ ან iteratively ან რეკურსიული.

447
00:34:06,780 --> 00:34:09,739
ლამაზი რამ შესახებ გზა ჩვენ მითითებული რამ up არის, რომ

448
00:34:09,739 --> 00:34:12,300
ეს lends თავად ჩვენი რეკურსიული გადაწყვეტა ბევრად უფრო ადვილია

449
00:34:12,300 --> 00:34:14,719
ვიდრე გლობალური-ცვლადი ასე.

450
00:34:14,719 --> 00:34:19,750
რადგან თუ ჩვენ უბრალოდ უნდა შეიცავს int ღირებულება, მაშინ ჩვენ არ გვაქვს გზა recursing ქვემოთ subtrees.

451
00:34:19,750 --> 00:34:24,130
ჩვენ უნდა ჰქონდეს ცალკე დამხმარე ფუნქცია recurses ქვემოთ subtrees ჩვენთვის.

452
00:34:24,130 --> 00:34:29,610
მაგრამ რადგან ჩვენ შეიცვალა მას მიიღოს ხე როგორც არგუმენტი,

453
00:34:29,610 --> 00:34:32,760
რომელიც მას უნდა ყოველთვის პირველ რიგში,

454
00:34:32,760 --> 00:34:35,710
ახლა ჩვენ შეგვიძლია recurse უფრო მარტივად.

455
00:34:35,710 --> 00:34:38,960
ამიტომ iterative ან რეკურსიული, ჩვენ წავიდეთ ორივე,

456
00:34:38,960 --> 00:34:46,139
მაგრამ ჩვენ ვხედავთ, რომ რეკურსიული მთავრდება მყოფი საკმაოდ მარტივია.

457
00:34:59,140 --> 00:35:02,480
Okay. ვინმეს აქვს რაიმე შეგვიძლია ვიმუშაოთ?

458
00:35:02,480 --> 00:35:12,000
>> [სტუდენტური] მაქვს iterative გადაწყვეტა. >> ყველა უფლება, iterative.

459
00:35:12,000 --> 00:35:16,030
Okay, ეს გამოიყურება კარგი.

460
00:35:16,030 --> 00:35:18,920
ასე რომ, მინდა ფეხით ჩვენს მეშვეობით იგი?

461
00:35:18,920 --> 00:35:25,780
[სტუდენტური] რა თქმა უნდა. ასე რომ მითითებული Temp ცვლადის მისაღებად პირველი კვანძის ხე.

462
00:35:25,780 --> 00:35:28,330
და მერე უბრალოდ looped საშუალებით ხოლო temp არ თანაბარი null,

463
00:35:28,330 --> 00:35:31,700
ასე, ხოლო ჯერ კიდევ ხე, ვფიქრობ.

464
00:35:31,700 --> 00:35:35,710
და თუ ღირებულება შეადგენს ღირებულების რომ Temp არის მიუთითებს,

465
00:35:35,710 --> 00:35:37,640
მაშინ ის დააბრუნებს, რომ ღირებულება.

466
00:35:37,640 --> 00:35:40,210
წინააღმდეგ შემთხვევაში, ის ამოწმებს, თუ ის მარჯვენა მხარეს ან მარცხენა მხარეს.

467
00:35:40,210 --> 00:35:43,400
თუ თქვენ ოდესმე კიდევ სიტუაცია, სადაც არ არსებობს უფრო მეტი ხე,

468
00:35:43,400 --> 00:35:47,330
მაშინ ის დააბრუნებს - ის ითიშება მარყუჟის და დააბრუნებს false.

469
00:35:47,330 --> 00:35:52,190
[Bowden] Okay. ასე რომ, როგორც ჩანს კარგი.

470
00:35:52,190 --> 00:35:58,470
ვინმეს აქვს რაიმე კომენტარს არაფერი?

471
00:35:58,470 --> 00:36:02,400
მე არ მაქვს სისწორის კომენტარი ყველა.

472
00:36:02,400 --> 00:36:11,020
ერთი რამ შეგვიძლია გავაკეთოთ არის ამ ბიჭს.

473
00:36:11,020 --> 00:36:21,660
ოჰ, ეს აპირებს პატარა longish.

474
00:36:21,660 --> 00:36:33,460
მე დაფიქსირება, რომ up. Okay.

475
00:36:33,460 --> 00:36:37,150
>> ყველას უნდა ახსოვდეს, როგორ ternary მუშაობს.

476
00:36:37,150 --> 00:36:38,610
არსებობს ნამდვილად იყო ტესტებში წარსულში

477
00:36:38,610 --> 00:36:41,170
რომ გაძლევთ ფუნქციის ternary ოპერატორი,

478
00:36:41,170 --> 00:36:45,750
და ამბობენ, თარგმნა ამ, რაღაც რომ არ გამოიყენებს ternary.

479
00:36:45,750 --> 00:36:49,140
ასე რომ, ეს ძალიან ხშირი შემთხვევაში, როდესაც მე ვფიქრობ გამოიყენოს ternary,

480
00:36:49,140 --> 00:36:54,610
აქ თუ რაღაც მდგომარეობა მითითებული ცვლადი რაიმე,

481
00:36:54,610 --> 00:36:58,580
სხვაგან მითითებული, რომ იგივე ცვლადი რაღაც.

482
00:36:58,580 --> 00:37:03,390
სწორედ ის, რაც ძალიან ხშირად შეიძლება გადაკეთდა ასეთი რამ

483
00:37:03,390 --> 00:37:14,420
სადაც მითითებული, რომ ცვლადი ამ - ან, ასევე, არის ამ ჭეშმარიტი? მაშინ ეს, სხვას ეს.

484
00:37:14,420 --> 00:37:18,550
[სტუდენტური] პირველი ის არის თუ ასეა, არა?

485
00:37:18,550 --> 00:37:25,570
[Bowden] Yeah. გზა მე ყოველთვის წავიკითხავ არის, Temp შეადგენს ღირებულების მეტი temp ღირებულება,

486
00:37:25,570 --> 00:37:30,680
მაშინ ეს, სხვას ეს. ის სვამს კითხვას.

487
00:37:30,680 --> 00:37:35,200
არის თუ არა უფრო დიდი? მაშინ ნუ პირველი რაც. Else გავაკეთოთ მეორე რამ.

488
00:37:35,200 --> 00:37:41,670
მე თითქმის ყოველთვის - მსხვილი ნაწლავის, უბრალოდ - ჩემი უფროსი, წავიკითხე როგორც სხვაგან.

489
00:37:41,670 --> 00:37:47,180
>> ვინმეს აქვს რეკურსიული გამოსავალი?

490
00:37:47,180 --> 00:37:49,670
Okay. ეს ერთი ჩვენ ვაპირებთ - ეს შეიძლება იყოს უკვე დიდი,

491
00:37:49,670 --> 00:37:53,990
მაგრამ ჩვენ ვაპირებთ, რათა ის უფრო უკეთესი.

492
00:37:53,990 --> 00:37:58,720
ეს არის საკმაოდ ბევრი იგივე ზუსტი იდეა.

493
00:37:58,720 --> 00:38:03,060
უბრალოდ, კარგად, გნებავთ ასახსნელად?

494
00:38:03,060 --> 00:38:08,340
[სტუდენტური] რა თქმა უნდა. ამიტომ ჩვენ მიღების დარწმუნებული ვარ, რომ ხე არ არის NULL პირველი,

495
00:38:08,340 --> 00:38:13,380
რადგან თუ ხე null მაშინ ის დაბრუნებას აპირებს ცრუ იმიტომ, რომ ჩვენ არ ი.

496
00:38:13,380 --> 00:38:19,200
და თუ მაინც ხე, ჩვენ წასვლას - ჩვენ პირველი შეამოწმოს თუ ღირებულება მიმდინარე კვანძში.

497
00:38:19,200 --> 00:38:23,740
TRUE თუ ეს და, თუ არ ჩვენ recurse მარცხენა ან მარჯვენა.

498
00:38:23,740 --> 00:38:25,970
Does რომ ხმის შესაბამისი? >> MM-hmm. (შეთანხმება)

499
00:38:25,970 --> 00:38:33,880
ასე რომ ეს არის თითქმის - სტრუქტურულად ძალიან ჰგავს iterative გადაწყვეტა.

500
00:38:33,880 --> 00:38:38,200
უბრალოდ, ნაცვლად recursing, გვქონდა ხოლო loop.

501
00:38:38,200 --> 00:38:40,840
და ბაზის შემთხვევაში აქ, სადაც ხე არ თანაბარი null

502
00:38:40,840 --> 00:38:44,850
იყო მდგომარეობა, რომლის თანახმადაც ჩვენ იფეთქა of ხოლო loop.

503
00:38:44,850 --> 00:38:50,200
ისინი ძალიან გავს. მაგრამ ჩვენ ვაპირებთ ამ ერთი ნაბიჯით შემდგომი.

504
00:38:50,200 --> 00:38:54,190
ახლა, ჩვენ იგივე აქ.

505
00:38:54,190 --> 00:38:57,680
გაითვალისწინეთ ჩვენ დაბრუნების იგივე ორივე ამ ხაზები,

506
00:38:57,680 --> 00:39:00,220
გარდა ერთი არგუმენტი არის სხვადასხვა.

507
00:39:00,220 --> 00:39:07,950
ამიტომ, ჩვენ ვაპირებთ, რათა რომ შევიდა ternary.

508
00:39:07,950 --> 00:39:13,790
მე მოხვდა ვარიანტი რაღაც, და ეს გააკეთა სიმბოლო. Okay.

509
00:39:13,790 --> 00:39:21,720
ამიტომ, ჩვენ ვაპირებთ დაბრუნებას შეიცავს, რომ.

510
00:39:21,720 --> 00:39:28,030
ეს დღითიდღე იყოს მრავალჯერადი ხაზები, ასევე, zoomed მასში არის.

511
00:39:28,030 --> 00:39:31,060
ჩვეულებრივ, როგორც სტილისტური რამ, არა მგონია, ბევრი ადამიანი

512
00:39:31,060 --> 00:39:38,640
დააყენა სივრცეში შემდეგ arrow, მაგრამ ვფიქრობ, თუ თქვენ თანმიმდევრული, ეს ჯარიმა.

513
00:39:38,640 --> 00:39:44,320
თუ მნიშვნელობა ნაკლებია ხის ღირებულება, ჩვენ გვინდა recurse on ხე მარცხენა

514
00:39:44,320 --> 00:39:53,890
სხვაგან გვინდა recurse on ხე უფლება.

515
00:39:53,890 --> 00:39:58,610
ასე რომ იყო ნაბიჯი ერთი მიღების ამ სახეს პატარა.

516
00:39:58,610 --> 00:40:02,660
ნაბიჯი ორ მიღების ამ სახეს პატარა -

517
00:40:02,660 --> 00:40:09,150
ჩვენ შეგვიძლია გამოვყოთ ეს რამდენიმე სტრიქონი.

518
00:40:09,150 --> 00:40:16,500
Okay. ნაბიჯი ორი რაც მას გამოიყურებოდეს პატარა აქ არის,

519
00:40:16,500 --> 00:40:25,860
ასე დაბრუნებული მნიშვნელობა ტოლია ხე ღირებულებით, ან შეიცავს რასაც.

520
00:40:25,860 --> 00:40:28,340
>> ეს არის მთავარი.

521
00:40:28,340 --> 00:40:30,860
მე არ ვარ დარწმუნებული, თუ მისი თქმით, მკაფიოდ კლასში,

522
00:40:30,860 --> 00:40:34,740
მაგრამ ეს ე.წ. მოკლე ჩართვა შეფასება.

523
00:40:34,740 --> 00:40:41,060
იდეა აქ არის ღირებულება == ხე ღირებულებით.

524
00:40:41,060 --> 00:40:49,960
თუ ეს მართალია, მაშინ ეს მართლაც ასეა, და ჩვენ გვინდა "ან" რომ რაც მეტი აქ.

525
00:40:49,960 --> 00:40:52,520
ასე გარეშე კი ფიქრი რაც მეტი აქ,

526
00:40:52,520 --> 00:40:55,070
რა არის მთელი გამოხატულება დაბრუნებას აპირებს?

527
00:40:55,070 --> 00:40:59,430
[სტუდენტური] True? >> Yeah, რადგან სიმართლეა არაფერი,

528
00:40:59,430 --> 00:41:04,990
or'd - ან ნამდვილი or'd ერთად არაფერი აუცილებლად ჭეშმარიტი.

529
00:41:04,990 --> 00:41:08,150
ასე რომ როგორც კი ჩვენ ვხედავთ დაბრუნებული მნიშვნელობა = ხე ღირებულებით,

530
00:41:08,150 --> 00:41:10,140
ჩვენ უბრალოდ დაბრუნებას აპირებს ჭეშმარიტი.

531
00:41:10,140 --> 00:41:15,710
კი არ აპირებს recurse შემდგომი შეიცავს ქვემოთ ხაზი.

532
00:41:15,710 --> 00:41:20,980
ჩვენ შეუძლია მიიღოს ამ ერთი ნაბიჯით შემდგომი.

533
00:41:20,980 --> 00:41:29,490
დაბრუნება ხე არ თანაბარი null და ყველა ამ.

534
00:41:29,490 --> 00:41:32,650
იგი გახადა ერთი ხაზი ფუნქციონირებს.

535
00:41:32,650 --> 00:41:36,790
ეს არის ასევე მაგალითი მოკლე ჩართვა შეფასება.

536
00:41:36,790 --> 00:41:40,680
მაგრამ ახლა ეს იგივე იდეა -

537
00:41:40,680 --> 00:41:47,320
ნაცვლად - ასე რომ, თუ ხე არ თანაბარი null - ან, ისევე,

538
00:41:47,320 --> 00:41:49,580
თუ ხე არ თანაბარი null, რომელიც ცუდი საქმე,

539
00:41:49,580 --> 00:41:54,790
თუ ხე შეადგენს null, მაშინ პირველი მდგომარეობა იქნება ყალბი.

540
00:41:54,790 --> 00:42:00,550
ასე რომ ცრუ anded ერთად არაფერი იქნება რა?

541
00:42:00,550 --> 00:42:04,640
[სტუდენტური] ყალბი. >> Yeah. ეს არის მეორე ნახევარში მოკლე ჩართვა შეფასება,

542
00:42:04,640 --> 00:42:10,710
აქ თუ ხე არ თანაბარი null, მაშინ ჩვენ არ ვაპირებთ თუნდაც წასვლა -

543
00:42:10,710 --> 00:42:14,930
ან თუ ხე არ თანაბარი null, მაშინ ჩვენ არ ვაპირებთ ღირებულება == ხე ღირებულებით.

544
00:42:14,930 --> 00:42:17,010
ჩვენ უბრალოდ აპირებს დაუყოვნებლივ დაბრუნებას ყალბი.

545
00:42:17,010 --> 00:42:20,970
რაც მნიშვნელოვანია, რადგან თუკი მას არ მოკლე ჩართვა შეაფასოს,

546
00:42:20,970 --> 00:42:25,860
მაშინ თუ ხე არ თანაბარი null, ამ მეორე მდგომარეობა აპირებს seg ბრალია,

547
00:42:25,860 --> 00:42:32,510
რადგან ხე-> ღირებულება dereferencing null.

548
00:42:32,510 --> 00:42:40,490
ასე რომ, რომ. შეუძლია ამ - გადაეტანა ერთხელ დასრულდა.

549
00:42:40,490 --> 00:42:44,840
ეს არის ძალიან გავრცელებული რამ ასევე, არ ვდებთ ამ ერთ ხაზს ამისა,

550
00:42:44,840 --> 00:42:49,000
მაგრამ საერთო რამ პირობებში, შესაძლოა, სწორი არ აქ,

551
00:42:49,000 --> 00:42:59,380
მაგრამ თუ (ხე = NULL, და ხე-> ღირებულების == ღირებულების), გააკეთოს რასაც.

552
00:42:59,380 --> 00:43:01,560
ეს არის ძალიან საერთო მდგომარეობა, სადაც ნაცვლად, რომელმაც

553
00:43:01,560 --> 00:43:06,770
მოხსნა ამ ორ IFS, სადაც მინდა, არის ხე null?

554
00:43:06,770 --> 00:43:11,780
Okay, ეს არ null, ამიტომ ახლა არის ხე ღირებულების ტოლია მნიშვნელობა? ამის გაკეთება.

555
00:43:11,780 --> 00:43:17,300
ამის ნაცვლად, ამ მდგომარეობაში, ეს არასდროს არ seg ბრალია

556
00:43:17,300 --> 00:43:21,220
იმიტომ, რომ ეს იქნება შესვენება, თუ ეს მოხდება, რომ იყოს null.

557
00:43:21,220 --> 00:43:24,000
ისე, ვფიქრობ, თუ თქვენი ხე არის სრულიად არასწორი მაჩვენებელი, მას შეუძლია კვლავ seg ბრალია,

558
00:43:24,000 --> 00:43:26,620
მაგრამ მას არ შეუძლია seg ბრალია თუ ხე null.

559
00:43:26,620 --> 00:43:32,900
თუ ეს იყო null, ეს იქნებოდა შესვენება წინაშე ოდესმე dereferenced მაჩვენებელი პირველ რიგში.

560
00:43:32,900 --> 00:43:35,000
[სტუდენტური] არის ამ ე.წ. ზარმაცი შეფასება?

561
00:43:35,000 --> 00:43:40,770
>> [Bowden] Lazy შეფასება ცალკე ამბავია.

562
00:43:40,770 --> 00:43:49,880
Lazy შეფასება უფრო მოსწონს თქვენ ეკითხებით ღირებულება,

563
00:43:49,880 --> 00:43:54,270
თქვენ ჰკითხავთ გამოვთვალოთ ღირებულება, სახის, მაგრამ თქვენ არ სჭირდება დაუყოვნებლივ.

564
00:43:54,270 --> 00:43:59,040
ასე რომ, სანამ თქვენ ნამდვილად სჭირდება, არ არის შეფასებული.

565
00:43:59,040 --> 00:44:03,920
ეს არ არის ზუსტად იგივე, მაგრამ Huffman pset,

566
00:44:03,920 --> 00:44:06,520
იგი ამბობს, რომ ჩვენ "lazily" წერენ.

567
00:44:06,520 --> 00:44:08,670
მიზეზი გავაკეთოთ, რომ ეს იმიტომ რომ ჩვენ რეალურად buffering ჩაწერის -

568
00:44:08,670 --> 00:44:11,820
ჩვენ არ გვინდა, რომ წერენ ინდივიდუალური ბიტი დროს,

569
00:44:11,820 --> 00:44:15,450
ან ინდივიდუალური bytes დროს, ჩვენ ნაცვლად გვინდა ბლოკი bytes.

570
00:44:15,450 --> 00:44:19,270
მაშინ კიდევ გვაქვს ბლოკი ბაიტი, მაშინ ჩვენ დავწეროთ ის.

571
00:44:19,270 --> 00:44:22,640
მიუხედავად იმისა, რომ თქვენ ჰკითხავთ ეს დაწერა - და fwrite და fread იგივე სახის რამ.

572
00:44:22,640 --> 00:44:26,260
ისინი ბუფერში შესანახი თქვენი ნათქვამია და წერს.

573
00:44:26,260 --> 00:44:31,610
მიუხედავად იმისა, რომ თქვენ ჰკითხავთ ეს დაწერა დაუყოვნებლივ, მას ალბათ არ.

574
00:44:31,610 --> 00:44:34,540
და ვერ იქნება დარწმუნებული, რომ ყველაფერი იქნება დაწერილი

575
00:44:34,540 --> 00:44:37,540
სანამ რეკავთ hfclose ან რასაც იგი,

576
00:44:37,540 --> 00:44:39,620
რომელიც შემდეგ ამბობს, okay, მე დახურვის ჩემი ფაილი,

577
00:44:39,620 --> 00:44:43,450
ეს ნიშნავს, რომ მინდა უკეთესი დაწეროს ყველაფერი მე არ წერია ამჟამად.

578
00:44:43,450 --> 00:44:45,770
მას არ აქვს უნდა დაწეროთ ყველაფერს

579
00:44:45,770 --> 00:44:49,010
სანამ არ ვკეტავთ ფაილი, და მაშინ უნდა.

580
00:44:49,010 --> 00:44:56,220
ასე რომ უბრალოდ რა ზარმაცი - ის ელოდება სანამ ის მოხდება.

581
00:44:56,220 --> 00:44:59,990
ეს - მიიღოს 51 და თქვენ წასვლას იგი უფრო დეტალურად,

582
00:44:59,990 --> 00:45:05,470
რადგან OCaml და ყველაფერი 51, ყველაფერი უკან.

583
00:45:05,470 --> 00:45:08,890
არ არსებობს iterative გადაწყვეტილებები, ძირითადად.

584
00:45:08,890 --> 00:45:11,550
ყველაფერი უკან და ზარმაცი შეფასება

585
00:45:11,550 --> 00:45:14,790
იქნება მნიშვნელოვანი ბევრი გარემოებები

586
00:45:14,790 --> 00:45:19,920
სადაც, თუ არ lazily შეაფასოს, რომ ნიშნავს -

587
00:45:19,920 --> 00:45:24,760
მაგალითად არის ნაკადულები, რომლებიც უსასრულოდ გრძელი.

588
00:45:24,760 --> 00:45:30,990
თეორიულად, შეგიძლიათ წარმოიდგინოთ, რომ ბუნებრივი ნომრები ნაკადი 1-2-3-4-5-6-7,

589
00:45:30,990 --> 00:45:33,090
ამიტომ lazily შეაფასეს რამ ჯარიმა.

590
00:45:33,090 --> 00:45:37,210
თუ მე ვიტყვი, მინდა მეათე ნომერი, მერე შეუძლია შეაფასოს მდე მეათე ნომერი.

591
00:45:37,210 --> 00:45:40,300
თუკი მინდა მეასედ ნომერი, მერე შეუძლია შეაფასოს მდე მეასედ ნომერი.

592
00:45:40,300 --> 00:45:46,290
გარეშე ზარმაცი შეფასება, მაშინ იგი აპირებს ცდილობენ შეაფასონ ყველა ნომრები დაუყოვნებლივ.

593
00:45:46,290 --> 00:45:50,000
თქვენ შეფასებისას უსასრულოდ ბევრი ნომრები, და ეს მხოლოდ შეუძლებელია.

594
00:45:50,000 --> 00:45:52,080
ასე რომ ბევრი გარემოებები, სადაც ზარმაცი შეფასება

595
00:45:52,080 --> 00:45:57,840
მხოლოდ არსებითი მიღების რამ მუშაობა.

596
00:45:57,840 --> 00:46:05,260
>> ახლა ჩვენ გვინდა დავწეროთ ჩანართით, სადაც ჩანართით იქნება

597
00:46:05,260 --> 00:46:08,430
ანალოგიურად შეცვლის თავის განმარტება.

598
00:46:08,430 --> 00:46:10,470
ასე რომ ახლა ეს bool ჩანართით (int value).

599
00:46:10,470 --> 00:46:23,850
ჩვენ ვაპირებთ, რომ შეიცვალოს, რომ bool ჩანართით (int ღირებულება, node * ხე).

600
00:46:23,850 --> 00:46:29,120
ჩვენ რეალურად შეიცვლება, რომ კვლავ bit, ვნახავთ, თუ რატომ.

601
00:46:29,120 --> 00:46:32,210
და მოდით გადაადგილება build_node, მხოლოდ heck ეს,

602
00:46:32,210 --> 00:46:36,730
ზემოთ ჩადეთ ასე არ გვაქვს დაწერა ფუნქციის პროტოტიპი.

603
00:46:36,730 --> 00:46:42,450
რაც მინიშნება, რომ თქვენ უნდა გამოყენებით build_node წელს ჩანართით.

604
00:46:42,450 --> 00:46:49,590
Okay. Take წუთი რომ.

605
00:46:49,590 --> 00:46:52,130
ვფიქრობ გადაარჩინა გადასინჯვის თუ გსურთ გაიყვანოს ამისა,

606
00:46:52,130 --> 00:47:00,240
ან, ყოველ შემთხვევაში, მე ახლა.

607
00:47:00,240 --> 00:47:04,190
მინდოდა მცირე შესვენების ფიქრი ლოგიკა ჩანართით,

608
00:47:04,190 --> 00:47:08,750
თუ თქვენ ვერ ვფიქრობ იგი.

609
00:47:08,750 --> 00:47:12,860
ძირითადად, თქვენ მხოლოდ ოდესმე იქნება ჩასმა საათზე ფოთლები.

610
00:47:12,860 --> 00:47:18,640
მსგავსად, თუ ჩადეთ 1, მაშინ მე აუცილებლად იქნება ჩასმა 1 -

611
00:47:18,640 --> 00:47:21,820
მე შეცვლის შავი - I'll იყოს ჩასმა 1 ზე აქ.

612
00:47:21,820 --> 00:47:28,070
ან თუ ჩადეთ 4, მინდა იყოს ჩასმა 4 ზე აქ.

613
00:47:28,070 --> 00:47:32,180
ასე რომ არ აქვს მნიშვნელობა, თუ რას აკეთებთ, თქვენ უნდა ჩასმა საათზე ფოთოლი.

614
00:47:32,180 --> 00:47:36,130
ყველა თქვენ უნდა გააკეთოთ iterate ქვემოთ ხე სანამ თქვენ მიიღებთ კვანძში

615
00:47:36,130 --> 00:47:40,890
რომ უნდა იყოს კვანძის მშობელი, ახალი კვანძის მშობელი,

616
00:47:40,890 --> 00:47:44,560
და შემდეგ შეცვალოს მისი მარცხენა ან მარჯვენა კურსორი, რაც დამოკიდებულია თუ არა

617
00:47:44,560 --> 00:47:47,060
ეს მეტია ან ნაკლებია, ვიდრე მიმდინარე კვანძში.

618
00:47:47,060 --> 00:47:51,180
ცვლილება, რომელიც მაჩვენებელმა აღვნიშნო თქვენს ახალ კვანძში.

619
00:47:51,180 --> 00:48:05,490
ამიტომ iterate ქვემოთ ხე, გახადოს ფოთოლი წერტილი ახალი კვანძში.

620
00:48:05,490 --> 00:48:09,810
ასევე ვფიქრობ, რატომ, რომ კრძალავს ტიპის სიტუაციის წინაშე,

621
00:48:09,810 --> 00:48:17,990
სადაც მე აშენებული ორობითი ხე, სადაც ეს იყო სწორი

622
00:48:17,990 --> 00:48:19,920
თუ თქვენ მხოლოდ შევხედე ერთ კვანძში,

623
00:48:19,920 --> 00:48:24,830
მაგრამ 9 იყო მარცხნივ 7 თუ iterated ქვემოთ ყველა გზა.

624
00:48:24,830 --> 00:48:29,770
ასე რომ შეუძლებელია ამ სცენარით, რადგან -

625
00:48:29,770 --> 00:48:32,530
ვიფიქროთ ჩასმა 9 ან რამე; პირველივე კვანძში,

626
00:48:32,530 --> 00:48:35,350
მე ვაპირებ ვხედავ 7 და მე უბრალოდ აპირებს მისვლას უფლება.

627
00:48:35,350 --> 00:48:38,490
ასე რომ არ აქვს მნიშვნელობა რა გავაკეთო, თუ მე ჩასმა მიერ აპირებს ფოთოლი,

628
00:48:38,490 --> 00:48:40,790
და ფოთოლი გამოყენებით შესაბამისი ალგორითმი,

629
00:48:40,790 --> 00:48:43,130
ეს იქნება შეუძლებელი ჩემთვის ჩასასმელად 9 მარცხნივ 7

630
00:48:43,130 --> 00:48:48,250
რადგან როგორც კი მოხვდა 7 მე ვაპირებ წასვლა უფლება.

631
00:48:59,740 --> 00:49:02,070
ვინმეს აქვს რაიმე იწყება?

632
00:49:02,070 --> 00:49:05,480
[სტუდენტური] გავაკეთო. >> დარწმუნებული.

633
00:49:05,480 --> 00:49:09,200
[სტუდენტი გაუგებარია]

634
00:49:09,200 --> 00:49:14,390
[სხვა სტუდენტი, გაუგებარია]

635
00:49:14,390 --> 00:49:18,330
[Bowden] ეს დასაფასებელია. Okay. მინდა განვმარტო?

636
00:49:18,330 --> 00:49:20,690
>> [სტუდენტური] ვინაიდან ჩვენ ვიცით, რომ ჩვენ ჩასმა

637
00:49:20,690 --> 00:49:24,060
ახალი კვანძების დასასრულს ხე,

638
00:49:24,060 --> 00:49:28,070
მე looped საშუალებით ხე iteratively

639
00:49:28,070 --> 00:49:31,360
სანამ მე მივიღე რომ კვანძის რომ მიუთითა null.

640
00:49:31,360 --> 00:49:34,220
და მერე გადავწყვიტეთ, რომ ეს არც მარჯვენა მხარეს ან მარცხენა მხარეს

641
00:49:34,220 --> 00:49:37,420
გამოყენებით ამ უფლების ცვლადი, ის მითხრა, სად უნდა თქვა.

642
00:49:37,420 --> 00:49:41,850
და მაშინ, არსებითად, მე უბრალოდ, რომ ბოლო -

643
00:49:41,850 --> 00:49:47,520
რომ Temp კვანძის წერტილი ახალი კვანძის რომ იგი შექმნა,

644
00:49:47,520 --> 00:49:50,770
ან მარცხენა მხარეს ან მარჯვენა მხარეს, დამოკიდებულია რა ღირებულების უფლება იყო.

645
00:49:50,770 --> 00:49:56,530
და ბოლოს, მე მითითებული ახალი კვანძის მნიშვნელობა ღირებულება მისი ტესტირება.

646
00:49:56,530 --> 00:49:59,550
[Bowden] Okay, ასე ვხედავ ერთი საკითხი აქ.

647
00:49:59,550 --> 00:50:02,050
ეს არის მსგავსად 95% გზა არსებობს.

648
00:50:02,050 --> 00:50:07,550
ერთი საკითხი, რომელიც მე ვერ ვხედავ, ისევე, ამჯამად ვინმეს ვხედავთ საკითხი?

649
00:50:07,550 --> 00:50:18,400
რა არის გარემოება, რომლის თანახმადაც ისინი დაარღვიოს გარეთ loop?

650
00:50:18,400 --> 00:50:22,100
[სტუდენტური] თუ Temp არის null? >> Yeah. ასე რომ, თუ როგორ შესვენება გარეთ loop არის თუ Temp არის null.

651
00:50:22,100 --> 00:50:30,220
მაგრამ რა გავაკეთოთ უფლება აქ?

652
00:50:30,220 --> 00:50:35,410
მე dereference temp, რომელიც აუცილებლად null.

653
00:50:35,410 --> 00:50:39,840
ასე რომ სხვა რამ რაც თქვენ გჭირდებათ რომ გააკეთოთ, არის არა მხოლოდ ტრეკზე სანამ Temp არის null,

654
00:50:39,840 --> 00:50:45,590
გსურთ ტრეკზე მშობელს ნებისმიერ დროს.

655
00:50:45,590 --> 00:50:52,190
ჩვენ ასევე გვინდა კვანძის * მშობელს, ვფიქრობ ჩვენ შეგვიძლია შევინარჩუნოთ, რომ null თავდაპირველად.

656
00:50:52,190 --> 00:50:55,480
ეს აპირებს აქვს უცნაური ქცევის ფესვი ხეს,

657
00:50:55,480 --> 00:50:59,210
მაგრამ ამას კიდევ რომ.

658
00:50:59,210 --> 00:51:03,950
თუ მნიშვნელობა მეტია რასაც, მაშინ temp = temp უფლება.

659
00:51:03,950 --> 00:51:07,910
მაგრამ სანამ ჩვენ გავაკეთებთ, რომ, მშობელი = temp.

660
00:51:07,910 --> 00:51:14,500
ან მშობლები ყოველთვის აპირებს თანაბარი temp? ის არის, რომ საქმე?

661
00:51:14,500 --> 00:51:19,560
თუ temp არ null, მაშინ მე ვაპირებ ქვევით, არ აქვს მნიშვნელობა, რა,

662
00:51:19,560 --> 00:51:24,030
დან კვანძის რისთვისაც Temp არის მშობელი.

663
00:51:24,030 --> 00:51:27,500
ამიტომ მშობელი იქნება temp, და მერე გადავიდეს temp ქვემოთ.

664
00:51:27,500 --> 00:51:32,410
ახლა არის temp null, მაგრამ მშობელს მიუთითებს მშობელი რაც null.

665
00:51:32,410 --> 00:51:39,110
ასე ქვევით აქ, მე არ მინდა შექმნას უფლება უდრის 1.

666
00:51:39,110 --> 00:51:41,300
ასე რომ გადავიდა უფლება, ასე რომ, თუ უფლება = 1,

667
00:51:41,300 --> 00:51:45,130
და ვფიქრობ, თქვენც გსურთ -

668
00:51:45,130 --> 00:51:48,530
თუ თქვენ გადატანა მარცხნივ, გსურთ უფლება ტოლია 0.

669
00:51:48,530 --> 00:51:55,950
ანდა თუ ოდესმე გადასვლის უფლება.

670
00:51:55,950 --> 00:51:58,590
ასე რომ უფლება = 0. თუ უფლება = 1,

671
00:51:58,590 --> 00:52:04,260
ახლა ჩვენ გვსურს მშობელს უფლება მომცეთ newnode,

672
00:52:04,260 --> 00:52:08,520
სხვაგან ჩვენ გვსურს მშობელი მარცხენა კურსორი newnode.

673
00:52:08,520 --> 00:52:16,850
კითხვები რომ?

674
00:52:16,850 --> 00:52:24,880
Okay. ასე რომ, ეს გზა ჩვენ - კარგად, ფაქტობრივად, ნაცვლად აკეთებს ეს

675
00:52:24,880 --> 00:52:29,630
ჩვენ ნახევარი მოსალოდნელია გამოიყენოთ build_node.

676
00:52:29,630 --> 00:52:40,450
და მაშინ თუ newnode შეადგენს null, დაბრუნდნენ ყალბი.

677
00:52:40,450 --> 00:52:44,170
სწორედ რომ. ახლა, ეს არის ის, რაც ჩვენ მოსალოდნელია თქვენ უნდა გააკეთოს.

678
00:52:44,170 --> 00:52:47,690
>> ეს არის ის, რაც პერსონალის გადაწყვეტილებები გავაკეთოთ.

679
00:52:47,690 --> 00:52:52,360
მე არ ეთანხმებიან ამ როგორც "სწორი" გზა მიდის ამაზე

680
00:52:52,360 --> 00:52:57,820
მაგრამ ეს შესანიშნავად ჯარიმა და ის იმუშავებს.

681
00:52:57,820 --> 00:53:02,840
ერთი რამ, რომ ცოტა უცნაური ახლავე არის

682
00:53:02,840 --> 00:53:08,310
თუ ხე იწყებს off როგორც null, ჩვენ კორიდორი null ხე.

683
00:53:08,310 --> 00:53:12,650
ვფიქრობ ეს დამოკიდებულია, თუ როგორ განსაზღვრავს ქცევის გადადის null ხე.

684
00:53:12,650 --> 00:53:15,490
მინდა ვფიქრობ, რომ თუ თქვენ კორიდორი null ხე,

685
00:53:15,490 --> 00:53:17,520
მაშინ ჩასმა ღირებულება შევიდა null ხე

686
00:53:17,520 --> 00:53:23,030
უნდა უბრალოდ დააბრუნოს ხე სადაც მხოლოდ ღირებულება ის არის, რომ ერთჯერადი კვანძში.

687
00:53:23,030 --> 00:53:25,830
ნუ ხალხს ვეთანხმები, რომ? თქვენ შეიძლება, თუ სურდა,

688
00:53:25,830 --> 00:53:28,050
თუ კორიდორი null ხე

689
00:53:28,050 --> 00:53:31,320
და გსურთ ჩადეთ ღირებულება მივანიჭო, დაბრუნდნენ ყალბი.

690
00:53:31,320 --> 00:53:33,830
ეს თქვენი გადასაწყვეტია, რათა განისაზღვროს, რომ.

691
00:53:33,830 --> 00:53:38,320
იმისათვის რომ პირველი, რაც მე ვთქვი და მერე -

692
00:53:38,320 --> 00:53:40,720
ასევე, თქვენ აპირებს უჭირთ აკეთებს, რადგან

693
00:53:40,720 --> 00:53:44,090
ეს იქნება ადვილი, თუ გვქონდა გლობალური მომცეთ რამ,

694
00:53:44,090 --> 00:53:48,570
მაგრამ ასე არ მოხდა, ასე რომ, თუ ხის არის null, არაფერი შეგვიძლია გავაკეთოთ ამის შესახებ.

695
00:53:48,570 --> 00:53:50,960
ჩვენ შეგვიძლია მხოლოდ დაბრუნების ცრუ.

696
00:53:50,960 --> 00:53:52,840
ამიტომ, მე ვაპირებ, რომ შეიცვალოს ჩანართით.

697
00:53:52,840 --> 00:53:56,540
ჩვენ ტექნიკურად შეეძლო უბრალოდ შეცვალეთ ეს უფლება აქ,

698
00:53:56,540 --> 00:53:58,400
როგორ ის iterating მეტი რამ,

699
00:53:58,400 --> 00:54:04,530
მაგრამ მე ვაპირებ, რომ შეიცვალოს ჩასმა მიიღოს კვანძის ** ხე.

700
00:54:04,530 --> 00:54:07,510
ორმაგი პოინტერები.

701
00:54:07,510 --> 00:54:09,710
რას ნიშნავს ეს?

702
00:54:09,710 --> 00:54:12,330
იმის ნაცვლად, რომ საქმე მითითებას კვანძების,

703
00:54:12,330 --> 00:54:16,690
რამ მე ვაპირებ იყოს მანიპულირებენ ეს მაჩვენებელი.

704
00:54:16,690 --> 00:54:18,790
მე ვაპირებ იყოს მანიპულირებენ ამ მაჩვენებელმა.

705
00:54:18,790 --> 00:54:21,770
მე ვაპირებ იყოს მანიპულირების პოინტერები პირდაპირ.

706
00:54:21,770 --> 00:54:25,760
ეს აზრი, რადგან, ვიფიქროთ Down -

707
00:54:25,760 --> 00:54:33,340
ასევე, ახლავე ამ მიუთითებს null.

708
00:54:33,340 --> 00:54:38,130
რა მინდა გააკეთოთ მანიპულირება ამ მაჩვენებელმა აღვნიშნო, რომ არ null.

709
00:54:38,130 --> 00:54:40,970
მინდა ეს აღვნიშნო, რომ ჩემი ახალი კვანძში.

710
00:54:40,970 --> 00:54:44,870
თუ მე მხოლოდ ტრეკზე მითითებას ჩემი პოინტერები,

711
00:54:44,870 --> 00:54:47,840
მაშინ მე არ უნდა ტრეკზე მშობელი მაჩვენებელი.

712
00:54:47,840 --> 00:54:52,640
მე შემიძლია მხოლოდ ტრეკზე თუ კურსორი არის მიუთითებს null,

713
00:54:52,640 --> 00:54:54,580
და თუ მაჩვენებელი არის მიუთითებს null,

714
00:54:54,580 --> 00:54:57,370
შეცვლის აღვნიშნო, რომ კვანძის მინდა.

715
00:54:57,370 --> 00:55:00,070
და შემიძლია შეცვლის რადგან მე მომცეთ მაჩვენებელი.

716
00:55:00,070 --> 00:55:02,040
ვნახოთ ამ წუთას.

717
00:55:02,040 --> 00:55:05,470
თქვენ შეგიძლიათ რეალურად გავაკეთებთ რეკურსიული საკმაოდ მარტივად.

718
00:55:05,470 --> 00:55:08,080
გვინდა ამის გაკეთება?

719
00:55:08,080 --> 00:55:10,980
დიახ, ჩვენ ვაკეთებთ.

720
00:55:10,980 --> 00:55:16,790
>> ვნახოთ ეს რეკურსიული.

721
00:55:16,790 --> 00:55:24,070
პირველი, რა არის ჩვენი ბაზის შემთხვევაში იქნება?

722
00:55:24,070 --> 00:55:29,140
თითქმის ყოველთვის ჩვენი ბაზის შემთხვევაში, მაგრამ რეალურად, ეს არის სახის სახიფათო.

723
00:55:29,140 --> 00:55:34,370
რაც პირველხარისხოვანია, თუ (ხე == NULL)

724
00:55:34,370 --> 00:55:37,550
ვფიქრობ ჩვენ უბრალოდ დაბრუნებას აპირებს ყალბი.

725
00:55:37,550 --> 00:55:40,460
ეს განსხვავდება თქვენი ხე მყოფი null.

726
00:55:40,460 --> 00:55:44,510
ეს არის მომცეთ თქვენი root მაჩვენებელი მყოფი null

727
00:55:44,510 --> 00:55:48,360
რაც იმას ნიშნავს, რომ თქვენი root მაჩვენებელი არ არსებობს.

728
00:55:48,360 --> 00:55:52,390
ასე ქვევით აქ, თუ

729
00:55:52,390 --> 00:55:55,760
კვანძის * - მოდით უბრალოდ reuse ამ.

730
00:55:55,760 --> 00:55:58,960
Node * root = NULL,

731
00:55:58,960 --> 00:56:00,730
და მაშინ მე ვაპირებ მოვუწოდო ჩასმა ამით რაღაც,

732
00:56:00,730 --> 00:56:04,540
ჩადეთ 4 შევიდა და root.

733
00:56:04,540 --> 00:56:06,560
ამიტომ & root, თუ root არის კვანძის *

734
00:56:06,560 --> 00:56:11,170
მაშინ & root იქნება კვანძის **.

735
00:56:11,170 --> 00:56:15,120
ეს არის სწორი. ამ შემთხვევაში, ხე, აქ,

736
00:56:15,120 --> 00:56:20,120
ხე არ არის null - ან ჩანართით.

737
00:56:20,120 --> 00:56:24,630
აქ. ხე არ არის null; * ხე null, რომელიც სახვითი

738
00:56:24,630 --> 00:56:26,680
რადგან თუ * ხე null, მაშინ მე შემიძლია მის მართვას

739
00:56:26,680 --> 00:56:29,210
აქამდე აღვნიშნო, რომ რაც მე მინდა ის აღვნიშნო, რომ.

740
00:56:29,210 --> 00:56:34,750
მაგრამ თუ ხე null, რაც იმას ნიშნავს, მე უბრალოდ დაინგრა აქ და განაცხადა null.

741
00:56:34,750 --> 00:56:42,710
რომ არ აქვს აზრი. მე ვერაფერს, რომ.

742
00:56:42,710 --> 00:56:45,540
თუ ხე null, დაბრუნდნენ ყალბი.

743
00:56:45,540 --> 00:56:48,220
ამიტომ, მე ძირითადად უკვე განაცხადა რა ჩვენი რეალური ბაზის საქმე.

744
00:56:48,220 --> 00:56:50,580
და რა არის, რომ იქნება?

745
00:56:50,580 --> 00:56:55,030
[სტუდენტი გაუგებარია]

746
00:56:55,030 --> 00:57:00,000
[Bowden] დიახ. ასე რომ, თუ (* ხე == NULL).

747
00:57:00,000 --> 00:57:04,520
ეს ეხება საქმე აქ

748
00:57:04,520 --> 00:57:09,640
აქ თუ ჩემი წითელი მაჩვენებელი არის კურსორი მე ფოკუსირებული,

749
00:57:09,640 --> 00:57:12,960
ასე მოსწონს მე ფოკუსირებული ამ მაჩვენებელმა, ახლა მე ფოკუსირებული ამ მაჩვენებელმა.

750
00:57:12,960 --> 00:57:15,150
ახლა მე ფოკუსირებული ამ მაჩვენებელმა.

751
00:57:15,150 --> 00:57:18,160
ასე რომ, თუ ჩემი წითელი მაჩვენებელი, რომელიც ჩემი კვანძის **,

752
00:57:18,160 --> 00:57:22,880
ოდესმე - თუ *, ჩემი წითელი მაჩვენებელი, ოდესმე null,

753
00:57:22,880 --> 00:57:28,470
რაც იმას ნიშნავს, რომ ვარ შემთხვევაში მე აქცენტი მაჩვენებელი, ქულა -

754
00:57:28,470 --> 00:57:32,530
ეს მაჩვენებელი, ეკუთვნის ფოთოლი.

755
00:57:32,530 --> 00:57:41,090
მინდა შეცვალოთ ეს მაჩვენებელი აღვნიშნო, რომ ჩემი ახალი კვანძში.

756
00:57:41,090 --> 00:57:45,230
დავბრუნდებით მეტი აქ.

757
00:57:45,230 --> 00:57:56,490
ჩემი newnode იქნება მხოლოდ კვანძის * N = build_node (ღირებულება)

758
00:57:56,490 --> 00:58:07,300
მაშინ N, თუ n = NULL, დაბრუნდნენ ყალბი.

759
00:58:07,300 --> 00:58:12,600
Else გვინდა რომ შეიცვალოს რა მაჩვენებელი არის გაკეთებული მიუთითებს

760
00:58:12,600 --> 00:58:17,830
აქამდე აღვნიშნო, რომ ჩვენი ახლად აშენებული კვანძში.

761
00:58:17,830 --> 00:58:20,280
ჩვენ შეგვიძლია რეალურად გავაკეთოთ, რომ აქ.

762
00:58:20,280 --> 00:58:30,660
იმის ნაცვლად, რომ ვამბობ, N, ვამბობთ * ხე = თუ * ხე.

763
00:58:30,660 --> 00:58:35,450
ყველას გვესმის, რომ? რომ საქმე მითითებას პოინტერები,

764
00:58:35,450 --> 00:58:40,750
ჩვენ შეგვიძლია შევცვალოთ null მითითებას აღვნიშნო, რომ რამ გვინდა მათ აღვნიშნო, რომ.

765
00:58:40,750 --> 00:58:42,820
სწორედ ჩვენი ბაზის შემთხვევაში.

766
00:58:42,820 --> 00:58:45,740
>> ახლა ჩვენი რეციდივი, ან ჩვენი უკან,

767
00:58:45,740 --> 00:58:51,430
იქნება ძალიან გავს ყველა სხვა recursions ჩვენ ვაკეთებთ.

768
00:58:51,430 --> 00:58:55,830
ჩვენ ვაპირებთ, რომ გსურთ ჩადეთ ღირებულება,

769
00:58:55,830 --> 00:58:59,040
და ახლა მე ვაპირებ გამოიყენოთ ternary ისევ, მაგრამ რა არის ჩვენი მდგომარეობა იქნება?

770
00:58:59,040 --> 00:59:05,180
რა არის ეს ჩვენ ვეძებთ, რათა მიიღოს გადაწყვეტილება გვინდა წასვლა მარცხენა ან მარჯვენა?

771
00:59:05,180 --> 00:59:07,760
მოდით ეს ცალკე ნაბიჯები.

772
00:59:07,760 --> 00:59:18,850
თუ (value <) რა?

773
00:59:18,850 --> 00:59:23,200
[სტუდენტური] ხე მისი მნიშვნელობა?

774
00:59:23,200 --> 00:59:27,490
[Bowden] ასე მახსოვს, რომ მე გაკეთებული -

775
00:59:27,490 --> 00:59:31,260
[სტუდენტები, გაუგებარია]

776
00:59:31,260 --> 00:59:34,140
[Bowden] ჰო, ისე უფლება აქ, ვთქვათ, რომ ეს მწვანე arrow

777
00:59:34,140 --> 00:59:39,050
არის მაგალითი რა ხე გაკეთებული არის, არის მომცეთ ამ მაჩვენებელმა.

778
00:59:39,050 --> 00:59:46,610
ასე რომ ნიშნავს მე მომცეთ მომცეთ 3.

779
00:59:46,610 --> 00:59:48,800
Dereference ორჯერ გაისმა კარგი.

780
00:59:48,800 --> 00:59:51,010
რა - როგორ გავაკეთო ეს?

781
00:59:51,010 --> 00:59:53,210
[სტუდენტური] Dereference ერთხელ, და შემდეგ გააკეთოს arrow რომ გზა?

782
00:59:53,210 --> 00:59:58,420
[Bowden] ასე (* ხე) არის dereference ერთხელ, -> ღირებულება

783
00:59:58,420 --> 01:00:05,960
აპირებს მომეცი ღირებულება კვანძის რომ მე ირიბად მიუთითებს.

784
01:00:05,960 --> 01:00:11,980
ასე, რომ შეიძლება ასევე დაწერა ** tree.value თუ თქვენ გსურთ, რომ.

785
01:00:11,980 --> 01:00:18,490
ან მუშაობს.

786
01:00:18,490 --> 01:00:26,190
თუ ეს საქმე, მაშინ მინდა მოვუწოდო ჩადეთ ერთად ღირებულება.

787
01:00:26,190 --> 01:00:32,590
და რა არის ჩემი ახლდება კვანძის ** იქნება?

788
01:00:32,590 --> 01:00:39,440
მინდა წასვლა მარცხენა, ასე ** tree.left იქნება ჩემი მარცხენა.

789
01:00:39,440 --> 01:00:41,900
და მინდა მომცეთ რომ რამ

790
01:00:41,900 --> 01:00:44,930
ასე რომ თუ მარცხენა მთავრდება მყოფი null მაჩვენებელი,

791
01:00:44,930 --> 01:00:48,360
შემიძლია ცვლილებები ის აღვნიშნო, რომ ჩემი ახალი კვანძში.

792
01:00:48,360 --> 01:00:51,460
>> და სხვა შემთხვევაში შეიძლება ძალიან მსგავსი.

793
01:00:51,460 --> 01:00:55,600
მოდით რეალურად გააკეთოს, რომ ჩემი ternary ახლავე.

794
01:00:55,600 --> 01:01:04,480
ჩადეთ ღირებულება თუ ფასეულობა <(** ხე). ღირებულება.

795
01:01:04,480 --> 01:01:11,040
მაშინ ჩვენ გვინდა განაახლოს ჩვენი ** მარცხნივ,

796
01:01:11,040 --> 01:01:17,030
სხვაგან გვინდა განაახლოს ჩვენი ** მარჯვნივ.

797
01:01:17,030 --> 01:01:22,540
[სტუდენტური] არა, რომ მიიღოთ მომცეთ მაჩვენებელი?

798
01:01:22,540 --> 01:01:30,940
[Bowden] გახსოვდეთ, რომ - ** tree.right არის კვანძის ვარსკვლავი.

799
01:01:30,940 --> 01:01:35,040
[სტუდენტი გაუგებარია] >> Yeah.

800
01:01:35,040 --> 01:01:41,140
** Tree.right ჰგავს ეს მაჩვენებელი ან რამე.

801
01:01:41,140 --> 01:01:45,140
ასე ხდება მომცეთ, რომ, რომელიც მაძლევს რაც მე მინდა

802
01:01:45,140 --> 01:01:50,090
საქართველოს მომცეთ, რომ ბიჭს.

803
01:01:50,090 --> 01:01:54,260
[სტუდენტური] ვერ ჩვენ კვლავ რატომ ჩვენ გამოყენებით ორი პოინტერები?

804
01:01:54,260 --> 01:01:58,220
[Bowden] Yeah. ასე რომ - არა, თქვენ შეგიძლიათ, და რომ გამოსავალი ადრე

805
01:01:58,220 --> 01:02:04,540
იყო გზა ამის გაკეთება გარეშე აკეთებს ორ მითითებას.

806
01:02:04,540 --> 01:02:08,740
თქვენ უნდა იყოს იგებს გამოყენებით ორი პოინტერები,

807
01:02:08,740 --> 01:02:11,660
და ეს არის სუფთა გადაწყვეტა.

808
01:02:11,660 --> 01:02:16,090
ასევე შეამჩნევთ, რომ, რა მოხდება თუ ჩემი ხე -

809
01:02:16,090 --> 01:02:24,480
რა მოხდება თუ ჩემი root იყო null? რა მოხდება, თუ ამ შემთხვევაში სწორედ აქ?

810
01:02:24,480 --> 01:02:30,540
ასე რომ კვანძის * root = NULL, ჩადეთ 4 შევიდა და root.

811
01:02:30,540 --> 01:02:35,110
რა არის root იქნება ამის შემდეგ?

812
01:02:35,110 --> 01:02:37,470
[სტუდენტი გაუგებარია] >> Yeah.

813
01:02:37,470 --> 01:02:41,710
Root ღირებულება იქნება 4.

814
01:02:41,710 --> 01:02:45,510
Root მარცხენა იქნება null, ძირეული უფლება იქნება null.

815
01:02:45,510 --> 01:02:49,490
იმ შემთხვევაში, სადაც ჩვენ არ გაივლის root მისამართის მიხედვით,

816
01:02:49,490 --> 01:02:52,490
ჩვენ ვერ ცვლილებები root.

817
01:02:52,490 --> 01:02:56,020
იმ შემთხვევაში, ხე - სადაც root იყო null,

818
01:02:56,020 --> 01:02:58,410
ჩვენ უბრალოდ ჰქონდა დაბრუნების ცრუ. არაფერია ჩვენ შეგვიძლია გავაკეთოთ.

819
01:02:58,410 --> 01:03:01,520
ჩვენ ვერ ჩადეთ კვანძის შევიდა ცარიელი ხე.

820
01:03:01,520 --> 01:03:06,810
მაგრამ ახლა ჩვენ შეგვიძლია, ჩვენ მხოლოდ იმის ცარიელი ხე შევიდა ერთი კვანძის ხე.

821
01:03:06,810 --> 01:03:13,400
რაც ჩვეულებრივ მოსალოდნელი გზა, რომ ის უნდა იმუშაოს.

822
01:03:13,400 --> 01:03:21,610
>> გარდა ამისა, ეს არის მნიშვნელოვნად მოკლეა, ვიდრე

823
01:03:21,610 --> 01:03:26,240
ასევე შენახვა ტრეკზე მშობელი, და ასე რომ თქვენ iterate ქვემოთ ყველა გზა.

824
01:03:26,240 --> 01:03:30,140
ახლა მე მაქვს ჩემი მშობელი, და მე უბრალოდ ჩემი მშობელი უფლება მომცეთ რასაც.

825
01:03:30,140 --> 01:03:35,640
სამაგიეროდ, თუ ეს გავაკეთეთ iteratively, ეს მინდა იყოს იგივე იდეა ხოლო loop.

826
01:03:35,640 --> 01:03:38,100
მაგრამ ნაცვლად, რომელმაც უნდა გაუმკლავდეთ ჩემი მშობელი მაჩვენებელი,

827
01:03:38,100 --> 01:03:40,600
ნაცვლად ჩემი ამჟამინდელი მაჩვენებელი იქნებოდა რამ

828
01:03:40,600 --> 01:03:43,790
რომ მე პირდაპირ შეცვლის აღვნიშნო, რომ ჩემი ახალი კვანძში.

829
01:03:43,790 --> 01:03:46,090
მე არ მაქვს გამკლავება თუ არა ეს მიუთითებს მარცხენა.

830
01:03:46,090 --> 01:03:48,810
მე არ მაქვს გამკლავება თუ არა ეს მიუთითებს უფლება.

831
01:03:48,810 --> 01:04:00,860
უბრალოდ რასაც ამ მაჩვენებელმა არის, მე ვაპირებ ვაყენებთ მას აღვნიშნო, რომ ჩემი ახალი კვანძში.

832
01:04:00,860 --> 01:04:05,740
ყველას გვესმის, როგორ მუშაობს?

833
01:04:05,740 --> 01:04:09,460
თუ არ რატომ გვინდა ამის გაკეთება ამ გზით,

834
01:04:09,460 --> 01:04:14,920
მაგრამ მაინც, რომ ეს სამუშაოები როგორც გამოსავალი?

835
01:04:14,920 --> 01:04:17,110
[სტუდენტური] სად ვბრუნდებით მართალია?

836
01:04:17,110 --> 01:04:21,550
[Bowden], რომ ალბათ სწორედ აქ.

837
01:04:21,550 --> 01:04:26,690
თუ ჩვენ სწორად ჩადეთ დისკი, დაუბრუნოს ჭეშმარიტი.

838
01:04:26,690 --> 01:04:32,010
სხვაგან, ქვემოთ აქ ჩვენ ვაპირებთ მინდა დაბრუნდეს რასაც ჩასმა ბრუნდება.

839
01:04:32,010 --> 01:04:35,950
>> და რაც განსაკუთრებულ ამ რეკურსიული ფუნქცია?

840
01:04:35,950 --> 01:04:43,010
ეს კუდი რეკურსიული, ამიტომ სანამ ჩვენ კომპილაციის ზოგიერთი ოპტიმიზაცია,

841
01:04:43,010 --> 01:04:48,060
იგი აღიარებს, რომ და თქვენ არასოდეს მიიღოთ Stack overflow ამ,

842
01:04:48,060 --> 01:04:53,230
მაშინაც კი, თუ ჩვენი ხე აქვს სიმაღლე 10,000 ან 10 მლნ.

843
01:04:53,230 --> 01:04:55,630
[სტუდენტი გაუგებარია]

844
01:04:55,630 --> 01:05:00,310
[Bowden] მე ვფიქრობ, რომ არ ეს Dash - ან რა ოპტიმიზაცია დონეზე

845
01:05:00,310 --> 01:05:03,820
საჭიროა კუდი უკან უნდა იყოს აღიარებული.

846
01:05:03,820 --> 01:05:09,350
მე ვფიქრობ, რომ აღიარებს - gcc და Clang

847
01:05:09,350 --> 01:05:12,610
ასევე აქვს სხვადასხვა მნიშვნელობა მათი ოპტიმიზაციისათვის დონეზე.

848
01:05:12,610 --> 01:05:17,870
მინდა ვთქვა, რომ ეს DashO 2, დარწმუნებული ვარ, რომ ეს აღიარონ კუდი უკან.

849
01:05:17,870 --> 01:05:27,880
მაგრამ ჩვენ - თქვენ შეიძლება ააშენოს მოსწონს Fibonocci მაგალითად ან რამე.

850
01:05:27,880 --> 01:05:30,030
ეს არ არის ადვილი, რათა გამოსცადოს ამისა, რადგან ძნელია მშენებლობა

851
01:05:30,030 --> 01:05:32,600
ორობითი ხე რომ იმდენად დიდი.

852
01:05:32,600 --> 01:05:37,140
მაგრამ ჰო, მე ვფიქრობ, DashO 2, რომ

853
01:05:37,140 --> 01:05:40,580
თუ კომპილაციის ერთად DashO 2, ამას გადახედეთ კუდი უკან

854
01:05:40,580 --> 01:05:54,030
და ოპტიმიზაცია, რომ.

855
01:05:54,030 --> 01:05:58,190
მოდით დავუბრუნდეთ - ჩადეთ არის სიტყვასიტყვით ბოლო რამ სჭირდება.

856
01:05:58,190 --> 01:06:04,900
მოდით დავუბრუნდეთ ჩანართით მეტი აქ

857
01:06:04,900 --> 01:06:07,840
სადაც ჩვენ ვაპირებთ იგივე იდეას.

858
01:06:07,840 --> 01:06:14,340
ეს ისევ აქვს ხარვეზი არა მიმდინარეობს შეუძლია მთლიანად განიმუხტება

859
01:06:14,340 --> 01:06:17,940
როდესაც root თავისთავად null, ან წარსულში შესვლის null,

860
01:06:17,940 --> 01:06:20,060
მაგრამ ნაცვლად საქმე მშობელს მაჩვენებელი,

861
01:06:20,060 --> 01:06:27,430
მოდით ვრცელდება იგივე ლოგიკას შენახვა მითითებას პოინტერები.

862
01:06:27,430 --> 01:06:35,580
თუ აქ ჩვენ შევინარჩუნოთ კვანძის ** მიმდ.,

863
01:06:35,580 --> 01:06:37,860
და ჩვენ არ უნდა ტრეკზე უფლება აღარ,

864
01:06:37,860 --> 01:06:47,190
მაგრამ კვანძის ** მიმდ. = & ხე.

865
01:06:47,190 --> 01:06:54,800
და ახლა ჩვენი ხოლო loop იქნება, ხოლო * მიმდ. არ თანაბარი null.

866
01:06:54,800 --> 01:07:00,270
არ გჭირდებათ ტრეკზე მშობლები უქმნით.

867
01:07:00,270 --> 01:07:04,180
არ გჭირდებათ ტრეკზე მარცხენა და მარჯვენა.

868
01:07:04,180 --> 01:07:10,190
მე კი ეძახით temp, რადგან ჩვენ უკვე იყენებს temp.

869
01:07:10,190 --> 01:07:17,200
Okay. ასე რომ, თუ (value> * temp),

870
01:07:17,200 --> 01:07:24,010
მაშინ & (* Temp) -> უფლება

871
01:07:24,010 --> 01:07:29,250
სხვაგან temp = & (* Temp) -> დაუტოვებიათ.

872
01:07:29,250 --> 01:07:32,730
და ახლა, ამ ეტაპზე, ამის შემდეგ, ხოლო მარყუჟის,

873
01:07:32,730 --> 01:07:36,380
მე მხოლოდ ამას ვაკეთებთ, რადგან შეიძლება უფრო ადვილია ფიქრი iteratively ვიდრე რეკურსიული,

874
01:07:36,380 --> 01:07:39,010
მაგრამ მას შემდეგ, რაც ამ ხოლო მარყუჟის,

875
01:07:39,010 --> 01:07:43,820
* Temp არის კურსორი ჩვენ გვინდა, რომ შეიცვალოს.

876
01:07:43,820 --> 01:07:48,960
>> სანამ ჩვენ გვქონდა მშობელი, და გვინდოდა, რომ შეცვალოს ან მშობელი ან მარცხენა მშობლის უფლება,

877
01:07:48,960 --> 01:07:51,310
მაგრამ თუ ჩვენ გვინდა, რომ შეიცვალოს მშობლის უფლება,

878
01:07:51,310 --> 01:07:54,550
მაშინ * Temp არის მშობელი უფლება, და ჩვენ შეგვიძლია შევცვალოთ იგი პირდაპირ.

879
01:07:54,550 --> 01:08:05,860
ასე ქვევით აქ, შეგვიძლია გავაკეთოთ * temp = newnode, და ამით ყველაფერი მთავრდება.

880
01:08:05,860 --> 01:08:09,540
ასე შეტყობინება, ყველა ჩვენ ამ იყო აიღოს ხაზების კოდი.

881
01:08:09,540 --> 01:08:14,770
იმისათვის, რომ ტრეკზე მშობელი ყველა რომ არის დამატებითი ძალისხმევა.

882
01:08:14,770 --> 01:08:18,689
აქ, თუ ჩვენ მხოლოდ ტრეკზე მომცეთ მაჩვენებელი,

883
01:08:18,689 --> 01:08:22,990
და მაშინაც კი, თუ გვინდოდა დავაღწიოთ ყველა ამ Curly braces ახლა,

884
01:08:22,990 --> 01:08:27,170
რათა ის გამოიყურება მოკლე.

885
01:08:27,170 --> 01:08:32,529
ეს არის არის ზუსტად იგივე გადაწყვეტა,

886
01:08:32,529 --> 01:08:38,210
მაგრამ ნაკლები ხაზების კოდი.

887
01:08:38,210 --> 01:08:41,229
ერთხელ თქვენ დაიწყოს აღიარების ეს სწორი გამოსავალი,

888
01:08:41,229 --> 01:08:43,529
ასევე ადვილია მიზეზი შესახებ, ვიდრე მოსწონს, okay,

889
01:08:43,529 --> 01:08:45,779
რატომაა ეს დროშა int უფლება?

890
01:08:45,779 --> 01:08:49,290
რას ნიშნავს ეს? ოჰ, ეს signifying რომ

891
01:08:49,290 --> 01:08:51,370
ყოველ ჯერზე მე უფლება, მე უნდა ვაყენებთ მას,

892
01:08:51,370 --> 01:08:53,819
სხვას თუ მე დაუტოვებიათ მე უნდა ვაყენებთ მას ნულოვანი.

893
01:08:53,819 --> 01:09:04,060
აქ, მე არ მაქვს მიზეზი რომ, უბრალოდ ადვილია ფიქრი.

894
01:09:04,060 --> 01:09:06,710
კითხვები?

895
01:09:06,710 --> 01:09:16,290
[სტუდენტი გაუგებარია] >> Yeah.

896
01:09:16,290 --> 01:09:23,359
Okay, ასე ბოლო bit -

897
01:09:23,359 --> 01:09:28,080
ვფიქრობ ერთი სწრაფი და მარტივი ფუნქცია შეგვიძლია გავაკეთოთ არის,

898
01:09:28,080 --> 01:09:34,910
let's - ერთად, ვფიქრობ, შეეცდება და დაწეროთ შეიცავს ფუნქცია

899
01:09:34,910 --> 01:09:38,899
, რომელსაც არ ადარდებს თუ არა ორობითი ძებნა ხე.

900
01:09:38,899 --> 01:09:43,770
ეს შეიცავს ფუნქცია იქნება TRUE

901
01:09:43,770 --> 01:09:58,330
თუ სადმე ამ ზოგადი ორობითი ხე არის ღირებულება ჩვენ ვეძებთ.

902
01:09:58,330 --> 01:10:02,520
მოდით პირველ გავაკეთებთ რეკურსიული და შემდეგ ჩვენ გავაკეთებთ iteratively.

903
01:10:02,520 --> 01:10:07,300
ჩვენ შეგვიძლია რეალურად მხოლოდ გავაკეთებთ ერთად, რადგან ეს იქნება მართლაც მოკლე.

904
01:10:07,300 --> 01:10:11,510
>> რა არის ჩემი ბაზა შემთხვევაში იქნება?

905
01:10:11,510 --> 01:10:13,890
[სტუდენტი გაუგებარია]

906
01:10:13,890 --> 01:10:18,230
[Bowden] ასე რომ, თუ (ხე == NULL), მერე რა?

907
01:10:18,230 --> 01:10:22,740
[სტუდენტური] დაბრუნება ყალბი.

908
01:10:22,740 --> 01:10:26,160
[Bowden] სხვაგან, ისე, მე არ გვჭირდება სხვა.

909
01:10:26,160 --> 01:10:30,250
თუ იყო ჩემი სხვა ბაზის შემთხვევაში.

910
01:10:30,250 --> 01:10:32,450
[სტუდენტური] ხე მისი მნიშვნელობა? >> Yeah.

911
01:10:32,450 --> 01:10:36,430
ასე რომ, თუ (ხე-> ღირებულების == ღირებულება.

912
01:10:36,430 --> 01:10:39,920
გაითვალისწინეთ ჩვენ თავში კვანძის *, არ კვანძის ** s?

913
01:10:39,920 --> 01:10:42,990
შეიცავს არასდროს უნდა გამოვიყენოთ კვანძის **,

914
01:10:42,990 --> 01:10:45,480
მას შემდეგ, რაც ჩვენ არ შეცვლის პოინტერები.

915
01:10:45,480 --> 01:10:50,540
ჩვენ უბრალოდ traversing მათ.

916
01:10:50,540 --> 01:10:53,830
თუ ეს მოხდება, მაშინ ჩვენ გვინდა დაბრუნდეს ჭეშმარიტი.

917
01:10:53,830 --> 01:10:58,270
Else გვინდა traverse შვილი.

918
01:10:58,270 --> 01:11:02,620
ამიტომ, ჩვენ ვერ მიზეზი თუ არა ყველაფერი, რათა მარცხენა ნაკლებია

919
01:11:02,620 --> 01:11:05,390
და ყველაფერი მარჯვნივ არის უფრო დიდი.

920
01:11:05,390 --> 01:11:09,590
რა არის ჩვენი მდგომარეობა იქნება აქ - ან, რას აპირებს?

921
01:11:09,590 --> 01:11:11,840
[სტუდენტი გაუგებარია] >> Yeah.

922
01:11:11,840 --> 01:11:17,400
დაბრუნება შეიცავს (ღირებულება, ხის-> მარცხნივ)

923
01:11:17,400 --> 01:11:26,860
ან შეიცავს (ღირებულება, ხის-> მარჯვნივ). და ამით ყველაფერი.

924
01:11:26,860 --> 01:11:29,080
და შენიშნავს, არსებობს გარკვეული მოკლე ჩართვა შეფასება,

925
01:11:29,080 --> 01:11:32,520
აქ თუ ჩვენ მოხდეს მოძიების ღირებულების მარცხენა ხე,

926
01:11:32,520 --> 01:11:36,820
ჩვენ არასოდეს უნდა შევხედოთ უფლება ხე.

927
01:11:36,820 --> 01:11:40,430
სწორედ მთელი ფუნქცია.

928
01:11:40,430 --> 01:11:43,690
ახლა მოდით ეს iteratively,

929
01:11:43,690 --> 01:11:48,060
რაც იქნება ნაკლებად ლამაზი.

930
01:11:48,060 --> 01:11:54,750
ჩვენ მიიღოს ჩვეულებრივი დაწყების კვანძის * მიმდ. = ხე.

931
01:11:54,750 --> 01:12:03,250
მიუხედავად იმისა (მიმდ. = NULL).

932
01:12:03,250 --> 01:12:08,600
სწრაფად აპირებს ვხედავ პრობლემას.

933
01:12:08,600 --> 01:12:12,250
თუ მიმდ. - აქ, თუ ჩვენ ოდესმე შესვენება აქედან,

934
01:12:12,250 --> 01:12:16,020
მაშინ ჩვენ ამოიწურა რამ შევხედოთ, ამიტომ დაბრუნების ცრუ.

935
01:12:16,020 --> 01:12:24,810
თუ (მიმდ.-> ღირებულების == ღირებულების), დაუბრუნოს ჭეშმარიტი.

936
01:12:24,810 --> 01:12:32,910
ახლა, ჩვენ ვიმყოფებით ადგილი -

937
01:12:32,910 --> 01:12:36,250
ჩვენ არ ვიცით თუ არა ჩვენ გვინდა წავიდეთ მარცხნივ ან მარჯვნივ.

938
01:12:36,250 --> 01:12:44,590
ასე თვითნებურად, მოდით უბრალოდ დაუტოვებიათ.

939
01:12:44,590 --> 01:12:47,910
მე აშკარად გადაეყარონ საკითხი, სადაც მე სრულიად მიტოვებული ყველაფერი -

940
01:12:47,910 --> 01:12:50,760
მე მხოლოდ ოდესმე შეამოწმოთ მარცხენა მხარეს ხე.

941
01:12:50,760 --> 01:12:56,050
მე არასდროს შეამოწმოს ყველაფერი, რაც არის სწორი ბავშვი არაფერი.

942
01:12:56,050 --> 01:13:00,910
როგორ შემიძლია დაფიქსირება ამ?

943
01:13:00,910 --> 01:13:05,260
[სტუდენტური] თქვენ უნდა ტრეკზე მარცხენა და მარჯვენა Stack.

944
01:13:05,260 --> 01:13:13,710
[Bowden] Yeah. მოდით იყოს იგი

945
01:13:13,710 --> 01:13:32,360
struct სია, node * n, და შემდეგ კვანძის ** შემდეგი?

946
01:13:32,360 --> 01:13:40,240
მე ვფიქრობ, რომ მუშაობს ჯარიმა.

947
01:13:40,240 --> 01:13:45,940
ჩვენ გვინდა წავიდეთ მეტი მარცხენა, ან let's - აქ.

948
01:13:45,940 --> 01:13:54,350
Struct სია სია =, ეს დავიწყებთ

949
01:13:54,350 --> 01:13:58,170
out ამ struct სიაში.

950
01:13:58,170 --> 01:14:04,040
* სიაში = null. ასე რომ იქნება ჩვენი დაკავშირებული სია

951
01:14:04,040 --> 01:14:08,430
საქართველოს subtrees რომ ჩვენ გამოტოვებენ დასრულდა.

952
01:14:08,430 --> 01:14:13,800
ჩვენ ვაპირებთ, რომ ტრავერსზე დაუტოვებიათ ახლა,

953
01:14:13,800 --> 01:14:17,870
მაგრამ რადგან ჩვენ აუცილებლად უნდა დაუბრუნდეს უფლება,

954
01:14:17,870 --> 01:14:26,140
ჩვენ ვაპირებთ შენარჩუნება მარჯვენა მხარეს შიგნით ჩვენი struct სიაში.

955
01:14:26,140 --> 01:14:32,620
მაშინ გვექნება new_list ან struct,

956
01:14:32,620 --> 01:14:41,080
struct სია *, new_list = malloc (sizeof (სია)).

957
01:14:41,080 --> 01:14:44,920
მე ვაპირებ იგნორირება შეცდომის შემოწმების რომ, მაგრამ თქვენ უნდა შეამოწმეთ, რომ მისი null.

958
01:14:44,920 --> 01:14:50,540
New_list კვანძის ის აპირებს აღვნიშნო, რომ -

959
01:14:50,540 --> 01:14:56,890
OH, ამიტომ მინდოდა ეს აქ. იგი აპირებს აღვნიშნო, რომ მეორე struct სიაში.

960
01:14:56,890 --> 01:15:02,380
ეს მხოლოდ როგორ უკავშირდება სიები მუშაობა.

961
01:15:02,380 --> 01:15:04,810
ეს არის იგივე როგორც int უკავშირდება სია

962
01:15:04,810 --> 01:15:06,960
გარდა ჩვენ უბრალოდ შეცვალა int ერთად კვანძის *.

963
01:15:06,960 --> 01:15:11,040
ეს ზუსტად იგივე.

964
01:15:11,040 --> 01:15:15,100
ამიტომ new_list, ღირებულების ჩვენი new_list კვანძში,

965
01:15:15,100 --> 01:15:19,120
იქნება მიმდ.-> უფლება.

966
01:15:19,120 --> 01:15:24,280
ღირებულება ჩვენი new_list-> შემდეგი იქნება ჩვენი ორიგინალური სიაში,

967
01:15:24,280 --> 01:15:30,760
და მაშინ ჩვენ ვაპირებთ განაახლოს ჩვენი სიიდან აღვნიშნო, რომ new_list.

968
01:15:30,760 --> 01:15:33,650
>> ახლა ჩვენ გვჭირდება გარკვეული გზა უბიძგებენ რამ,

969
01:15:33,650 --> 01:15:37,020
როგორც ჩვენ არ გადიოდა მთელი მარცხენა subtree.

970
01:15:37,020 --> 01:15:40,480
ახლა ჩვენ უნდა გაიყვანოს პერსონალის გარეთ,

971
01:15:40,480 --> 01:15:43,850
მოსწონს მიმდ. არის null, ჩვენ არ გვინდა უბრალოდ დააბრუნოს ყალბი.

972
01:15:43,850 --> 01:15:50,370
ჩვენ გვინდა ახლა გაიყვანოს გარეთ ჩვენი ახალი სია.

973
01:15:50,370 --> 01:15:53,690
მოსახერხებელი გზა კეთების ამ - ისევე, ფაქტობრივად, არსებობს მრავალი გზები აკეთებენ.

974
01:15:53,690 --> 01:15:56,680
ვინმეს აქვს შემოთავაზება?

975
01:15:56,680 --> 01:15:58,790
სადაც მე უნდა გავაკეთოთ ამა თუ როგორ უნდა გავაკეთოთ ეს?

976
01:15:58,790 --> 01:16:08,010
ჩვენ მხოლოდ რამდენიმე წუთის შემდეგ, მაგრამ რაიმე შემოთავაზება?

977
01:16:08,010 --> 01:16:14,750
იმის ნაცვლად, რომ ერთ - ერთი გზა, ნაცვლად ჩვენს პირობებში მყოფი ხოლო,

978
01:16:14,750 --> 01:16:17,090
რა ჩვენ გაკეთებული ეძებს არ არის null,

979
01:16:17,090 --> 01:16:22,340
ნაცვლად ჩვენ გავაგრძელებთ წასვლა სანამ ჩვენს სიაში თავისთავად null.

980
01:16:22,340 --> 01:16:25,680
ასე რომ, თუ ჩვენს სიაში მთავრდება მყოფი null,

981
01:16:25,680 --> 01:16:30,680
მაშინ ჩვენ არ ამოიწურა რამ მოსაძებნად, ძებნის დასრულდა.

982
01:16:30,680 --> 01:16:39,860
მაგრამ ეს იმას ნიშნავს, რომ პირველი, რაც ჩვენს სიაში მხოლოდ იქნება პირველი კვანძი.

983
01:16:39,860 --> 01:16:49,730
ძალიან პირველი რაც იქნება - ჩვენ აღარ უნდა დაინახოს, რომ.

984
01:16:49,730 --> 01:16:58,710
ასე რომ ლენტა-> n იქნება ჩვენი ხე.

985
01:16:58,710 --> 01:17:02,860
სიის-> შემდეგი იქნება null.

986
01:17:02,860 --> 01:17:07,580
და ახლა, ხოლო სიაში არ თანაბარი null.

987
01:17:07,580 --> 01:17:11,610
მიმდ. აპირებს დახევის რაღაც ჩვენი სიიდან.

988
01:17:11,610 --> 01:17:13,500
ამიტომ მიმდ. აპირებს თანაბარი სიაში-> n.

989
01:17:13,500 --> 01:17:20,850
და მაშინ სიაში აპირებს თანაბარი სიაში-> N, ან სიაში-> მომავალი.

990
01:17:20,850 --> 01:17:23,480
ასე რომ, თუ მიმდ. ღირებულება შეადგენს ღირებულების.

991
01:17:23,480 --> 01:17:28,790
ახლა ჩვენ შეგიძლიათ დაამატოთ როგორც ჩვენი უფლება მაჩვენებელი და ჩვენი მარცხენა კურსორი

992
01:17:28,790 --> 01:17:32,900
რადგან ისინი არ null.

993
01:17:32,900 --> 01:17:36,390
Down აქ, ვფიქრობ, უნდა გაკეთდეს, რომ პირველ რიგში.

994
01:17:36,390 --> 01:17:44,080
თუ (მიმდ.-> უფლება! = NULL)

995
01:17:44,080 --> 01:17:56,380
მაშინ ჩვენ ვაპირებთ ჩადეთ რომ კვანძის ჩვენს სიაში.

996
01:17:56,380 --> 01:17:59,290
თუ (მიმდ.-> მარცხნივ), ეს ცოტა ზედმეტი მუშაობა, მაგრამ ჯარიმა.

997
01:17:59,290 --> 01:18:02,690
თუ (მიმდ.-> მარცხენა = NULL),

998
01:18:02,690 --> 01:18:14,310
და ჩვენ ვაპირებთ ჩადეთ მარცხენა ჩვენს უკავშირდება სია,

999
01:18:14,310 --> 01:18:19,700
და რომ უნდა იყოს იგი.

1000
01:18:19,700 --> 01:18:22,670
ჩვენ iterate - სანამ ჩვენ გვაქვს რაღაც ჩვენი სიიდან,

1001
01:18:22,670 --> 01:18:26,640
ჩვენ გვაქვს კიდევ ერთი კვანძის შევხედოთ.

1002
01:18:26,640 --> 01:18:28,920
ასე შევხედავთ, რომ კვანძის,

1003
01:18:28,920 --> 01:18:31,390
ჩვენ წინასწარ ჩვენს სიაში მომდევნო ერთი.

1004
01:18:31,390 --> 01:18:34,060
თუ რომ კვანძის არის ღირებულება ჩვენ ვეძებთ, ჩვენ შეგვიძლია იქნება TRUE.

1005
01:18:34,060 --> 01:18:37,640
Else ჩადეთ ორივე ჩვენი მარჯვენა და მარცხენა subtrees,

1006
01:18:37,640 --> 01:18:40,510
რადგან ისინი არ null, ჩვენს სიაში

1007
01:18:40,510 --> 01:18:43,120
ასე, რომ ჩვენ აუცილებლად წავიდეთ მათზე.

1008
01:18:43,120 --> 01:18:45,160
ასე რომ, თუ ისინი არ null,

1009
01:18:45,160 --> 01:18:47,950
თუ ჩვენი ძირეული მაჩვენებელი მიუთითებს ორი რამ,

1010
01:18:47,950 --> 01:18:51,670
მაშინ პირველ რიგში ჩვენ გამოყვანილია რაიმე ისე ჩვენს სიაში მთავრდება მყოფი null.

1011
01:18:51,670 --> 01:18:56,890
და შემდეგ ჩვენ დააყენა ორი რამ უკან, ასე რომ ახლა ჩვენს სიაში არის ზომა 2.

1012
01:18:56,890 --> 01:19:00,030
მაშინ ჩვენ ვაპირებთ მარყუჟი back up და ჩვენ უბრალოდ აპირებს გაიყვანოს,

1013
01:19:00,030 --> 01:19:04,250
ვთქვათ, მარცხენა კურსორი ჩვენი ძირეული კვანძის.

1014
01:19:04,250 --> 01:19:07,730
და რომ ყველაფერს მხოლოდ შენარჩუნება ხდება, ჩვენ დასრულდება მდე looping ზე ყველაფერი.

1015
01:19:07,730 --> 01:19:11,280
>> გაითვალისწინეთ, რომ ეს იყო მნიშვნელოვნად უფრო რთული

1016
01:19:11,280 --> 01:19:14,160
წელს რეკურსიული გადაწყვეტა.

1017
01:19:14,160 --> 01:19:17,260
და მე განაცხადა რამდენჯერმე

1018
01:19:17,260 --> 01:19:25,120
რომ რეკურსიული გადაწყვეტა ჩვეულებრივ გაცილებით საერთო iterative გადაწყვეტა.

1019
01:19:25,120 --> 01:19:30,820
აქ სწორედ რეკურსიული გადაწყვეტა აკეთებს.

1020
01:19:30,820 --> 01:19:36,740
მხოლოდ ცვლილება არის, რომ ნაცვლად მინიშნებით გამოყენებით დასტის, პროგრამის დასტის,

1021
01:19:36,740 --> 01:19:40,840
როგორც თქვენი გზა შენახვის ტრეკზე რა კვანძების თქვენ კვლავ უნდა ეწვევა,

1022
01:19:40,840 --> 01:19:45,430
ახლა თქვენ უნდა პირდაპირ გამოყენება დაკავშირებული სიაში.

1023
01:19:45,430 --> 01:19:49,070
ორივე შემთხვევაში თქვენ შენახვა ტრეკზე რა კვანძის მაინც საჭიროებს ეწვია.

1024
01:19:49,070 --> 01:19:51,790
In რეკურსიული შემთხვევაში უბრალოდ ადვილია რადგან დასტის

1025
01:19:51,790 --> 01:19:57,100
ხორციელდება, როგორც პროგრამის დასტის.

1026
01:19:57,100 --> 01:19:59,550
გაითვალისწინეთ, რომ ეს დაკავშირებულია სიაში, ეს არის დასტის.

1027
01:19:59,550 --> 01:20:01,580
რაც ჩვენ უბრალოდ ჩაიცვი დასტის

1028
01:20:01,580 --> 01:20:09,960
მაშინვე, რაც ჩვენ ვაპირებთ დახევის off დასტის ეწვევა შემდეგი.

1029
01:20:09,960 --> 01:20:14,380
ჩვენ გარეთ, მაგრამ რაიმე კითხვა?

1030
01:20:14,380 --> 01:20:23,530
[სტუდენტი გაუგებარია]

1031
01:20:23,530 --> 01:20:27,790
[Bowden] Yeah. ასე რომ, თუ ჩვენ გვაქვს დაკავშირებული სიაში,

1032
01:20:27,790 --> 01:20:30,150
მიმდინარე აპირებს აღვნიშნო, რომ ამ ბიჭს,

1033
01:20:30,150 --> 01:20:34,690
და ახლა ჩვენ უბრალოდ მიიწევს ჩვენი დაკავშირებული სიაში ფოკუსირება ამ ბიჭს.

1034
01:20:34,690 --> 01:20:44,200
ჩვენ traversing მეტი უკავშირდება სიაში რომ ხაზი.

1035
01:20:44,200 --> 01:20:51,200
და მაშინ ვხვდები, ჩვენ უნდა გავათავისუფლოთ ჩვენი დაკავშირებული სიაში და პერსონალი

1036
01:20:51,200 --> 01:20:53,880
ერთხელ სანამ ჭეშმარიტი ან ცრუ, ჩვენ უნდა

1037
01:20:53,880 --> 01:20:57,360
iterate მეტი ჩვენი უკავშირდება სიაში და ყოველთვის ქვევით აქ, ვფიქრობ,

1038
01:20:57,360 --> 01:21:03,900
თუ ჩვენ მიმდ. უფლება არ არის ტოლი, დაამატოთ, ასე რომ, ახლა ჩვენ გვინდა გასათავისუფლებლად

1039
01:21:03,900 --> 01:21:09,600
მიმდ. რადგან, ისევე, არც ჩვენ სრულიად დაივიწყოს სიაში? Yeah.

1040
01:21:09,600 --> 01:21:12,880
ასე რომ, რაც ჩვენ გვსურს რომ აქ.

1041
01:21:12,880 --> 01:21:16,730
სად არის მაჩვენებელი?

1042
01:21:16,730 --> 01:21:23,320
მიმდ. იყო მაშინ - ჩვენ გვინდა struct სია * 10 ტოლია სიის მომდევნო.

1043
01:21:23,320 --> 01:21:29,240
უფასო სია, სიაში = temp.

1044
01:21:29,240 --> 01:21:32,820
და იმ შემთხვევაში, ჩვენ იქნება TRUE, ჩვენ გვჭირდება iterate

1045
01:21:32,820 --> 01:21:37,050
მეტი ნაშთი ჩვენი დაკავშირებული სიაში გამონთავისუფლების რამ.

1046
01:21:37,050 --> 01:21:39,700
ლამაზი რამ შესახებ რეკურსიული გამოსავალი გამონთავისუფლების რამ

1047
01:21:39,700 --> 01:21:44,930
მხოლოდ იმას ნიშნავს, popping factorings off დასტის რომელიც მოხდება თქვენთვის.

1048
01:21:44,930 --> 01:21:50,720
ამიტომ ჩვენ წავიდა რაღაც ასეთი 3 ხაზების ძნელად ვფიქრობ-ს შესახებ კოდი

1049
01:21:50,720 --> 01:21:57,520
რაიმე რომ მნიშვნელოვნად მრავალი სხვა ძნელად ვფიქრობ-ს შესახებ ხაზი კოდი.

1050
01:21:57,520 --> 01:22:00,620
ნებისმიერი უფრო მეტი შეკითხვა?

1051
01:22:00,620 --> 01:22:08,760
ყველა უფლება. ჩვენ კარგი. Bye!

1052
01:22:08,760 --> 01:22:11,760
[CS50.TV]