1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [பகுதி 7] [குறைவான வசதியான]

2
00:00:02,500 --> 00:00:04,890
[நேட் Hardison] [ஹார்வர்ட் பல்கலைக்கழகம்]

3
00:00:04,890 --> 00:00:07,000
[இந்த CS50 உள்ளது.] [CS50.TV]

4
00:00:07,000 --> 00:00:09,080
>> பகுதி 7 வரவேற்கிறது.

5
00:00:09,080 --> 00:00:11,330
, சூறாவளி சாண்டி நன்றி

6
00:00:11,330 --> 00:00:13,440
அதற்கு பதிலாக, இந்த வாரம் ஒரு சாதாரண பிரிவில் இருந்து,

7
00:00:13,440 --> 00:00:17,650
நாங்கள் கேள்விகள் பிரிவு மூலம், தேர்வு மூலம் இந்த செய்கிறீர்கள்.

8
00:00:17,650 --> 00:00:22,830
நான், 6 குறிப்பு அமை பிரச்சினை இணைந்து தொடர்ந்து இருக்க போகிறேன்

9
00:00:22,830 --> 00:00:25,650
மற்றும் எல்லா கேள்விகளுக்கும் நடக்கிறது

10
00:00:25,650 --> 00:00:27,770
கேள்விகள் பிரிவின் ஒரு பகுதி.

11
00:00:27,770 --> 00:00:30,940
எந்த கேள்விகள் இருந்தால்,

12
00:00:30,940 --> 00:00:32,960
CS50 Discuss இந்த பதிவு செய்யவும்.

13
00:00:32,960 --> 00:00:35,480
>> அது சரி. அது துவங்கட்டும்.

14
00:00:35,480 --> 00:00:40,780
இப்போது நான் பிரச்சினை அமை குறிப்பு ஒரு பக்கம் 3 பார்த்துக்கொண்டிருக்கிறேன்.

15
00:00:40,780 --> 00:00:44,110
நாம் முதலில் பைனரி மரங்கள் பற்றி தொடங்க போகிறீர்கள்

16
00:00:44,110 --> 00:00:47,850
அந்த இந்த வாரம் சிக்கல் ஜோடி தொடர்பு நிறைய இருந்து -

17
00:00:47,850 --> 00:00:49,950
ஹஃப்மேன் மரம் குறியாக்க.

18
00:00:49,950 --> 00:00:55,000
நாம் CS50 மீது பேசினார் முதல் தரவு கட்டமைப்புகள் ஒரு வரிசை இருந்தது.

19
00:00:55,000 --> 00:01:00,170
ஒரு வரிசைக்கு தனிமங்களின் வரிசை என்று ஞாபகம் -

20
00:01:00,170 --> 00:01:04,019
அதே வகை அனைத்து - நினைவகத்தில் சரி ஒருவருக்கொருவர் அடுத்த சேமிக்கப்படும்.

21
00:01:04,019 --> 00:01:14,420
நான் இந்த பெட்டிகள், எண்கள், முழு எண்கள் பாணியில் பயன்படுத்தி வரைய முடியும் என்று ஒரு முழு எண் வரிசை இருந்தால் -

22
00:01:14,420 --> 00:01:20,290
நாம் நான் முதல் பெட்டியில் 5 சொல்ல, நான், இரண்டாவது 7 வேண்டும்

23
00:01:20,290 --> 00:01:27,760
நான் இறுதி பெட்டியில் 8, 10, மற்றும் 20 இருக்கிறது.

24
00:01:27,760 --> 00:01:33,000
இந்த வரிசை பற்றி நினைவில், இரண்டு நல்ல விஷயங்கள்

25
00:01:33,000 --> 00:01:38,800
நாங்கள் எந்த குறிப்பிட்ட உறுப்பு இந்த நிலையான நேர இணைப்பு இல்லை

26
00:01:38,800 --> 00:01:40,500
 வரிசையில் நாம் அதன் குறியீட்டு தெரிந்தால்.

27
00:01:40,500 --> 00:01:44,670
உதாரணமாக, நான் வரிசையில் மூன்றாவது உறுப்பு அடைய விரும்பினால் -

28
00:01:44,670 --> 00:01:47,870
குறியீட்டு 2 எங்கள் பூஜ்யம் சார்ந்த அட்டவணையிடுதல் கணினியை பயன்படுத்தி -

29
00:01:47,870 --> 00:01:52,220
நான் மொழியில் மட்டும், ஒரு எளிய கணித கணக்கீடு செய்ய வேண்டும்

30
00:01:52,220 --> 00:01:56,170
, வரிசையில் அந்த நிலைக்கு ஹாப்

31
00:01:56,170 --> 00:01:57,840
அங்கு சேமிக்கப்படும் என்று 8, வெளியே இழுக்க

32
00:01:57,840 --> 00:01:59,260
நான் போய் நல்ல இருக்கிறேன்.

33
00:01:59,260 --> 00:02:03,350
>> இந்த வரிசை பற்றி தவறாக ஒன்று - நாங்கள் பேசினார் என்று

34
00:02:03,350 --> 00:02:05,010
நாம் இணைக்கப்பட்ட பட்டியல்கள் விவாதிக்கப்படும் போது -

35
00:02:05,010 --> 00:02:09,120
நான் இந்த வரிசையில் ஒரு உறுப்பு சேர்க்க வேண்டும் என்று, தான்

36
00:02:09,120 --> 00:02:11,090
நான் சில சுற்றி மாற்றுவதால் செய்ய வேண்டும் போகிறேன்.

37
00:02:11,090 --> 00:02:12,940
இங்கே எடுத்துக்காட்டாக, இந்த வரிசை

38
00:02:12,940 --> 00:02:16,850
வரிசைப்படுத்தப்பட்ட வரிசையில் உள்ளது - இன் படி ஏறுவரிசையில் வரிசைப்படுத்தப்பட்டுள்ளது -

39
00:02:16,850 --> 00:02:19,440
5, பின்னர் அந்த 7, 8, 10, மற்றும் 20 -

40
00:02:19,440 --> 00:02:23,100
ஆனால் நான் இந்த வரிசையில் இந்த எண் 9 சேர்க்க விரும்பினால்,

41
00:02:23,100 --> 00:02:27,460
நான் இடத்தை அடைவதற்காக உறுப்புகள் சில மாற்ற வேண்டும் போகிறேன்.

42
00:02:27,460 --> 00:02:30,440
நாம் இங்கே இந்த வரைய முடியும்.

43
00:02:30,440 --> 00:02:35,650
நான் 5, 7 நகர்த்த வேண்டும், பின்னர் 8;

44
00:02:35,650 --> 00:02:38,720
, நான் 9 முடியும் ஒரு இடைவெளி உருவாக்க

45
00:02:38,720 --> 00:02:45,910
பின்னர் 10 மற்றும் 20 9 வலது செல்லலாம்.

46
00:02:45,910 --> 00:02:49,450
இந்த ஒரு வலி வகையான ஏனெனில் மிக மோசமான சூழ்நிலையில் -

47
00:02:49,450 --> 00:02:54,350
நாம் தொடக்கத்தில் அல்லது இறுதியில் அல்லது செருக கொண்ட போது

48
00:02:54,350 --> 00:02:56,040
வரிசைக்கு, எப்படி பொறுத்து நாம் மாற்றுவதால் -

49
00:02:56,040 --> 00:02:58,850
நாம் கூறுகள் அனைத்தையும் மாற்ற கொண்ட கூடும்

50
00:02:58,850 --> 00:03:00,750
நாம் தற்போது வரிசையில் சேமித்து என்று.

51
00:03:00,750 --> 00:03:03,810
>> எனவே, இந்த சுற்றி வழி என்ன?

52
00:03:03,810 --> 00:03:09,260
இந்த சுற்றி வழி எங்கே எங்கள் இணைக்கப்பட்ட பட்டியலில் முறை சென்று இருந்தது -

53
00:03:09,260 --> 00:03:19,820
அதற்கு பதிலாக கூறுகள் 5, 7, 8, 10, மற்றும் நினைவகத்தில் ஒருவருக்கொருவர் அடுத்த 20 அனைத்து சேமிக்கும் -

54
00:03:19,820 --> 00:03:25,630
நாம் பதிலாக நாம் சேமிக்க வேண்டும் எங்கிருந்தாலும் அவர்களை வகையான சேமிக்க என்ன

55
00:03:25,630 --> 00:03:32,470
இந்த இணைக்கப்பட்ட பட்டியலில் புள்ளிகளில் இது நான், இங்கே தற்காலிக வகையான வெளியே இழுத்து.

56
00:03:32,470 --> 00:03:42,060
மற்றும் நாம் இந்த அடுத்த சுட்டிகள் பயன்படுத்தி அவர்களை ஒன்றாக இணைக்கப்பட்டுள்ளது.

57
00:03:42,060 --> 00:03:44,370
நான், 5 முதல் 7 மணி வரை ஒரு சுட்டிக்காட்டி முடியும்

58
00:03:44,370 --> 00:03:46,420
7 இருந்து 8 ஒரு சுட்டிக்காட்டி,

59
00:03:46,420 --> 00:03:47,770
8 முதல் 10 வரை சுட்டிக்காட்டி,

60
00:03:47,770 --> 00:03:51,220
இறுதியாக, 10 முதல் 20 ஒரு சுட்டிக்காட்டி,

61
00:03:51,220 --> 00:03:54,880
பின்னர் 20 மணிக்கு பூஜ்ய சுட்டிக்காட்டி இடது ஒன்றுமில்லை என்று சுட்டிக்காட்டியது.

62
00:03:54,880 --> 00:03:59,690
நாம் இங்கே வேண்டும் என்று வர்த்தக பரிமாற்றம்

63
00:03:59,690 --> 00:04:05,360
நாம் வரிசைப்படுத்தப்பட்ட பட்டியலில் எண் 9 சேர்க்க வேண்டும் என்று, இப்போது

64
00:04:05,360 --> 00:04:08,270
நாம் செய்ய வேண்டியதெல்லாம், 9 புதிய கணு உருவாக்க உள்ளது

65
00:04:08,270 --> 00:04:12,290
, பொருத்தமான இடத்தில் சுட்டிக்காட்ட அது கம்பி

66
00:04:12,290 --> 00:04:20,630
பின்னர் மீண்டும் கம்பி 8 9 கீழே சுட்டிக்காட்ட.

67
00:04:20,630 --> 00:04:25,660
என்று நாம் 9 செருக வேண்டுமோ அந்த இடத்தில் நாம் சரியாக தெரியும் அனுமானித்து, மிகவும் சீக்கிரமாக தான்.

68
00:04:25,660 --> 00:04:32,610
ஆனால் இந்த பங்கு வர்த்தக பரிமாற்றத்தை நாம் இப்போது மாறா நேரம் அணுகல் இழந்துவிட்டேன் என்று

69
00:04:32,610 --> 00:04:36,230
எங்கள் தரவு கட்டமைப்பில் எந்த குறிப்பிட்ட உறுப்பு வேண்டும்.

70
00:04:36,230 --> 00:04:40,950
உதாரணமாக, நான் இந்த இணைக்கப்பட்ட பட்டியலில் நான்காவது உறுப்பு கண்டறிய வேண்டும் என்றால்,

71
00:04:40,950 --> 00:04:43,510
நான் பட்டியல் மிக ஆரம்பத்தில் தொடங்க வேண்டும் போகிறேன்

72
00:04:43,510 --> 00:04:48,930
நான் நான்காவது ஒரு கண்டறிய வரை மற்றும் முனை மூலம் கணு எண்ணி மூலம் என் வேலை.

73
00:04:48,930 --> 00:04:55,870
>> ஒரு இணைக்கப்பட்ட பட்டியலில் விட அணுகல் செயல்திறன் பெறுவதற்காக -

74
00:04:55,870 --> 00:04:59,360
ஆனால் நாம் அந்த நன்மைகள் சில தக்கவைத்து

75
00:04:59,360 --> 00:05:01,800
ஒரு இணைக்கப்பட்ட பட்டியலில் இருந்து செருகும் நேர அடிப்படையில் -

76
00:05:01,800 --> 00:05:05,750
ஒரு பைனரி மரம் ஒரு சிறிய மேலும் நினைவக பயன்படுத்த வேண்டும் போகிறது.

77
00:05:05,750 --> 00:05:11,460
குறிப்பாக, அதற்கு பதிலாக ஒரு பைனரி மரம் முனை ஒரு சுட்டிக்காட்டி கொண்டிருக்கும் -

78
00:05:11,460 --> 00:05:13,350
இணைக்கப்பட்ட பட்டியலில் போன்ற முனை இல்லை -

79
00:05:13,350 --> 00:05:16,950
நாம் பைனரி மரம் முனை இரண்டாவது சுட்டிக்காட்டி சேர்க்க போகிறோம்.

80
00:05:16,950 --> 00:05:19,950
மாறாக தான், அடுத்த உறுப்பு ஒரு சுட்டிக்காட்டி கொண்டிருக்கும்

81
00:05:19,950 --> 00:05:24,420
நாம் ஒரு இடது குழந்தை மற்றும் ஒரு சரியான குழந்தை ஒரு சுட்டிக்காட்டி போகிறது.

82
00:05:24,420 --> 00:05:26,560
>> இது உண்மையில் தெரிகிறது என்று பார்க்க ஒரு படம் வரைய வேண்டும்.

83
00:05:26,560 --> 00:05:31,350
மீண்டும், நான் இந்த பெட்டிகள் மற்றும் அம்புகள் பயன்படுத்த போகிறேன்.

84
00:05:31,350 --> 00:05:37,150
ஒரு பைனரி மரம் முனை ஒரு எளிய பெட்டியில் தொடங்குகின்றன.

85
00:05:37,150 --> 00:05:40,940
இது, மதிப்பு ஒரு இடைவெளி வேண்டும் நடக்கிறது

86
00:05:40,940 --> 00:05:47,280
பின்னர் இது இடது குழந்தை மற்றும் வலது குழந்தை ஒரு இடைவெளி வேண்டும் நடக்கிறது.

87
00:05:47,280 --> 00:05:49,280
நான் இங்கே லேபிள் போகிறேன்.

88
00:05:49,280 --> 00:05:57,560
நாம் இடது குழந்தை பெற போகிறோம், மற்றும் நாம் சரியான குழந்தை போகிறது.

89
00:05:57,560 --> 00:05:59,920
இதை பல வழிகள் உள்ளன.

90
00:05:59,920 --> 00:06:02,050
சில நேரங்களில் விண்வெளி மற்றும் வசதிக்காக,

91
00:06:02,050 --> 00:06:06,460
நான் கீழே இங்கே எடுப்பது போல் நான் உண்மையில் அதை வரைய வேண்டும்

92
00:06:06,460 --> 00:06:10,910
நான் மேலே மதிப்பு போகிறேன் எங்கே,

93
00:06:10,910 --> 00:06:14,060
பின்னர் கீழ் வலது வலது குழந்தை,

94
00:06:14,060 --> 00:06:16,060
கீழே இடது மற்றும் இடது குழந்தை.

95
00:06:16,060 --> 00:06:20,250
இந்த உயர்மட்ட வரைபடம் செல்கிறேன்,

96
00:06:20,250 --> 00:06:22,560
நாம், மிக உயர்ந்த மதிப்பு

97
00:06:22,560 --> 00:06:25,560
நாம் இடது குழந்தை சுட்டிக்காட்டி வேண்டும், மற்றும் நாம் வலது குழந்தை சுட்டிக்காட்டி இருக்கிறது.

98
00:06:25,560 --> 00:06:30,110
>> சிக்கல் அமை குறிப்பு இல்,

99
00:06:30,110 --> 00:06:33,110
நாம், ஒரு மதிப்பு 7 என்று ஒரு முனை வரையும் பற்றி பேச

100
00:06:33,110 --> 00:06:39,750
பின்னர் பூஜ்ய என்று ஒரு இடது குழந்தை சுட்டிக்காட்டி, ஒரு வலதுசாரி குழந்தை சுட்டிக்காட்டி பூஜ்ய என்று.

101
00:06:39,750 --> 00:06:46,040
நாம் ஒன்று இடைவெளி மூலதனம் NULL எழுதலாம்

102
00:06:46,040 --> 00:06:51,610
இடது குழந்தை மற்றும் வலது குழந்தை, அல்லது நாங்கள் இருவரும் இந்த குறுக்கு சாய்வு வரைய முடியும்

103
00:06:51,610 --> 00:06:53,750
பெட்டிகள் ஒவ்வொரு மூலம் அது வெற்று என்று குறிக்க.

104
00:06:53,750 --> 00:06:57,560
நான் அந்த எளிமையான விஷயம் தான் அதை செய்ய போகிறேன்.

105
00:06:57,560 --> 00:07:03,700
ஒரு மிக எளிய பைனரி மரம் முனை வரைபட இரண்டு வழிகளில் இங்கு என்ன பார்க்க வேண்டும்

106
00:07:03,700 --> 00:07:07,960
நாம் மதிப்பு 7 மற்றும் பூஜ்ய குழந்தை சுட்டிகள் எங்கே.

107
00:07:07,960 --> 00:07:15,220
>> எப்படி இணைக்கப்பட்ட பட்டியலில் சுமார் எங்கள் விவரக்குறிப்பு பேச்சு இரண்டாம் பகுதி -

108
00:07:15,220 --> 00:07:18,270
நினைவி, நாம் மட்டுமே பட்டியலில் முதல் உறுப்பு மீது நடத்த வேண்டும்

109
00:07:18,270 --> 00:07:20,270
முழு பட்டியலை நினைவில் -

110
00:07:20,270 --> 00:07:26,140
மற்றும் இதேபோல், ஒரு பைனரி மரம் கொண்டு, நாம் மட்டும் மரம் ஒரு சுட்டிக்காட்டி மீது நடத்த வேண்டும்

111
00:07:26,140 --> 00:07:31,120
முழு தரவு அமைப்பு மீதான கட்டுப்பாட்டை தக்க வைத்து கொள்ள.

112
00:07:31,120 --> 00:07:36,150
மரம் இந்த சிறப்பு உறுப்பு மரத்தின் வேர் கணு அழைக்கப்படுகிறது.

113
00:07:36,150 --> 00:07:43,360
உதாரணமாக, இந்த ஒரு முனை - மதிப்பு 7 கொண்ட இந்த கணு

114
00:07:43,360 --> 00:07:45,500
- பூஜ்ய இடது மற்றும் வலது குழந்தை சுட்டிகள் கொண்ட

115
00:07:45,500 --> 00:07:47,360
, நம் மரம் மட்டுமே மதிப்பு இருந்தது

116
00:07:47,360 --> 00:07:50,390
இந்த நம் வேர் கணு வேண்டும்.

117
00:07:50,390 --> 00:07:52,240
அது நம் மரத்தின் ஆரம்பத்தில் தான்.

118
00:07:52,240 --> 00:07:58,530
நாம் மரம் இன்னும் முனைகளில் சேர்க்க முறை நாம் இன்னும் தெளிவாக இந்த ஒரு சிறிய பார்க்க முடியும்.

119
00:07:58,530 --> 00:08:01,510
எனக்கு ஒரு புதிய பக்கம் மேலே நாம்.

120
00:08:01,510 --> 00:08:05,000
>> இப்போது நாம், ரூட் 7 என்று ஒரு மரம் பெற போகிறோம்

121
00:08:05,000 --> 00:08:10,920
மற்றும் இடது குழந்தை, மற்றும் சரியான குழந்தை 9 உள்ளே 3 உள்ளே.

122
00:08:10,920 --> 00:08:13,500
மீண்டும், இந்த அழகான எளிது.

123
00:08:13,500 --> 00:08:26,510
நாம் 7 கிடைத்துவிட்டது, 3 ஒரு முனை, 9 ஒரு முனை, வரைய

124
00:08:26,510 --> 00:08:32,150
மற்றும் நான், 3 கொண்ட முனை சுட்டிக்காட்ட 7 இடது குழந்தை சுட்டிக்காட்டி அமைக்க போகிறேன்

125
00:08:32,150 --> 00:08:37,850
மற்றும் 9 கொண்ட முனை 7 கொண்ட முனையத்தின் வலது குழந்தை சுட்டிக்காட்டி.

126
00:08:37,850 --> 00:08:42,419
இப்போது, 3 முதல் 9, எந்த குழந்தைகள் இல்லை

127
00:08:42,419 --> 00:08:48,500
நாம் பூஜ்ய இருக்கும் தங்கள் குழந்தை சுட்டிகள் அனைத்து அமைக்க போகிறீர்கள்.

128
00:08:48,500 --> 00:08:56,060
இங்கே, நம் மரத்தின் வேர் எண் 7 கொண்ட முனை ஒத்துள்ளது.

129
00:08:56,060 --> 00:09:02,440
நாம் அனைவரும் அந்த வேர் கணு ஒரு சுட்டிக்காட்டி நீங்கள், அந்த பார்க்கலாம்

130
00:09:02,440 --> 00:09:07,330
நாம் நமது மரம் வழியாக நடக்க மற்றும் குழந்தை முனைகள் இரண்டு அணுக முடியும் -

131
00:09:07,330 --> 00:09:10,630
3 மற்றும் 9 ஆகிய இரண்டு.

132
00:09:10,630 --> 00:09:14,820
எந்த மரத்தில் ஒவ்வொரு கணு சுட்டிகளையும் பராமரிக்க வேண்டும்.

133
00:09:14,820 --> 00:09:22,080
அது சரி. இப்போது நாம் இந்த வரைபடம் மற்றொரு முனை சேர்க்க போகிறோம்.

134
00:09:22,080 --> 00:09:25,370
நாம், 6 கொண்ட ஒரு முனை சேர்க்க போகிறோம்

135
00:09:25,370 --> 00:09:34,140
நாங்கள் 3 கொண்ட முனை வலது குழந்தை இந்த சேர்க்க போகிறோம்.

136
00:09:34,140 --> 00:09:41,850
அதை செய்ய, நான் 3-முனை என்று பூஜ்ய சுட்டிக்காட்டி அழிக்க போகிறேன்

137
00:09:41,850 --> 00:09:47,750
மற்றும் 6 கொண்ட முனை சுட்டிக்காட்ட அது கம்பி. அது சரி.

138
00:09:47,750 --> 00:09:53,800
>> இந்த கட்டத்தில், இன் சொல் சிறிது மீது செல்லலாம்.

139
00:09:53,800 --> 00:09:58,230
, இந்த குறிப்பிட்ட ஒரு பைனரி மரம் என்று காரணம் தொடங்க

140
00:09:58,230 --> 00:10:00,460
இரண்டு குழந்தை சுட்டிகள் இருக்கிறது.

141
00:10:00,460 --> 00:10:06,020
மேலும் குழந்தை சுட்டிகள் என்று மரங்கள் மற்ற வகையான உள்ளன.

142
00:10:06,020 --> 00:10:10,930
குறிப்பாக, நீங்கள் ஒரு பிரச்சினை அமை 5 ல் 'முயற்சி' என்று.

143
00:10:10,930 --> 00:10:19,310
நீங்கள் முயற்சித்து என்று கவனிக்க வேண்டும், நீங்கள் வேறு குழந்தைகளுக்கு 27 வெவ்வேறு சுட்டிகள் இருந்தது -

144
00:10:19,310 --> 00:10:22,410
ஆங்கிலம் எழுத்துக்களில் 26 எழுத்துக்கள் ஒவ்வொன்றும் ஒரு,

145
00:10:22,410 --> 00:10:25,410
பின்னர் மேற்கோளைச் க்கு 27 -

146
00:10:25,410 --> 00:10:28,900
எனவே, அந்த மரத்தில் ஒரு வகை போல தான்.

147
00:10:28,900 --> 00:10:34,070
ஆனால் இங்கே, அது பைனரி இருந்து, நாம் மட்டும் இரண்டு குழந்தை சுட்டிகள் வேண்டும்.

148
00:10:34,070 --> 00:10:37,880
>> நாம் பற்றி பேசினார் என்று இந்த வேர் கணு கூடுதலாக,

149
00:10:37,880 --> 00:10:41,470
நாம் இந்த கால சுற்றி எறிந்து 'குழந்தை.'

150
00:10:41,470 --> 00:10:44,470
ஒரு முனை மற்றொரு முனை ஒரு குழந்தை இருக்கிறது அது என்ன அர்த்தம்?

151
00:10:44,470 --> 00:10:54,060
அது உண்மையில் ஒரு குழந்தை முனை மற்றொரு முனை ஒரு குழந்தை என்று தான் அர்த்தம்

152
00:10:54,060 --> 00:10:58,760
மற்ற முனை என்று முனை சுட்டிக்காட்ட அமைக்க அதன் குழந்தை சுட்டிகள் ஒன்று இருந்தால்.

153
00:10:58,760 --> 00:11:01,230
இந்த, இன்னும் உறுதியான விதிமுறைகளை கொண்டு வைக்க

154
00:11:01,230 --> 00:11:11,170
3 7 குழந்தை சுட்டிகள் ஒருவர் சுட்டிக்காட்டினார் என்றால், பிறகு 3 7 ஒரு குழந்தை உள்ளது.

155
00:11:11,170 --> 00:11:14,510
- நாங்கள் 7 குழந்தைகள் என்ன கண்டுபிடிக்க இருந்தால்

156
00:11:14,510 --> 00:11:18,510
நன்றாக, நாம், 7 3 ஒரு சுட்டிக்காட்டி மற்றும் 9 ஒரு சுட்டிக்காட்டி உள்ளது என்று பார்க்க

157
00:11:18,510 --> 00:11:22,190
அதனால் 9 மற்றும் 3 7 குழந்தைகள்.

158
00:11:22,190 --> 00:11:26,650
ஒன்பது அதன் குழந்தை சுட்டிகள் பூஜ்ய ஏனெனில் குழந்தைகள் உள்ளது,

159
00:11:26,650 --> 00:11:30,940
மற்றும் 3 ஒரே ஒரு குழந்தை, 6 கொண்டுள்ளது.

160
00:11:30,940 --> 00:11:37,430
அதன் சுட்டிகள் இருவரும் நாம் இப்போது வரைய வேண்டும் என்ற வெற்று, ஏனெனில் ஆறு கூட இல்லை குழந்தைகள் உள்ளன.

161
00:11:37,430 --> 00:11:45,010
>> மேலும், நாம், ஒரு குறிப்பிட்ட முனை பெற்றோர் பற்றி பேச

162
00:11:45,010 --> 00:11:51,100
நீங்கள் எதிர்பார்க்க அப்படியே இந்த, இந்த குழந்தை விளக்கம் தலைகீழ் ஆகும்.

163
00:11:51,100 --> 00:11:58,620
அதற்கு பதிலாக இரண்டு மனிதர்களின் உடன் எதிர்பார்க்க முடியும் என - ஒவ்வொரு முனையும் ஒரு பெற்றோர் உள்ளது.

164
00:11:58,620 --> 00:12:03,390
உதாரணமாக, 3 பெற்றோர் 7.

165
00:12:03,390 --> 00:12:10,800
9 பெற்றோர் மேலும் 7 மற்றும் 6 பெற்றோர் 3. அது ஒன்றும் இல்லை.

166
00:12:10,800 --> 00:12:15,720
நாங்கள், தாத்தா, பாட்டி மற்றும் பேரப்பிள்ளைகள் பற்றி பேச வார்த்தைகள் இல்லை

167
00:12:15,720 --> 00:12:18,210
மேலும் பொதுவாக நாம் முன்னோர்கள் பற்றி பேச

168
00:12:18,210 --> 00:12:20,960
ஒரு குறிப்பிட்ட முனை வம்சாவளிகள்.

169
00:12:20,960 --> 00:12:25,710
ஒரு முனை என்ற மாறாக அல்லது முன்னோர்கள்,, - ஒரு முனையத்தின் மூதாதையர் -

170
00:12:25,710 --> 00:12:32,730
ரூட் இருந்து அந்த முனை பாதையில் பொய் என்று முனைகளில் அனைத்தும்.

171
00:12:32,730 --> 00:12:36,640
உதாரணமாக, நான் முனை 6 பார்த்துக்கொண்டிருக்கிறேன் என்றால்,

172
00:12:36,640 --> 00:12:46,430
பின்னர் முன்னோர்கள் 3 மற்றும் 7 ஆகிய இரு போகிறீர்கள்.

173
00:12:46,430 --> 00:12:55,310
9 முன்னோர்கள், உதாரணத்திற்கு, அவை - நான் முனை 9 பார்த்துக்கொண்டிருக்கிறேன் என்றால் -

174
00:12:55,310 --> 00:12:59,990
பின்னர் 9 மூதாதையர் தான் 7.

175
00:12:59,990 --> 00:13:01,940
மற்றும் மரபினர் சரியாக தலைகீழ் இருக்கும்.

176
00:13:01,940 --> 00:13:05,430
நான் 7 வம்சாவளியினரை அனைத்து பார்க்க விரும்பினால்,

177
00:13:05,430 --> 00:13:11,020
நான் அதை கீழே முனைகள் அனைத்து பார்க்க வேண்டும்.

178
00:13:11,020 --> 00:13:16,950
எனவே, நான் 7 வம்சாவளிகள் 3, 9, மற்றும் 6 அனைத்து வேண்டும்.

179
00:13:16,950 --> 00:13:24,170
>> நாம் பற்றி பேசுவேன் என்று இறுதி கால ஒரு சகோதரர் என்று இந்த கருத்து உள்ளது.

180
00:13:24,170 --> 00:13:27,980
உடன்பிறப்புகளின் - இந்த குடும்ப நிபந்தனைகளை சேர்த்து தொடர்ந்து வகையான -

181
00:13:27,980 --> 00:13:33,150
மரம் அதே அளவில் இருக்கும் என்று முனைகள் இருக்கும்.

182
00:13:33,150 --> 00:13:42,230
அவர்கள் மரம் அதே அளவில் இருப்பதால் எனவே, 3 மற்றும் 9 உடன்பிறப்புகள் உள்ளனர்.

183
00:13:42,230 --> 00:13:46,190
அவர்கள் இருவரும் அதே பெற்றோர், 7 வேண்டும்.

184
00:13:46,190 --> 00:13:51,400
9 எந்த குழந்தைகள் இல்லை, ஏனெனில் 6 உடன்பிறப்புகளின் உள்ளது.

185
00:13:51,400 --> 00:13:55,540
அது நம் மரத்தின் வேர் காரணம் மற்றும் 7, எந்த உடன்பிறப்புகள் இல்லை

186
00:13:55,540 --> 00:13:59,010
தான் எப்போதும் 1 ரூட் உள்ளது.

187
00:13:59,010 --> 00:14:02,260
7 உடன்பிறப்புகள் வேண்டும் அங்கு 7 மேலே ஒரு முனை இருக்க வேண்டும்.

188
00:14:02,260 --> 00:14:07,480
இனி மரத்தின் வேர் என வழக்கு 7 7 ஒரு பெற்றோர், இருக்க வேண்டும்.

189
00:14:07,480 --> 00:14:10,480
பின்னர் 7 புதிய பெற்றோர் கூட, ஒரு குழந்தை வேண்டும்

190
00:14:10,480 --> 00:14:16,480
மற்றும் அந்த குழந்தை 7 உறவினருடன் வேண்டும்.

191
00:14:16,480 --> 00:14:21,040
>> அது சரி. செல்லும்.

192
00:14:21,040 --> 00:14:24,930
நாம் பைனரி மரங்கள் எங்கள் விவாதம் தொடங்கிய போது,

193
00:14:24,930 --> 00:14:28,790
நாம் அவற்றை பயன்படுத்த போகிறோம் என்பதை பற்றி பேசினார்

194
00:14:28,790 --> 00:14:32,800
கோவை மற்றும் தொடர்புடைய பட்டியல்கள் இரு மீது அனுகூலத்தையும் பெற.

195
00:14:32,800 --> 00:14:37,220
மற்றும் நாம் அதை செய்ய போகிறோம் வழி இந்த ஆர்டர் சொத்து உள்ளது.

196
00:14:37,220 --> 00:14:41,080
நாம், விவரக்குறிப்பு படி, ஒரு பைனரி மரம் உத்தரவிட்டார் என்று கூற

197
00:14:41,080 --> 00:14:45,740
எங்கள் மரம் ஒவ்வொரு முனையின் என்றால், இடது அதன் சந்ததிகள் அனைத்து -

198
00:14:45,740 --> 00:14:48,670
இடது குழந்தை மற்றும் இடது குழந்தையின் சந்ததிகள் அனைத்து -

199
00:14:48,670 --> 00:14:54,510
குறைந்த மதிப்புகள், மற்றும் வலது முனைகளில் அனைத்து வேண்டும் -

200
00:14:54,510 --> 00:14:57,770
வலது குழந்தை மற்றும் வலது குழந்தையின் சந்ததிகள் அனைத்து -

201
00:14:57,770 --> 00:15:02,800
நாம் பார்த்து வருகிறோம் என்று தற்போதைய முனை மதிப்பை விட முனைகளில் வேண்டும்.

202
00:15:02,800 --> 00:15:07,850
ஒரு எளிமை வேண்டும், நாம் நமது மரம் எந்த பிரதி முனைகளில் இல்லை என்று கருதி போகிறோம்.

203
00:15:07,850 --> 00:15:11,180
எடுத்துக்காட்டாக, இந்த மரத்தில் நாங்கள் வழக்கு சமாளிக்க போவதில்லை

204
00:15:11,180 --> 00:15:13,680
நாம் வேரில் மதிப்பு 7 எங்கே

205
00:15:13,680 --> 00:15:16,720
 பின்னர் நாங்கள் மதிப்பு வேறு கிளையில் 7 வேண்டும்.

206
00:15:16,720 --> 00:15:24,390
இந்த வழக்கில், நீங்கள் இந்த மரம் உண்மையில் உத்தரவிட்டார் என்று கவனிக்க வேண்டும்.

207
00:15:24,390 --> 00:15:26,510
நாம் வேரில் மதிப்பு 7 வேண்டும்.

208
00:15:26,510 --> 00:15:29,720
7 இடது எல்லாம் -

209
00:15:29,720 --> 00:15:35,310
நான் இங்கே இந்த சிறிய மதிப்பெண்கள் அனைத்து மீளமை என்றால் -

210
00:15:35,310 --> 00:15:40,450
7 இடது எல்லாம் - 3 மற்றும் 6 -

211
00:15:40,450 --> 00:15:49,410
அந்த மதிப்புகளை இரண்டு 7 விட குறைவாக, மற்றும் உரிமை அனைத்தையும் - இந்த 9 என்பது -

212
00:15:49,410 --> 00:15:53,450
7 அதிகமாக இருக்கும்.

213
00:15:53,450 --> 00:15:58,650
>> இந்த மதிப்புகள் கொண்ட மட்டும் உத்தரவிட்டார் மரம் அல்ல,

214
00:15:58,650 --> 00:16:03,120
ஆனால் அவர்களுக்கு ஒரு சில வரைய வேண்டும்.

215
00:16:03,120 --> 00:16:05,030
நாம் இதை செய்ய முடியும் என்று பல வழிகளில் மொத்தமாக உண்மையில் உள்ளது.

216
00:16:05,030 --> 00:16:09,380
நான் எங்கே விஷயங்களை எளிமையாக வைத்து ஒரு சுருக்கெழுத்து பயன்படுத்த போகிறேன் -

217
00:16:09,380 --> 00:16:11,520
மாறாக பெட்டிகள் மற்றும் அம்புகள் முழுவதும் வெளியே இழுத்து விட -

218
00:16:11,520 --> 00:16:14,220
நான் எண்களை வரைந்து அவற்றை இணைக்கும் அம்புகள் சேர்க்க போகிறேன்.

219
00:16:14,220 --> 00:16:22,920
, ஒரு 3 பின், தொடங்க நாங்கள் 7 எங்கே நாம் மீண்டும் எமது உண்மையான மரம் எழுத வேண்டும், மற்றும்

220
00:16:22,920 --> 00:16:25,590
பின்னர் 3, 6 உரிமை மீண்டும் சுட்டிக்காட்டினார்

221
00:16:25,590 --> 00:16:30,890
மற்றும் 7 9 என்று ஒரு சரியான குழந்தை இருந்தது.

222
00:16:30,890 --> 00:16:33,860
அது சரி. இந்த மரம் எழுத முடியும் என்று மற்றொரு வழி என்ன?

223
00:16:33,860 --> 00:16:38,800
3 கொண்டு, 7 இடது குழந்தை பதிலாக

224
00:16:38,800 --> 00:16:41,360
நாங்கள் 6, 7 இடது குழந்தை முடியும்

225
00:16:41,360 --> 00:16:44,470
பின்னர் 3 6 இடது குழந்தை.

226
00:16:44,470 --> 00:16:48,520
நான் 7 கிடைத்தது அந்த இங்கே, இந்த மரம் போன்று இருக்கும்

227
00:16:48,520 --> 00:16:57,860
பின்னர் 6, 3, மற்றும் சரியான ஒரு 9.

228
00:16:57,860 --> 00:17:01,490
நாம் நம் வேர் கணு 7 வேண்டும் இல்லை.

229
00:17:01,490 --> 00:17:03,860
நாம் நம் வேர் கணு போன்ற 6 முடியும்.

230
00:17:03,860 --> 00:17:06,470
என்ன இருக்க முடியும் என்று?

231
00:17:06,470 --> 00:17:09,230
இந்த உத்தரவு சொத்து பராமரிக்க போகிறீர்கள் என்றால்,

232
00:17:09,230 --> 00:17:12,970
6 இடது எல்லாம் அதை விட குறைவாக இருக்க வேண்டும்.

233
00:17:12,970 --> 00:17:16,540
அங்கு ஒரே ஒரு வாய்ப்பு, அதாவது 3 உள்ளது.

234
00:17:16,540 --> 00:17:19,869
ஆனால் பின்னர் 6 உரிமை குழந்தை, நாம் இரண்டு சாத்தியக்கூறுகள் உள்ளன.

235
00:17:19,869 --> 00:17:25,380
முதல், நாம், 9 பின்னர் 7 மற்றும் முடியும்

236
00:17:25,380 --> 00:17:28,850
அல்லது நாம் அதை பெற முடியும் - நான் இங்கே செய்ய உள்ளேன் போல் -

237
00:17:28,850 --> 00:17:34,790
நாங்கள் 6 உரிமை குழந்தை 9 எங்கே,

238
00:17:34,790 --> 00:17:39,050
பின்னர் 9 இடது குழந்தை 7.

239
00:17:39,050 --> 00:17:44,240
>> இப்போது, 7 மற்றும் 6 ரூட் மட்டுமே சாத்தியம் மதிப்புகள் இல்லை.

240
00:17:44,240 --> 00:17:50,200
நாங்கள் 3 ரூட் இருக்க முடியும்.

241
00:17:50,200 --> 00:17:52,240
3 ரூட் உள்ளது என்றால் என்ன நடக்கும்?

242
00:17:52,240 --> 00:17:54,390
இங்கே, சிறிது சுவாரசியமான கிடைக்கும்.

243
00:17:54,390 --> 00:17:58,440
மூன்று, அதை விட குறைவாக எந்த மதிப்புகள் இல்லை

244
00:17:58,440 --> 00:18:02,070
அதனால் மரத்தின் முழு இடது பக்க வெறும் வெற்று போகிறது.

245
00:18:02,070 --> 00:18:03,230
அங்கு எதுவும் இருக்க போவதில்லை.

246
00:18:03,230 --> 00:18:07,220
சரி, நாம் ஏறுவரிசையில் விஷயங்களை பட்டியலிட முடியும்.

247
00:18:07,220 --> 00:18:15,530
நாம் பின்னர் 3, பின்னர் 6, 7, 9 முடியும்.

248
00:18:15,530 --> 00:18:26,710
அல்லது, நாம் 7, பின், பிறகு, 9 6 3 செய்ய.

249
00:18:26,710 --> 00:18:35,020
அல்லது, நாம் 9, பின், பிறகு, 6 ​​7 3 செய்ய.

250
00:18:35,020 --> 00:18:40,950
அல்லது, 3, 7 - உண்மையில் இல்லை, நாம் இனி ஒரு 7 செய்ய முடியாது.

251
00:18:40,950 --> 00:18:43,330
அங்கு நம் ஒரு விஷயம்.

252
00:18:43,330 --> 00:18:54,710
நாம் 9 செய்ய முடியும், அதன் பிறகு 9 இருந்து நாம் 7 பிறகு 6 செய்ய முடியும்.

253
00:18:54,710 --> 00:19:06,980
அல்லது, நாம், பின், 7, 9 3 செய்ய, பின்னர் 6 முடியும்.

254
00:19:06,980 --> 00:19:12,490
>> இங்கே உங்கள் கவனத்திற்கு ஒரு விஷயம்

255
00:19:12,490 --> 00:19:14,510
இந்த மரங்கள் சற்றே காணப்படும் என்று.

256
00:19:14,510 --> 00:19:17,840
குறிப்பாக, நாம் வலது புறத்தில் 4 மரங்கள் பாருங்கள் -

257
00:19:17,840 --> 00:19:20,930
நான் இங்கே, அவர்கள் வட்டமிட்டு வேண்டும் -

258
00:19:20,930 --> 00:19:28,410
இந்த மரங்கள் ஒரு இணைக்கப்பட்ட பட்டியலில் போன்ற கிட்டத்தட்ட சரியாக இருக்கும்.

259
00:19:28,410 --> 00:19:32,670
ஒவ்வொரு முனையும், ஒரே ஒரு குழந்தை உள்ளது

260
00:19:32,670 --> 00:19:38,950
அதனால் நாம், உதாரணமாக, நாம் பார்க்க இந்த மரம் போன்ற அமைப்பு எந்த இல்லை

261
00:19:38,950 --> 00:19:44,720
 கீழே இடது இங்கு இந்த ஒரு தனி மரம்.

262
00:19:44,720 --> 00:19:52,490
இந்த மரங்கள் உண்மையில், பைனரி மரங்கள் சிதைந்த அழைக்கப்படுகின்றன

263
00:19:52,490 --> 00:19:54,170
நாம் எதிர்காலத்தில் இந்த அதிக பற்றி பேசுவோம் -

264
00:19:54,170 --> 00:19:56,730
நீங்கள் மற்ற கணினி அறிவியல் படிப்புகள் எடுத்து சென்று குறிப்பாக.

265
00:19:56,730 --> 00:19:59,670
இந்த மரங்கள் சிதைந்த இருக்கும்.

266
00:19:59,670 --> 00:20:03,780
உண்மையில், இந்த அமைப்பு தன்னை வழங்கியிருக்கிறது ஏனெனில் அவர்கள் மிகவும் பயனுள்ளதாக இருக்கும்

267
00:20:03,780 --> 00:20:08,060
 ஒரு இணைக்கப்பட்ட பட்டியலில் ஒத்த முறை தேடல் வேண்டும்.

268
00:20:08,060 --> 00:20:13,050
நாம் கூடுதல் நினைவகத்தை பயன்படுத்தி கொள்ள கூடாது - இந்த கூடுதல் சுட்டிக்காட்டி -

269
00:20:13,050 --> 00:20:18,840
ஏனெனில் எங்கள் அமைப்பு இந்த வழியில் மோசமான இருப்பது.

270
00:20:18,840 --> 00:20:24,700
போ மற்றும் ரூட் உள்ள 9 என்று பைனரி மரங்கள் வெளியே இழுத்து விட,

271
00:20:24,700 --> 00:20:27,220
நாம் என்று இறுதி நிகழ்வில், அது

272
00:20:27,220 --> 00:20:32,380
நாம் இந்த மற்ற கால பற்றி கொஞ்சம் பேச போகிறேன், இந்த கட்டத்தில், அதற்கு பதிலாக தான்

273
00:20:32,380 --> 00:20:36,150
உயரம் அழைக்கப்படும் மரங்கள், பற்றி பேசும் போது நாம் பயன்படுத்தும்.

274
00:20:36,150 --> 00:20:45,460
>> ஒரு மரத்தின் உயரம், ரூட் இருந்து மிகவும் தொலைவில் உள்ள முனை தூரத்தில் இல்லை

275
00:20:45,460 --> 00:20:48,370
அல்லது நீங்கள் பொருட்டு செய்ய வேண்டும் என்று ஹாப்ஸ் எண்ணிக்கை

276
00:20:48,370 --> 00:20:53,750
ரூட் இருந்து ஆரம்பித்து பின்னர் மரம் மிக-தொலைதூர முனை மணிக்கு முடிவடையும்.

277
00:20:53,750 --> 00:20:57,330
நாம் இங்கே வரையப்பட்ட செய்த இந்த மரங்கள் சில, பார்த்தால்

278
00:20:57,330 --> 00:21:07,870
நாம், 3 மணிக்கு நாங்கள் மேல் இடது மூலையில் இந்த மரம் எடுத்து நாம் தொடங்கலாம் என்று பார்க்கலாம்

279
00:21:07,870 --> 00:21:14,510
நாம் 1 ஹாப் 6 பெற, 7 பெற இரண்டாவது ஹாப், செய்ய வேண்டும்

280
00:21:14,510 --> 00:21:20,560
ஒரு மூன்றாவது ஹாப் 9 பெற.

281
00:21:20,560 --> 00:21:26,120
எனவே, இந்த மரத்தின் உயரம் 3.

282
00:21:26,120 --> 00:21:30,640
நாம், இந்த பச்சை மூலம் கோடிட்டு மற்ற மரங்கள் அதே உடற்பயிற்சி செய்ய

283
00:21:30,640 --> 00:21:40,100
நாம் இந்த மரங்கள் அனைத்தும் உயரம் உண்மையில் மேலும் 3 என்று பார்க்க.

284
00:21:40,100 --> 00:21:45,230
அவர்களுக்கு சிதைந்த என்பதை ஒரு பகுதி -

285
00:21:45,230 --> 00:21:53,750
அவற்றின் உயரம், முழு மரம் முனைகளுக்கிடையே எண்ணிக்கை விட ஒரு குறைந்த என்று.

286
00:21:53,750 --> 00:21:58,400
நாம் மறுபுறத்தில் சிவப்பு உடன் படர்ந்துள்ளன என்று இந்த மற்ற மரம், பார்த்தால்

287
00:21:58,400 --> 00:22:03,920
நாம் மிகவும் தொலைவில் இலை முனைகள் 6 மற்றும் 9 என்று பார்க்க -

288
00:22:03,920 --> 00:22:06,940
குழந்தைகள் இல்லை என்று அந்த முனைகளில் இருந்து விட்டு.

289
00:22:06,940 --> 00:22:11,760
எனவே, வேர் கணு இருந்து 6 அல்லது 9 அல்லது பெற வேண்டும்,

290
00:22:11,760 --> 00:22:17,840
நாம், 7 பெற ஒரு ஹாப் செய்ய வேண்டும் பின்னர் 9 பெற இரண்டாவது ஹாப்

291
00:22:17,840 --> 00:22:21,240
மற்றும் இதேபோல், 7 மட்டுமே இரண்டாவது ஹாப் 6 பெற.

292
00:22:21,240 --> 00:22:29,080
எனவே, இங்கு இந்த மரத்தின் உயரம் மட்டுமே 2.

293
00:22:29,080 --> 00:22:35,330
நீங்கள் திரும்பி சென்று நாம் முன்னரே விவாதிக்கப்பட்ட மற்ற மரங்களை எல்லாம் செய்ய முடியும்

294
00:22:35,330 --> 00:22:37,380
7 மற்றும் 6 தொடங்கி,

295
00:22:37,480 --> 00:22:42,500
நீங்கள் அந்த மரங்கள் அனைத்தும் உயரம் மேலும் 2 என்று கண்டுபிடிக்க வேண்டும்.

296
00:22:42,500 --> 00:22:46,320
>> நாம் பற்றி பேசி கொண்டிருக்கிறேன் காரணம் பைனரி மரங்கள் உத்தரவிட்டார்

297
00:22:46,320 --> 00:22:50,250
நீங்கள் அவர்களை மூலம் தேட முடியும் என்பதால் மற்றும் அவர்கள் ஏன் அமைதியாக இருக்கிறீர்கள் என்று

298
00:22:50,250 --> 00:22:53,810
ஒரு வரிசைப்படுத்தப்பட்ட வரிசை தேட ஒரு ஒத்த வழி.

299
00:22:53,810 --> 00:22:58,720
இந்த நாங்கள் மேம்பட்ட தேடல் நேரம் கிடைக்கும் பற்றி பேச எங்கே

300
00:22:58,720 --> 00:23:02,730
எளிய இணைக்கப்பட்ட பட்டியலில் மேல்.

301
00:23:02,730 --> 00:23:05,010
ஒரு இணைக்கப்பட்ட பட்டியல் - நீங்கள் ஒரு குறிப்பிட்ட உறுப்பு கண்டுபிடிக்க வேண்டும் என்றால் -

302
00:23:05,010 --> 00:23:07,470
நீங்கள் சிறந்த நேர்கோட்டு தேடல் ஒருவித செய்ய இருக்கிறாய்

303
00:23:07,470 --> 00:23:10,920
நீங்கள் ஒரு பட்டியல் மற்றும் ஹாப் ஒரு மூலம் ஒரு ஆரம்பத்தில் தொடங்க அங்கு -

304
00:23:10,920 --> 00:23:12,620
ஒரு முனை ஒரு முனை -

305
00:23:12,620 --> 00:23:16,060
நீங்கள் தேடும் என்ன வரும் வரை முழு பட்டியல் மூலம்.

306
00:23:16,060 --> 00:23:19,440
, இந்த நல்ல வடிவம் சேமிக்கப்பட்டுள்ள ஒரு பைனரி மரம் இருந்தால், அதேசமயம்

307
00:23:19,440 --> 00:23:23,300
நீங்கள் உண்மையில் நடக்கிறது ஒரு பைனரி தேடல் இன்னும் பெற முடியும்

308
00:23:23,300 --> 00:23:25,160
நீங்கள் பிரித்து வெற்றி உள்ளூரில்

309
00:23:25,160 --> 00:23:29,490
ஒவ்வொரு படியிலும் மரத்தின் பொருத்தமான பாதி மூலம் தேடல்.

310
00:23:29,490 --> 00:23:32,840
அது அந்த பணிகளை எப்படி என்று பார்ப்போம்.

311
00:23:32,840 --> 00:23:38,850
>> நாம் இருந்தால் - மீண்டும், நமது உண்மையான மரம் செல்கிறேன் -

312
00:23:38,850 --> 00:23:46,710
நாம், வலது, நாம் இடது 3 வேண்டும், 7 மணிக்கு 9 தொடங்க

313
00:23:46,710 --> 00:23:51,740
மற்றும் 3 அடியில் நாங்கள் 6 வேண்டும்.

314
00:23:51,740 --> 00:24:01,880
இந்த மரத்தில் எண் 6 தேட வேண்டும் என்றால், நாம் ரூட் துவங்க விரும்புகிறோம்.

315
00:24:01,880 --> 00:24:08,910
நாம், 6 கூற, தேடும் மதிப்பு ஒப்பிட்டு என்று

316
00:24:08,910 --> 00:24:12,320
நாம் தற்போது 7, மணிக்கு தேடும் முனை சேமிக்கப்படும் மதிப்பு,

317
00:24:12,320 --> 00:24:21,200
6 உண்மையில் குறைவாக 7, எனவே நாம் இடது நகர என்று கண்டறிய.

318
00:24:21,200 --> 00:24:25,530
6 மதிப்பு 7 அதிகமாக இருந்தால், நாம் அதற்கு சென்றார்.

319
00:24:25,530 --> 00:24:29,770
எங்களுக்கு தெரியும் என்பதால் - நமது உத்தரவிட்டார் பைனரி மரம் கட்டமைப்பு காரணமாக -

320
00:24:29,770 --> 00:24:33,910
7 குறைவான மதிப்புகள் அனைத்து, 7 இடது சேமித்து வைக்க போகிறோம்

321
00:24:33,910 --> 00:24:40,520
கூட மரம் வலது பக்க வழியாக பார்த்து கவலை தேவையில்லை.

322
00:24:40,520 --> 00:24:43,780
ஒருமுறை நாங்கள் இடது செல்ல நாங்கள் 3 கொண்ட முனை இப்போது தான்

323
00:24:43,780 --> 00:24:48,110
நாங்கள் 3 மற்றும் 6 ஒப்பிட்டு அங்கு நாம் மீண்டும் அதே ஒப்பீடு செய்ய முடியும்.

324
00:24:48,110 --> 00:24:52,430
, 3 விட அதிகமாக இருக்கும் - நாம் தேடும் மதிப்பு - நாம் போது 6 என்று கண்டறிய

325
00:24:52,430 --> 00:24:58,580
நாங்கள் 3 கொண்ட முனை வலது பக்க செல்லலாம்.

326
00:24:58,580 --> 00:25:02,670
இல்லை இடது பக்க இங்கே தான், நாம் அந்த அலட்சியம் முடியும்.

327
00:25:02,670 --> 00:25:06,510
ஆனால் நாம் மட்டும், நாம் மரம் தன்னை தேடும் காரணம் என்று

328
00:25:06,510 --> 00:25:08,660
நாம் மரம் குழந்தைகள் என்று பார்க்கலாம்.

329
00:25:08,660 --> 00:25:13,640
>> அதை, நாம் மனிதர்கள் என நம்மை செய்கிறீர்கள் என்றால் இந்த கிளையில் 6 பார்க்க கூட அழகாக எளிதாக

330
00:25:13,640 --> 00:25:16,890
ஆனால் என்ன என்று ஒரு கணினி போன்ற இயந்திர இந்த செயல்முறை பின்பற்ற நாம்

331
00:25:16,890 --> 00:25:18,620
உண்மையில் வழிமுறை புரிந்து கொள்ள.

332
00:25:18,620 --> 00:25:26,200
இந்த கட்டத்தில், நாம் இப்போது, 6 கொண்ட ஒரு முனை பார்க்க

333
00:25:26,200 --> 00:25:29,180
நாம், மதிப்பு 6 தேடுகிறீர்கள்

334
00:25:29,180 --> 00:25:31,740
எனவே, உண்மையில், நாம் சரியான கணு எதுவும் காணப்படவில்லை.

335
00:25:31,740 --> 00:25:35,070
நாம் கிளையில் மதிப்பு 6 கண்டு, நாம் நமது தேடலை நிறுத்த முடியும்.

336
00:25:35,070 --> 00:25:37,330
இந்த கட்டத்தில், என்ன நடக்கிறது என்பதை பொறுத்து,

337
00:25:37,330 --> 00:25:41,870
நாம் சொல்ல முடியும், ஆம், நாம் மதிப்பு 6 கிடைத்தது, அது எங்கள் மரம் உள்ளது.

338
00:25:41,870 --> 00:25:47,640
நாம் ஏதாவது ஒரு முனை செருக அல்லது செய்ய திட்டம் என்றால் அல்லது, நாம் இந்த நேரத்தில் அதை செய்ய முடியும்.

339
00:25:47,640 --> 00:25:53,010
>> எப்படி இந்த வேலை பார்க்க இன்னும் இரண்டு ஐ செய்வோம்.

340
00:25:53,010 --> 00:25:59,390
நாம் முயற்சி மற்றும் மதிப்பு 10 வரை இருக்கும் என்றால் என்ன பார்க்கிறேன்.

341
00:25:59,390 --> 00:26:02,970
நாம் மதிப்பு 10 பார்க்க இருந்தால், நாம் ரூட் துவங்க வேண்டும்.

342
00:26:02,970 --> 00:26:07,070
நாங்கள் 10 7 விட அதிகம் என்று பார்க்க விரும்புகிறேன், எனவே சரியான செல்ல விரும்புகிறேன்.

343
00:26:07,070 --> 00:26:13,640
நாம் 9 பெற மற்றும் 10 9 ஒப்பிட்டு மற்றும் 9 உண்மையில் குறைவாக 10 என்று பார்க்க விரும்புகிறேன்.

344
00:26:13,640 --> 00:26:16,210
எனவே மீண்டும், நாம் சரியான செல்ல முயற்சி என்று.

345
00:26:16,210 --> 00:26:20,350
ஆனால் இந்த கட்டத்தில், நாம் ஒரு வெற்று முனை இருக்கும்போது என்று கவனிக்க வேண்டும்.

346
00:26:20,350 --> 00:26:23,080
ஒன்றும் இல்லை. 10 இருக்க வேண்டும், அங்கு ஒன்றுமில்லை.

347
00:26:23,080 --> 00:26:29,360
மரம் இல்லை 10 உண்மையில் இல்லை என்று - நாம் தோல்வி குறித்து முடியும் இது.

348
00:26:29,360 --> 00:26:35,420
இறுதியாக, நாம் கிளையில் 1 தேட முயற்சிக்கும் அங்கு வழக்கு வழியாக செல்லலாம்.

349
00:26:35,420 --> 00:26:38,790
இந்த, நாங்கள் 10 வரை இருக்கும் என்றால் என்ன பதில் சொல்வது செல்லும் தவிர, அது போல

350
00:26:38,790 --> 00:26:41,260
நாம் இடது செல்ல போகிறோம்.

351
00:26:41,260 --> 00:26:46,170
நாம் 7 மணிக்கு தொடங்கி 1 7 குறைவாக உள்ளது என்று பார்க்க, நாம் இடது நகர்த்த.

352
00:26:46,170 --> 00:26:51,750
நாங்கள் 3 பெற மற்றும் 1 3 விட குறைவாக உள்ளது என்று பார்க்க, எனவே மீண்டும் நாம் இடது செல்ல முயற்சி.

353
00:26:51,750 --> 00:26:59,080
இந்த இடத்தில் நாம் ஒரு வெற்று முனை வேண்டும், எனவே மீண்டும் நாம் தோல்வி குறித்து முடியும்.

354
00:26:59,080 --> 00:27:10,260
>> நீங்கள், பைனரி மரங்கள் பற்றி மேலும் அறிய வேண்டும் என்றால்

355
00:27:10,260 --> 00:27:14,420
நீங்கள் செய்ய முடியாது என்று வேடிக்கையாக சிறிய பிரச்சினைகள் ஒரு மொத்தமாக உள்ளன.

356
00:27:14,420 --> 00:27:19,450
நான் இந்த வரைபடங்களை ஒரு மூலம் ஒரு சித்திரம் அவுட் பயிற்சி

357
00:27:19,450 --> 00:27:21,910
மேலும், பல்வேறு நடவடிக்கைகளை அனைத்து மூலம் தொடர்ந்து

358
00:27:21,910 --> 00:27:25,060
இந்த சூப்பர் கைக்குள் வரும் என்பதால்

359
00:27:25,060 --> 00:27:27,480
நீங்கள் ஹஃப்மேன் எழுத்துரு பிரச்சினை தொகுப்பு செய்கிறீர்கள் மட்டும் போது

360
00:27:27,480 --> 00:27:29,390
ஆனால் எதிர்காலத்தில் பாடத்திட்டங்களில் -

361
00:27:29,390 --> 00:27:32,220
நான் இந்த தரவு கட்டமைப்புகளை வரைந்து பிரச்சினைகள் மூலம் என்று எப்படி கற்றல்

362
00:27:32,220 --> 00:27:38,000
இந்த பேனா மற்றும் காகிதம் அல்லது, இந்த வழக்கில், ஐபாட் மற்றும் ஸ்டைலஸ்.

363
00:27:38,000 --> 00:27:41,000
>> எனினும் இந்த கட்டத்தில், நாங்கள் சில குறியீட்டு நடைமுறையில் செய்ய செல்ல போகிறோம்

364
00:27:41,000 --> 00:27:44,870
உண்மையில் இந்த பைனரி மரங்கள் விளையாட மற்றும் பார்க்க.

365
00:27:44,870 --> 00:27:52,150
நான் என் கணினியில் மீது மீண்டும் மாற்ற போகிறேன்.

366
00:27:52,150 --> 00:27:58,480
அதற்கு பதிலாக CS50 ரன் அல்லது CS50 இடைவெளி பயன்படுத்தி பிரிவு, இந்த பகுதியில்,

367
00:27:58,480 --> 00:28:01,500
நான் சாதனம் பயன்படுத்த போகிறேன்.

368
00:28:01,500 --> 00:28:04,950
>> சிக்கல் அமை விவரக்குறிப்பு இணைந்து தொடர்ந்து,

369
00:28:04,950 --> 00:28:07,740
நான், நான் பயன்பாட்டிற்கான திறக்க வேண்டும் என்று நான் பார்க்கிறேன்

370
00:28:07,740 --> 00:28:11,020
என் டிராப்பாக்ஸ் கோப்புறையை சென்று, பகுதி 7 என்று ஒரு கோப்புறையை உருவாக்க

371
00:28:11,020 --> 00:28:15,730
பின்னர் binary_tree.c என்று ஒரு கோப்பு உருவாக்க.

372
00:28:15,730 --> 00:28:22,050
இங்கே நாம். நான் பயன்பாடு முன்பே திறந்த கிடைத்துவிட்டது.

373
00:28:22,050 --> 00:28:25,910
நான் ஒரு முனை மேலே செல்கிறேன்.

374
00:28:25,910 --> 00:28:38,250
நான் டிராப்பாக்ஸ் கோப்புறையை போக போகிறேன், section7 என்று ஒரு அடைவு வைக்க,

375
00:28:38,250 --> 00:28:42,230
இது முற்றிலும் காலியாக தான் பார்க்க.

376
00:28:42,230 --> 00:28:48,860
இப்போது நான் binary_tree.c திறக்க போகிறேன்.

377
00:28:48,860 --> 00:28:51,750
அது சரி. இங்கே நாம் - காலியாக கோப்பு.

378
00:28:51,750 --> 00:28:54,330
>> இந்த விவரக்குறிப்பு திரும்பி செல்லலாம்.

379
00:28:54,330 --> 00:28:59,850
விவரக்குறிப்பு ஒரு புதிய வகை வரையறை உருவாக்க கேட்கும்

380
00:28:59,850 --> 00:29:03,080
int மதிப்புகள் கொண்ட பைனரி மரம் முனைக்கு -

381
00:29:03,080 --> 00:29:07,110
நாங்கள் எங்கள் முன் வரைபட வெளியே வந்தது என்று மதிப்புகள் போன்ற.

382
00:29:07,110 --> 00:29:11,740
நாம் இங்கேயே செய்த இந்த பாய்லர் typedef பயன்படுத்த போகிறோம்

383
00:29:11,740 --> 00:29:14,420
நீங்கள் பிரச்சனை அமை 5 இருந்து அங்கீகரிக்க வேண்டும் என்று -

384
00:29:14,420 --> 00:29:19,190
நீங்கள் வெல்ல speller திட்டத்தின் ஹாஷ் அட்டவணை வழி செய்தால்.

385
00:29:19,190 --> 00:29:22,540
நீங்கள் கடந்த வாரம் பிரிவில் இருந்து அதை அங்கீகரிக்க வேண்டும்

386
00:29:22,540 --> 00:29:23,890
நாம் இணைக்கப்பட்ட பட்டியல்கள் பற்றி பேசினர்.

387
00:29:23,890 --> 00:29:27,870
நாம், ஒரு struct முனையும் இந்த typedef கிடைத்துவிட்டது

388
00:29:27,870 --> 00:29:34,430
நாம் இந்த struct முனை முன்பு struct முனையும் இந்த பெயர் கொடுத்துள்ளேன்

389
00:29:34,430 --> 00:29:39,350
நாம் struct முனை சுட்டிகள் வேண்டும் நான் இருந்து நாம் அதை பார்க்கவும் முடியும்

390
00:29:39,350 --> 00:29:45,740
எங்கள் struct பகுதியாக, ஆனால் நாம் இந்த படர்ந்துள்ளன நான் -

391
00:29:45,740 --> 00:29:47,700
அல்லது மாறாக, இந்த இணைக்கப்பட்டுள்ளது - ஒரு typedef உள்ள

392
00:29:47,700 --> 00:29:54,600
அதனால், பின்னர் குறியீடு, நாம் அதற்கு பதிலாக ஒரு struct முனை மட்டும் ஒரு முனையில் இந்த struct பார்க்கவும் முடியாது.

393
00:29:54,600 --> 00:30:03,120
>> இந்த நாங்கள் கடந்த வாரம் பார்த்தேன் என்று தனித்தனி தொடர்புடைய பட்டியல் வரையறை மிகவும் ஒத்த போகிறது.

394
00:30:03,120 --> 00:30:20,070
இதை செய்ய, அது வெறும் பாய்லர் அவுட் எழுதி ஆரம்பிப்போம்.

395
00:30:20,070 --> 00:30:23,840
நாம், நாம் ஒரு முழு எண் மதிப்பை வேண்டும் என்று

396
00:30:23,840 --> 00:30:32,170
நாம் எண்ணாக மதிப்பு வைத்து, பின்னர் அதற்கு பதிலாக அடுத்த உறுப்பு ஒரே ஒரு சுட்டிக்காட்டி கொண்டிருக்கும் நான் -

397
00:30:32,170 --> 00:30:33,970
நாம் தனித்தனி தொடர்புடைய பட்டியல்கள் செய்ததை போல -

398
00:30:33,970 --> 00:30:38,110
நாம் இடது மற்றும் வலது குழந்தை சுட்டிகள் போகிறது.

399
00:30:38,110 --> 00:30:42,880
அதுவும் அழகான எளிது - struct முனை * இடது குழந்தை;

400
00:30:42,880 --> 00:30:51,190
மற்றும் struct முனை * வலது குழந்தை;. Cool.

401
00:30:51,190 --> 00:30:54,740
ஒரு நல்ல தொடக்கத்தை தெரிகிறது.

402
00:30:54,740 --> 00:30:58,530
இந்த விவரக்குறிப்பு திரும்பி செல்லலாம்.

403
00:30:58,530 --> 00:31:05,030
>> இப்போது நாம் ஒரு மரத்தின் வேர் ஒரு உலக முனை * மாறி அறிவிக்க வேண்டும்.

404
00:31:05,030 --> 00:31:10,590
நாம் கூட உலக எங்கள் இணைக்கப்பட்ட பட்டியலில் முதல் சுட்டிக்காட்டி செய்து போல் இந்த உலக போகிறாய்.

405
00:31:10,590 --> 00:31:12,690
இந்த அதனால் தான் நாம் எழுத என்று செயல்பாடுகள்

406
00:31:12,690 --> 00:31:16,180
நாம் இந்த ரூட் சுற்றி செல்லும் வைக்க இல்லை -

407
00:31:16,180 --> 00:31:19,620
நாங்கள், நீங்கள் செய்தால் மீண்டும் மீண்டும் இந்த செயல்பாடுகளை எழுத வேண்டும் என்று நான் பார்க்கிறேன் என்று

408
00:31:19,620 --> 00:31:22,830
அது முதல் இடத்தில் கூட ஒரு உலகளாவிய அதை சுற்றி கடக்க முடியாது நல்லது இருக்கலாம்

409
00:31:22,830 --> 00:31:28,090
அதற்கு பதிலாக உங்கள் முக்கிய இடத்தில் அதை துவக்க.

410
00:31:28,090 --> 00:31:31,960
ஆனால், நாம் தொடங்க உலகளவில் அதை செய்கிறேன்.

411
00:31:31,960 --> 00:31:39,920
மீண்டும், நாம் இடைவெளிகளை ஒரு ஜோடி தருகிறேன், நான் ஒரு முனை * ரூட் அறிவிக்க போகிறேன்.

412
00:31:39,920 --> 00:31:46,770
இப்போது நான் இந்த uninitialized விட்டு இல்லை என்று உறுதி செய்ய, நான் பூஜ்ய சமமாக அமைக்க போகிறேன்.

413
00:31:46,770 --> 00:31:52,210
இப்போது, முக்கிய செயல்பாடு - நாம் இங்கு மிகவும் விரைவாக எழுத வேண்டும் என்பது -

414
00:31:52,210 --> 00:32:00,450
int முக்கிய (int argc, கான்ஸ்ட் எரிப்பதை * argv []) -

415
00:32:00,450 --> 00:32:10,640
மற்றும் நான் நான் என்று கான்ஸ்ட் என் argv வரிசை அறிவித்தார் தொடங்க போகிறேன்

416
00:32:10,640 --> 00:32:14,550
அந்த வாதங்களை நான் ஒருவேளை மாற்ற வேண்டாம் என்று வாதங்கள் என்று.

417
00:32:14,550 --> 00:32:18,390
நான் அவர்களை மாற்ற வேண்டும் என்றால் நான் அவர்களை பிரதிகளை உருவாக்கும்.

418
00:32:18,390 --> 00:32:21,740
இந்த குறியீடு நிறைய காணலாம்.

419
00:32:21,740 --> 00:32:25,440
அது சரி அல்லது வழி. நீங்கள் விரும்பினால் கான்ஸ்ட் மாட்டா - அது அதை விட்டு நல்லது.

420
00:32:25,440 --> 00:32:28,630
நான் பொதுவாக நான் நினைவூட்ட என்று தான் போட்டது

421
00:32:28,630 --> 00:32:33,650
 நான் அநேகமாக அந்த வாதங்கள் மாற்ற விரும்பவில்லை என்று.

422
00:32:33,650 --> 00:32:39,240
>> எப்போதும் போல், நான் முக்கிய இறுதியில் இந்த பதிலுக்கு 0 வரி ஆகியவை அடங்கும் போகிறேன்.

423
00:32:39,240 --> 00:32:45,730
இங்கே, நான் என் வேர் கணு துவக்க வேண்டும்.

424
00:32:45,730 --> 00:32:48,900
அது இப்போது உள்ளது போல, நான், பூஜ்ய அமைக்க என்று ஒரு சுட்டிக்காட்டி கிடைத்துவிட்டது

425
00:32:48,900 --> 00:32:52,970
அது எதுவும் சுட்டி காட்டும்.

426
00:32:52,970 --> 00:32:57,480
வரிசையில் உண்மையில், கணு கட்டி தொடங்க

427
00:32:57,480 --> 00:32:59,250
நான் முதலில் நினைவகம் ஒதுக்க வேண்டும்.

428
00:32:59,250 --> 00:33:05,910
நான் malloc பயன்படுத்தி குவியல் மீது நினைவகம் மூலம் அதை செய்ய போகிறேன்.

429
00:33:05,910 --> 00:33:10,660
நான், malloc விளைவு சமமாக ரூட் அமைக்க போகிறேன்

430
00:33:10,660 --> 00:33:19,550
நான் ஒரு முனை அளவு கணக்கிட sizeof ஆபரேட்டர் பயன்படுத்த போகிறேன்.

431
00:33:19,550 --> 00:33:24,990
பதிலாக நான் sizeof முனை பயன்படுத்த காரணம், என்று

432
00:33:24,990 --> 00:33:37,020
malloc (4 + 4 +4) அல்லது malloc 12 - இப்படி ஏதோ செய்து -

433
00:33:37,020 --> 00:33:40,820
நான் என் குறியீடு கூடுமானவரை உடையதாக இருக்க வேண்டும், ஏனெனில் இது.

434
00:33:40,820 --> 00:33:44,540
நான் இந்த. கேட்ச் கோப்பு எடுக்க முடியும் வேண்டும், சாதனம் அதை தொகுக்க

435
00:33:44,540 --> 00:33:48,820
பின்னர் என் 64 பிட் மேக் இது தொகுத்தல் -

436
00:33:48,820 --> 00:33:52,040
அல்லது முற்றிலும் வேறுபட்ட கட்டமைப்பு மீது -

437
00:33:52,040 --> 00:33:54,640
நான் இந்த அனைத்து அதே வேலை செய்ய வேண்டும்.

438
00:33:54,640 --> 00:33:59,510
>> நான் மாறிகள் அளவு பற்றி ஊகங்கள் செய்கிறேன் என்றால் -

439
00:33:59,510 --> 00:34:02,070
ஒரு முழு எண்ணாக அல்லது ஒரு சுட்டிக்காட்டி அளவு அளவு -

440
00:34:02,070 --> 00:34:06,070
நான் கூட கட்டமைப்புகள் வகையான அனுமானங்கள் செய்கிறேன்

441
00:34:06,070 --> 00:34:10,440
ரன் போது எனது குறியீடு வெற்றிகரமாக தொகுத்தல் முடியாது.

442
00:34:10,440 --> 00:34:15,030
கைமுறையாக struct துறைகளில் கூட்டலாம் எதிராக எப்போதும் sizeof பயன்படுத்த.

443
00:34:15,030 --> 00:34:20,500
மற்ற காரணம் கூட தொகுப்பி struct மீது வைக்கும் திணிப்பு இருக்கலாம் என்று.

444
00:34:20,500 --> 00:34:26,570
கூட தனிப்பட்ட துறைகள் கூட்டலாம், நீங்கள் வழக்கமாக செய்ய வேண்டும் என்று ஒன்று இல்லை

445
00:34:26,570 --> 00:34:30,340
எனவே, அந்த வரியை நீக்க.

446
00:34:30,340 --> 00:34:33,090
இப்போது, உண்மையில், இந்த வேர் கணு துவக்க

447
00:34:33,090 --> 00:34:36,489
நான் அதன் பல்வேறு துறைகளில் ஒவ்வொரு மதிப்புகள் அடைப்பை வேண்டும் போகிறேன்.

448
00:34:36,489 --> 00:34:41,400
எடுத்துக்காட்டாக, மதிப்பு நான் 7 துவக்க வேண்டும் என்று,

449
00:34:41,400 --> 00:34:46,920
இப்போது நான் இடது குழந்தை பூஜ்ய இருக்கும் அமைக்க போகிறேன்

450
00:34:46,920 --> 00:34:55,820
வலது குழந்தை கூட பூஜ்ய வேண்டும். கிரேட்!

451
00:34:55,820 --> 00:35:02,670
நாம் குறிப்பிட்ட அந்த பகுதி செய்துவிட்டேன்.

452
00:35:02,670 --> 00:35:07,390
>> பக்கம் 3 கீழே உள்ள குறிப்புகளை கீழே மூன்று முனைகளில் உருவாக்க என்னை கேட்டால் -

453
00:35:07,390 --> 00:35:10,600
9 3, 6 கொண்ட ஒன்று கொண்ட ஒரு -

454
00:35:10,600 --> 00:35:14,210
பின்னர் அது சரியாக நம் மரம் வரைபடம் போல் அவர்களை கம்பி

455
00:35:14,210 --> 00:35:17,120
நாம் முன்னர் பற்றி என்று.

456
00:35:17,120 --> 00:35:20,450
நாம் இங்கே அந்த அழகான விரைவாக செய்ய.

457
00:35:20,450 --> 00:35:26,270
நான் நகல் குறியீடு ஒரு கொத்து எழுத ஆரம்பிக்க போகிறேன் என்று மிகவும் விரைவாக காண முடியும்.

458
00:35:26,270 --> 00:35:32,100
நான் ஒரு முனை * உருவாக்க போகிறேன், நான் மூன்று அழைக்க போகிறேன்.

459
00:35:32,100 --> 00:35:36,000
நான் malloc (sizeof (முனை)) அது சம அமைக்க போகிறேன்.

460
00:35:36,000 --> 00:35:41,070
நான் மூன்று> மதிப்பு = 3 அமைக்க போகிறேன்.

461
00:35:41,070 --> 00:35:54,780
மூன்று -> left_child = NULL; மூன்று -> உரிமை _child = NULL; அதே.

462
00:35:54,780 --> 00:36:01,150
என்று ரூட் ஆரம்பிக்கும் என்று அழகாக அதே போல், அந்த சரியாக என்ன

463
00:36:01,150 --> 00:36:05,760
நான் அதே 6 மற்றும் 9 ஆரம்பிக்கும் ஆரம்பித்தால் செய்ய வேண்டும் போகிறேன்.

464
00:36:05,760 --> 00:36:20,720
நான் விரைவில் இங்கே அதை செய்கிறேன் - உண்மையில், நான் ஒரு சிறிய நகல் மற்றும் பேஸ்ட் செய்ய போகிறேன்,

465
00:36:20,720 --> 00:36:46,140
சரி - என்று நான் உறுதி.

466
00:36:46,470 --> 00:37:09,900
 இப்போது, நான் அதை நகல் மற்றும் நான் போய் 6 இந்த சமமாக அமைக்க முடியும்.

467
00:37:09,900 --> 00:37:14,670
இந்த சிறிது எடுத்து சூப்பர் திறன் இல்லை என்று பார்க்கலாம்.

468
00:37:14,670 --> 00:37:22,610
ஒரு சிறிதுநேரத்தில், நாம் இந்த செய்வேன் என்று ஒரு செயல்பாடு எழுத வேண்டும்.

469
00:37:22,610 --> 00:37:32,890
நான் ஒரு 9 இந்த பதிலாக வேண்டும், ஒரு 6 என்று மாற்றவும்.

470
00:37:32,890 --> 00:37:37,360
>> இப்போது நாங்கள் எங்கள் முனைகளில் அனைத்து உருவாக்கப்பட்ட மற்றும் துவக்கப்படும் கிடைத்துவிட்டது.

471
00:37:37,360 --> 00:37:41,200
நாம், நமது ரூட் 7 சமமாக அமைக்க கிடைத்தது, அல்லது மதிப்பு 7 கொண்ட

472
00:37:41,200 --> 00:37:46,510
3 கொண்டிருக்கும் எங்கள் முனை, 9 கொண்டுள்ள 6 கொண்ட நம் முனை, மற்றும் நம் முனை.

473
00:37:46,510 --> 00:37:50,390
இந்த கட்டத்தில், நாம் செய்ய வேண்டிய அனைத்து வரை கம்பி எல்லாமே.

474
00:37:50,390 --> 00:37:53,020
நான் வெற்று அனைத்து சுட்டிகளையும் துவக்கப்படும் காரணம் நான் நிச்சயமாக அந்த செய்ய தான் என்று

475
00:37:53,020 --> 00:37:56,260
நான் விபத்தில் அங்கு எந்த uninitialized குறிப்புகள் இல்லை.

476
00:37:56,260 --> 00:38:02,290
மேலும் பின்னர், இந்த இடத்தில், நான் மட்டுமே உண்மையில் ஒன்றுக்கொன்று முனைகளில் இணைக்க வேண்டும் -

477
00:38:02,290 --> 00:38:04,750
அவர்கள் உண்மையில் இணைக்கப்படும் என்று ஒன்றை - நான் வழியாக சென்று செய்ய வேண்டாம்

478
00:38:04,750 --> 00:38:08,240
அனைத்து nulls பொருத்தமான இடங்களில் அங்கு உள்ளன என்று.

479
00:38:08,240 --> 00:38:15,630
>> ரூட் தொடங்கி, நான் ரூட் இடது குழந்தை 3 என்று எனக்கு தெரியும்.

480
00:38:15,630 --> 00:38:21,250
நான் ரூட் உரிமையை குழந்தை 9 என்று எனக்கு தெரியும்.

481
00:38:21,250 --> 00:38:24,880
பின்னர், நான் கவலைப்பட விட்டார்கள் என்று மட்டுமே மற்ற குழந்தை

482
00:38:24,880 --> 00:38:39,080
6 இது 3 உரிமையை குழந்தை உள்ளது.

483
00:38:39,080 --> 00:38:44,670
இந்த கட்டத்தில், அது அனைத்து நல்ல தெரிகிறது.

484
00:38:44,670 --> 00:38:54,210
நாம் இந்த வரிகளை சில நீக்க வேண்டும்.

485
00:38:54,210 --> 00:38:59,540
இப்போது எல்லாம் நல்ல தெரிகிறது.

486
00:38:59,540 --> 00:39:04,240
நமது விவரக்குறிப்பு சென்று, நாம் அடுத்த என்ன செய்ய வேண்டும் என்று பார்ப்போம்.

487
00:39:04,240 --> 00:39:07,610
>> இந்த கட்டத்தில், நாங்கள் என்று ஒரு செயல்பாடு 'உள்ளது' எழுத வேண்டும்

488
00:39:07,610 --> 00:39:14,150
'bool கொண்டுள்ளது (int மதிப்பு)' ஒரு ப்ரோட்டோடைப்.

489
00:39:14,150 --> 00:39:17,060
இந்த செயல்பாடு உண்மை திரும்ப போகிறது கொண்டுள்ளது

490
00:39:17,060 --> 00:39:21,200
 மரம் எங்கள் உலக ரூட் மாறி மூலம் சுட்டிக்காட்டினார் என்றால்

491
00:39:21,200 --> 00:39:26,950
 செயல்பாடு மற்றும் தவறான இல்லையெனில் கடந்து மதிப்பு உள்ளது.

492
00:39:26,950 --> 00:39:29,000
தான் போய் அதை செய்ய விடுங்கள்.

493
00:39:29,000 --> 00:39:35,380
இந்த துல்லியமாக நாம் தான் சற்று முன்பு iPad இல் கையால் அந்த பார்வை இருக்க வேண்டும்.

494
00:39:35,380 --> 00:39:40,130
நாம் சற்று திரும்பி பெரிதாக்கவும் மற்றும் மேலே.

495
00:39:40,130 --> 00:39:43,130
நம் முக்கிய செயல்பாடு மேலே இந்த விழாவில் வைத்து போகிறாய்

496
00:39:43,130 --> 00:39:48,990
அதனால் நாம் மூலப்பொருளுக்கு எந்த செய்ய இல்லை.

497
00:39:48,990 --> 00:39:55,960
எனவே, bool (int மதிப்பு) கொண்டுள்ளது.

498
00:39:55,960 --> 00:40:00,330
அங்கு நாம். எங்கள் பாய்லர் அறிவிப்பு உள்ளது.

499
00:40:00,330 --> 00:40:02,900
இப்போது, இந்த தொகுக்கலாம் என்று உறுதி செய்ய

500
00:40:02,900 --> 00:40:06,820
நான் போய் ஒரு தவறான திரும்ப சமமாக அமைக்க போகிறேன்.

501
00:40:06,820 --> 00:40:09,980
இப்போது இந்த செயல்பாடு தான் எதையும் செய்ய முடியாது, எப்போதும் அந்த அறிக்கை

502
00:40:09,980 --> 00:40:14,010
நாம் தேடும் மதிப்பு மரம் இல்லை.

503
00:40:14,010 --> 00:40:16,280
>> இந்த கட்டத்தில், இது அநேகமாக ஒரு நல்ல யோசனை -

504
00:40:16,280 --> 00:40:19,600
நாம் குறியீடு ஒரு மொத்தமாக எழுதப்பட்ட நாங்கள் இன்னும் அதை சோதனை முயற்சி இல்லை என்பதால் -

505
00:40:19,600 --> 00:40:22,590
இது அனைத்து தொகுக்கும் உறுதி செய்ய.

506
00:40:22,590 --> 00:40:27,460
நாம் இந்த உண்மையில் தொகுக்கலாம் என்று உறுதி செய்ய வேண்டும் என்று விஷயங்களை ஒரு ஜோடி உள்ளன.

507
00:40:27,460 --> 00:40:33,530
நாம் இன்னும் சேர்க்கப்படவில்லை என்று எந்த நூலகங்கள் எந்த செயல்பாடுகளை பயன்படுத்தி வருகிறேன் என்றால், முதலில் பார்க்க.

508
00:40:33,530 --> 00:40:37,940
நாம் இதுவரை பயன்படுத்தி செயல்பாடுகள், malloc இருக்கும்

509
00:40:37,940 --> 00:40:43,310
மற்றும் நாம் இந்த வகை பயன்படுத்தி - 'bool' என்று இந்த நிலையான வகை -

510
00:40:43,310 --> 00:40:45,750
இது வழக்கமான bool தலைப்பு கோப்பு சேர்க்கப்பட்டுள்ளது.

511
00:40:45,750 --> 00:40:53,250
நாம் நிச்சயமாக bool வகை நிலையான bool.h, சேர்க்க வேண்டும்

512
00:40:53,250 --> 00:40:59,230
மற்றும் நாம் # நிலையான நூலகங்கள் நிலையான lib.h சேர்க்க வேண்டும்

513
00:40:59,230 --> 00:41:03,530
அந்த malloc, மற்றும் இலவச, மற்றும் அனைத்து அடங்கும்.

514
00:41:03,530 --> 00:41:08,660
எனவே, ஜூம் அவுட், நாம் வெளியேற போகிறோம்.

515
00:41:08,660 --> 00:41:14,190
முயற்சி மற்றும் இந்த உண்மையில் தொகுப்பு என்று உறுதி செய்யலாம்.

516
00:41:14,190 --> 00:41:18,150
நாம் அது என்று பார்க்க, நாம் சரியான பாதையில் தான்.

517
00:41:18,150 --> 00:41:22,990
>> மீண்டும் binary_tree.c திறந்து விட.

518
00:41:22,990 --> 00:41:34,530
அதை தொகுக்கும். போய் நாம் கொண்டிருக்கும் செயல்பாடு சில அழைப்புகள் செருக என்று நாம் -

519
00:41:34,530 --> 00:41:40,130
அந்த அனைத்து நல்ல என்று உறுதிப்படுத்தி கொள்ள.

520
00:41:40,130 --> 00:41:43,170
உதாரணமாக, நாம் முன்னர் நமது மரம் சில லுக்அப்களுக்கு செய்த போது,

521
00:41:43,170 --> 00:41:48,500
, நாம் மதிப்புகள் 6, 10, மற்றும் 1 பார்க்க முயற்சி, மற்றும் நாம் 6 மரம் என்று தெரியும்

522
00:41:48,500 --> 00:41:52,220
10 மரம் இல்லை, மற்றும் 1 அல்லது மரம் இல்லை.

523
00:41:52,220 --> 00:41:57,230
இது கண்டுபிடிக்க ஒரு வழியாக அந்த மாதிரி அழைப்புகளை பயன்படுத்த அனுமதிக்க அல்லது இல்லையா

524
00:41:57,230 --> 00:41:59,880
எங்கள் கொண்டுள்ளது செயல்பாடு வருகிறது.

525
00:41:59,880 --> 00:42:05,210
அந்த வகையில், நான், printf செயல்பாட்டை பயன்படுத்த போகிறேன்

526
00:42:05,210 --> 00:42:10,280
மற்றும் நாம் கொண்டிருக்கும் அழைப்பை விளைவாக அவுட் அச்சிட போகிறோம்.

527
00:42:10,280 --> 00:42:13,280
நான் ஒரு சரம் போட்டு போகிறேன் "கொண்டுள்ளது (% d) = ஏனெனில்

528
00:42:13,280 --> 00:42:20,470
 நாம் பார்க்க போகிறோம் என்று மதிப்பு பிளக் போகிறோம்,

529
00:42:20,470 --> 00:42:27,130
மற்றும் =% s \ n "என்று பயன்படுத்த எங்கள் வடிவம் சரம் போன்ற.

530
00:42:27,130 --> 00:42:30,720
உண்மையில் திரையில் அவுட் அச்சிட - நாம் பார்க்க போகிறோம் -

531
00:42:30,720 --> 00:42:32,060
என்ன ஒரு செயல்பாடு அழைப்பு தெரிகிறது.

532
00:42:32,060 --> 00:42:33,580
இந்த உண்மையில் செயல்பாடு அழைப்பு அல்ல.

533
00:42:33,580 --> 00:42:36,760
 இந்த ஒரு சார்பு அழைப்பு போல் வடிவமைக்கப்பட்ட ஒரு சரம்.

534
00:42:36,760 --> 00:42:41,140
>> இப்போது, நாம் மதிப்புகள் அடைப்பை போகிறோம்.

535
00:42:41,140 --> 00:42:43,580
நாம், 6 கொண்டுள்ளது முயற்சி செய்ய போகிறோம்

536
00:42:43,580 --> 00:42:48,340
மற்றும் நாம் இங்கு செய்ய போகிறோம் என்ன என்று மும்மை ஆபரேட்டர் பயன்படுத்த உள்ளது.

537
00:42:48,340 --> 00:42:56,340
6 கொண்டுள்ளது - - நாம் பார்க்க மிகவும், இப்போது நான் 6 கொண்டிருந்தது நான் மற்றும் 6 கொண்டிருந்தால் உண்மைதான்,

538
00:42:56,340 --> 00:43:01,850
நாங்கள்% கள் வடிவம் தன்மை அனுப்ப போகிறோம் என்று சரம்

539
00:43:01,850 --> 00:43:04,850
சரம் "உண்மை" இருக்க போகிறது.

540
00:43:04,850 --> 00:43:07,690
நாம் சிறிது மீது உருட்டவும்.

541
00:43:07,690 --> 00:43:16,210
இல்லையெனில், நாங்கள் தவறான 6 வருமானத்தை கொண்டிருந்தால் சரம் "தவறான" அனுப்ப வேண்டும்.

542
00:43:16,210 --> 00:43:19,730
இந்த ஒரு சிறிய முட்டாள்தனமான காணப்படும், ஆனால் நான் நன்றாக விளக்க வேண்டும் விளங்கும்படியான

543
00:43:19,730 --> 00:43:23,780
என்ன மும்மை ஆபரேட்டர் நாங்கள் கொஞ்ச அதை பார்க்கவில்லை இருந்து தெரிகிறது.

544
00:43:23,780 --> 00:43:27,670
இந்த எங்கள் கொண்டுள்ளது செயல்பாடு வேலை செய்தால் கண்டுபிடிக்க ஒரு நல்ல, எளிது இருக்கும்.

545
00:43:27,670 --> 00:43:30,040
நான், இடது மீது மீண்டும் உருட்டும் போகிறேன்

546
00:43:30,040 --> 00:43:39,900
நான் ஒரு சில முறை நகலெடுத்து இந்த வரி ஒட்டவும் போகிறேன்.

547
00:43:39,900 --> 00:43:44,910
அது, சுமார் இந்த மதிப்புகள் சில மாற்றம்

548
00:43:44,910 --> 00:43:59,380
எனவே இந்த 1 போகிறது, மற்றும் இந்த 10 ஆக போகிறது.

549
00:43:59,380 --> 00:44:02,480
>> இந்த இடத்தில் நாம் ஒரு நல்ல கொண்டுள்ளது செயல்பாடு கிடைத்துவிட்டது.

550
00:44:02,480 --> 00:44:06,080
நாம் சில பரிசோதனைகள், மற்றும் இந்த அனைத்து வேலைகளையும் நாம் பார்க்கலாம்.

551
00:44:06,080 --> 00:44:08,120
இந்த இடத்தில் நாம் சில குறியீடு எழுதியுள்ளேன்.

552
00:44:08,120 --> 00:44:13,160
வெளியே விட்டுவிட்டு எல்லாம் இன்னும் தொகுக்கும் உறுதி நேரம்.

553
00:44:13,160 --> 00:44:20,360
வெளியே விட்டு, இப்போது மீண்டும் பைனரி மரம் உருவாக்கும் முயற்சி செய்வோம்.

554
00:44:20,360 --> 00:44:22,260
நாம் ஒரு பிழை கிடைத்தது போல நன்றாக, அது, தெரிகிறது

555
00:44:22,260 --> 00:44:26,930
நாம் இந்த வெளிப்படையாக printf நூலகம் செயல்பாடு அறிவித்தார்.

556
00:44:26,930 --> 00:44:39,350
நாம் போய் # standardio.h சேர்க்க வேண்டும் போல் இருக்கிறது.

557
00:44:39,350 --> 00:44:45,350
அத்துடன் எல்லாம் தொகுக்க வேண்டும். நாம் அனைவரும் நல்ல இருக்கும்.

558
00:44:45,350 --> 00:44:50,420
இப்போது பைனரி மரம் இயங்கும் முயற்சி மற்றும் என்ன நடக்கிறது என்று பார்க்கலாம்.

559
00:44:50,420 --> 00:44:53,520
இங்கே நாம். / Binary_tree,, இல்லை

560
00:44:53,520 --> 00:44:55,190
மற்றும் நாம் எதிர்பார்த்தபடி, என்று பார்க்க -

561
00:44:55,190 --> 00:44:56,910
நாம் செயல்படுத்தப்படவில்லை ஏனெனில், இன்னும் உள்ளது

562
00:44:56,910 --> 00:44:59,800
அல்லது மாறாக, நாம் தான் தவறான பதிலுக்கு சேர்த்திருக்கிறேன் -

563
00:44:59,800 --> 00:45:03,300
நாம், அது அவர்களுக்கு அனைத்து தவறான திரும்பி என்று பார்க்க

564
00:45:03,300 --> 00:45:06,180
அதனால் அனைத்து நன்றாக பெரும்பாலான வேலை.

565
00:45:06,180 --> 00:45:11,860
>> இந்த கட்டத்தில் உள்ளது திரும்பி சென்று உண்மையில் செயல்படுத்த வேண்டும்.

566
00:45:11,860 --> 00:45:17,490
நான், கீழே பெரிதாக்க போகிறேன், மற்றும் -

567
00:45:17,490 --> 00:45:22,330
நினைவி, நாம் பயன்படுத்திய படிமுறை நாம் வேர் கணு மணிக்கு தொடங்கியது என்று

568
00:45:22,330 --> 00:45:28,010
பின்னர் நாம் சந்திக்கும் ஒவ்வொரு முனையும் போது, நாம், ஒரு ஒப்பீடு செய்ய

569
00:45:28,010 --> 00:45:32,380
அந்த ஒப்பீட்டு அடிப்படையில் நாம் ஒன்று இடது குழந்தை அல்லது வலது குழந்தை செல்ல.

570
00:45:32,380 --> 00:45:39,670
இந்த நாங்கள் முந்தைய கால எழுதினார் என்று இரும தேடல் குறியீடு போலவே இருக்கும் போகிறது.

571
00:45:39,670 --> 00:45:47,810
நாம் துவங்க போது, நாம் தற்போதைய முனை மீது நடத்த வேண்டும் என்று

572
00:45:47,810 --> 00:45:54,050
நாம் பார்க்கும், மற்றும் தற்போதைய கணு மூல கணு துவக்கப்படும் வேண்டும் என்று.

573
00:45:54,050 --> 00:45:56,260
இப்போது, நாம், மரம் வழியாக செல்ல போகிறோம்

574
00:45:56,260 --> 00:45:58,140
எங்கள் நிறுத்தும் நிலை என்பதை நினைவில் -

575
00:45:58,140 --> 00:46:01,870
 நாம் உண்மையில் கை எடுத்துக்காட்டாக மூலம் வேலை போது -

576
00:46:01,870 --> 00:46:03,960
நாம் ஒரு வெற்று முனை ஏற்பட்டது போது, அவர்

577
00:46:03,960 --> 00:46:05,480
நாம் ஒரு வெற்று குழந்தை பார்த்தபோது,

578
00:46:05,480 --> 00:46:09,620
மாறாக நாம் உண்மையில் மரம் ஒரு முனை சென்றார் போது

579
00:46:09,620 --> 00:46:12,640
நாம் ஒரு வெற்று முனை இருக்கும்போது கண்டறியப்பட்டது.

580
00:46:12,640 --> 00:46:20,720
நடப்பு பூஜ்ய சமமாக இல்லை வரை நாம் மீண்டும் கூறு போகிறோம்.

581
00:46:20,720 --> 00:46:22,920
மற்றும் நாம் என்ன செய்ய போகிறோம்?

582
00:46:22,920 --> 00:46:31,610
நாம் சோதிக்க போகிறீர்கள் என்றால் (நடப்பு -> மதிப்பு == மதிப்பு),

583
00:46:31,610 --> 00:46:35,160
நாங்கள் உண்மையில் நாம் தேடும் கணு எதுவும் காணப்படவில்லை என்று எனக்கு தெரியும்.

584
00:46:35,160 --> 00:46:40,450
இங்கு, நாம் உண்மையான திரும்ப முடியும்.

585
00:46:40,450 --> 00:46:49,830
இல்லையெனில், நாங்கள் மதிப்பு குறைவாக இருக்கிறதா அல்லது இல்லையா என்பதை பார்க்க வேண்டும்.

586
00:46:49,830 --> 00:46:53,850
தற்போதைய முனை மதிப்பு மதிப்பு குறைவாக இருந்தால் நாம், தேடுகிறீர்கள்

587
00:46:53,850 --> 00:46:57,280
நாம் சரியான செல்ல போகிறோம்.

588
00:46:57,280 --> 00:47:10,600
எனவே, நடப்பு = நடப்பு -> right_child; இல்லையெனில் மற்றும், நாம் இடது செல்ல போகிறோம்.

589
00:47:10,600 --> 00:47:17,480
நடப்பு = நடப்பு -> left_child;. அழகான எளிமையான.

590
00:47:17,480 --> 00:47:22,830
>> ஒருவேளை நீங்கள் இந்த போலவே தெரிகிறது என்று வளைய அங்கீகரிக்க

591
00:47:22,830 --> 00:47:27,580
முந்தைய கால இரும தேடல், பின்னர் தவிர நாம் குறைந்த, நடுத்தர, மற்றும் உயர் கையாள்வதில்.

592
00:47:27,580 --> 00:47:30,000
இங்கே, நாம் தான், தற்போதைய மதிப்பு பார்க்க வேண்டும்

593
00:47:30,000 --> 00:47:31,930
அது நல்ல மற்றும் எளிது.

594
00:47:31,930 --> 00:47:34,960
நாம் இந்த குறியீடு வேலை உறுதி.

595
00:47:34,960 --> 00:47:42,780
முதல், அது தொகுக்கும் உறுதி. அது போல்.

596
00:47:42,780 --> 00:47:47,920
அது இயங்கும் பார்க்கலாம்.

597
00:47:47,920 --> 00:47:50,160
உண்மையில், அது நாம் எதிர்பார்க்கப்படுகிறது என்று எல்லாம் அவுட் அச்சிடுகிறது.

598
00:47:50,160 --> 00:47:54,320
10 மரம் இல்லை, ஏனெனில் அது மரத்தில் 6 காண்கிறார், 10 கண்டறிய இல்லை

599
00:47:54,320 --> 00:47:57,740
1 மரம் கூட இல்லை, ஏனெனில் மற்றும் அல்லது 1 தெரியாது.

600
00:47:57,740 --> 00:48:01,420
Cool stuff.

601
00:48:01,420 --> 00:48:04,470
>> அது சரி. நமது விவரக்குறிப்பு சென்று, அடுத்த என்ன என்று பார்ப்போம்.

602
00:48:04,470 --> 00:48:07,990
இப்போது, அது எங்கள் மரம் இன்னும் சில முனைகளில் சேர்க்க விரும்புகிறார்.

603
00:48:07,990 --> 00:48:11,690
அது 5, 2, மற்றும் 8 சேர்க்க, மற்றும் நம் குறியீடு உள்ளது என்பதை உறுதி செய்ய வேண்டும்

604
00:48:11,690 --> 00:48:13,570
இன்னும் எதிர்பார்த்தபடி வேலை.

605
00:48:13,570 --> 00:48:14,900
நாம் அதை செய்ய வேண்டும்.

606
00:48:14,900 --> 00:48:19,430
இந்த கட்டத்தில், மாறாக மீண்டும் அந்த எரிச்சலூட்டும் நகல் மற்றும் பேஸ்ட் செய்து விட,

607
00:48:19,430 --> 00:48:23,770
அது உண்மையில் ஒரு முனை உருவாக்க ஒரு செயல்பாடு எழுத அனுமதிக்க.

608
00:48:23,770 --> 00:48:27,740
நாங்கள் முக்கிய அனைத்து வழி கீழே இருந்தால், நாம் இந்த பண்ணினீங்க என்று பார்க்க

609
00:48:27,740 --> 00:48:31,210
நாம் ஒரு முனை உருவாக்க வேண்டும் என்று ஒவ்வொரு முறையும் மீது மீண்டும் மீது மிகவும் ஒத்த குறியீடு.

610
00:48:31,210 --> 00:48:39,540
>> அது உண்மையில் எங்களுக்கு ஒரு முனை உருவாக்க மற்றும் அதை திருப்பி என்று ஒரு செயல்பாடு எழுத அனுமதிக்க.

611
00:48:39,540 --> 00:48:41,960
நான் அதை build_node அழைக்க போகிறேன்.

612
00:48:41,960 --> 00:48:45,130
நான் ஒரு குறிப்பிட்ட மதிப்பு ஒரு முனை உருவாக்க போகிறேன்.

613
00:48:45,130 --> 00:48:51,040
இங்கே உள்ள பெரிதாக்கவும்.

614
00:48:51,040 --> 00:48:56,600
நான் செய்ய போகிறேன் முதல் என்னவென்றால் குவியல் மீது கணு இடைவெளி உருவாக்க வேண்டும்.

615
00:48:56,600 --> 00:49:05,400
எனவே, கணு * n = malloc (sizeof (முனை)); n -> மதிப்பு = மதிப்பு;

616
00:49:05,400 --> 00:49:14,960
பின்னர் இங்கே, நான் சரியான மதிப்புகள் இருக்கும் துறைகளில் அனைத்து துவக்க போகிறேன்.

617
00:49:14,960 --> 00:49:22,500
மிகவும் இறுதியில், நாங்கள் எங்கள் முனை தருகிறேன்.

618
00:49:22,500 --> 00:49:28,690
அது சரி. கவனிக்க ஒன்று இந்த செயல்பாடு என்று இங்கே இருக்கிறது

619
00:49:28,690 --> 00:49:34,320
குவியல்-ஒதுக்கீடு உள்ளது என்று நினைவகம் ஒரு சுட்டிக்காட்டி திரும்ப போகிறது.

620
00:49:34,320 --> 00:49:38,880
என்ன இது நல்லது இப்போது இந்த முனை ஆகும் -

621
00:49:38,880 --> 00:49:42,420
நாம் நாம் ஸ்டேக் அதை அறிவித்தார் ஏனெனில் குவியல் அதை அறிவிக்க வேண்டும்

622
00:49:42,420 --> 00:49:45,050
நாம் இந்த விழாவில் அதை செய்ய முடியாது.

623
00:49:45,050 --> 00:49:47,690
அந்த நினைவக திறன் வெளியே செல்ல வேண்டும்

624
00:49:47,690 --> 00:49:51,590
நாம் பிறகு அணுக முயற்சி என்றால் தவறானது என்று.

625
00:49:51,590 --> 00:49:53,500
நாம் குவியல்-ஒதுக்கப்பட்டுள்ள நினைவகத்தை அறிவித்தார் பின்னர்,

626
00:49:53,500 --> 00:49:55,830
நாம் பின்னர் அதை பெறலாம் பார்த்துக்கொள்ள வேண்டும்

627
00:49:55,830 --> 00:49:58,530
எங்கள் நிரல் எந்த நினைவகத்தை கசியவிடுகிறது இல்லை.

628
00:49:58,530 --> 00:50:01,270
நாம் குறியீடு எல்லாமே அந்த மீது punting

629
00:50:01,270 --> 00:50:02,880
ஒரு நேரத்தில் எளிமை மீது ஆணையாக,

630
00:50:02,880 --> 00:50:05,610
ஆனால் நீங்கள் எப்போதாவது இந்த மாதிரி ஒரு செயல்பாடு எழுத வேண்டும்

631
00:50:05,610 --> 00:50:10,370
நீங்கள் கிடைத்துவிட்டது, அங்கு - சில உள்ளே ஒரு malloc அல்லது realloc அழைப்பு -

632
00:50:10,370 --> 00:50:14,330
நீங்கள், நீங்கள் சொல்வது இங்கே கருத்து ஒருவித போட என்பதை உறுதி செய்ய வேண்டும்

633
00:50:14,330 --> 00:50:29,970
ஏய், உனக்கு தெரியுமா, கடந்து-ல் மதிப்பு துவக்கப்படும் ஒரு குவியல்-ஒதுக்கீடு முனை திரும்பும்.

634
00:50:29,970 --> 00:50:33,600
பின்னர் நீங்கள் சொல்வது குறிப்பு ஒருவித வைக்க உறுதி செய்ய வேண்டும்

635
00:50:33,600 --> 00:50:41,720
அழைப்பவர் மீண்டும் நினைவு விடுவிக்க வேண்டும்.

636
00:50:41,720 --> 00:50:45,450
அந்த வழியில், ஒருவர் எப்போதும் சென்று என்றால், அந்த செயல்பாடு பயன்படுத்துகிறது

637
00:50:45,450 --> 00:50:48,150
அவர்கள் அந்த விழாவில் இருந்து திரும்ப பெற என்ன என்று தெரியும்

638
00:50:48,150 --> 00:50:50,870
சில கட்டத்தில் விடுதலை வேண்டும்.

639
00:50:50,870 --> 00:50:53,940
>> , அனைத்து இங்கே நல்ல என்று அனுமானித்து

640
00:50:53,940 --> 00:51:02,300
நாம் குறியீடு இறங்கி சென்று வலது இங்கே இந்த வரிகளை அனைத்து மாற்ற முடியும்

641
00:51:02,300 --> 00:51:05,410
எங்கள் உருவாக்க முனையும் செயல்பாடு அழைப்புகள் மூலம்.

642
00:51:05,410 --> 00:51:08,170
உலகின் மிகவும் விரைவாக செய்வோம்.

643
00:51:08,170 --> 00:51:15,840
நாம் பதிலாக போவதில்லை என்று ஒரு பகுதி கீழே இங்கே இந்த பகுதி

644
00:51:15,840 --> 00:51:18,520
நாம் உண்மையில் ஒருவருக்கொருவர் சுட்டிக்காட்ட முனைகள் வரை கம்பி அங்கு கீழே,

645
00:51:18,520 --> 00:51:21,030
என்று நாம் நமது செயல்பாடு செய்ய முடியாது.

646
00:51:21,030 --> 00:51:37,400
ஆனால், நாம் என்ன செய்ய ரூட் = build_node (7); முனை * மூன்று = build_node (3);

647
00:51:37,400 --> 00:51:47,980
கணு * ஆறு = build_node (6); முனை * ஒன்பது = build_node (9);.

648
00:51:47,980 --> 00:51:52,590
இப்போது, நாங்கள் ஐந்து முனைகளில் சேர்க்க வேண்டும் -

649
00:51:52,590 --> 00:52:03,530
கணு * ஐந்து = build_node (5); முனை * எட்டு = build_node (8);

650
00:52:03,530 --> 00:52:09,760
மற்ற முனை என்ன? இங்கே பார்க்கலாம். நாம் ஒரு 2 சேர்க்க வேண்டும் -

651
00:52:09,760 --> 00:52:20,280
கணு * இரண்டு = build_node (2).

652
00:52:20,280 --> 00:52:26,850
அது சரி. இந்த கட்டத்தில், நாங்கள் 7, 3, 9, மற்றும் 6 கிடைத்துவிட்டது என்று

653
00:52:26,850 --> 00:52:30,320
அனைத்து சரியான வரை கம்பி, ஆனால் என்ன 5, 8 மற்றும் 2 பற்றி?

654
00:52:30,320 --> 00:52:33,550
சரியான வரிசையில் எல்லாம் வைத்து,

655
00:52:33,550 --> 00:52:39,230
நாங்கள் மூன்று உரிமையை குழந்தை 6 என்று எனக்கு தெரியும்.

656
00:52:39,230 --> 00:52:40,890
எனவே, நாங்கள் 5 சேர்க்க போகிறோம் என்றால்,

657
00:52:40,890 --> 00:52:46,670
5 மேலும், 3 ரூட் இது மரம் வலதுபுறம் சொந்தமானது

658
00:52:46,670 --> 00:52:50,440
எனவே 5 6 இடது குழந்தை சொந்தமானது.

659
00:52:50,440 --> 00:52:58,650
நாம், ஆறு என்று செய்யலாம் -> left_child = ஐந்து;

660
00:52:58,650 --> 00:53:10,790
;> left_child = எட்டு - பின்னர் 8 ஒன்பது எனவே, 9 இடது குழந்தை சொந்தமானது

661
00:53:10,790 --> 00:53:22,190
பின்னர் 2 3 இடது குழந்தை, எனவே நாம் இங்கு அதை செய்ய முடியும் - உம்மை -> left_child = இரண்டு;.

662
00:53:22,190 --> 00:53:27,730
நீங்கள் மிகவும் என்று சேர்த்து பின்பற்ற முடியவில்லை என்றால், நான் உங்களை வெளியே இழுக்க தெரிவிக்கின்றன.

663
00:53:27,730 --> 00:53:35,660
>> அது சரி. இந்த காப்பாற்ற நாம். நாம், வெளியே சென்று அதை தொகுக்கும் உறுதி

664
00:53:35,660 --> 00:53:40,760
பின்னர் நாங்கள் எங்கள் கொண்டுள்ளது அழைப்புகளில் சேர்க்க முடியும்.

665
00:53:40,760 --> 00:53:44,120
எல்லாம் இன்னும் தொகுக்கும் தெரிகிறது.

666
00:53:44,120 --> 00:53:51,790
இது போக சில அழைப்புகளை கொண்டுள்ளது உள்ள சேர்க்க.

667
00:53:51,790 --> 00:53:59,640
மீண்டும், நான் நகல் மற்றும் பேஸ்ட் சிறிது செய்ய போகிறேன்.

668
00:53:59,640 --> 00:54:15,860
இப்போது நாம் 5 8, மற்றும் 2, தேட. அது சரி.

669
00:54:15,860 --> 00:54:28,330
நாம் இந்த அனைத்து இன்னும் நன்றாக இருக்கிறது என்று. கிரேட்! சேமிக்க மற்றும் விலகினார்.

670
00:54:28,330 --> 00:54:33,220
இப்போது தொகுத்தல், அது செய்யலாம், இப்போது தான் இயக்க வேண்டும்.

671
00:54:33,220 --> 00:54:37,540
எல்லாம் நல்ல நன்றாக வேலை போன்ற முடிவுகளில் இருந்து, அது தெரிகிறது.

672
00:54:37,540 --> 00:54:41,780
கிரேட்! எனவே இப்போது நாம் கொண்டிருக்கும் எழுதப்பட்ட தரக்குறியீடுகள் கிடைத்துவிட்டது.

673
00:54:41,780 --> 00:54:46,160
நாம் மேலே மரத்தில் முனைகளில் செருக எப்படி வேலை

674
00:54:46,160 --> 00:54:50,000
நாம் இப்போது அதை செய்கிறீர்கள் என பின்னர், விஷயங்களை அழகாக இல்லை.

675
00:54:50,000 --> 00:54:52,280
>> நாம் விவரக்குறிப்பு திரும்பி சென்றால்,

676
00:54:52,280 --> 00:55:00,540
ஒரு bool திரும்பி, மீண்டும் - இது செருக என்று ஒரு செயல்பாடு எழுத எங்களுக்கு கேட்கும்

677
00:55:00,540 --> 00:55:04,400
அல்லது நாம் உண்மையில் மரத்தில் முனை சேர்க்க முடியும் -

678
00:55:04,400 --> 00:55:07,710
பின்னர் மரம் செருக, மதிப்பை குறிப்பிடப்படும்

679
00:55:07,710 --> 00:55:11,060
எங்கள் சேர்த்த செயல்பாடு மட்டுமே வாதம்.

680
00:55:11,060 --> 00:55:18,180
நாம் உண்மையில் மரத்தில் முனை கொண்ட மதிப்பை செருக என்று நாம், உண்மை வந்துடுவாங்க

681
00:55:18,180 --> 00:55:20,930
இது, நாம், ஒரு, போதுமான நினைவகம் என்று அர்த்தம்

682
00:55:20,930 --> 00:55:24,840
பின்னர் இரண்டு, என்று முனை ஏற்கனவே இருந்து மரம் இல்லை -

683
00:55:24,840 --> 00:55:32,170
நினைவி, நாம் தான் எளிதாக்குவது, மரம் உள்ள நகல் மதிப்புகள் வேண்டும் போவதில்லை.

684
00:55:32,170 --> 00:55:35,590
அது சரி. குறியீடு செல்ல.

685
00:55:35,590 --> 00:55:44,240
அதை திறக்க. ஒரு பிட் பெரிதாக்கு, பின்னர் கீழே.

686
00:55:44,240 --> 00:55:47,220
வலது கொண்டுள்ளது மேலே சேர்த்த செயல்பாடு வைக்கிறேன்.

687
00:55:47,220 --> 00:55:56,360
மீண்டும், இது (int மதிப்பு) bool நுழைவு என்றழைக்கப்படும் நடக்கிறது.

688
00:55:56,360 --> 00:56:01,840
ஒரு முன்னிருப்பு, அது இன்னும் சிறிது இடைவெளி கொடுத்து, மற்றும்,

689
00:56:01,840 --> 00:56:08,870
மிக இறுதியில் தவறான பதிலுக்கு வைத்து விடுங்கள்.

690
00:56:08,870 --> 00:56:22,620
இப்போது கீழே கீழே, மேல் மற்றும் பதிலாக கைமுறையாக முனைகளில் கட்டியெழுப்புவதற்கான செல்லலாம்

691
00:56:22,620 --> 00:56:27,900
முக்கிய நம்மை மற்றும் வயரிங் அவற்றை நாம் செய்கிறோம் போன்ற ஒருவருக்கொருவர் சுட்டிக்காட்ட,

692
00:56:27,900 --> 00:56:30,600
நாங்கள் அதை செய்ய நம் சேர்த்த செயல்பாடு தங்கியிருக்க வேண்டும்.

693
00:56:30,600 --> 00:56:35,510
நாங்கள், இன்னும் புதிதாக முழு மரம் உருவாக்க எங்கள் சேர்த்த செயல்பாடு நம்ப மாட்டேன்

694
00:56:35,510 --> 00:56:39,970
மாறாக நாம் இந்த வரிகளை அகலும் - we'll இந்த வரிகளை அவுட் கருத்து -

695
00:56:39,970 --> 00:56:43,430
அந்த முனைகளில் 5, 8 மற்றும் 2 கட்ட.

696
00:56:43,430 --> 00:56:55,740
அதற்கு பதிலாக, நாம் சேர்த்த செயல்பாடு அழைப்புகள் சேர்க்க வேண்டும்

697
00:56:55,740 --> 00:57:01,280
உண்மையில் வேலை என்று உறுதிப்படுத்தி கொள்ள.

698
00:57:01,280 --> 00:57:05,840
இங்கே நாம்.

699
00:57:05,840 --> 00:57:09,300
>> இப்போது நாம் இந்த வரிகளை அவுட் கருத்து.

700
00:57:09,300 --> 00:57:13,700
நாம் இந்த நேரத்தில் நம் கிளையில் 7, 3, 9, மற்றும் 6 வேண்டும்.

701
00:57:13,700 --> 00:57:18,870
இந்த அனைத்து உழைக்கும் என்று உறுதி செய்ய,

702
00:57:18,870 --> 00:57:25,050
நாம், நம் பைனரி ட்ரீ செய்ய, அவுட் பெரிதாக்கவும் முடியும்

703
00:57:25,050 --> 00:57:30,750
அதை இயக்க, மற்றும் நாம் இப்போது நாங்கள் முற்றிலும் சரி என்று சொல்வதை தான் உள்ளது என்று பார்க்கலாம் -

704
00:57:30,750 --> 00:57:33,110
5 8, மற்றும் 2, மரம் இல்லை.

705
00:57:33,110 --> 00:57:37,960
குறியீடு மீண்டும் சென்று,

706
00:57:37,960 --> 00:57:41,070
எப்படி நாம் நுழைக்க போகிறோம்?

707
00:57:41,070 --> 00:57:46,290
நாம் உண்மையில் முன்னர், 8, மற்றும் 2 5 சேர்த்த போது நாம் என்ன ஞாபகம்.

708
00:57:46,290 --> 00:57:50,100
நாம் ரூட் மணிக்கு தொடங்கியது அங்கு நாங்கள், அந்த Plinko விளையாட்டு

709
00:57:50,100 --> 00:57:52,780
ஒருவர் பின் ஒருவராக மூலம் மரம் ஒன்று கீழே சென்றது

710
00:57:52,780 --> 00:57:54,980
நாம் சரியான இடைவெளி காணப்படுகிறது வரை,

711
00:57:54,980 --> 00:57:57,570
மற்றும் நாம் சரியான இடத்தில் முனை உள்ள கம்பி.

712
00:57:57,570 --> 00:57:59,480
நாம் தான் செய்ய போகிறோம்.

713
00:57:59,480 --> 00:58:04,070
இந்த நாம் பயன்படுத்திய குறியீடு எழுதி போன்ற அடிப்படையில் செயல்பாடு உள்ளது

714
00:58:04,070 --> 00:58:05,910
கணு வேண்டும் இடத்திலிருந்து கண்டுபிடிக்க,

715
00:58:05,910 --> 00:58:10,560
மற்றும் நாம் சரியாக இருக்கிறது முனை நுழைக்க போகிறோம்.

716
00:58:10,560 --> 00:58:17,000
நாம் என்று ஆரம்பித்தாய்.

717
00:58:17,000 --> 00:58:24,200
>> எனவே நாம் ஒரு முனை * நடப்பு = ரூட் வேண்டும்; நாங்கள் குறியீடு உள்ளது பின்பற்ற போகிறோம்

718
00:58:24,200 --> 00:58:26,850
நாம் அது மிகவும் எங்களுக்கு வேலை இல்லை என்று கண்டுபிடிக்கும் வரை.

719
00:58:26,850 --> 00:58:32,390
தற்போதைய உறுப்பு பூஜ்ய அல்ல போது நாம் மரம் செல்ல போகிறோம்,

720
00:58:32,390 --> 00:58:45,280
நாம் கண்டறிய வேண்டும் என்று நடப்பு மதிப்பு நாம் சேர்க்க முயற்சிக்கும் மதிப்பு சமமாக இருக்கும் -

721
00:58:45,280 --> 00:58:49,600
நன்றாக, இந்த நாம் உண்மையில் முனை நுழைக்க முடியவில்லை இதில் நிகழ்வுகளில் ஒன்றாக

722
00:58:49,600 --> 00:58:52,730
மரம் இந்த ஒரு போலி மதிப்பு ஆகும் என்பதால்.

723
00:58:52,730 --> 00:58:59,010
இங்கே நாம் உண்மையில் தவறான திரும்ப போகிறோம்.

724
00:58:59,010 --> 00:59:08,440
இப்போது, நடப்பு மதிப்பு, மதிப்பு குறைவாக இருந்தால்,

725
00:59:08,440 --> 00:59:10,930
இப்போது நாம் சரியான நடவடிக்கை என்று

726
00:59:10,930 --> 00:59:17,190
 மதிப்பு நடப்பு மரம் வலது பகுதியில் சொந்தமானது என்பதால்.

727
00:59:17,190 --> 00:59:30,110
இல்லையெனில், நாங்கள் இடது செல்ல போகிறோம்.

728
00:59:30,110 --> 00:59:37,980
அந்த அடிப்படையில் எமது கொண்டுள்ளது அங்கு செயல்பட வேண்டும்.

729
00:59:37,980 --> 00:59:41,820
>> இந்த கட்டத்தில், நாம், இந்த நேரத்தில் வளைய முடித்துவிட்டேன்

730
00:59:41,820 --> 00:59:47,350
எங்கள் நடப்பு சுட்டிக்காட்டி பூஜ்ய குறிக்கின்ற போகிறது

731
00:59:47,350 --> 00:59:51,540
விழாவில் ஏற்கனவே திரும்பி வரவில்லை என்றால்.

732
00:59:51,540 --> 00:59:58,710
நாம் புதிய கணு செருக வேண்டுமோ அந்த இடத்தில் நாம் எனவே இடத்தில் நடப்பு நேர்கிறது.

733
00:59:58,710 --> 01:00:05,210
என்ன செய்ய வேண்டும், உண்மையில் புதிய கணு உருவாக்க வேண்டும்

734
01:00:05,210 --> 01:00:08,480
இது நாம் மிகவும் எளிதாக செய்ய முடியும்.

735
01:00:08,480 --> 01:00:14,930
நாம், நமது சூப்பர் எளிது உருவாக்க முனையும் செயல்பாட்டை பயன்படுத்தலாம்

736
01:00:14,930 --> 01:00:17,210
நாம் முன்பே செய்யவில்லை என்று ஒன்று -

737
01:00:17,210 --> 01:00:21,400
நாம் தான் வகையான வழங்கப்படும் எடுத்து ஆனால் இப்போது நாம் உறுதி செய்ய வேண்டும் -

738
01:00:21,400 --> 01:00:27,130
நாம் புதிய கணு வந்தார் மதிப்பு உண்மையில் என்று உறுதி செய்ய சோதிக்க வேண்டும்

739
01:00:27,130 --> 01:00:33,410
பூஜ்ய இல்லை, நாம் அதை வெற்று இருந்தால் அந்த நினைவு அணுகும் தொடங்க வேண்டாம், ஏனெனில்.

740
01:00:33,410 --> 01:00:39,910
நாம் புதிய கணு பூஜ்ய சமமாக இல்லை என்பதை உறுதி செய்ய சோதிக்க முடியும்.

741
01:00:39,910 --> 01:00:42,910
அது உண்மையில் பூஜ்ய இருந்தால் அல்லது அதற்கு பதிலாக, நாம், பார்க்க முடியும்

742
01:00:42,910 --> 01:00:52,120
அது வெற்று இருந்தால் மற்றும், நாம் தான் ஆரம்பத்தில் தவறான திரும்ப முடியும்.

743
01:00:52,120 --> 01:00:59,090
>> இந்த கட்டத்தில், நாங்கள் மரம் அதன் சரியான இடத்தில் புதிய முனை கம்பி வேண்டும்.

744
01:00:59,090 --> 01:01:03,510
நாங்கள் முக்கிய வந்து பார் மற்றும் நாம், முன் உண்மையில் மதிப்புகள் வயரிங் இருந்தது

745
01:01:03,510 --> 01:01:08,470
நாம் அது செய்துகொண்டு வழியில் நாம் கிளையில் 3 வைக்க வேண்டும் என்று பார்க்க

746
01:01:08,470 --> 01:01:11,750
நாம் ரூட் இடது குழந்தை அணுக வேண்டும்.

747
01:01:11,750 --> 01:01:14,920
நாம் மரம் 9 வைத்து போது, நாம் ரூட் உரிமையை குழந்தை அணுக வேண்டும்.

748
01:01:14,920 --> 01:01:21,030
நாம் மரம் ஒரு புதிய மதிப்பை வைத்து பொருட்டு தாய் ஒரு சுட்டிக்காட்டி கொண்டிருக்க வேண்டும்.

749
01:01:21,030 --> 01:01:24,430
செருக மீண்டும் உருட்டுதல், என்று இங்கே மிகவும் வேலைக்கு போகவில்லை

750
01:01:24,430 --> 01:01:27,550
நாம் ஒரு தாய் சுட்டிக்காட்டி இல்லை என்பதால்.

751
01:01:27,550 --> 01:01:31,650
நாம் என்ன செய்ய முடியும் வேண்டும், இந்த இடத்தில், தான்

752
01:01:31,650 --> 01:01:37,080
பெற்றோர் மதிப்பு சரிபார்த்து பார்க்க - நன்றாக, ஐயோ,

753
01:01:37,080 --> 01:01:41,990
பெற்றோர் மதிப்பு தற்போதைய மதிப்பு குறைவாக இருந்தால்,

754
01:01:41,990 --> 01:01:54,440
பின்னர் பெற்றோர் உரிமை குழந்தை புதிய கணு இருக்க வேண்டும்;

755
01:01:54,440 --> 01:02:07,280
இல்லையெனில், பெற்றோர் இடது குழந்தை புதிய கணு இருக்க வேண்டும்.

756
01:02:07,280 --> 01:02:10,290
ஆனால், நாம் மிகவும் இன்னும் இந்த பெற்றோர் சுட்டிக்காட்டி இல்லை.

757
01:02:10,290 --> 01:02:15,010
>> நாம் மரம் வழியாக சென்று அதை பெறுவதற்காக, நாம் உண்மையில் அது கண்காணிக்க வேண்டும்

758
01:02:15,010 --> 01:02:18,440
மேலே எங்கள் வட்டத்திற்கு பொருத்தமான இடத்தை கண்டறிய.

759
01:02:18,440 --> 01:02:26,840
நாம் சேர்த்த செயல்பாடு மேல் திரும்பி வரை ஸ்க்ரோலிங் மூலம் அதை செய்ய முடியும்

760
01:02:26,840 --> 01:02:32,350
மற்றொரு சுட்டிக்காட்டி மாறி தேடும் பெற்றோர் என்று.

761
01:02:32,350 --> 01:02:39,340
நாம் முதலில் பூஜ்ய சமமாக அதை அமைக்க போகிறீர்கள்

762
01:02:39,340 --> 01:02:43,640
பின்னர் ஒவ்வொரு முறையும் நாம், மரம் செல்ல

763
01:02:43,640 --> 01:02:51,540
நாம் தற்போதைய சுட்டிக்காட்டி பொருத்த பெற்றோர் சுட்டிக்காட்டி அமைக்க போகிறீர்கள்.

764
01:02:51,540 --> 01:02:59,140
நடப்பு சமமாக பெற்றோர் அமைக்க.

765
01:02:59,140 --> 01:03:02,260
இந்த வழியில், நாம் செல்ல ஒவ்வொரு முறையும்,

766
01:03:02,260 --> 01:03:05,550
நாம் தற்போதைய சுட்டிக்காட்டி வாங்கியவுடன் incremented உறுதி செய்ய போகிறீர்கள்

767
01:03:05,550 --> 01:03:12,640
பெற்றோர் சுட்டிக்காட்டி அது பின்வருமாறு - மரம் தற்போதைய சுட்டிக்காட்டி விட ஒரு நிலை உயர்.

768
01:03:12,640 --> 01:03:17,370
அனைத்து நல்ல தெரிகிறது.

769
01:03:17,370 --> 01:03:22,380
>> நான் நாம் சரி செய்ய வேண்டும் என்று ஒன்று இந்த முனை திரும்பி பூஜ்ய கட்ட நினைக்கிறேன்.

770
01:03:22,380 --> 01:03:25,380
உண்மையில் வெற்றிகரமாக பூஜ்ய திரும்ப முனை கட்ட பெறுவதற்காக,

771
01:03:25,380 --> 01:03:31,060
நாம், அந்த குறியீடு மாற்ற வேண்டும்

772
01:03:31,060 --> 01:03:37,270
இங்கே ஏனெனில், நாம் malloc சரியான சுட்டிக்காட்டி மீண்டும் உறுதி செய்ய சோதனை.

773
01:03:37,270 --> 01:03:53,390
எனவே, நீங்கள் (n = NULL!), பின் -

774
01:03:53,390 --> 01:03:55,250
malloc சரியான சுட்டிக்காட்டி வந்தார் என்றால், நாம் அதை துவக்க வேண்டும்;

775
01:03:55,250 --> 01:04:02,540
இல்லையெனில், நாங்கள் மட்டும் தருகிறேன், அது எங்களுக்கு பூஜ்ய திரும்பி கதிதான்.

776
01:04:02,540 --> 01:04:13,050
இப்போது அனைத்து நல்ல தெரிகிறது. இந்த உண்மையில் தொகுக்கும் உறுதி செய்யலாம்.

777
01:04:13,050 --> 01:04:22,240
பைனரி ட்ரீ செய்ய, மற்றும் ஓ, நாம் இங்கே ஏதோ ஒரு பொருள் கிடைத்திருக்கிறது.

778
01:04:22,240 --> 01:04:29,230
>> நாம் செயல்பாடு ஒரு தெளிவான அறிவிப்பை முனை கட்ட கிடைத்துவிட்டது.

779
01:04:29,230 --> 01:04:31,950
மீண்டும், இந்த கம்பைலர்களை கொண்டு, நாம் மேலே தொடங்க போகிறோம்.

780
01:04:31,950 --> 01:04:36,380
என்ன அர்த்தம் வேண்டும் நான் உண்மையில் அது பிரகடனம் செய்த முன் நான் முனை கட்ட போன் செய்கிறேன் என்று.

781
01:04:36,380 --> 01:04:37,730
உலகின் மிகவும் விரைவாக குறியீடு திரும்பி செல்லலாம்.

782
01:04:37,730 --> 01:04:43,510
கீழே, மற்றும் நிச்சயமாக போதுமான, என் சேர்த்த செயல்பாடு அறிவித்தார் உள்ளது

783
01:04:43,510 --> 01:04:47,400
உருவாக்க முனையும் செயல்பாடு மேலே,

784
01:04:47,400 --> 01:04:50,070
ஆனால் நான் சேர்த்த உள்ளே முனை உருவாக்க பயன்படுத்த முயற்சி செய்கிறேன்.

785
01:04:50,070 --> 01:05:06,610
நான் மற்றும் நகல் போக போகிறேன் - பின்னர் மேல் இங்கு உருவாக்க முனையும் செயல்பாடு வழி ஒட்டவும்.

786
01:05:06,610 --> 01:05:11,750
அந்த வழியில், வட்டம் என்று வேலை செய்யும். இந்த மற்றொரு போய் கொடுக்கலாம்.

787
01:05:11,750 --> 01:05:18,920
இப்போது அனைத்து தொகுத்தெழுதுகிறது. அனைத்து நல்லது.

788
01:05:18,920 --> 01:05:21,640
>> ஆனால் இந்த கட்டத்தில், நாம் உண்மையில் நம் சேர்த்த செயல்பாடு என்று இல்லை.

789
01:05:21,640 --> 01:05:26,510
நாம் அதை தொகுக்கும் என்று, எனவே சென்று சில அழைப்புகளை உள்ளே போட அனுமதிக்க

790
01:05:26,510 --> 01:05:28,240
எங்கள் முக்கிய செயல்பாடு அதை செய்ய விடுங்கள்.

791
01:05:28,240 --> 01:05:32,390
இங்கே, நாங்கள், 5, 8, மற்றும் 2, வெளியே கருத்து

792
01:05:32,390 --> 01:05:36,680
மற்றும் நாம் கீழே இங்கே அவர்களை கம்பி இல்லை.

793
01:05:36,680 --> 01:05:41,640
நாட்டின் சில அழைப்புகள் செருக செய்யலாம்,

794
01:05:41,640 --> 01:05:46,440
மற்றும் அது கூட நாம் பயன்படுத்திய பொருட்களை அதே வகையான பயன்படுத்த அனுமதிக்க

795
01:05:46,440 --> 01:05:52,810
நாங்கள் எல்லாம் ஒழுங்காக செருகிய நடந்தது என்பதை உறுதி செய்ய இந்த printf அழைப்புகள் போது.

796
01:05:52,810 --> 01:06:00,550
நான், நகலெடுத்து ஒட்டவும் போகிறேன்

797
01:06:00,550 --> 01:06:12,450
நாம் சேர்த்த செய்ய போகிறோம் பதிலாக உள்ளது.

798
01:06:12,450 --> 01:06:30,140
அதற்கு பதிலாக 6, 10, மற்றும் 1, நாங்கள் 5 8, மற்றும் 2, பயன்படுத்த போகிறோம்.

799
01:06:30,140 --> 01:06:37,320
இந்த வட்டம் மரத்தில் 5 8, மற்றும் 2, நுழைக்க வேண்டும்.

800
01:06:37,320 --> 01:06:44,050
தொகுத்தல். அனைத்து நல்லது. இப்போது நாம் உண்மையில் நம் நிரலை இயக்க வேண்டும்.

801
01:06:44,050 --> 01:06:47,330
>> எல்லாம் பொய் திரும்பினார்.

802
01:06:47,330 --> 01:06:53,830
எனவே, 5, 8, மற்றும் 2 செல்லவில்லை, மற்றும் கொண்டுள்ளது அல்லது அவர்களை கண்டுபிடிக்க முடியவில்லை போல் தெரிகிறது.

803
01:06:53,830 --> 01:06:58,890
என்ன நடக்கிறது? வெளியே பெரிதாக்க வேண்டும்.

804
01:06:58,890 --> 01:07:02,160
முதல் பிரச்சனை, நுழைவு தவறான திரும்ப தோன்றியது என்று

805
01:07:02,160 --> 01:07:08,750
அதை நாம் மீண்டும் தவறான அழைப்பு விட்டு ஏனெனில் அது போல், தெரிகிறது

806
01:07:08,750 --> 01:07:14,590
நாம் உண்மையில் உண்மை திரும்பினார்.

807
01:07:14,590 --> 01:07:17,880
நாம் அமைக்க முடியும்.

808
01:07:17,880 --> 01:07:25,290
நாம் கூட இரண்டாவது பிரச்சனை இப்போது, தான் - இந்த சேமிக்க, இந்த விலகினார்

809
01:07:25,290 --> 01:07:34,530
மீண்டும் செய்ய ரன், அதை இயக்கவும், தொகுத்தல் -

810
01:07:34,530 --> 01:07:37,670
நாம் வேறு ஏதாவது இங்கே நடந்தது என்று பாருங்கள்.

811
01:07:37,670 --> 01:07:42,980
5, 8 மற்றும் 2 இன்னமும் மரம் காணப்படுகிறது.

812
01:07:42,980 --> 01:07:44,350
அதனால், என்ன நடக்கிறது?

813
01:07:44,350 --> 01:07:45,700
>> இந்த குறியீடு இந்த ஒரு பார்க்கலாம்.

814
01:07:45,700 --> 01:07:49,790
நாம் இந்த கண்டுபிடிக்க முடியும் என்றால் பார்க்கலாம்.

815
01:07:49,790 --> 01:07:57,940
நாம் பெற்றோர் பூஜ்ய இல்லை தொடங்க.

816
01:07:57,940 --> 01:07:59,510
நாம், ரூட் சுட்டிக்காட்டி சமமாக தற்போதைய சுட்டிக்காட்டி அமைக்க

817
01:07:59,510 --> 01:08:04,280
நாம் மரம் வழியாக நம் வழி கீழே வேலை செய்ய போகிறீர்கள்.

818
01:08:04,280 --> 01:08:08,650
தற்போதைய முனை வெற்று இல்லையெனில், நாங்கள் கொஞ்சம் கீழே நகர்த்த முடியும் என்பது எனக்கு தெரியும்.

819
01:08:08,650 --> 01:08:12,330
நாம், தற்போதைய சுட்டிக்காட்டி சமமாக இருக்கும் எங்கள் பெற்றோர் சுட்டிக்காட்டி அமைக்க

820
01:08:12,330 --> 01:08:15,420
மதிப்பு சரி - மதிப்புகள் அதே நாம் தவறான திரும்பினார்.

821
01:08:15,420 --> 01:08:17,540
மதிப்புகள் குறைவாக இருந்தால், நாம் சரி சென்றார்;

822
01:08:17,540 --> 01:08:20,399
இல்லையெனில், நாங்கள் இடது சென்றார்.

823
01:08:20,399 --> 01:08:24,220
நாம் ஒரு முனை உருவாக்க. நான் கொஞ்சம் பெரிதாக்க வேண்டும்.

824
01:08:24,220 --> 01:08:31,410
இங்கே, நாங்கள் அதே இருக்கும் மதிப்புகள் வரை கம்பி முயற்சி செய்ய போகிறோம்.

825
01:08:31,410 --> 01:08:37,250
என்ன நடக்கிறது? ஒருவேளை Valgrind எங்களுக்கு ஒரு குறிப்பை கொடுக்க முடியும் என்றால் பார்க்கலாம்.

826
01:08:37,250 --> 01:08:43,910
>> நான் தான் மிகவும் விரைவாக ரன்கள் Valgrind Valgrind பயன்படுத்த விரும்புகிறேன்

827
01:08:43,910 --> 01:08:46,729
எந்த நினைவக பிழைகள் இருந்தால் நீங்கள் சொல்கிறது.

828
01:08:46,729 --> 01:08:48,300
நாம், குறியீடு மீது Valgrind ரன் போது

829
01:08:48,300 --> 01:08:55,859
நீங்கள் பார்க்க முடியும் என உரிமை here--Valgrind./binary_tree--and வெற்றி உள்ளிடவும்.

830
01:08:55,859 --> 01:09:03,640
நாம் எந்த நினைவக பிழை இல்லை என்று பார்க்க, அதனால் எல்லாம் இதுவரை பரவாயில்லை போல் தெரிகிறது.

831
01:09:03,640 --> 01:09:07,529
நாங்கள் இல்லை, ஏனெனில் நாங்கள், நாங்கள் என்று சில நினைவக கசிவை வேண்டும்

832
01:09:07,529 --> 01:09:08,910
எங்கள் முனைகளில் எந்த விடுவிக்க நடக்கிறது.

833
01:09:08,910 --> 01:09:13,050
அது உண்மையில் என்ன நடக்கிறது என்பதை GDB இயங்கும் பார்க்கலாம்.

834
01:09:13,050 --> 01:09:20,010
நாம் gdb ஐ செய்வேன். / Binary_tree. அது நன்றாக வரை துவங்கியதும்.

835
01:09:20,010 --> 01:09:23,670
தான் சேர்த்த ஒரு பிரேக் பாயிண்ட் அமைக்கலாம்.

836
01:09:23,670 --> 01:09:28,600
தான் இயக்க வேண்டும்.

837
01:09:28,600 --> 01:09:31,200
நாம் உண்மையில் நுழைவு என்று எப்போதும் போல தெரிகிறது.

838
01:09:31,200 --> 01:09:39,410
பிரச்சனை இப்போது நான் முக்கிய இங்கு கீழே மாற்றப்பட்ட போது அது போல -

839
01:09:39,410 --> 01:09:44,279
கொண்டிருக்கும் இந்த printf அழைப்புகள் அனைத்து -

840
01:09:44,279 --> 01:09:56,430
நான் உண்மையில் நுழைவு அழைக்க இந்த மாற்றம்.

841
01:09:56,430 --> 01:10:01,660
இப்போது அதை முயற்சித்து கொடுக்கலாம். அது தொகுக்க வேண்டும்.

842
01:10:01,660 --> 01:10:09,130
அனைத்து அங்கு நல்ல தெரிகிறது. இப்போது அது இயங்கும் முயற்சி செய்யலாம், என்ன நடக்கிறது என்று பார்க்கலாம்.

843
01:10:09,130 --> 01:10:13,320
அது சரி! எல்லாம் நல்ல தெரிகிறது.

844
01:10:13,320 --> 01:10:18,130
>> யோசிக்க இறுதி விஷயம், இந்த நுழைவு எந்த விளிம்பில் உள்ளன?

845
01:10:18,130 --> 01:10:23,170
அது மாறிவிடும் எப்போதும் யோசிக்க சுவாரஸ்யமான என்று ஒரு முனை வழக்கில், அந்த

846
01:10:23,170 --> 01:10:26,250
இது, உங்கள் மரம் காலியாக இருந்தால் என்ன நடக்கும் இந்த நுழைவு செயல்பாடு அழைப்பு?

847
01:10:26,250 --> 01:10:30,330
இது வேலை செய்யும்? சரி, அது ஒரு முயற்சி கொடுக்க வேண்டும்.

848
01:10:30,330 --> 01:10:32,110
- Binary_tree கேட்ச். -

849
01:10:32,110 --> 01:10:35,810
நாம் இந்த சோதிக்க போகிறோம் வழி, நாம், நமது முக்கிய செயல்பாடு கீழே போக போகிறோம்

850
01:10:35,810 --> 01:10:41,690
மற்றும் பதிலாக இந்த இணைப்பு இந்த முனைகள் வரை விட,

851
01:10:41,690 --> 01:10:56,730
நாம் தான், இந்த விஷயம் வெளியே கருத்து போகிறாய்

852
01:10:56,730 --> 01:11:02,620
அதற்கு பதிலாக முனைகளில் நம்மை வரை வயரிங் பற்றிய,

853
01:11:02,620 --> 01:11:09,400
நாம் உண்மையில் நான் போய் இந்த அனைத்து நீக்க முடியும்.

854
01:11:09,400 --> 01:11:17,560
நாங்கள் எல்லாம் செருக ஒரு அழைப்பு செய்ய போகிறோம்.

855
01:11:17,560 --> 01:11:49,020
எனவே, செய்வோம் - பதிலாக 5, 8, மற்றும் 2, 3, 7 செருக, மற்றும் 9 போகிறோம்.

856
01:11:49,020 --> 01:11:58,440
பின்னர் நாங்கள் அதே 6 சேர்க்க வேண்டும் என்று நான் நினைக்கிறேன்.

857
01:11:58,440 --> 01:12:05,190
சேமிக்க. விலகினார். பைனரி ட்ரீ செய்ய.

858
01:12:05,190 --> 01:12:08,540
இது அனைத்து தொகுத்தெழுதுகிறது.

859
01:12:08,540 --> 01:12:10,320
நாம் அதை அப்படியே ரன் மற்றும் என்ன பார்க்க முடியும்

860
01:12:10,320 --> 01:12:12,770
ஆனால் இது என்று மிகவும் முக்கியமான இருக்கும் நடக்கிறது

861
01:12:12,770 --> 01:12:14,740
நாம், எந்த நினைவக பிழைகள் இல்லை

862
01:12:14,740 --> 01:12:16,840
இந்த நாங்கள் தெரியும் என்று எங்கள் விளிம்பில் நிகழ்வுகளில் ஒன்றாக இருந்து.

863
01:12:16,840 --> 01:12:20,150
>> நாம், அதை Valgrind கீழ் நன்றாக வேலை உறுதி

864
01:12:20,150 --> 01:12:28,310
நாம் தான் Valgrind. / binary_tree இயங்கும் மூலம் செய்யலாம் இது.

865
01:12:28,310 --> 01:12:31,110
நாம் உண்மையில் ஒரு சூழலில் இருந்து ஒரு பிழை உள்ளது போல் -

866
01:12:31,110 --> 01:12:33,790
இந்த அடுக்கு தவறு இல்லை.

867
01:12:33,790 --> 01:12:36,690
என்ன நடந்தது?

868
01:12:36,690 --> 01:12:41,650
அது எங்கே Valgrind உண்மையில் நமக்கு சொல்கிறது.

869
01:12:41,650 --> 01:12:43,050
சிறிது சிறிதாக்குக.

870
01:12:43,050 --> 01:12:46,040
அது நம் நுழைவு விழாவில் நடக்கிறது போல், தெரிகிறது

871
01:12:46,040 --> 01:12:53,420
நாம் நுழைவு உள்ள அளவு 4 ஒரு தவறான வாசிக்க வேண்டும், அங்கு, வரி 60.

872
01:12:53,420 --> 01:13:03,590
பின் போய் இங்கே என்ன நடக்கிறது என்று பார்க்கலாம்.

873
01:13:03,590 --> 01:13:05,350
உண்மையில் விரைவாக அவுட் பெரிதாக்கவும்.

874
01:13:05,350 --> 01:13:14,230
நாங்கள் எல்லாம் பார்க்க முடியும் அதை திரையில் விளிம்பில் சென்று இல்லை என்று உறுதி செய்ய வேண்டும்.

875
01:13:14,230 --> 01:13:18,760
சிறிதுநேரத்தில் என்று இழுக்க. அது சரி.

876
01:13:18,760 --> 01:13:35,030
கீழே, மற்றும் சிக்கல் இங்கே இருக்கிறது.

877
01:13:35,030 --> 01:13:40,120
, நாம் இறங்கி என்ன நடக்கும் நமது தற்போதைய முனை ஏற்கனவே பூஜ்ய உள்ளது

878
01:13:40,120 --> 01:13:44,010
நாம் மிக சிறந்த, சரியான இங்கே பாருங்க எனவே எங்கள் பெற்றோர் முனை, பூஜ்யம் என்பது -

879
01:13:44,010 --> 01:13:47,340
இந்த நிலையில் வளைய உண்மையில் செயல்படுத்தி இருந்தால்,

880
01:13:47,340 --> 01:13:52,330
நமது தற்போதைய மதிப்பு பூஜ்ஜிய ஏனெனில் - நடப்பு பூஜ்யம் என்பது நமது ரூட் பூஜ்ய இல்லை -

881
01:13:52,330 --> 01:13:57,810
பிறகு நமது பெற்றோர், நடப்பு அல்லது சரியான மதிப்பு அமைக்கப்பட்டால்

882
01:13:57,810 --> 01:14:00,580
எனவே, பெற்றோர் கூட வெற்று இருக்கும்.

883
01:14:00,580 --> 01:14:03,700
நாம் அந்த சரிபார்க்க நினைவில் கொள்ள வேண்டும்

884
01:14:03,700 --> 01:14:08,750
அந்த நேரத்தில் நாம் இறங்கி, மற்றும் பெற்றோர்களாகிய நாம் மதிப்பு அணுகும் தொடங்கும்.

885
01:14:08,750 --> 01:14:13,190
அதனால், என்ன நடக்கும்? நன்றாக, என்று பெற்றோர் பூஜ்ய இல்லை -

886
01:14:13,190 --> 01:14:17,990
(பெற்றோர் == NULL) என்றால் - நாம் தெரியும்

887
01:14:17,990 --> 01:14:19,530
மரத்தில் எதுவும் இருக்க கூடாது.

888
01:14:19,530 --> 01:14:22,030
நாம் ரூட் அது நுழைக்க முயற்சி.

889
01:14:22,030 --> 01:14:32,570
நாம் இப்போது ஒரு புதிய கணு சமமாக ரூட் மூலம் அதை செய்ய முடியும்.

890
01:14:32,570 --> 01:14:40,010
இந்த கட்டத்தில், நாம் உண்மையில் இந்த விஷயங்களை செல்ல விரும்பவில்லை.

891
01:14:40,010 --> 01:14:44,780
அதற்கு பதிலாக, இங்கே, நாம், ஒரு வேறு-என்றால், வேறு ஏதேனும் செய்ய முடியும்

892
01:14:44,780 --> 01:14:47,610
அல்லது நாம், ஒரு வேறு இங்கு எல்லாவற்றையும் சேர்த்து முடியும்

893
01:14:47,610 --> 01:14:56,300
ஆனால் இங்கே நாம் தான் வேறு பயன்படுத்த மற்றும் அது வழி செய்வேன்.

894
01:14:56,300 --> 01:14:59,030
இப்போது, நாம் நம் பெற்றோர் பூஜ்ய இல்லை என்று உறுதி செய்ய சோதிக்க போகிறோம்

895
01:14:59,030 --> 01:15:02,160
பின்னர் முன் உண்மையில் அதன் துறைகளில் அணுக முயற்சி.

896
01:15:02,160 --> 01:15:05,330
இந்த நம்மை பிரிவு தவற்றை தவிர்க்க உதவும்.

897
01:15:05,330 --> 01:15:14,740
எனவே, நாம் விட்டு, வெளியே பெரிதாக்கவும் தொகுத்தல், ரன்.

898
01:15:14,740 --> 01:15:18,130
>> இல்லை பிழைகள், ஆனால் நாம் இன்னும் நினைவு கசிவுகள் ஒரு கொத்து வேண்டும்

899
01:15:18,130 --> 01:15:20,650
நாம் முனைகளில் எந்த விடுவித்து ஏனெனில்.

900
01:15:20,650 --> 01:15:24,350
நாம் இங்கே சென்று இருந்தால், ஆனால், நாம், நம் நகல் பாருங்கள்

901
01:15:24,350 --> 01:15:30,880
நாம் நல்ல இது, உண்மை திரும்பி கொண்டு, நன்றாக, எங்கள் செருகி அனைத்து தெரிகிறது என்று பார்க்க.

902
01:15:30,880 --> 01:15:33,050
செருகி அனைத்து உண்மை,

903
01:15:33,050 --> 01:15:36,670
பின்னர் பொருத்தமான கொண்டுள்ளது அழைப்புகளை கூட உண்மை.

904
01:15:36,670 --> 01:15:41,510
>> வேலை நல்ல! நாம் வெற்றிகரமாக நுழைவு எழுதப்பட்ட நான் தெரிகிறது.

905
01:15:41,510 --> 01:15:47,430
என்று நாம் இந்த வாரம் சிக்கல் அமை குறிப்புகள் இடம் இல்லை அவ்வளவுதான்.

906
01:15:47,430 --> 01:15:51,720
யோசிப்பதற்கு ஒரு வேடிக்கை சவாலை நீங்கள் உண்மையில் போய் எப்படி இருக்கும்

907
01:15:51,720 --> 01:15:55,340
இந்த மரம் முனைகளுக்கிடையே அனைத்து இலவச.

908
01:15:55,340 --> 01:15:58,830
நாம், அதனால் வேறு பல வழிகளில் செய்ய முடியும்

909
01:15:58,830 --> 01:16:01,930
ஆனால் நான், சோதனை செய்ய உங்களுக்கு என்று ஒரு செல்கிறேன்

910
01:16:01,930 --> 01:16:06,080
ஒரு வேடிக்கை சவாலாக, முயற்சி மற்றும் நிச்சயமாக செய்ய முடியும் என்று

911
01:16:06,080 --> 01:16:09,490
இந்த Valgrind அறிக்கை பிழைகள் மற்றும் கசிவை இல்லை கொடுக்கிறது என்று.

912
01:16:09,490 --> 01:16:12,880
>> நல்ல அதிர்ஷ்டம் இந்த வாரம் ஹஃப்மேன் கோடிங் பிரச்சினை தொகுப்பில்,

913
01:16:12,880 --> 01:16:14,380
நாம் அடுத்த வாரம் பார்!

914
01:16:14,380 --> 01:16:17,290
[CS50.TV]