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