1
00:00:00,000 --> 00:00:02,500
[Powered by Google Translate] [7 વિભાગ] [ઓછી સાધારણ]

2
00:00:02,500 --> 00:00:04,890
[Nate 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 ચર્ચા પર પોસ્ટ કરો.

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
અને પછી ફરી વાયર 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
તમે અહીં જોઈ શું ખૂબ સરળ દ્વિસંગી વૃક્ષ નોડ diagramming બે માર્ગો છે

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
અને હું 7 ના નિર્દેશક ડાબા બાળક 3 સમાવતી નોડ માટે નિર્દેશ સેટ જાઉં છું,

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
તેથી, હું 3, 9, અને 6 7 વંશજો તરીકે બધા હોય છે.

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
આ 6 કોઈ બહેન છે કારણ કે 9 કોઈપણ બાળકો નથી.

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
શરૂ કરવા માટે, અમે અમારા મૂળ વૃક્ષ ફરીથી લખી શકશો જ્યાં અમે 7 હતી, અને તે પછી 3 એ,

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
પ્રથમ, અમે 7 હોય અને પછી શકે 9 એ,

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
અથવા, અમે 3 નહિં, તો શકે 6, પછી 9, 7 પછી.

249
00:18:26,710 --> 00:18:35,020
અથવા, અમે 3 નહિં, તો કરી શકે 7, પછી 6, 9, પછી.

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 થી અમે 6 કરવું અને પછી કરી શકો છો 7.

253
00:18:54,710 --> 00:19:06,980
અથવા, અમે 3 નહિં, તો કરી શકો છો 9, પછી 7, અને પછી 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
અમે 7 શરૂ થાય છે, અમે ડાબી પર 3 હોય છે, જમણી બાજુ પર 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
અને અમે શોધી છે કે જ્યારે 6 - મૂલ્ય અમે શોધી રહ્યાં છો - 3 કરતાં વધુ હોય છે,

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
સાથે પેન અને કાગળ અથવા, આ કિસ્સામાં iPad, અને stylus.

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
દ્વિસંગી વૃક્ષ પૂર્ણાંક કિંમતો સમાવતી નોડ માટે -

381
00:29:03,080 --> 00:29:07,110
ફક્ત કિંમતો છે કે અમે અમારી પહેલાં diagramming બહાર દોર્યું જેવા હોય છે.

382
00:29:07,110 --> 00:29:11,740
અમે આ boilerplate 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
અમે સ્ટ્રક્ટ નોડ આ typedef મળી છે,

388
00:29:27,870 --> 00:29:34,430
અને અમે આ સ્ટ્રક્ટ નોડ સ્ટ્રક્ટ નોડ આ પહેલાંથી નામ આપી છે

389
00:29:34,430 --> 00:29:39,350
તેથી અમે પછી તે સંદર્ભ લો ત્યારથી અમે સ્ટ્રક્ટ નોડ પોઇંટરો માંગો છો શકો છો

390
00:29:39,350 --> 00:29:45,740
અમારા સ્ટ્રક્ટ ભાગ તરીકે, પણ અમે તો પછી આ ઘેરી કર્યું છે -

391
00:29:45,740 --> 00:29:47,700
એક typedef માં - અથવા બદલે, આ બંધ

392
00:29:47,700 --> 00:29:54,600
જેથી, કોડ પાછળથી, અમે માત્ર એક સ્ટ્રક્ટ નોડ બદલે નોડ તરીકે આ સ્ટ્રક્ટ ઉલ્લેખ કરી શકે છે.

393
00:29:54,600 --> 00:30:03,120
>> આ ખૂબ યાદી singly સાથે જોડાયેલી વ્યાખ્યા જેવી જ છે કે અમે ગયા સપ્તાહે જોયું હશે છે.

394
00:30:03,120 --> 00:30:20,070
આ કરવા માટે, ચાલો માત્ર બહાર boilerplate લખીને શરૂ કરો.

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
અમે singly સાથે જોડાયેલી યાદીઓ સાથે હતી -

398
00:30:33,970 --> 00:30:38,110
અમે ડાબી અને જમણી બાળક પોઇન્ટર હોય રહ્યા છીએ.

399
00:30:38,110 --> 00:30:42,880
કે ખૂબ સરળ પણ છે - સ્ટ્રક્ટ નોડ * ડાબી બાળક;

400
00:30:42,880 --> 00:30:51,190
; અને સ્ટ્રક્ટ નોડ * અધિકાર બાળક. સરસ.

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
જોકે અમે જોશો કે જો તમે આ વિધેયો recursively લખવા માંગો છો,

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 બનાવવા માટે, હું તેને સમાન સેટ જાઉં છું માટે null.

413
00:31:46,770 --> 00:31:52,210
હવે, મુખ્ય કાર્ય માં - જે અમે ખરેખર ઝડપથી અહીં લખી કરીશું -

414
00:31:52,210 --> 00:32:00,450
પૂર્ણાંક મુખ્ય (પૂર્ણાંક argc, const ઘરનાં પરચૂરણ કામો * argv []) -

415
00:32:00,450 --> 00:32:10,640
અને હું const તરીકે મારા 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
તે દંડ ક્યાં રીત છે. તે દંડ કરવા માટે તેને રજા - એ const ભૂલી જવું જો તમે ગમશે.

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
કારણ કે તે હમણાં છે, હું એક નિર્દેશક કે null સેટ છે મળ્યો છે,

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) અથવા 12 malloc - આ કંઈક કરી -

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
હંમેશા sizeof વાપરો જાતે સ્ટ્રક્ટ ક્ષેત્રો એકત્ર કરવા માટે વિરોધ કર્યો હતો.

443
00:34:15,030 --> 00:34:20,500
અન્ય કારણ એ છે કે ત્યાં પણ ગાદી કે કમ્પાઇલરનું સ્ટ્રક્ટ માં મૂકે હોઈ શકે છે.

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
>> હવે અમે અમારા ગાંઠો તમામ બનાવનાર અને આરંભ મેળવ્યા છે.

471
00:37:37,360 --> 00:37:41,200
અમે મળી છે અમારા રુટ 7 સમાન સુયોજિત કરો, અથવા 7 કિંમત સમાવે છે,

472
00:37:41,200 --> 00:37:46,510
અમારા 3 સમાવતી નોડ, અમારા 6 સમાવતી નોડ, અને અમારા નોડ 9 છે.

473
00:37:46,510 --> 00:37:50,390
આ બિંદુએ, બધા અમે હોય તો વાયર અપ બધું છે.

474
00:37:50,390 --> 00:37:53,020
કારણ હું તમામ પોઇંટરો આરંભ કરવા માટે null છે એ જ કે હું કે ખાતરી કરો

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
માતાનો 3 અધિકાર બાળક છે, કે જે 6 છે.

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 (પૂર્ણાંક કિંમત છે) સમાવે છે' એક પ્રોટોટાઈપ.

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
તેથી અમે prototyping કોઇ પણ પ્રકારની કરતા નથી.

497
00:39:48,990 --> 00:39:55,960
તેથી, bool ધરાવે છે (પૂર્ણાંક કિંમત).

498
00:39:55,960 --> 00:40:00,330
ત્યાં અમે જાઓ. ત્યાં અમારા boilerplate ઘોષણા છે.

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
અને પછી અમે પણ આ પ્રકારની કરી છે ઉપયોગ કરીને - આ nonstandard '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 ખોટા વળતર સમાવે કરવા માંગો છો.

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
અમે ભારપૂર્વક કહેવું જઈ રહ્યાં છો ત્યાં સુધી વર્તમાન માટે null સમાન નથી.

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
તે વૃક્ષ 6 શોધે, 10 શોધી કારણ કે 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
હેય તમને ખબર છે, એક ઢગલો ફાળવવામાં મૂલ્ય પસાર થતા-સાથે આરંભ નોડ આપે છે.

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
પરંતુ, ચાલો રુટ કરવું = (7) build_node; નોડ ત્રણ * = build_node (3);

647
00:51:37,400 --> 00:51:47,980
નોડ છ * = (6) build_node; નોડ નવ * = build_node (9);.

648
00:51:47,980 --> 00:51:52,590
અને હવે, અમે પણ માટે ગાંઠો ઉમેરવા માગે છે -

649
00:51:52,590 --> 00:52:03,530
નોડ પાંચ * = (5) build_node; નોડ આઠ * = build_node (8);

650
00:52:03,530 --> 00:52:09,760
અને અન્ય નોડ શું હતું? માતાનો અહીં જોવા દો. અમે પણ એ 2 ઉમેરવા માગે છે -

651
00:52:09,760 --> 00:52:20,280
નોડ બે * = (2) build_node;.

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
અને પછી 8 ના 9 ડાબી બાળક તરીકે અનુસરે છે, તેથી નવ - આઠ> left_child =;

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
અમારા insert કામ કરવા માટે માત્ર દલીલ.

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
ચાલો એવા સમાવે ઉપર જમણી insert કાર્ય મૂકો.

687
00:55:47,220 --> 00:55:56,360
ફરી, તે bool insert કહેવાય (પૂર્ણાંક કિંમત) બનશે.

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
અમે અમારા insert કાર્ય પર આધાર રાખે છે કે જે કરવું પડશે.

693
00:56:30,600 --> 00:56:35,510
અમે અમારા insert કાર્ય પર આધાર રાખતા નથી શરૂઆતથી સમગ્ર વૃક્ષ હજુ સુધી નિર્માણ કરશે

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
અને તેના બદલે, અમે કૉલ અમારા insert કાર્ય શામેલ કરવા પડશે

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
યાદ રાખો, આપણે શું કર્યું જ્યારે અમે ખરેખર 5 દાખલ કરવામાં આવી હતી, 8, છે અને 2 અગાઉ.

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
અમારા વર્તમાન નિર્દેશક માટે null પોઇન્ટ કરી રહ્યું છે

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
હતી અમે રુટ ડાબી બાળક વાપરી શકાય છે.

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
આ પિતૃ કિંમત તપાસો અને જુઓ - સારી gosh,

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
અમે સ્ક્રોલિંગને દ્વારા કે અમારા insert કાર્ય ટોચ પર પાછા અપ કરી શકો છો

760
01:02:26,840 --> 01:02:32,350
અને અન્ય નિર્દેશક ચલ ટ્રેકિંગ પિતૃ કહેવામાં આવે છે.

761
01:02:32,350 --> 01:02:39,340
અમે તેને સમાન સેટ જઈ રહ્યાં છો પ્રારંભમાં null,

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
દ્વિસંગી વૃક્ષ બનાવે છે, અને ઓહ, અમે કેટલીક અહીં જઈને સામગ્રી મળી છે.

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
સરકાવો અને ખાતરી કરો કે પર્યાપ્ત, મારા insert કાર્ય જાહેર કરવામાં આવે છે

783
01:04:43,510 --> 01:04:47,400
બિલ્ડ નોડ કાર્ય ઉપર,

784
01:04:47,400 --> 01:04:50,070
પણ મને insert ની અંદર નોડ બિલ્ડ ઉપયોગ કરવાનો પ્રયાસ કરી રહ્યો છું.

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
>> પરંતુ આ સમયે, અમે ખરેખર અમારા insert કાર્ય ન કહેવાય છે.

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
અને બદલે સમાવે અમે insert કરવા જઇ રહ્યા છો.

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
પ્રથમ સમસ્યા એ હતી કે insert ખોટા પાછા લાગતું હતું,

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
અને અહીં, અમે સુધી કિંમતો 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
ચાલો insert પર બ્રેક બિંદુ સુયોજિત કરો.

836
01:09:23,670 --> 01:09:28,600
ચાલો ચલાવો.

837
01:09:28,600 --> 01:09:31,200
એવું લાગે છે કે અમે insert ખરેખર ક્યારેય કહેવામાં આવે છે.

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
હું આ ખરેખર ક્યારેય બદલીને insert કૉલ કરો.

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
>> ફાઇનલ વિશે વિચારો વસ્તુ છે, ત્યાં આ insert કોઈપણ ધાર કિસ્સાઓમાં?

845
01:10:18,130 --> 01:10:23,170
અને તે તારણ છે કે જે સારી રીતે, એક ધાર કેસ કે હંમેશા માટે વિશે વિચારો રસપ્રદ

846
01:10:23,170 --> 01:10:26,250
છે, જો તમારો વૃક્ષ ખાલી છે બને છે અને તમે આ insert કાર્ય કહી?

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, અમે 7 દાખલ કરો, 3, અને 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
જે અમે ફક્ત binary_tree. / Valgrind ચલાવીને કરવું પડશે.

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
એવું લાગે છે કે તે અમારી insert કાર્ય થઇ રહ્યું છે તે,

871
01:12:46,040 --> 01:12:53,420
જ્યાં અમે insert અંતે 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
>> નોકરી સારી! એવું લાગે છે કે અમે સફળતાપૂર્વક insert તેવા પરચૂરણ ખર્ચ કર્યો છે.

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]