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
మేము ప్రశ్నలు యొక్క విభాగం ద్వారా, WALK-ద్వారా ఈ చేయుచున్నారు.

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 చర్చించండి ఈ పోస్ట్ చేయండి.

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
, సరైన స్థలం సూచించడానికి దానిని WIRE

66
00:04:12,290 --> 00:04:20,630
తరువాత తిరిగి WIRE 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
నేను నాలుగో ఒక కనుగొనడానికి వరకు మరియు నోడ్-by-నోడ్ లెక్కింపు ద్వారా నా మార్గం పని.

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
ఇక్కడ, మా చెట్టు యొక్క root సంఖ్య 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
అది మా చెట్టు యొక్క root ఎందుకంటే మరియు 7, ఏ తోబుట్టువుల లేదు

186
00:13:55,540 --> 00:13:59,010
మరియు మాత్రమే ఎప్పుడూ 1 root ఉంది.

187
00:13:59,010 --> 00:14:02,260
7 తోబుట్టువుల కలిగి ఉన్నాయి 7 పై ఒక నోడ్ ఉండాలి.

188
00:14:02,260 --> 00:14:07,480
ఇకపై చెట్టు యొక్క root అవుతుంది కేసు 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
మేము root వద్ద విలువ 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
మేము root వద్ద విలువ 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 root మాత్రమే సాధ్యమయ్యే విలువలను కాదు.

240
00:17:44,240 --> 00:17:50,200
మేము కూడా 3 root వద్ద ఉన్నాయి.

241
00:17:50,200 --> 00:17:52,240
3 root వద్ద ఉంటే ఏమవుతుంది?

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
న వెళ్ళి root వద్ద 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
, మీరు ఈ nice ఫార్మాట్ లో నిల్వ ఒక బైనరీ చెట్టు ఉంటే, అయితే

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 శోధించడానికి మీరు అనుకుంటే, మేము root వద్ద మొదలు కావలసిన.

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 చూసేందుకు ఉంటే, మేము root వద్ద ప్రారంభిస్తుంది.

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 Spaces ఉపయోగించి యొక్క విభాగం, ఈ భాగం,

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
మీరు ఆక్రమించుకోనే స్పెల్లర్ కార్యక్రమం హాష్ పట్టిక విధంగా చేస్తే.

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
కాబట్టి మేము Int విలువ ఉంచారు, మరియు బదులుగా తరువాత మూలకం కేవలం ఒక పాయింటర్ కలిగి ఉంటుంది -

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 నోడ్ * కుడివైపు చైల్డ్;. కూల్.

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
>> ఇప్పుడు మేము ఒక చెట్టు యొక్క root ప్రపంచ నోడ్ * వేరియబుల్ ప్రకటించాలని అవసరం.

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
మేము ఈ root చుట్టూ ప్రయాణిస్తున్న ఉంచడానికి లేదు -

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
మళ్లీ, మేము ప్రాంతాల యొక్క జంట ఇస్తాము, మరియు నేను నోడ్ * root డిక్లేర్ వెళుతున్న.

412
00:31:39,920 --> 00:31:46,770
జస్ట్ నేను ఈ అవినియోగిత విడిచి నిర్ధారించాలి, నేను శూన్యం సమానంగా సెట్ వెళుతున్న.

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 యొక్క ఫలితంగా సమానంగా root సెట్ వెళుతున్న

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-bit Mac లో అది కంపైల్ -

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 లోకి తలదించుకునేలా padding ఉండవచ్చు అని.

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
మరియు ఆ విధంగా అది ఖచ్చితంగా మా చెట్టు చిత్రంలో కనిపిస్తోంది వాటిని WIRE

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
>> ఇప్పుడు మేము మా నోడ్స్ అన్ని రూపొందించినవారు మరియు initialized పొందారు.

471
00:37:37,360 --> 00:37:41,200
మేము, మా root 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
నేను శూన్యం అన్ని గమనికలు initialized కారణం నేను ఖచ్చితంగా ఆ తయారు కేవలం ఉంది

475
00:37:53,020 --> 00:37:56,260
నేను అనుకోకుండా అక్కడ ఏదైనా అవినియోగిత గమనికలు లేదు.

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
>> మూలం వద్ద ప్రారంభించి, నేను root యొక్క ఎడమ బాల 3 అని తెలుసు.

480
00:38:15,630 --> 00:38:21,250
నేను root యొక్క కుడి బాల 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
 చెట్టు మా గ్లోబల్ root వేరియబుల్ ద్వారా చూపారు ఉంటే

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
ఈ ఖచ్చితంగా మేము కొద్దిగా క్రితం ఐప్యాడ్ న చేతితో అని వెతకడం లాగా అన్నారు.

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
మేము% s ఫార్మాట్ పాత్ర పంపు చూడాలని ఉద్దేశ్యంతో స్ట్రింగ్

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 తిరిగి కలిగి ఉంటే స్ట్రింగ్ "FALSE" పంపాలనుకుంటున్నారా.

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
ఈ మా కలిగి ఫంక్షన్ పని ఉంటే గుర్తించడానికి ఒక nice, సులభ మార్గం.

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
మేము వద్ద చూస్తున్న, మరియు ప్రస్తుత నోడ్ రూట్ నోడ్ కు initialized కావడం అని.

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
ప్రస్తుత శూన్యం సమానం కాదు వరకు మేము iterate చూడాలని.

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
కూల్ స్టఫ్.

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
హేయ్, మీకు తెలిసిన, Passed ఇన్ విలువ initialized ఒక నిండుగా కేటాయించడం నోడ్ తిరిగి.

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
మేము నిజంగా ప్రతి ఇతర సూచించడానికి నోడ్స్ అప్ WIRE పేరు క్రింద,

645
00:51:18,520 --> 00:51:21,030
ఆ ఎందుకంటే మేము మా ఫంక్షన్ లో చెయ్యలేరు.

646
00:51:21,030 --> 00:51:37,400
కానీ, లెట్స్ చేయండి root = 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
ప్రతిది చక్కగా nice మరియు పని ఉన్నట్లు ఫలితాల నుండి, కనిపిస్తోంది.

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
మేము root వద్ద ప్రారంభించారు మేము, ఆ 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
>> కాబట్టి మేము ఒక నోడ్ * ప్రస్తుత = root ఉన్నాయి; మేము కోడ్ కలిగి అనుసరించండి చూడాలని

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
>> ఈ సమయంలో, మేము చెట్టు దాని సరైన స్థానంలో నూతన నోడ్ WIRE ఉంటుంది.

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
మేము root ఎడమ చైల్డ్ ప్రాప్తి.

747
01:01:11,750 --> 01:01:14,920
మేము చెట్టు 9 ఉంచారు, మేము root కుడి బాల యాక్సెస్ వచ్చింది.

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
మేము ప్రస్తుత పాయింటర్ చూసారు పెంచే హామీ చూడాలని

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
బైనరీ చెట్టు చేయండి, మరియు, OH మేము ఇక్కడ జరగబోతోంది కొన్ని అంశాలను పొందారు.

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
మరియు తర్వాత మేము డౌన్ వాటిని ఇక్కడ అప్ WIRE లేదు.

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
మేము, root పాయింటర్ సమానంగా ప్రస్తుత పాయింటర్ సెట్

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
మరియు ఇక్కడ, మేము అదే అని విలువలు అప్ WIRE ప్రయత్నించండి చూడాలని.

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
మా ప్రస్తుత విలువ NULL ఎందుకంటే - ప్రస్తుత శూన్య కాబట్టి మా root శూన్య ఉంది -

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
కాబట్టి, ఏమి జరుగుతుంది? Well, ఉంటే మాతృ శూన్య ఉంది -

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
మేము root వద్ద ఇన్సర్ట్ చెయ్యడానికి ప్రయత్నిస్తున్నారు ఉండాలి.

889
01:14:22,030 --> 01:14:32,570
మేము కొత్త నోడ్ సమానంగా root అమర్చుట ద్వారా ఆ చేయవచ్చు.

890
01:14:32,570 --> 01:14:40,010
ఈ సమయంలో, మేము నిజంగా ఈ ఇతర విషయాలు ద్వారా వెళ్ళడానికి లేదు.

891
01:14:40,010 --> 01:14:44,780
బదులుగా, ఇక్కడే, మేము, ఒక else-ఉంటే-else గాని చేయగలరు

892
01:14:44,780 --> 01:14:47,610
లేదా మేము, ఒక else ఇక్కడ ప్రతిదీ అప్ కలవచ్చు

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]