[Powered by Google Translate] [7 વિભાગ: વધુ સાનુકૂળ]
[રોબ બોડેન] [હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે] [CS50.TV]
અધિકાર છે. જેથી હું મારા ઇમેઇલમાં જણાવ્યું હતું કે, જેમ
આ વિભાગ દ્વિસંગી-વૃક્ષ સઘન પ્રયત્ન રહ્યું છે.
પરંતુ ત્યાં છે કે ઘણા પ્રશ્નો નથી.
તેથી અમે પ્રયત્ન કરો અને બહાર દરેક પ્રશ્ન દોરવા જઈ રહ્યાં છો
અને વસ્તુઓ કરવાથી તમામ શ્રેષ્ઠ રીતે દુઃખદાયક વિગતવાર માં જાઓ.
જેથી શરૂઆતમાં અધિકાર, અમે દ્વિસંગી વૃક્ષો અને સામગ્રી ની નમૂનો રેખાંકનો પસાર થાય છે.
અહીં, "યાદ રાખો કે દ્વિસંગી વૃક્ષ એક કડી થયેલ યાદી જ ગાંઠો છે,
ડાબી 'બાળક' માટે એક: બદલે એક નિર્દેશક ઓફ સિવાય ત્યાં બે છે
અને જમણી 'બાળક' માટે. એક "
દ્વિસંગી વૃક્ષ તેથી સંકળાયેલી યાદી જેમ જ છે,
આ સ્ટ્રક્ટ સિવાય બે પોઇન્ટર હોય રહ્યું છે.
ત્યાં trinary વૃક્ષો, જે ત્રણ પોઇન્ટર છે જઇ રહ્યા છે,
ત્યાં N-એરી વૃક્ષો છે, કે જે માત્ર સામાન્ય નિર્દેશક હોય છે
કે પછી તમે malloc હોય એટલા મોટા હોય પ્રયત્ન
બધા શક્ય બાળકોને પૂરતી પોઇન્ટર.
તેથી દ્વિસંગી વૃક્ષ માત્ર બે સતત નંબર હોય બને છે.
જો તમે કરવા માંગો છો, તો તમે unary વૃક્ષ તરીકે સંકળાયેલી યાદી આપી શકે છે,
પરંતુ હું નથી વિચારતો કે તે કહે છે.
"દ્વિસંગી વૃક્ષ નોડ એક રેખાકૃતિ બોક્સ અને તીરો દોરો
માતાનો Nate મનપસંદ નંબર, 7, જ્યાં દરેક બાળક નિર્દેશક નલ છે. સમાવતી "
તેથી આઇપેડ મોડ.
>> તે ખૂબ સરળ હશે.
અમે હમણાં જ એક નોડ છે જઈ રહ્યાં છો, હું તે એક ચોરસ તરીકે દોરવા પડશે.
અને હું અહીં કિંમતો દોરવા પડશે.
જેથી કિંમત અહીં જશે,
અને પછી નીચે અહીં અમે ડાબી પર ડાબી નિર્દેશક અને જમણી બાજુ પર જમણી નિર્દેશક પડશે.
અને તે ઘણો છે સંમેલન તેથી તે ડાબી અને જમણી નિર્દેશક નામો કહી છે.
આ બંને માટે નલ હશે આવે છે.
કે જે હમણાં જ નલ હશે, અને તે માત્ર નલ હશે.
ઠીક છે. તેથી અહીં બેક.
"એક કડી થયેલ યાદી સાથે, અમે માત્ર એક નિર્દેશક સ્ટોર હતો
યાદીમાં ક્રમમાં સમગ્ર કડી થયેલ યાદી છે, અથવા સંપૂર્ણ યાદી યાદ માં પ્રથમ નોડ છે.
તેવી જ રીતે, વૃક્ષો સાથે, અમે માત્ર એક નિર્દેશક સંગ્રહિત હોય છે
એક નોડ ક્રમમાં સમગ્ર વૃક્ષ યાદ કરવા માટે.
આ નોડ CALLE આ વૃક્ષના 'રુટ' છે.
પહેલાં તમારી રેખાકૃતિ પર બિલ્ડ અથવા એક નવું ડ્રો
જેમ કે તમે બાઈનરી વૃક્ષ એક નિરૂપણ બોક્સ અને તીર છે
સાથે 7 કિંમત, પછી ડાબી માં 3,
પછી જમણી 9, અને પછી 6 3 જમણી બાજુએ. "
ચાલો જોવા જો હું મારા માથા કે તમામ યાદ કરી શકો છો.
તેથી આ અમારી અહીં રુટ હોવા રહ્યું છે.
અમે કેટલાક નિર્દેશક ક્યાંક હોય છે, કંઈક પડશે કે અમે રુટ કહી શકશો,
અને તે આ વ્યક્તિ તરફ ઇશારો કરે છે.
હવે નવા નોડ બનાવવા માટે,
અમે શું હોય ડાબી બાજુ પર 3?
3 સાથે નવી ગાંઠ, અને તેથી તે શરૂઆતમાં નલ નિર્દેશ કરે છે.
મેં હમણાં જ એન મૂકીશું
હવે અમે બનાવવા માટે કે 7 ડાબી પર જાઓ કરવા માંગો છો.
તેથી અમે આ નિર્દેશક બદલવા માટે હવે આ વ્યક્તિ માટે નિર્દેશ કરે છે.
અને અમે એ જ કરી. અમે અહીં ઉપર 9 માંગો છો
જે શરૂઆતમાં માત્ર નલ કહે છે.
અમે 9 થી આ નિર્દેશક બિંદુ, બદલી રહ્યા છીએ,
અને હવે અમે 3 જમણી 6 મૂકવા માંગો છો.
તેથી તે ચાલી રહ્યું છે - 6 એક બનાવે છે.
અને તે વ્યક્તિ ત્યાં નિર્દેશ કરશે.
ઠીક છે. જેથી તમામ અમને કરવા માટે પૂછે નથી.
>> હવે આપણે કેટલીક પરિભાષા પર જાઓ.
અમે પહેલાથી જ કેવી રીતે વૃક્ષની રુટ વૃક્ષ નોડ ટોચના મોટાભાગના વિશે વાત કરી.
એક 7 છે. વૃક્ષના તળિયે ગાંઠો પાંદડા કહેવામાં આવે છે.
કોઈપણ નોડ કે જે માત્ર તેના બાળકો તરીકે નલ એક પર્ણ છે.
તેથી તે શક્ય છે, જો અમારા દ્વિસંગી વૃક્ષ માત્ર એક નોડ છે,
કે એક વૃક્ષ એક પાંદડુ છે, અને તે છે.
"વૃક્ષના 'ઊંચાઇ' અંતરોની સંખ્યા તમે બનાવવા માટે હોય છે
માટે ટોચ પરથી એક પર્ણ મેળવવા. "
અમે પ્રવેશ મેળવવા માટે, બીજા પડશે, તફાવત
સંતુલિત અને અસંતુલિત દ્વિસંગી વૃક્ષો વચ્ચે,
હવે પરંતુ, આ વૃક્ષ એકંદર ઊંચાઇ
હું 3 છે, કહો છો તેમ છતાં જો તમે અંતરોની સંખ્યા ગણતરી
તમે કરવા માટે 9 મેળવવા બનાવવા હોય, તો પછી તેને ખરેખર માત્ર 2 ની ઊંચાઇ છે.
હમણાં આ એક અસમતોલ દ્વિસંગી વૃક્ષ છે,
પરંતુ અમે સંતુલિત વિશે વાત કરી છે જ્યારે તે સુસંગત હોઈ નોંધાયો પડશે.
તેથી હવે અમે એક વૃક્ષ ગાંઠો વિશે દ્રષ્ટિએ વાત કરી શકો છો
આ વૃક્ષ અન્ય ગાંઠો સંબંધિત.
તેથી હવે અમે માતા - પિતા, બાળકો, ભાઈ, પૂર્વજો, અને વંશજો છે.
તેઓ ખૂબ સામાન્ય અર્થમાં છે, તેઓ શું અર્થ થાય.
તે માતા - પિતા - જો અમે પૂછો.
તેથી 3 ના પિતૃ શું છે?
7 [વિદ્યાર્થીઓ]. >> યાહ. પિતૃ માત્ર પ્રયત્ન શું તમે નિર્દેશ રહ્યું છે.
પછી 7 ના બાળકો શું છે?
3 અને [9 વિદ્યાર્થીઓ]. >> યાહ.
નોંધ કરો કે "બાળકો" શાબ્દિક અર્થ થાય છે બાળકો,
6 તેથી લાગુ નથી, કારણ કે તે પોતાના દીકરા કે દીકરીનું બાળક જેવું છે કરશે.
પરંતુ પછી જો આપણે વંશજો જાઓ, જેથી 7 વંશજો શું છે?
3, 6 અને 9 [વિદ્યાર્થીઓ]. >> યાહ.
રુટ નોડ વંશજો માટે વૃક્ષ બધું હોવું રહ્યું છે,
સિવાય કદાચ રુટ નોડ પોતે જ, જો તમે તે એક વંશજ ધ્યાનમાં નહિં માંગો.
અને છેલ્લે, પૂર્વજો છે, તેથી તેને વિરુદ્દ દિશા છે.
તેથી 6 પૂર્વજો શું છે?
3 અને 7 [વિદ્યાર્થીઓ]. >> યાહ. 9 શામેલ નથી.
તે માત્ર સીધા વંશ માટે રુટ પાછળ છે
છે તમારા પૂર્વજોના હશે.
>> "અમે કહે છે કે દ્વિસંગી વૃક્ષ વૃક્ષ દરેક નોડ માટે જો 'છે આદેશ આપ્યો',
ડાબી બાજુ પર તેના વંશજો તમામ ઓછા મૂલ્યો છે
અને જમણી બાજુ પર જેના તમામ મોટી કિંમતો છે.
ઉદાહરણ તરીકે, ઉપર વૃક્ષ આદેશ આપ્યો છે પરંતુ તે માત્ર શક્ય આદેશ આપ્યો વ્યવસ્થા નથી. "
પહેલાં અમે તે માટે વિચાર,
એક આદેશ આપ્યો દ્વિસંગી વૃક્ષ પણ દ્વિસંગી શોધ ટ્રી તરીકે ઓળખવામાં આવે છે.
અહીં અમે તેને આદેશ આપ્યો દ્વિસંગી વૃક્ષ કૉલ કરી થાય છે,
પરંતુ હું ક્યારેય સાંભળ્યું ન હોય તે આદેશ આપ્યો દ્વિસંગી વૃક્ષ પહેલાં કહેવાય છે,
અને એક ક્વિઝ પર અમે ખૂબ વધુ દ્વિસંગી શોધ વૃક્ષ મૂકી શકે છે.
તેઓ એક જ અને સમાન છો,
અને એ જરૂરી છે કે તમે બાઈનરી વૃક્ષ અને બાઈનરી શોધ વૃક્ષ વચ્ચે તફાવત સમજે છે.
એક દ્વિસંગી વૃક્ષ માત્ર એક વૃક્ષ છે કે બે વસ્તુઓ નિર્દેશ કરે છે.
દરેક નોડને બે વસ્તુઓ નિર્દેશ કરે છે.
ત્યાં કિંમતો છે કે તે નિર્દેશ વિશે કોઈ તર્ક છે.
તેથી ઉપર અહીં ગમે છે, કારણ કે તે બાઈનરી શોધ વૃક્ષ છે,
આપણે જાણીએ છીએ કે જો અમે જાઓ 7 ની બાકી,
પછી કિંમતો કે અમે કદાચ પહોંચી શકે તમામ
7 ની બાકી જઈને થી 7 કરતાં ઓછું હોય છે.
નોંધ કરો કે 7 કરતા ઓછું તમામ કિંમતો 3 અને 6 છે.
તે 7 ડાબી બધા છે.
જો અમે 7 જમણી પર જાઓ, બધું થી 7 કરતા વધારે હોવું જોઈએ,
તેથી 9 7 અધિકાર છે, તેથી અમે સારા છીએ.
આ એક દ્વિસંગી વૃક્ષ માટે કેસ નથી,
નિયમિત દ્વિસંગી વૃક્ષ માટે અમે માત્ર ઉપર, ડાબી 7 અંતે 3 હોઇ શકે છે,
9 7 ડાબી; ત્યાં કોઈ પ્રકારની કિંમતો ઓર્ડર છે.
હવે, અમે ખરેખર આ નથી કારણ કે તે જટિલ અને બિનજરૂરી થશે,
પરંતુ "માટે ઘણા આદેશ આપ્યો વૃક્ષો દોરવા તરીકે તમે વિચાર કરી શકો છો પ્રયાસ કરો
આ 7 નંબરો, 3, 9 વાપરી રહ્યા હોય, અને 6.
કેટલા અલગ વ્યવસ્થા છે? દરેક એક ઊંચાઇ શું છે? "
>> અમે એક દંપતી કરવા માટે, પરંતુ પડશે મુખ્ય વિચાર છે,
આ બોલ પર કોઈ રસ્તો દ્વિસંગી આ કિંમતો સમાવતી વૃક્ષ એક અનન્ય પ્રતિનિધિત્વ છે.
બધા અમે જરૂર અમુક દ્વિસંગી વૃક્ષ કે 7 સમાવે છે, 3, 6, અને 9 છે.
અન્ય એક શક્ય માન્ય રુટ 3 થશે,
ડાબી પર જાઓ અને તે 6 છે, ડાબી પર જાઓ અને 7 છે,
ડાબી પર જાઓ અને તે 9 છે.
કે જે એકદમ યોગ્ય દ્વિસંગી શોધ વૃક્ષ છે.
તે ખૂબ જ ઉપયોગી, નથી કારણ કે તે યાદીની લિંક જેવી જ છે
અને આ પોઇંટરો તમામ માત્ર નલ છે.
પરંતુ તે માન્ય વૃક્ષ છે. યાહ?
[વિદ્યાર્થી] કિંમતો અધિકાર પર વધુ પ્રયત્ન નથી શું?
અથવા આ છે -? >> આ હું અન્ય રીતે જવા માગો છો.
ત્યાં પણ છે - હા, ચાલો કે સ્વિચ કરો.
9, 7, 6, 3. ગુડ કેચ.
તે હજુ પણ પાલન શું દ્વિસંગી વૃક્ષ શોધ કરવા માનવામાં આવે છે.
તેથી ડાબી બધું કરવા માટે આપેલ કોઈપણ નોડ કરતાં ઓછી હોવી જોઇએ.
અમે હમણાં જ ખસેડવા માટે, કહેવું શકે, 6 આ અને તે અહીં મૂકો.
ના, અમે નથી કરી શકો છો. હું જે શા માટે રાખો છો?
ચાલો કરવું - અહીં 6 છે, અહીં 7 છે, 3 થી 6 નિર્દેશ કરે છે.
આ હજુ પણ માન્ય દ્વિસંગી શોધ વૃક્ષ છે.
શું ખોટું છે જો હું - આપણે શું હું એક વ્યવસ્થા સાથે આવી શકે છે.
અરે વાહ, ઠીક છે. તેથી આ શું વૃક્ષ સાથે ખોટું છે?
હું માનું હું પહેલેથી જ તમને એક સંકેતની કે ત્યાં તેની સાથે કંઇક ખોટું છે આપી છે.
હું જે શા માટે રાખો છો?
ઠીક છે. આ વાજબી લાગે છે.
જો અમે દરેક નોડ પર, 7, જેમ પછી 7 ડાબી નજર 3 છે.
તેથી અમે 3 હોય, 3 જમણી વાત એ 6 છે.
અને જો તમે 6 જોવા, 6 જમણી આ વસ્તુ 9 એક છે.
તેથી આ એક માન્ય દ્વિસંગી શોધ વૃક્ષ શા માટે નથી?
[9 વિદ્યાર્થીઓ] 7 ડાબી હજુ પણ છે. >> યાહ.
એ વાત સાચી છે કે જે બધી કિંમતો તમે કદાચ 7 ડાબી જઈને પહોંચી શકે 7 કરતા ઓછું હોય છે જ હોવી જોઈએ.
જો અમે જાઓ 7 ની બાકી, અમે 3 મેળવવા અને અમે હજુ પણ 6 થી મેળવી શકો છો,
અમે હજુ 9 મેળવવા શકો છો, પરંતુ બાદ 7 કરતાં ઓછી થઇ ગઇ છે,
અમે જે સંખ્યા 7 કરતા વધારે છે મેળવવા સક્ષમ ન હોવું જોઈએ.
તેથી આ એક માન્ય દ્વિસંગી શોધ વૃક્ષ નથી.
>> મારા ભાઇ ખરેખર એક મુલાકાતમાં પ્રશ્ન હતો
જે સામાન્ય માન્ય કરવા માટે કંઈક આ, માત્ર કોડ હતી
શું વૃક્ષ દ્વિસંગી શોધ વૃક્ષ છે,
અને તેથી પ્રથમ વસ્તુ તે કર્યું હતું માત્ર જોવા માટે ચકાસો
જો ડાબા અને જમણા સાચું છે, અને પછી નીચે ત્યાં ફરી વળવું.
પરંતુ માત્ર તમે કરી શકતા નથી કે ન કરો; તમે ટ્રેક રાખવો પડે છે
હકીકત એ છે કે હવે હું 7 ની બાકી ગઇ કરેલું,
આ ઉપવૃક્ષ બધું 7 કરતાં ઓછી હોવી જોઈએ.
યોગ્ય અલ્ગોરિધમનો ટ્રેક રાખવા જરૂર છે
સીમાડાં કિંમતો કદાચ સાઇન પડો શકે
અમે તેમને તમામ મારફતે જાય છે.
ત્યાં એક સરસ આવૃત્તિ સંબંધ છે,
જોકે આપણે તે ન મેળવેલ છે, અથવા આપણે તે ન મળશે,
વ્યાખ્યાયિત કેટલા ત્યાં ખરેખર છે.
તેથી 14 તેમને હોય છે.
તમે કેવી રીતે કરવું તે થશે જે વિચાર ગાણિતિક જેવું છે,
તમે કોઈ એક પસંદ કરવા માટે રુટ નોડ હોઇ શકે છે,
અને પછી જો હું 7 પસંદ કરવા માટે રુટ નોડ હોઇ શકે છે,
તો પછી ત્યાં કહે છે, કેટલાક નંબરો કે મારા ડાબા નોડ પ્રયત્ન જઈ શકે છે,
અને અમુક નંબર કે મારા જમણા નોડ હોઇ શકે છે,
પરંતુ જો હું કુલ નંબરો, પછી જે રકમ ડાબી જઈ શકો છો n છે
1 - વત્તા જથ્થો કે જમણા જઈ શકો છો n છે.
જેથી બાકીના સંખ્યામાં છે, તેઓ માટે ડાબે અથવા જમણે ક્યાં જઈ શકવા માટે સમર્થ હોય છે.
તે મુશ્કેલ લાગે છે કે, જો હું 3 પ્રથમ પછી મૂકી બધું ડાબી પર જાઓ ધરાવે છે,
પરંતુ જો હું 7 મૂકી, પછી કેટલીક વસ્તુઓ ડાબી જાઓ અને કેટલીક વસ્તુઓ જમણી જઇ શકે છે.
અને હું '3 પ્રથમ 'દ્વારા અર્થ થાય છે બધું યોગ્ય જઈ શકો છો.
તે ખરેખર, તમે માત્ર તે વિશે તરીકે લાગે છે,
કેટલી વસ્તુઓ વૃક્ષના આગલા સ્તર પર જવા માટે કરી શકો છો.
અને તે બહાર આવે થી 14 હોઈ; અથવા તમે તેમને બધા ડ્રો કરી શકે છે,
અને પછી તમે 14 મળશે.
>> અહીં પાછા જવાનું,
"આદેશ દ્વિસંગી વૃક્ષો લાગે છે કારણ કે અમે તેમના મારફતે શોધી શકો છો
ખૂબ સમાન એક છટણી એરે પર શોધ કરવા માટે રસ્તો છે.
આમ કરવા માટે, અમે રૂટ પર શરૂ અને વૃક્ષ નીચે અમારી રીતે કામ
પાંદડા પર કોઈ રન નોંધાયો, મૂલ્યો અમે શોધી રહ્યાં છો સામે દરેક નોડ કિંમતો ચકાસણી.
જો વર્તમાન નોડ કિંમત કિંમત કરતાં ઓછી હોય તો અમે શોધી રહ્યાં છો,
તમે જે નોડ અધિકાર બાળક માટે આગામી જાઓ.
અન્યથા, તમને નોડ ડાબી બાળક પર જાઓ.
અમુક બિંદુએ, તમે ક્યાં તો કિંમત તમે શોધી રહ્યાં છો તે શોધવા માટે, પડશે અથવા તમે નલ પણ પડશે,
મૂલ્ય સૂચવે વૃક્ષ છે. નથી "
હું વૃક્ષ અમે પહેલાં redraw હોય; કે બીજા લેવા પડશે.
પરંતુ અમે લુકઅપ છે કે શું 6, 10, અને 1 એ વૃક્ષ છે કરવા માંગો છો.
તેથી તે શું હતું, 7, 9, 3, 6. ઠીક છે.
તમે જે નંબરો માટે લુકઅપ માંગો છો, અમે 6 જુઓ.
આ કેવી રીતે અલ્ગોરિધમનો કામ કરે છે?
વેલ, અમે પણ કેટલાક રુટ અમારા વૃક્ષ નિર્દેશક હોય છે.
અને અમે રુટ પર જાઓ અને કહે છે, તો આ કિંમત અમે શોધી રહ્યાં છો સમાન મૂલ્ય છે?
તેથી અમે 6 શોધી રહ્યાં છો, તેથી તે બરાબર નથી.
તેથી અમે ચાલુ રાખવામાં, અને હવે અમે કહીએ છીએ, ઠીક છે, તેથી 6 7 કરતા ઓછું હોય છે.
શું તેનો અર્થ અમે ડાબી પર જાઓ કરવા માંગો છો, અથવા અમે અધિકાર પર જાઓ કરવા માંગો છો?
[વિદ્યાર્થી] ડાબી. >> યાહ.
તે નોંધપાત્ર રીતે સરળ છે, તમારે હોય તો એક વૃક્ષ શક્ય નોડ દોરવા છે
અને પછી તમે don't - બદલે તમારા માથા પર લાગે છે કરવાનો પ્રયાસ કરી,
ઠીક છે, જો કે તે ઓછી છે, હું ડાબી પર જાઓ નથી અથવા જમણી જાઓ,
ફક્ત આ ચિત્ર તરફ જોઈને, તે ખૂબ જ સ્પષ્ટ છે કે હું ડાબી જવું
જો આ નોડ મૂલ્ય કે હું શોધી રહ્યો છું કરતાં વધારે હોય છે.
તેથી તમે ડાબી પર જાઓ, હવે હું 3 અંતે છું.
હું માંગો છો - 3 મૂલ્ય હું શોધી રહ્યો છું, જે 6 ઓછી હોય છે.
તેથી અમે અધિકાર પર જાઓ, અને હવે હું 6 અંતે અંત,
જે કિંમત હું શોધી રહ્યો છું, તેથી હું સાચું પાછા છે.
આગામી કિંમત હું જોવા માટે જાઉં છું 10 છે.
ઠીક છે. કાપી કે - - જે રુટ અનુસરો જઈને 10 તેથી હવે રહ્યું છે.
હવે, 10 થી 7 કરતાં મોટી હોવી રહ્યું છે, જેથી હું અધિકાર નજર કરવા માંગો છો.
હું ઉપર અહીં આવવા જાઉં છું, 10 થી 9 કરતાં મોટી હોવી રહ્યું છે,
તેથી હું અધિકાર નજર કરવા માંગો છો જાઉં છું.
હું ઉપર અહીં આવે છે, પરંતુ અહીં પર હવે હું નલ અંતે છું.
જો હું નલ ફટકો કરવું?
[વિદ્યાર્થી] ખોટા વળતર? >> યાહ. હું 10 મળ્યાં નથી.
1 થી લગભગ સમાન કિસ્સામાં રહ્યું છે,
સિવાય કે તે માત્ર ઘસવું કરી રહ્યું છે; બદલે looking
જમણી બાજુએ નીચે, હું નીચે ડાબી બાજુ જુઓ જાઉં છું.
>> હવે મને લાગે છે કે અમે ખરેખર કોડ મેળવો.
અહીં છે જ્યાં - અપ CS50 સાધન ખોલો અને તમારી રીતે ત્યાં નેવિગેટ કરો,
પરંતુ તમે પણ જગ્યા તે માત્ર કરી શકો છો.
તે કદાચ તેને જગ્યા કરતા આદર્શ,
કારણ કે અમે જગ્યામાં કામ કરી શકો છો.
"પ્રથમ અમે દ્વિસંગી વૃક્ષ પૂર્ણાંક કિંમતો સમાવતી નોડ માટે એક નવો પ્રકાર વ્યાખ્યા કરવાની જરૂર પડશે.
નીચે typedef boilerplate મદદથી,
દ્વિસંગી વૃક્ષ એક નોડ માટે નવા પ્રકારની વ્યાખ્યા બનાવો.
જો તમે અટકી છે. . . "મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત, મૂર્ખામી ભરેલી વાહિયાત વાત. ઠીક છે.
તેથી આપણે તે boilerplate અહીં મૂકો,
typedef સ્ટ્રક્ટ નોડ, અને નોડ. અરે વાહ, ઠીક છે.
તેથી ક્ષેત્રો અમે અમારા નોડ માં કરવા માંગો છો જઈ રહ્યાં છો શું છે?
[વિદ્યાર્થી] ઈન્ અને પછી બે પોઇંટરો?
>> ઈન્ કિંમત, બે પોઇંટરો? હું પોઇંટરો કેવી રીતે લખી શકું?
[વિદ્યાર્થી] સ્ટ્રક્ટ. >> હું સાઇન ઝૂમ અરે વાહ, જેથી સ્ટ્રક્ટ નોડ બાકી * જોઈએ,
અને સ્ટ્રક્ટ નોડ અધિકાર *.
અને છેલ્લા સમયે ચર્ચા કરવાનું યાદ રાખો,
કે આ બોલ પર કોઈ અર્થમાં બનાવે છે, આ અર્થમાં બનાવે છે,
આ બોલ પર કોઈ અર્થમાં બનાવે છે.
તમે ત્યાં બધું કરવાની જરૂર કરવા માટે આ યાદ આવવું સ્ટ્રક્ટ વ્યાખ્યાયિત કરે છે.
ઠીક છે, જેથી અમારી વૃક્ષ શું જેમ દેખાય રહ્યું છે.
જો આપણે એક trinary વૃક્ષ કર્યું, તે પછી નોડ B1, B2, સ્ટ્રક્ટ નોડ B3 * જેમ દેખાય શકે છે,
જ્યાં બોલ્ડ એક શાખા છે - વાસ્તવમાં, હું વધુ સાંભળ્યું કર્યું છે કે તે બાકી, મધ્યમ, જમણી ગમે છે, પરંતુ.
અમે ફક્ત દ્વિસંગી ચિંતા છે, તેથી અધિકાર બાકી.
"હવે વૃક્ષના રુટ માટે વૈશ્વિક નોડ * ચલ જાહેર."
તેથી અમે તે નથી જઈ રહ્યાં છો.
ક્રમમાં વસ્તુઓ થોડી વધારે મુશ્કેલ અને વધુ સામાન્ય બનાવવા માટે,
અમે વૈશ્વિક નોડ ચલ નથી.
તેના બદલે, મુખ્ય આપણે આપણા બધા નોડ વસ્તુઓ જાહેર કરશે,
અને તે કે નીચે થાય છે, જ્યારે અમે ચાલી શરૂ
અમારા સમાવે કાર્ય અને અમારા insert કાર્ય,
તેના બદલે અમારી સમાવે ફક્ત આ વૈશ્વિક નોડ ચલ મદદથી કામ કરે છે
અમે હોય તે દલીલ તરીકે વૃક્ષ લઈ જઈ રહ્યાં છો કે અમે તેની પ્રક્રિયા કરવા માંગો છો.
વૈશ્વિક ચલ રાખવાથી વસ્તુઓ સરળ બનાવી ધારતા હતા.
અમે વસ્તુઓ સખત બનાવવા જઈ રહ્યાં છો.
હવે એકાદ મિનિટ વસ્તુ આ પ્રકારની કાર્ય,
જ્યાં અંદર મુખ્ય તમે આ વૃક્ષ બનાવવા માંગો છો, અને તે તમામ તમે કરવા માંગો છો છે.
પ્રયત્ન કરો અને તમારા મુખ્ય કાર્ય આ વૃક્ષ રચવા.
>> ઠીક છે. તેથી તમે પણ આ વૃક્ષ સમગ્ર માર્ગ નિર્માણ હજી સુધી નથી.
પરંતુ કોઈને કંઈક હું ખેંચી શકે છે
બતાવવા માટે કેવી રીતે એક જેમ કે વૃક્ષ બાંધવા શરૂ કરી શકે છે?
[વિદ્યાર્થી] ની કોઇએ એકાએક સપાટો, બહાર વિચાર પ્રયાસ કરે છે.
[બોડેન] તેમના વૃક્ષ બાંધકામ સાથે આરામદાયક કોઈપણ?
[વિદ્યાર્થી] શ્યોર. તે ન થાય છે. >> તે દંડ છે. અમે હમણાં જ સમાપ્ત કરી શકે છે -
ઓહ, તો તમે તેને સેવ કરી શકો છો? હુરે.
અહીં અમે હોય - ઓહ, હું સહેજ કાપી રહ્યો છું.
હું માં ઝૂમ કરેલું?
ઝૂમ, બહાર સરકાવવા. >> હું એક પ્રશ્ન છે. >> યાહ?
[વિદ્યાર્થી] જ્યારે તમે સ્ટ્રક્ટ વ્યાખ્યાયિત કરવા માટે, કશા માટે આરંભ જેવી વસ્તુઓ છે?
[બોડેન] નં >> ઠીક. જેથી તમે પ્રારંભ હશે -
[બોડેન] નંબર, જ્યારે તમે વ્યાખ્યાયિત કરવા માટે, અથવા જ્યારે તમે જાહેર એક સ્ટ્રક્ટ
તે મૂળભૂત રીતે આરંભ છે, તે માત્ર જો તમે પૂર્ણાંક જાહેર ગમે છે.
તે બરાબર એ જ વાત છે. તે તેના વ્યક્તિગત ક્ષેત્રો દરેક જેવું છે
તેને એક કચરો કિંમત હોઈ શકે છે. >> અને તે શક્ય છે વ્યાખ્યાયિત કરે છે - અથવા જાહેર એક સ્ટ્રક્ટ
તેમને એક રસ્તો છે કે તે માં પ્રારંભ?
[બોડેન] હા. તેથી, શોર્ટકટ આરંભ વાક્યરચના
છે જેમ દેખાય જતાં -
ત્યાં બે માર્ગો અમે આ કરવા માટે કરી શકો છો. મને લાગે છે કે અમે તેને કમ્પાઇલ જોઈએ
ખાતરી કરવા માટે રણકાર બનાવવા પણ કરે છે.
દલીલો ક્રમ કે સ્ટ્રક્ટ માં આવે છે,
તમે આ સર્પાકાર કૌંસ ની અંદર દલીલો ક્રમ તરીકે મૂકો.
તેથી જો તમે તેને 9 થી પ્રારંભ કરવા માંગો છો અને પછી બાકી અધિકાર નલ શકાય અને નલ હોઈ શકે છે,
તે 9 હોઇ શકે છે, નલ, નલ કરશે.
વૈકલ્પિક છે, અને સંપાદક આ વાક્યરચના પસંદ નથી,
અને તે વિચારે હું એક નવા બ્લોક કરવા માંગો છો,
પરંતુ વૈકલ્પિક કંઈક જેવી છે -
અહીં, હું તે નવા વાક્ય પર મૂકીશું.
તમે નિશ્ચિતપણે કહી શકે છે, હું ચોક્કસ સિન્ટેક્ષ ભૂલી જાવ.
જેથી તમે તેને સ્પષ્ટપણે નામ દ્વારા સંબોધવા કરી શકે છે, અને કહે છે,
કૈચ, અથવા.. કિંમત = 9, ડાબી. = NULL.
હું આ માટે અલ્પવિરામ પ્રયત્ન જરૂર અનુમાન લગાવવા છું.
અધિકાર. = NULL તેથી, આ રીતે તમને પસંદ નથી
વાસ્તવમાં સ્ટ્રક્ટ ક્રમ જાણવાની જરૂર છે,
અને જ્યારે તમે આ વાંચી રહ્યાં છો, તે વધુ સ્પષ્ટ છે
શું વિશે કિંમત રહી આરંભ છે.
>> આ એક વસ્તુઓ કે બને છે -
તેથી, મોટા ભાગ માટે, C + +, સી એક superset છે
તમે સી કોડ લે છે, તેને ખસેડવા ઉપર માટે C + +, અને તે કમ્પાઇલ જોઈએ કરી શકો છો.
આ એક વસ્તુઓ છે કે જે C + + આધાર આપતું નથી છે, તેથી લોકો તેને ન કરવું હોય છે.
હું જો કે માત્ર એ જ કારણ લોકો તેને ન કરવું વલણ ધરાવે છે ખબર નહિં હોય,
પણ આ કિસ્સામાં જ્યાં હું તેનો ઉપયોગ જરૂરી C + + અને તેથી હું આ ઉપયોગ ન કરી શકે સાથે કામ કરવાની જરૂર હતી.
કંઈક છે જે અન્ય એક ઉદાહરણ C + + સાથે કામ કરતું નથી
malloc એક "રદબાતલ *," કેવી રીતે આપે છે ટેકનિકલી,
પરંતુ તમે ઘરનાં પરચૂરણ કામો * એક્સ malloc = ગમે કહેવું શકે છે,
અને તે આપમેળે ચાર રચે છે * માટે ચૂક્યું હશે.
કે સ્વયંસંચાલિત કાસ્ટ ન થાય C + +.
કે કમ્પાઇલ નથી, અને તમે બાહ્ય રીતે કહેવું પડે
ઘરનાં પરચૂરણ કામો *, malloc, ગમે છે, તે ચાર રચે છે * માટે આપ્યા હતા.
ઘણી વસ્તુઓ છે કે સી અને સી + + પર અસહમત નથી,
પરંતુ તે બે છે.
તેથી અમે આ વાક્યરચના સાથે જઈશ.
પણ જો અમે તે વાક્યરચના સાથે નહોતા,
શું છે - આ ખોટું હોઈ શકે છે?
[વિદ્યાર્થી] હું તે ડિરેફરન્સ માટે જરૂર નથી? >> યાહ.
યાદ રાખો કે તીર ગર્ભિત ડિરેફરન્સ છે,
અને તેથી જ્યારે અમે માત્ર એક સ્ટ્રક્ટ સાથે કામ કરીએ છીએ,
અમે ઉપયોગ કરવા માંગો છો. માટે સ્ટ્રક્ટ એક ક્ષેત્ર અંદર વિચાર.
અને ફક્ત એક જ વખત અમે તીર ઉપયોગ જ્યારે અમે કરવા માંગો છો -
સાથે સાથે, તીર જેવું જ છે -
કે તે શું જો હું તીર ઉપયોગ અર્થ એવો થાય છે કરશે.
બધા તીર અર્થ, આ ડિરેફરન્સ છે, હવે હું એક સ્ટ્રક્ટ અંતે છું, અને હું આ ક્ષેત્રમાં મેળવી શકો છો.
ક્યાં તો સીધી રીતે અથવા ક્ષેત્ર ડિરેફરન્સ વિચાર અને આ ક્ષેત્રમાં વિચાર -
હું માનું આ કિંમત પ્રયત્ન કરીશું.
પરંતુ અહીં હું ફક્ત એક, એક સ્ટ્રક્ટ માટે નિર્દેશક ન સ્ટ્રક્ટ સાથે વ્યવહાર છું,
અને તેથી હું તીર ઉપયોગ કરી શકતા નથી.
પરંતુ વસ્તુ આ પ્રકારની અમે તમામ ગાંઠો માટે કરી શકો છો.
ઓહ ગોડ.
આ 6, 7, અને 3 છે.
પછી અમે અમારી વૃક્ષ શાખાઓ સેટ કરી શકો છો, અમે 7 હોઈ શકે છે -
અમે, તેની ડાબી 3 થી કરીશું નિર્દેશ કરી શકો છો.
તેથી અમે તે કેવી રીતે કરવું?
[વિદ્યાર્થીઓ, દુર્બોધ] >> યાહ. Node3 ઓફ સરનામું,
અને જો તમે સરનામા ન હતા, પછી તે ફક્ત કમ્પાઇલ કરશે.
યાદ પણ છે કે આ આગામી ગાંઠો પોઇન્ટર છે.
જમણી 9 થી નિર્દેશ જોઈએ,
અને 3 માટે 6 જમણી બાજુ પર નિર્દેશ કરીશું.
મને લાગે છે કે આ બધું સેટ છે. કોઈપણ ટિપ્પણીઓ અથવા પ્રશ્નો છે?
[વિદ્યાર્થી, દુર્બોધ] આ માટે રુટ 7 હોઇ શકે રહ્યું છે.
અમે હમણાં જ નોડ કહી શકો * ptr =
અથવા રુટ =, અને node7.
>> અમારા હેતુઓ માટે, અમે insert સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો,
તેથી અમે માટે આ દ્વિસંગી વૃક્ષ દાખલ કાર્ય લખવા માંગો છો જઈ રહ્યાં છો
અને insert અનાવશ્યક malloc કૉલ કરવા માટે આ વૃક્ષ માટે નવી નોડ બનાવવા જઈ રહ્યું છે.
તેથી વસ્તુઓ એ હકીકત સાથે અવ્યવસ્થિત વિચાર જવું છે કે અમુક ગાંઠો
સ્ટેક પર હાલમાં
અને અન્ય નોડ સુધી હીપ પર અંત જ્યારે અમે તેમને સામેલ થશે.
આ એકદમ યોગ્ય છે, પરંતુ માત્ર કારણ
અમે સ્ટેક પર આવું કરવાનો છો
છે કારણ કે તે, જેમ કે contrived ઉદાહરણ છે કે આપણે જાણીએ છીએ
વૃક્ષ થી 7, 3, 6, 9 તરીકે બાંધવામાં આવશે તેવું માનવામાં આવે છે.
જો આપણે આ ન હતી, તો પછી અમે પ્રથમ સ્થાને malloc ન હોય.
આપણે થોડીવાર પછી જોશો, અમે malloc'ing જોઇએ.
હમણાં તે સંપૂર્ણપણે વાજબી છે એ સ્ટેક પર મૂકવામાં આવે છે,
દો પરંતુ એક malloc અમલીકરણ માટે આ બદલો.
તેથી આ દરેક હવે કંઈક જેવો હોવો રહ્યું છે
નોડ node9 * = malloc ((નોડ) sizeof).
અને હવે અમે અમારા ચેક કરો રહ્યા છીએ.
જો (== NULL node9) - હું કે માંગતા ન -
1 પાછા ફરવા માટે, અને પછી અમે node9-> શું કારણ કે હવે તે એક નિર્દેશક શકે છે,
કિંમત = 6, node9-> બાકી = NULL,
node9-> અધિકાર NULL =,
અને અમે તે ગાંઠો દરેક માટે તે હોય તો જઈ રહ્યાં છો.
તેથી તેના બદલે, ચાલો તે અલગ કાર્ય ની અંદર મૂકો.
ચાલો તે નોડ build_node * કહી,
અને આ કંઈક કે APIs અમે હફમેનના કોડિંગ પૂરી પાડવા માટે સમાન છે.
અમે તમને એક વૃક્ષ માટે ઇનિશિયલાઇઝર વિધેયો આપી
અને deconstructor તે વૃક્ષો અને જંગલો માટે જ "વિધેયો".
>> તેથી અહીં આપણે એક ઇનિશિયલાઇઝર કાર્ય છે જઈ રહ્યાં છો
માત્ર આપણા માટે નોડ બિલ્ડ.
અને તે આ જેવી જ ખૂબ સુંદર દેખાવું બનશે.
અને હું પણ આળસુ હશે છું અને ચલ નું નામ બદલી શકતા નથી,
ભલે node9 કોઈ અર્થ હવે બનાવે છે.
ઓહ, હું node9 કિંમત ધારી ન હતી કરીશું 6.
હવે અમે node9 પાછા આવી શકો છો.
અને અહીં આપણે નલ પરત કરીશું.
દરેક કાર્ય બિલ્ડ અ નોડ પર સંમત છે?
તેથી હવે અમે માત્ર કહી છે કે જે આપેલ કિંમત અને નલ પોઇન્ટર સાથે કોઇપણ નોડ બનાવવા માટે કરી શકો છો.
હવે અમે તે કહી શકો છો, અમે નોડ node9 * = build_node (9) કરી શકે છે.
દો અને કામ કરે છે. . .
6, 3, 7, 6, 3, 7.
અને હવે અમે આ જ પોઇંટરો સેટ કરવા માંગો છો,
હવે સિવાય બધું પોઇંટરો દ્રષ્ટિએ પહેલેથી જ છે
જેથી લાંબા સમય સુધી ના સરનામા જરૂર છે.
ઠીક છે. જેથી છેલ્લા મેં કરવા માંગો છો શું?
ત્યાં એક ભૂલ ચકાસણી કે હું નથી કરી રહ્યો છું છે.
શું નોડ વળતર બિલ્ડ થાય છે?
[વિદ્યાર્થી, દુર્બોધ] >> યાહ. જો malloc નિષ્ફળ, તે નલ પરત મળશે.
તેથી હું તેને lazily મૂકી નીચે દરેક માટે એક શરત કરી બદલે અહીં જાઉં છું.
જો (node9 NULL ==, અથવા - વધુ સરળ,
આ node9 માત્ર જો સમકક્ષ છે.
તેથી જો node9 નથી, નથી અથવા node6, અથવા ન node3, અથવા ન node7, 1 આવો.
કદાચ અમે છાપી કરીશું malloc નિષ્ફળ થયેલ છે, અથવા કંઈક.
[વિદ્યાર્થી] સમાન ખોટા માટે પણ null છે?
[બોડેન] કોઈપણ શૂન્ય કિંમત ખોટું છે.
તેથી નલ એક શૂન્ય કિંમત છે.
શૂન્ય એક શૂન્ય કિંમત છે. ખોટા એક શૂન્ય કિંમત છે.
કોઈપણ - ખૂબ ખૂબ માત્ર 2 શૂન્ય કિંમતો નલ અને શૂન્ય છે,
ખોટા માત્ર શૂન્ય તરીકે વ્યાખ્યાયિત હેશ છે.
પણ લાગુ પડે છે જો આપણે વૈશ્વિક ચલ જાહેર નથી.
જો અમે નોડ * રુટ હોય અહીં કર્યું,
પછી - વૈશ્વિક ચલો વિશે સરસ વસ્તુ એ છે કે તે હંમેશા એક પ્રારંભિક કિંમત હોય છે.
કે વિધેયો સાચા નથી, અહીં ની અંદર કેવી રીતે,
જો અમે હોય છે, જેમ કે, નોડ * અથવા નોડ એક્સ.
અમે કોઇ વિચાર શું x.value, x.whatever હોય છે,
અથવા આપણે તેમને છાપી અને તેઓ આર્બીટરી હોઈ શકે શકે છે.
કે વૈશ્વિક ચલો સાચા નથી.
તેથી નોડ રુટ નોડ અથવા એક્સ.
મૂળભૂત રીતે, બધું છે કે વૈશ્વિક છે, જો ન નિશ્ચિતપણે કેટલાક કિંમત આરંભ,
તેની કિંમત તરીકે શૂન્ય કિંમત ધરાવે છે.
તેથી અહીં, નોડ * રુટ, અમે સ્પષ્ટપણે કંઈપણ તેને ન પ્રારંભ નથી,
જેથી તેની મૂળભૂત કિંમત નલ હોઈ શકે છે, જે પોઇંટરો એ શૂન્ય કિંમત છે.
X ની મૂળભૂત કિંમત અર્થ કે x.value શૂન્ય છે રહ્યું છે,
x.left નલ છે, અને x.right નલ છે.
તેથી, કેમ કે તે સ્ટ્રક્ટ છે, સ્ટ્રક્ટ ના બધા ક્ષેત્રોમાં શૂન્ય કિંમતો હશે.
અમે અહીં ઉપયોગ કરવાની જરૂર છે, છતાં નથી.
[વિદ્યાર્થી] આ સ્ટ્ર્ક્ટ્સ અન્ય ચલો કરતાં અલગ છે, અને અન્ય ચલો છે
કચરો કિંમતો; આ zeros છે?
[બોડેન] અન્ય ઘણી કિંમતો. તેથી એક્સ માં, એક્સ શૂન્ય હશે.
જો તે વૈશ્વિક અવકાશ પર છે, તે પ્રારંભિક મૂલ્ય છે. ઠીક છે. >>
[બોડેન] ક્યાં તો પ્રારંભિક કિંમત તમે તેને અથવા શૂન્ય આપ્યો હતો.
મને લાગે છે કે આ બધી કાળજી લે છે.
>> ઠીક છે. તેથી પ્રશ્ન આગળના ભાગ પૂછે છે,
"હવે અમે કહેવાય સમાવે કાર્ય લખવા માંગો છો
bool એક પ્રોટોટાઈપ પૂર્ણાંક કિંમત સમાવે છે. "
અમે આમ bool પૂર્ણાંક કિંમત સમાવે ન જવું છે.
અમારા પ્રોટોટાઇપ માટે આના જેવો રહ્યું છે
bool (પૂર્ણાંક કિંમત સમાવે છે.
અને પછી અમે પણ તેને વૃક્ષ પસાર જઈ રહ્યાં છો
કે તે જોવા માટે જો તે મૂલ્ય છે ચકાસણી કરવી જોઈએ.
તેથી નોડ * વૃક્ષ). ઠીક છે.
અને પછી અમે તેને કંઈક સાથે કહી શકો છો,
કદાચ અમે printf અથવા કંઈક કરવા માંગો છો પડશે.
6, અમારા રુટ સમાવે છે.
કે એક, અથવા સાચું પાછા જોઈએ,
જ્યારે સમાવે 5 રુટ ખોટો પરત કરીશું.
તેથી બીજા લેવા માટે આ અમલ.
તમે તેને ક્યાં iteratively અથવા recursively કરી શકો છો.
જે રીતે આપણે વસ્તુઓને સેટ અપ વિશે સરસ વસ્તુ એ છે કે
તે પોતે અમારી યાદ આવવું ખૂબ સરળ ઉકેલ માટે પૂરું પાડે
કરતાં રીતે વૈશ્વિક-ચલ હતી.
કારણ કે જો અમે માત્ર છે પૂર્ણાંક કિંમત સમાવે છે, તે પછી અમે નીચે subtrees recursing કોઈ રીત હોય છે.
અમે એક અલગ મદદગાર કાર્ય કે નીચે અમને માટે subtrees recurses હોય હશે.
પરંતુ ત્યાર બાદ અમે બદલ્યું છે તે દલીલ તરીકે વૃક્ષ લેવા માટે,
જે તેને હંમેશા પ્રથમ સ્થાને રહી છે જોઈએ,
હવે અમે recurse કરી શકો છો સરળતાથી વધુ.
પુનરાવર્તન તેથી અથવા ફરી યાદ આવવું, આપણે બન્ને પર જઈશ,
પરંતુ અમે તદ્દન સરળ હોવા અપ કે ફરી યાદ આવવું અંત જોશો.
ઠીક છે. શું કોઇને કંઈક સાથે કામ કરી શકે છે?
>> [વિદ્યાર્થી] હું મળી છે એક ઉકેલ પુનરાવર્તન. >> અધિકાર બધા, પુનરાવર્તન.
ઠીક, આ સારું લાગે છે.
તેથી, અમને તે લઈ જવામાં કરવા માંગો છો?
[વિદ્યાર્થી] શ્યોર. તેથી હું temp ચલ સુયોજિત વૃક્ષ પ્રથમ નોડ છે.
અને પછી હું ફક્ત જ્યારે કામચલાઉ નોકર સમાન નલ નથી મારફતે looped,
તેથી જ્યારે વૃક્ષ હજી પણ, હું માનું.
અને જો કિંમત મૂલ્ય સમાન છે કે કામચલાઉ નોકર તરફ ઇશારો છે,
પછી તે કિંમત આપે છે.
નહિંતર, તે ચકાસે છે કે શું તે જમણી બાજુ અથવા ડાબી બાજુએ છે.
જો તમે ક્યારેય પરિસ્થિતિ વિચાર જ્યાં ત્યાં વધુ વૃક્ષ છે,
પછી તેને આપે છે - તે બહાર નીકળે છે તે લૂપ અને ખોટા આપે છે.
[બોડેન] ઠીક. જેથી સારું લાગે છે.
કોઈપણ કંઈપણ પર કોઈ પણ ટિપ્પણી છે?
હું કોઈ બધા ચોકસાઈ ટિપ્પણીઓ.
આ એક વસ્તુ આપણે શું કરી શકો છો અને આ વ્યક્તિની છે.
ઓહ, તે થોડી longish જાઓ બનશે.
હું જે ઠીક પડશે. ઠીક છે.
>> દરેક વ્યક્તિને યાદ રાખવું જોઈએ કે કેવી રીતે ત્રણ ભાગનું બનેલું કામ કરે છે.
ત્યાં ચોક્કસપણે ભૂતકાળમાં છે અંગેની ક્વિઝ કરવામાં
કે તમે ત્રણ ભાગનું બનેલું ઓપરેટર સાથે કાર્ય આપે છે,
અને કહે છે, આ અનુવાદ, કંઈક કે જે ત્રણ ભાગનું બનેલું ઉપયોગ કરતું નથી કરવું.
તેથી આ એક ખૂબ જ સામાન્ય કિસ્સામાં છે જ્યારે હું ત્રણ ભાગનું બનેલું ઉપયોગ લાગે હો,
જ્યાં જો અમુક પરિસ્થિતિ કંઈક કરવા માટે ચલની સુયોજિત કરો,
બીજું કંઈક બીજું એ જ ચલ સુયોજિત કરો.
કે જે ઘણી વારંવાર વસ્તુ આ પ્રકારની પરિવર્તિત કરી શકાય છે
જ્યાં આ માટે તે ચલ સુયોજિત - અથવા, સાથે સાથે, આ સાચું છે? તો પછી આ સિવાય આ.
[વિદ્યાર્થી] પ્રથમ એક છે જો સાચું અધિકાર?
[બોડેન] યાહ. જે રીતે હું હંમેશા તે વાંચી છે, temp temp કિંમત કરતાં વધારે કિંમત સમકક્ષ,
તો પછી આ સિવાય આ. તે એક પ્રશ્ન પૂછવાનો છે.
તે વધારે હોય છે? પછી પ્રથમ વસ્તુ નથી. બાકી બીજા વસ્તુ નથી.
હું હંમેશા - આંતરડા, હું હમણાં જ - મારા માથા માં, હું તરીકે બીજું વાંચો.
>> શું કોઇને એક યાદ આવવું ઉકેલ છે?
ઠીક છે. આ એક અમે જઈ રહ્યાં છો - તે પહેલાથી જ મહાન હોઈ શકે,
પરંતુ અમે તે વધુ સારું બનાવવા જઈ રહ્યાં છો.
આ એક ખૂબ સુંદર જ ચોક્કસ વિચાર છે.
તે માત્ર છે, પણ તમે તે સમજાવવા માટે કરવા માંગો છો?
[વિદ્યાર્થી] શ્યોર. તેથી અમે ખાતરી કરો કે વૃક્ષ પ્રથમ નથી null છે બનાવી રહ્યા છો,
કારણ કે જો વૃક્ષ નલ પછી તે ખોટા પાછા કારણ કે અમે તેને મળ્યા નથી ચાલી રહ્યું છે.
અને જો ત્યાં હજી પણ વૃક્ષ છે, અમે જાય - અમે પ્રથમ તપાસો જો કિંમત વર્તમાન નોડ છે.
સાચું આપશે જો તે છે, અને જો નથી તો અમે ડાબે અથવા જમણે recurse.
કે અવાજ કરે યોગ્ય? >> MM-હમ્મ. (કરાર)
તેથી નોંધ્યું છે કે આ લગભગ છે - માળખાકીય ખૂબ ઉકેલ પુનરાવર્તન કરવા જેવી હતી.
તે માત્ર છે કે recursing બદલે, અમે જ્યારે લૂપ હતી.
અને આધાર અહીં કેસ જ્યાં વૃક્ષ સમાન નલ નથી
આ પરિસ્થિતિ કે જે હેઠળ અમે જ્યારે લૂપની ફાટી હતી.
તેઓ ખૂબ જ સમાન છીએ. પરંતુ અમે આ એક પગલું આગળ લે છે જઈ રહ્યાં છો.
હવે, અમે જ અહીં વસ્તુ નથી.
નોંધ અમે આ રેખાઓ બંને એક જ વસ્તુ પરત કરી રહ્યાં છો,
સિવાય એક દલીલ અલગ છે.
તેથી અમે એક ત્રિપુટીઓમાં માં કે કરી રહ્યા છીએ.
હું વિકલ્પ કંઈક ફટકો, અને તે પ્રતીક બનાવવામાં આવે છે. ઠીક છે.
તેથી અમે પાછા જઈ રહ્યાં છો કે જે સમાવે છે.
આ બહુવિધ રેખાઓ પ્રયત્ન થઈ રહ્યો છે, સાથે સાથે, તે છે ઝૂમ કરેલું.
સામાન્ય રીતે, એક શૈલીયુક્ત બાબત તરીકે, હું અનેક લોકોને લાગતું નથી
તીર પછી જગ્યા મૂકવા, પરંતુ હું માનું જો તમે સુસંગત છો, તે દંડ છે.
જો કિંમત વૃક્ષ કિંમત કરતાં ઓછી છે, અમે વૃક્ષ ડાબી બાજુ પર recurse કરવા માંગો છો,
બીજું અમે વૃક્ષ અધિકાર પર recurse કરવા માંગો છો.
જેથી આ દેખાવ નાના બનાવવા એક પગલું હતું.
બે આ દેખાવ નાના બનાવવા પગલાં -
અમે આ બહુવિધ રેખાઓ માટે અલગ કરી શકે છે.
ઠીક છે. જેનાથી તે નાની જુઓ બે પગલું અહીં છે,
જેથી વળતર કિંમત વૃક્ષ કિંમત સમકક્ષ, અથવા ગમે સમાવે છે.
>> આ એક મહત્વપૂર્ણ વસ્તુ છે.
મને ખાતરી છે કે જો તેણે કહ્યું કે તેનાથી વર્ગ સ્પષ્ટ નથી,
પરંતુ તે ટૂંકા સર્કિટ મૂલ્યાંકન કહેવાય છે.
અહીં વિચાર કિંમત છે == વૃક્ષ મૂલ્ય.
જો કે સાચું છે, તો પછી આ બાબત સાચી છે, અને અમે માંગો છો? 'અથવા' સાથે ગમે પર અહીં છે.
તેથી પણ ગમે અહીં વધારે છે તેના વિશે વિચારવાનો વગર,
સમગ્ર પર પાછા જવા અભિવ્યક્તિ શું છે?
[વિદ્યાર્થી] સાચું? >> અરે વાહ, કારણ કે કંઈપણ સાચું,
or'd - કંઈપણ સાથે અથવા સાચું or'd જરૂરી સાચી છે.
તેથી જલદી અમે વળતર કિંમત = વૃક્ષ કિંમત જુઓ,
અમે હમણાં જ સાચું પાછા જઈ રહ્યાં છો.
Recurse પણ નથી જવાનું વધુ નીચે લીટી સમાવે છે.
અમે આ એક પગલું આગળ લઈ શકો છો.
રીટર્ન વૃક્ષ સમાન નલ અને આ તમામ નથી.
તે કાર્ય એક લીટી કરી હતી.
આ પણ ટૂંકા સર્કિટ મૂલ્યાંકન એક ઉદાહરણ છે.
પરંતુ હવે તે જ વિચાર છે -
બદલે છે - તેથી જો વૃક્ષ નથી નલ સમાન કરે છે - અથવા, તેમજ,
જો વૃક્ષ સમાન નલ કરે છે, કે જે ખરાબ કેસ છે,
જો વૃક્ષ નલ સમકક્ષ હોય તો, પ્રથમ શરત ખોટી સાબિત થઇ રહ્યું છે.
તેથી કંઈપણ સાથે anded ખોટા માટે શું હોવું રહ્યું છે?
[વિદ્યાર્થી] ખોટું. >> યાહ. આ ટૂંકા સર્કિટ મૂલ્યાંકન બીજી અડધા છે,
જ્યાં જો વૃક્ષ નથી સમાન નલ નથી, તો પછી અમે જોઈ રહ્યા છે પણ જવા નથી -
અથવા જો વૃક્ષ સમાન નલ કરે છે, તો પછી અમે == કિંમત વૃક્ષ કિંમત નથી જવાનું છે.
અમે હમણાં જ તરત જ ખોટા પાછા જઈ રહ્યાં છો.
જે મહત્વપૂર્ણ છે, કારણ કે તે જો મૂલ્યાંકન ટૂંકા સર્કિટ નથી,
પછી જો વૃક્ષ સમાન નલ કરે છે, આ બીજા શરત seg ખામી માટે રહ્યું છે,
કારણ કે વૃક્ષ-> કિંમત નલ dereferencing છે.
જેથી તે છે. આ કરી શકો છો - એક વખત પર પાળી.
આ એક ખૂબ જ સામાન્ય બાબત પણ છે, જેનાથી આ સાથે આ એક લીટી નથી,
પરંતુ તે પરિસ્થિતિમાં એક સામાન્ય વાત છે, અહીંથી કદાચ નથી,
પરંતુ જો (વૃક્ષ = NULL!, અને વૃક્ષ-> કિંમત == કિંમત), ગમે નથી.
આ એક ખૂબ જ સામાન્ય સ્થિતિ છે, જ્યાં કર્યા બદલે
બે IFS આ ભંગ છે, જ્યાં માંગો, વૃક્ષ નલ છે?
ઠીક છે, તે નલ નથી, તેથી હવે વૃક્ષ કિંમત સમાન મૂલ્ય છે? આ કરવા માટે.
તેને બદલે, આ શરત, આ ખામી ક્યારેય seg કરશે
કારણ કે તેને તોડી જો આ નલ બને આવશે.
વેલ, હું માનું જો તમારી વૃક્ષ સંપૂર્ણપણે અમાન્ય નિર્દેશક છે, તે હજુ પણ દોષ seg કરી શકો છો,
પરંતુ તે દોષ નથી seg જો વૃક્ષ નલ શકે છે.
જો તે નલ હતા, તેને તોડી પહેલાં તમે ક્યારેય પ્રથમ સ્થાને નિર્દેશક dereferenced કરશે.
[વિદ્યાર્થી] આ કહેવાતા પ્રમાદી મૂલ્યાંકન છે?
>> [બોડેન] સુસ્ત મૂલ્યાંકન અલગ વસ્તુ છે.
સુસ્ત મૂલ્યાંકન વધુ છે કે તમે કિંમત માટે પૂછો,
તમે કિંમત, પ્રકારની ગણતરી પૂછો, પરંતુ તમે તે તુરંત જ કરવાની જરૂર નથી.
જેથી જ્યાં સુધી તમે ખરેખર તેની જરૂર પડશે, તે મૂલ્યાંકન છે.
આ બરાબર આ જ વાત નથી, પરંતુ હફમેનના pset માં,
તે કહે છે કે અમે "lazily" લખો.
કારણ કે અમે નથી કારણ કે અમે ખરેખર લખવા તટસ્થ કરી રહ્યા છીએ -
અમે એક સમયે વ્યક્તિગત બિટ્સ લખી નથી માંગતા,
અથવા એક સમયે વ્યક્તિગત બાઇટ્સ, અમે તેના બદલે બાઇટ્સ એક ભાગ મેળવવા માંગો છો.
પછી એક વાર અમે બાઇટ્સ એક ભાગ હોય, તો પછી અમે તેને લખી બહાર પડશે.
ભલે તમે કહો લખવા માટે - અને fwrite અને fread વસ્તુ સમાન પ્રકારના હોય છે.
તેઓ તમારા વાંચે છે અને લખે છે બફર.
છતાં પણ તમે તે માટે કહી તરત જ લખવા માટે, તે કદાચ નથી.
અને તમે ખાતરી કરો કે વસ્તુઓ લખાયેલ હશે નથી હોઈ શકે છે
જ્યાં સુધી તમે hfclose કૉલ અથવા જે તે છે,
જે પછી કહે છે, ઠીક, હું મારું ફાઇલ બંધ છું,
તેનો અર્થ એ કે હું સારી રીતે બધું હું હજી સુધી ન હોય તેવા પરચૂરણ છે લખવા માંગો છો.
તે કોઈ બધું લખી બહાર જરૂર છે
જ્યાં સુધી તમે ફાઇલ બંધ કરવામાં આવે છે, અને પછી તે જરૂર છે.
જેથી બેકાર શું માત્ર - તે રાહ જુએ છે ત્યાં સુધી તે થાય છે.
આ - 51 લાગે છે અને તમે તેને વધુ વિગતવાર જઈશ,
કારણ કે અને 51 માં OCaml બધું, બધું રિકર્ઝન છે.
ત્યાં કોઈ ઉકેલ પુનરાવર્તન છે, મૂળભૂત રીતે.
બધું રિકર્ઝન, અને આળસુ મૂલ્યાંકન છે
છે સંજોગોમાં ઘણા મહત્વપૂર્ણ હશે
, જો તમે lazily મૂલ્યાંકન કર્યું નથી, જ્યાં તેનો અર્થ એ થાય -
ઉદાહરણ સ્ટ્રીમ્સ, જે અનંત લાંબા હોય છે.
સિદ્ધાંત, તમે 1-2-3-4-5-6-7 એક સ્ટ્રીમ તરીકે કુદરતી સંખ્યામાં વિચાર કરી શકો છો,
તેથી lazily મૂલ્યાંકન વસ્તુઓ દંડ છે.
જો હું કહું છું હું દસમા નંબર કરવા માંગો છો, તો પછી હું દસમા નંબર પર મૂલ્યાંકન કરી શકે છે.
જો હું સો નંબર કરવા માંગો છો, તો પછી હું સો નંબર માટે મૂલ્યાંકન કરી શકે છે.
પ્રમાદી મૂલ્યાંકન વગર, પછી તે માટે બધી સંખ્યાઓ તરત મૂલ્યાંકન પ્રયાસ ચાલી રહ્યું છે.
તમે અનંત ઘણા નંબરો મૂલ્યાંકન કરી રહ્યાં છો, અને કે જે હમણાં જ શક્ય નથી.
તેથી ત્યાં સંજોગો ઘણો છે જ્યાં બેકાર મૂલ્યાંકન
ફક્ત વસ્તુઓ કામ માટે મેળવવામાં માટે જરૂરી છે.
>> હવે અમે insert લખવા જ્યાં દાખલ કરવા માટે પ્રયત્ન રહ્યું છે માંગો છો
એ જ રીતે તેની વ્યાખ્યા માં બદલાતી રહે છે.
તેથી હમણાં તે bool insert (પૂર્ણાંક કિંમત) છે.
અમે bool insert (પૂર્ણાંક કિંમત, નોડ * વૃક્ષ) કે બદલી રહ્યા છીએ.
અમે ખરેખર એક બીટ કે ફરીથી બદલી રહ્યા છીએ, અમે શા માટે જોઈ શકશો.
અને ચાલો build_node તેના હેક માટે જ, ખસેડવા માટે,
ઉપર દાખલ તેથી અમે એક કાર્ય પ્રોટોટાઇપ લખી નથી.
જે સંકેત છે કે તમે insert માં build_node ઉપયોગ કરી રહ્યા છીએ.
ઠીક છે. તે માટે એક મિનિટ લો.
મને લાગે છે કે હું પુનરાવર્તન સાચવી જો તમે તે માંથી ખેંચવાનો માંગો છો,
અથવા, ઓછામાં ઓછું, હું હવે હતી.
હું થોડો માટે insert તર્કના વિશે વિચારો વિરામ માગતા હતા,
જો તમે તે કરી શકતો નથી.
મૂળભૂત રીતે, તમે માત્ર ક્યારેય પાંદડા થઈ દાખલ કરશે.
જેમ, તો હું 1 દાખલ કરો, પછી હું ખચીત માટે 1 દાખલ કરી જાઉં છું -
હું કાળો બદલવા પડશે - I'll અહીં ઉપર 1 દાખલ કરવામાં આવશે.
અથવા જો હું 4 દાખલ કરો, હું અહીં ઉપર 4 દાખલ કરવામાં કરવા માંગો છો.
તેથી કોઇ વાંધો નથી કે તમે શું કરો છો, તો તમે પર્ણ પર દાખલ કરી રહ્યા છીએ.
બધા તમારે હોય છે ડાઉન વૃક્ષ પર ફરી વળવું જ્યાં સુધી તમે નોડ મેળવવા
કે જે નોડ પિતૃ, નવા નોડ પિતૃ હોવો જોઈએ,
અને પછી તેની ડાબે અથવા જમણે નિર્દેશક બદલવા માટે, કે શું તેના પર આધાર રાખીને
તે કરતાં વધારે અથવા વર્તમાન નોડ કરતાં ઓછી છે.
કે નિર્દેશક બદલવા માટે તમારા નવા નોડ માટે નિર્દેશ કરે છે.
જેથી નીચે વૃક્ષ પર ફરી વળવું, નવા નોડ માટે પર્ણ બિંદુ બનાવે છે.
પણ શા માટે તે પહેલાં પરિસ્થિતિ પ્રકાર મનાઇ ફરમાવે વિશે વિચારો,
જ્યાં હું દ્વિસંગી વૃક્ષ બાંધકામ જ્યાં તે સાચો હતો
જો તમે માત્ર એક જ નોડ પર દેખાતો હતો,
પરંતુ 9 7 ડાબી હતો જો તમે બધા માર્ગ iterated.
જેથી આ દ્રશ્ય માં અશક્ય છે, કારણ -
વિચારો 9 કે કંઈક દાખલ; પહેલીવાર ગાંઠ પર,
હું 7 જુઓ અને હું માત્ર અધિકાર પર જાઓ જાઉં છું જાઉં છું.
તેથી વાંધો કોઈ મારે શું કરવું, જો હું એક પર્ણ પર જઈને દાખલ છું,
અને એક યોગ્ય અલ્ગોરિધમનો ઉપયોગ કરીને પર્ણ માટે,
તે અશક્ય છે મારા માટે 9 7 ડાબી દાખલ કરવા માટે ચાલી રહ્યું છે
કારણ કે વહેલી તકે હું 7 ફટકો મારે અધિકાર પર જાઓ જાઉં છું.
શું કોઇને સાથે શરૂ કંઈક છે?
[વિદ્યાર્થી] હું નથી. શ્યોર. >>
[વિદ્યાર્થી, દુર્બોધ]
[અન્ય વિદ્યાર્થી, દુર્બોધ]
[બોડેન] તે પ્રશંસા છે. ઠીક છે. તે સમજાવવા માટે કરવા માંગો છો?
>> [વિદ્યાર્થી] ત્યારથી આપણે જાણીએ છીએ કે અમે દાખલ કરવામાં આવ્યા હતા
વૃક્ષ ઓવરને અંતે નવી ગાંઠો,
હું વૃક્ષ દ્વારા iteratively looped
ત્યાં સુધી હું નોડ કે જે null નિર્દેશ કર્યો.
અને પછી હું તેને જમણી બાજુ અથવા ડાબી બાજુએ ક્યાં મૂકવા નિર્ણય લીધો
આ અધિકાર ચલ મદદથી, તે મને કહ્યું તેને મૂકી છે.
અને પછી, જરૂરીયાતમાં, હું હમણાં જ કરી હતી કે, છેલ્લા -
કે કામચલાઉ નોકર નોડ નવી ગાંઠ કે તે બનાવવા માટે કરવામાં આવી હતી બિંદુ,
ક્યાં તો ડાબી બાજુ પર અથવા જમણી બાજુ પર, કિંમત શું અધિકાર હતો પર આધાર રાખીને.
છેલ્લે, હું નવું નોડને તેની ચકાસણી કિંમત સાથે કિંમત સુયોજિત કરો.
[બોડેન] ઠીક છે, જેથી હું એક મુદ્દો અહીં જુઓ.
આ ત્યાં માર્ગ 95% જેવું છે.
આ એક સમસ્યા છે જે હું જોવા માટે, સારી રીતે, બીજા કોઈની સમસ્યા દેખાઈ નથી?
આ સંજોગોમાં જે હેઠળ તેઓ લૂપની બહાર ભંગ શું છે?
[વિદ્યાર્થી] જો temp નલ છે? >> યાહ. તેથી તમે કેવી રીતે આ લૂપની બહાર ભંગ છે જો temp નલ છે.
પરંતુ હું શું અહીં શું કરે છે?
હું ડિરેફરન્સ કામચલાઉ નોકર છે, કે જે અનાવશ્યક નલ છે.
તેથી અન્ય વસ્તુ તમારા માટે જરૂર છે માત્ર ટ્રેક રાખવા સુધી કામચલાઉ નોકર નલ છે,
તમે જે પિતૃ બધા સમયે ટ્રેક રાખવા માંગો છો.
અમે પણ નોડ * પિતૃ માંગો છો, ત્યારે મને લાગ્યું કે અમે પ્રથમ નલ ખાતે રાખી શકો છો.
આ વૃક્ષની રુટ માટે વિચિત્ર વર્તન હોય રહ્યું છે,
પરંતુ અમે તે માટે મળશે.
જો કિંમત ગમે કરતા વધારે હોય તો, પછી કામચલાઉ નોકર temp = અધિકાર.
પરંતુ તે પહેલાં અમે કે, = કામચલાઉ નોકર પિતૃ.
અથવા માતા - પિતા હંમેશા સમાન temp જવા? કે જે છે?
જો temp નલ નથી, તો પછી હું નીચે ખસેડો, કોઇ વાંધો શું જાઉં છું,
નોડ કે જેના માટે કામચલાઉ નોકર પિતૃ છે.
તેથી પિતૃ કામચલાઉ નોકર જ હશે, અને પછી હું temp નીચે ખસેડો.
હવે કામચલાઉ નોકર નલ છે, પરંતુ વસ્તુ કે નલ છે પિતૃ પિતૃ નિર્દેશ કરે છે.
જેથી નીચે અહીં, હું સેટ અધિકાર 1 સમકક્ષ કરવા નથી માંગતા.
તેથી હું તે જમણી તરફ, તેથી જો યોગ્ય = 1,
અને હું માનું તમે પણ કરવા માંગો છો -
જો તમે ડાબી ખસેડવા માટે, તમારે યોગ્ય 0 સમાન સેટ કરવા માંગો છો.
અથવા અન્ય જો તમે ક્યારેય જમણી ખસેડો.
તેથી યોગ્ય = 0. અધિકાર = 1 જો,
હવે અમે પિતૃ અધિકાર નિર્દેશક newnode બનાવવા માંગો છો,
બીજું અમે પિતૃ ડાબી નિર્દેશક newnode બનાવવા માંગો છો.
પર પ્રશ્નો?
ઠીક છે. જેથી આ રીતે આપણે છે - પણ વાસ્તવમાં, તેના બદલે આ કૃત્ય,
અમે અડધા તમે build_node વાપરવા માટે અપેક્ષિત છે.
અને પછી જો newnode નલ સમકક્ષ, ખોટી આવો.
કે જે તે છે. હવે, આપણે શું તમે કરવું તેવી શક્યતા હતી.
>> આ સ્ટાફ ઉકેલો શું.
હું તે વિશે જવાની "અધિકાર" માર્ગ તરીકે આ સાથે અસહમત
પરંતુ આ સંપૂર્ણપણે દંડ છે અને તે જ કામ કરશે.
એક વસ્તુ છે કે જે થોડું વિચિત્ર અધિકાર હવે છે
જો વૃક્ષ નલ તરીકે બોલ શરૂ થાય છે, આપણે નલ વૃક્ષ પાસ.
હું માનું તે કેવી રીતે તમે નલ વૃક્ષ પસાર વર્તણૂક વ્યાખ્યાયિત પર આધાર રાખે છે.
મને લાગે છે કે જો તમે નલ વૃક્ષ પાસ,
પછી નલ વૃક્ષ માં કિંમત દાખલ
માત્ર એક વૃક્ષ પરત કરીશું જ્યાં માત્ર કિંમત છે કે જે એક ગાંઠ છે.
શું લોકો સાથે સંમત? તમે, જો તમે ઇચ્છતા કરી શકતા,
જો તમે નલ વૃક્ષ પાસ
અને તમે તેને એક મૂલ્ય દાખલ કરવા માંગો છો, ખોટી આવો.
તે તમારા પર છે કે વ્યાખ્યાયિત કરે છે.
પ્રથમ વસ્તુ મેં કહ્યું અને પછી શું -
સાથે સાથે, શું તમે તે કરી મુશ્કેલી હોય જઈ રહ્યાં છો, કારણ કે
તેને સરળ હોઈ શકે જો આપણે વસ્તુ વૈશ્વિક નિર્દેશક હતું,
પરંતુ અમે, તેથી તો વૃક્ષ નલ હોય, ત્યાં કંઇ અમે તે વિશે શું કરી શકો છો.
અમે હમણાં જ ખોટા પાછા આવી શકો છો.
તેથી હું insert બદલી જાઉં છું.
અમે તકનીકી ફક્ત આ અધિકાર અહીં બદલી શકે છે,
તે વસ્તુઓ પર કેવી રીતે વારો છે,
પણ મને insert બદલવા માટે નોડ ** વૃક્ષ લેવા જાઉં છું.
ડબલ પોઇન્ટર.
આ શું અર્થ છે?
તેના બદલે ગાંઠો પોઇન્ટર સાથે વ્યવહાર છે,
આ વસ્તુ હું ફેરફાર કરી જાઉં છું આ નિર્દેશક છે.
હું આ નિર્દેશક ફેરફાર કરી જાઉં છું.
હું પોઇંટરો હેરફેર સીધા જ જાઉં છું.
આ અર્થમાં બનાવે છે, કારણ નીચે વિશે વિચારો -
તેમજ, હમણાં આ પોઇન્ટ null છે.
હું કરવા માંગો છો શું છે આ નિર્દેશક ચાલાકી માટે null નથી નિર્દેશ કરે છે.
હું તેને મારી નવી નોડ માટે નિર્દેશ કરવા માંગો છો.
જો હું માત્ર પોઇંટરો ટ્રેક મારા પોઇંટરો માટે, રાખવું
પછી હું પિતૃ નિર્દેશક ટ્રૅક રાખવા જરૂર નથી.
મેં હમણાં જ ટ્રેક રાખવા માટે જુઓ જો નિર્દેશક માટે null પોઇન્ટ કરી શકો છો,
અને જો નિર્દેશક પોઇન્ટ છે null માટે,
તેને બદલવા માટે નોડ હું કરવા માંગો છો નિર્દેશ કરે છે.
અને હું તેને બદલી ત્યારથી હું નિર્દેશક માટે નિર્દેશક હોઈ શકે છે.
માતાનો આ હમણાં જોવા દો.
તમે ખરેખર તેને recursively ખૂબ સરળતાથી કરી શકે છે.
શું અમે તે કરવા માંગો છો?
હા, અમે નથી.
>> ચાલો તે recursively જુઓ.
પ્રથમ, અમારી આધાર કેસ શું હોવું રહ્યું છે?
લગભગ હંમેશા અમારા આધાર કેસ, પરંતુ વાસ્તવમાં, આ કપટી પ્રકારની છે.
પ્રથમ પ્રથમ વસ્તુઓ, જો (વૃક્ષ NULL ==)
હું માનું અમે માત્ર ખોટા પાછા જઈ રહ્યાં છો.
આ તમારા વૃક્ષ છે નલ અલગ છે.
આ તમારા રુટ નિર્દેશક નલ હોવા માટે નિર્દેશક છે
જેનો અર્થ છે કે તમારા રુટ નિર્દેશક અસ્તિત્વમાં નથી.
જેથી નીચે અહીં, જો હું
નોડ * - ચાલો ખાલી આ પુનઃઉપયોગ.
નોડ * રુટ = NULL,
અને પછી હું કંઈક કરવાથી insert કૉલ જાઉં છું,
રુટ અને માં 4 દાખલ કરો.
તેથી અને રુટ જો રુટ નોડ * છે
અને તે પછી રુટ નોડ ** પ્રયત્ન રહ્યું છે.
આ માન્ય છે. આ કિસ્સામાં, વૃક્ષ, અહીં અપ
અથવા insert - વૃક્ષ નલ નથી.
અહીં. વૃક્ષ નલ નથી; * વૃક્ષ નલ છે, જે સારું હોય છે
કારણ કે જો * વૃક્ષ નલ હોય, તો પછી હું આ કામ કરી શકે છે
હવે હું શું તે નિર્દેશ કરવા માંગો છો નિર્દેશ કરે છે.
પરંતુ જો વૃક્ષ નલ છે, તેનો અર્થ એ કે હું ફક્ત નીચે અહીં આવ્યા હતા અને નલ જણાવ્યું હતું.
તે અર્થમાં નથી. હું જે કંઇ પણ સાથે ન કરી શકો.
જો વૃક્ષ નલ છે, ખોટી આવો.
તેથી હું મૂળભૂત પહેલેથી જ કહ્યું હતું કે, અમારી વાસ્તવિક આધાર કેસ શું છે.
અને તે શું હોવો રહ્યું છે?
[વિદ્યાર્થી, દુર્બોધ]
[બોડેન] હા. તેથી જો (* વૃક્ષ NULL ==).
આ અહીં આ કેસ સાથે સંલગ્ન
જ્યાં જો મારા લાલ નિર્દેશક પોઇન્ટર છે હું પર ધ્યાન કેન્દ્રિત છું,
આની જેમ હું આ નિર્દેશક પર ધ્યાન કેન્દ્રિત કરી રહ્યો છું, હવે હું આ નિર્દેશક પર ધ્યાન કેન્દ્રિત કરી રહ્યો છું.
હવે હું આ નિર્દેશક પર ધ્યાન કેન્દ્રિત કરી રહ્યો છું.
તેથી જો મારા લાલ નિર્દેશક, જે મારા નોડ ** છે,
ક્યારેય છે - * જો, મારા લાલ નિર્દેશક, ક્યારેય નલ છે,
તેનો અર્થ એ કે એ કે હું કેસ જ્યાં હું નિર્દેશક કે પોઇન્ટ પર ધ્યાન કેન્દ્રિત કરી રહ્યો છું છું -
આ નિર્દેશક કે એક પાંદડુ આવતી હોય છે.
હું આ નિર્દેશક બદલવા માટે મારી નવી નોડ માટે નિર્દેશ કરવા માંગો છો.
અહીં પર પાછા આવો.
મારા newnode માત્ર નોડ * = n build_node (કિંમત) હશે
પછી n એ, = n NULL જો, ખોટી આવો.
બાકી અમે બદલવા નિર્દેશક શું હાલમાં પોઇન્ટ છે કરવા માંગો છો
હવે અમારા નવા બાંધવામાં નોડ માટે નિર્દેશ કરે છે.
અમે ખરેખર અહીં કરી શકો છો.
તેના બદલે n એ કહેતા, અમે કહીએ છીએ વૃક્ષ * = * વૃક્ષ હોય.
દરેક વ્યક્તિને સમજો કે? કે પોઇંટરો માટે પોઇન્ટર સાથે વ્યવહાર દ્વારા,
અમે નલ પોઇંટરો બદલવા માટે વસ્તુઓ અમે તેમને નિર્દેશ કરવા માંગો છો નિર્દેશ કરી શકો છો.
તે અમારી આધાર કેસ છે.
>> હવે અમારા આવૃત્તિ, અથવા અમારી રિકર્ઝન,
છે ખૂબ બધા અન્ય recursions અમે કરી રહ્યા છો સમાન હશે.
અમે માટે કિંમત દાખલ કરો માંગો છો જઈ રહ્યાં છો,
અને હવે હું ફરીથી ત્રણ ભાગનું બનેલું ઉપયોગ જાઉં છું, પણ અમારા સ્થિતિ શું થઇ રહ્યું છે?
તે શું અમે નક્કી કરો કે શું અમે ડાબે અથવા જમણે જવા માગતા માટે કરી રહ્યાં છો માગે છે?
ચાલો તેને અલગ પગલાં કામ કરે છે.
જો (કિંમત <) શું?
[વિદ્યાર્થી] આ વૃક્ષ કિંમત?
[બોડેન] તેથી યાદ રાખો કે હું હાલમાં છું -
[વિદ્યાર્થીઓ, દુર્બોધ]
[બોડેન] યાહ, તેથી અહીં, ચાલો કહે છે કે આ લીલા તીર
વૃક્ષ શું હાલમાં એક ઉદાહરણ છે, આ નિર્દેશક માટે નિર્દેશક છે.
તેથી તેનો અર્થ એ કે હું 3 માટે નિર્દેશક માટે નિર્દેશક છું.
આ ડિરેફરન્સ બે વાર સારા sounded.
શું હું નથી - હું કેવી રીતે કરે છે કે શું?
[વિદ્યાર્થી] એકવાર ડિરેફરન્સ અને પછી શું તીર રીતે?
તેથી [બોડેન] (* વૃક્ષ) એ ડિરેફરન્સ વાર છે, - કિંમત>
છે મને નોડ કે હું પરોક્ષ તરફ ઇશારો કરી રહ્યો છું કિંમત આપવા જઈ રહી છે.
તેથી હું પણ લખી તે tree.value ** જો તમે કે પ્રાધાન્ય કરી શકો છો.
ક્યાં કામ કરે છે.
જો કે આ કેસ હોય તો, પછી હું કિંમત સાથે સામેલ કૉલ કરવા માંગો છો.
અને મારા સુધારાશે નોડ શું ** છે હશે?
હું ડાબી જવા માગતા, તેથી ** tree.left મારા ડાબા પ્રયત્ન રહ્યું છે.
અને મને તે વસ્તુ નિર્દેશક માંગો છો
જેથી જો ડાબી થાય તો નલ નિર્દેશક છે,
હું તેને સુધારવા માટે મારી નવી નોડ માટે નિર્દેશ કરી શકો છો.
>> અને અન્ય કેસ ખૂબ સમાન હોઈ શકે છે.
ચાલો ખરેખર મારા ત્રણ ભાગનું બનેલું છે કે જે હમણાં બનાવે છે.
કિંમત જો કિંમત <(** વૃક્ષ). કિંમત દાખલ કરો.
તો પછી અમે ડાબી અમારી ** અપડેટ કરવા માંગો છો,
બીજું અમે અધિકાર અમારી ** અપડેટ કરવા માંગો છો.
[વિદ્યાર્થી] કે નિર્દેશક માટે શું નિર્દેશક મળી શકે?
[બોડેન] યાદ રાખો કે - ** tree.right નોડ તારો છે.
[વિદ્યાર્થી, દુર્બોધ] >> યાહ.
** Tree.right આ નિર્દેશક અથવા કંઈક જેવું છે.
જેથી એક નિર્દેશક લઈને, જે મને આપે છે હું શું કરવા માંગો છો
કે વ્યક્તિ માટે નિર્દેશક છે.
[વિદ્યાર્થી] આપણે ઉપર ફરીથી જાઓ શકાયું શા માટે આપણે બે પોઇંટરો ઉપયોગ કરી રહ્યા છો?
[બોડેન] યાહ. તેથી - નો, તમે, અને તે ઉકેલ શકો તે પહેલાં
તે બે પોઇંટરો કરવાનું વિના કરી એક માર્ગ હતો.
તમે બે પોઇંટરો મદદથી સમજી કરવાનો પ્રયત્ન કરવાની જરૂર છે,
અને આ ક્લીનર ઉકેલ છે.
પણ નોટિસ, કે જે, શું થાય છે મારું વૃક્ષ જો -
શું થાય છે જો મારા રુટ નલ હતો? તો શું થાય હું આ કેસ અહીં છે?
તેથી નોડ રુટ * = NULL, રુટ & માં 4 દાખલ કરો.
રુટ શું આ પછી જ જવાની છે?
[વિદ્યાર્થી, દુર્બોધ] >> યાહ.
રુટ કિંમત 4 હોઇ રહ્યું છે.
રુટ ડાબી નલ પ્રયત્ન રહ્યું છે, રુટ જમણી નલ પ્રયત્ન રહ્યું છે.
કિસ્સામાં અમે રુટ જ્યાં સરનામા દ્વારા પાસ ન,
અમે રુટ નહિં સંશોધિત કરી શકે છે.
કિસ્સામાં જ્યાં વૃક્ષ - જ્યાં રુટ નલ હતી,
અમે હમણાં જ પાછા ખોટા હતા. ત્યાં કંઇ અમે કરી શકતા હતા.
અમે એક ખાલી વૃક્ષ એક નોડ સામેલ કરી શકતા નથી.
પરંતુ હવે અમે કરી શકો છો; આપણે માત્ર એક વૃક્ષ એક ગાંઠમાં ખાલી વૃક્ષ બનાવે છે.
જે સામાન્ય રીતે અપેક્ષિત રીતે કે તે કામ કરવા માટે માનવામાં આવે છે છે.
>> વધુમાં, આ નોંધપાત્ર કરતાં ટૂંકો હોય છે
પણ પિતૃ રાખવામાં આવેલ છે, અને તેથી તમે બધા માર્ગ પર ફરી વળવું.
હવે હું મારા પિતૃ હોય છે, અને હું માત્ર મારા પિતૃ જમણી ગમે માટે નિર્દેશક હોય છે.
તેની જગ્યાએ, જો આપણે આ iteratively કર્યું, તે વખતે લૂપ સાથે જ વિચાર હશો.
પરંતુ તેને બદલે મારા પિતૃ નિર્દેશક સામનો કરવો પડે છે,
તેના બદલે મારા વર્તમાન નિર્દેશક આ વસ્તુ હશે
કે હું સીધી મારા નવા નોડ માટે નિર્દેશ બદલવા છું.
હું શું તે ડાબી તરફ પોઇન્ટ છે સાથે વ્યવહાર નથી.
હું શું તે જમણી તરફ પોઇન્ટ છે સાથે વ્યવહાર નથી.
તે ફક્ત ગમે આ નિર્દેશક, હું તેને સુયોજિત કરવા માટે મારી નવી નોડ માટે નિર્દેશ છું રહ્યું છે.
દરેક વ્યક્તિને સમજવા તે કેવી રીતે કામ કરે છે?
જો નહિં તો અમે તેને આ રીતે કરવું શા માટે કરવા માંગો છો,
પરંતુ ઓછામાં ઓછા કે ઉકેલ તરીકે આ કામ કરે?
[વિદ્યાર્થી] આપણે સાચા ક્યાં પાછા નથી?
[બોડેન] તે કદાચ અહીં છે.
જો અમે યોગ્ય રીતે તે દાખલ કરો, સાચું આવો.
બાકી, નીચે અહીં આપણે ગમે insert વળતર પરત કરવા માંગો છો જઈ રહ્યાં છો.
>> અને આ શું ફરી યાદ આવવું કાર્ય વિશે ખાસ છે?
તે ફરી યાદ આવવું પૂંછડી છે, તેથી લાંબા તરીકે અમે કેટલીક ઓપ્ટિમાઇઝેશન સાથે સંકલન,
તે ઓળખી અને તમે આ સ્ટેક ઓવરફ્લો ક્યારેય વિચાર કરશે,
પણ જો અમારા વૃક્ષ 10,000 અથવા 10 મિલિયન એક ઊંચાઇ ધરાવે છે.
[વિદ્યાર્થી, દુર્બોધ]
[બોડેન] મને લાગે છે કે તે ડૅશ અંતે કરે છે - અથવા ઓપ્ટિમાઇઝેશન કયા સ્તરની
છે એક પૂંછડી માટે ઓળખી શકાય રિકર્ઝન માટે જરૂરી છે.
મને લાગે છે કે તે ઓળખે છે - GCC અને ખણખણાટ
પણ તેમના ઓપ્ટિમાઇઝેશન સ્તરો માટે અલગ અર્થ હોય છે.
હું કહેવા તે 2 ખાતરી કરો કે તે પૂંછડી રિકર્ઝન ઓળખશે માટે, DashO છે કરવા માંગો છો.
પરંતુ અમે - તમે Fibonocci ઉદાહરણ અથવા કંઈક જેવા રચવા શકે છે.
તે સરળ આ સાથે ચકાસો, નથી કારણ કે તે મુશ્કેલ છે બાંધવા
દ્વિસંગી વૃક્ષ કે જેથી મોટા છે.
પરંતુ હા, મને લાગે છે કે તે 2 DashO, કે
જો તમે 2 DashO સાથે સંકલન, તે પૂંછડી રિકર્ઝન માટે જોવા મળશે
અને મહત્તમ જે.
ચાલો પાછા જાઓ - દાખલ શાબ્દિક છેલ્લા વસ્તુ તે જરૂર છે.
ચાલો એવા દાખલ કરવા માટે અહીં પાછા ઉપર જાઓ
જ્યાં અમે એ જ વિચાર કરી રહ્યા છીએ.
તે હજુ પણ છે સંપૂર્ણપણે સંભાળી શકે નહીં દોષ પડશે
જ્યારે રુટ પોતે નલ હોય છે, અથવા ભૂતકાળમાં પ્રવેશ નલ છે,
પરંતુ તેને બદલે પિતૃ નિર્દેશક સાથે કામ છે,
ચાલો પોઇંટરો માટે રાખવા પોઇંટરો એ જ તર્ક લાગુ પડે છે.
અહીં જો અમે અમારા નોડ વર્તમાન ** રાખવા માટે,
અને અમે સાચવી રાખે અધિકાર હવે જરૂર નથી,
પરંતુ નોડ વર્તમાન ** = વૃક્ષ અને.
અને હવે અમારી, જ્યારે લૂપ માટે પ્રયત્ન કરતી વખતે * વર્તમાન સમાન નલ નથી જઈ રહ્યું છે.
શું કરવાની જરૂર નથી માતા - પિતા ટ્રેક હવે રાખો.
શું કરવાની જરૂર નથી ડાબી અને જમણી સાચવી રાખે.
અને હું તેને કામચલાઉ નોકર કૉલ, પડશે કારણ કે અમે પહેલાથી જ temp ઉપયોગ કરી રહ્યાં છો.
ઠીક છે. તેથી જો (કિંમત> કામચલાઉ નોકર *),
અને તે પછી (* temp) -> જમણે
બીજું temp = અને (* temp) - બાકી>.
અને હવે, આ બિંદુએ, આ વખતે લૂપ બાદ,
હું માત્ર આ કરવા કારણ કે કદાચ તેને સરળ છે તે વિશે કરતાં recursively iteratively વિચારો,
પરંતુ આ વખતે લૂપ બાદ,
* Temp પોઇન્ટર અમે બદલવા માંગો છો.
>> પહેલાં અમે પિતૃ હતી, અને અમે ક્યાં પિતૃ ડાબે અથવા જમણે પિતૃ બદલવા માગતા હતા,
પરંતુ જો અમે પિતૃ અધિકાર બદલવા માંગો છો,
પછી * temp પિતૃ અધિકાર છે, અને અમે તેને સીધી બદલી શકો છો.
જેથી નીચે અહીં, અમે * temp = newnode કરી શકે છે, અને એ છે કે તે છે.
સૂચના તેથી, બધા અમે આ કર્યું હતું બહાર કોડ રેખાઓ લઇ હતી.
ક્રમમાં તમામ પિતૃ છે કે વધારાની પ્રયાસ છે ટ્રૅક રાખવા માટે.
અહીં, જો અમે ફક્ત નિર્દેશક માટે નિર્દેશક ટ્રેક રાખવા માટે,
અને જો આપણે આ બધા સર્પાકાર કૌંસ છૂટકારો હવે વિચાર માગતા હતા,
તેને ટૂંકા જુઓ.
આ હવે ચોક્કસ જ ઉકેલ છે,
પરંતુ કોડ ઓછા રેખાઓ.
એકવાર તમે એક માન્ય ઉકેલ તરીકે આ માન્યતા શરૂ કરવા માટે,
તે પણ જેવી કરતાં લગભગ કારણ સરળ, ઠીક,
હું પૂર્ણાંક જમણે શા માટે નથી આ ધ્વજ છે?
કે શું અર્થ છે? ઓહ, તે દર્શાવે છે છે કે
દર વખતે હું અધિકાર જાઓ, હું તેને સુયોજિત કરવાની જરૂર છે,
બીજું જો હું જવા બાકી હું તેને શૂન્ય સુયોજિત કરવાની જરૂર છે.
અહીં, હું તે વિશે કારણ નહિં હોય, તે હવે સરળ છે તે વિશે વિચારો.
પ્રશ્નો?
[વિદ્યાર્થી, દુર્બોધ] >> યાહ.
ઠીક છે, જેથી છેલ્લા બીટ માં -
હું માનું એક ઝડપી અને સરળ કાર્ય કરીએ છીએ તે કરી શકે છે,
let's - મળીને મને લાગ્યું, પ્રયાસ અને લખી વિધેય સમાવે છે
જે કાળજી નથી કે શું તે બાઈનરી શોધ વૃક્ષ છે.
આ સમાવે છે કાર્ય સાચું પાછા જોઈએ
જો આ સામાન્ય દ્વિસંગી વૃક્ષ ગમે ત્યાં કિંમત અમે શોધી રહ્યાં છો તે છે.
તેથી આપણે તેને પ્રથમ વખત recursively કરવું અને પછી અમે તેને iteratively કરવું પડશે.
અમે ખરેખર માત્ર તે કરી શકો છો એકસાથે, કારણ કે આ ખરેખર ટૂંકા પ્રયત્ન રહ્યું છે.
>> મારા આધાર કેસ શું જવાનું છે આવશે?
[વિદ્યાર્થી, દુર્બોધ]
[બોડેન] તેથી જો (વૃક્ષ NULL ==) પછી શું?
[વિદ્યાર્થી] ખોટા પાછા ફરો.
[બોડેન] બાકી, તો સાથે સાથે, હું બીજું જરૂર નથી.
જો મારા અન્ય આધાર કેસ હતો.
[વિદ્યાર્થી] ની ટ્રી કિંમત? >> યાહ.
તેથી (વૃક્ષ-> કિંમત == કિંમત હોય.
નોંધ અમે નોડ * પાછા છો નોડ ઓ ** નથી?
સમાવે નોડ ** ઉપયોગ ક્યારેય જરૂર રહેશે નહીં,
કારણ કે અમે પોઇંટરો નથી ફેરફાર કરવામાં આવે છે.
અમે હમણાં જ તેમને સરકાઉ કરી રહ્યાં છો.
જો આવું થાય, તો પછી અમે સાચી પરત કરવા માંગો છો.
બાકી અમે બાળકો પસાર કરવા માંગો છો.
તેથી અમે કે શું ડાબી બધું ઓછી છે તે વિશે નથી કારણ કરી શકો છો
અને જમણી બધું વધારે હોય છે.
તેથી અમારા સ્થિતિ શું અહીં રહ્યું છે - અથવા, અમે શું જવાનું છે કરું?
[વિદ્યાર્થી, દુર્બોધ] >> યાહ.
વળતર ધરાવે છે (કિંમત, વૃક્ષ-> ડાબે)
અથવા સમાવે છે (કિંમત, વૃક્ષ-> જમણે). અને તે છે.
નોટિસ અને કેટલાક મૂલ્યાંકન ટૂંકા સર્કિટ હોય છે,
જ્યાં જો અમે ડાબી વૃક્ષ કિંમત શોધવા થાય છે,
અમે ક્યારેય અધિકાર વૃક્ષ જુઓ.
કે સમગ્ર કાર્ય છે.
હવે તે iteratively દો,
જે ઓછા સરસ પ્રયત્ન રહ્યું છે.
અમે નોડ * વર્તમાન = વૃક્ષ ની સામાન્ય શરૂઆત લેવા પડશે.
જ્યારે (વર્તમાન = NULL!).
ઝડપથી એક સમસ્યા જોવા જવાનું.
જો વર્તમાન - આઉટ અહીં, જો આપણે ક્યારેય આ ભંગ,
પછી અમે વસ્તુઓ સ્કોર કર્યું જોવા, જેથી ખોટી આવો.
જો (વર્તમાન-> કિંમત == કિંમત), સાચું આવો.
તેથી હવે, અમે એક જગ્યાએ હોય છે -
અમે જાણતા નથી કે શું અમે ડાબે અથવા જમણે જવા માંગો છો.
તેથી આપખુદ, ચાલો માત્ર જાઓ છોડી દીધી.
હું ચોક્કસપણે એક મુદ્દો કે જ્યાં હું સંપૂર્ણપણે બધું છોડી દીધો છે પણ કર્યું છે -
હું માત્ર ક્યારેય વૃક્ષ ડાબી બાજુ તપાસ કરશે.
હું જે કંઇ પણ કંઈ પણ એક અધિકાર બાળક છે ક્યારેય તપાસ કરશે.
હું આ કેવી રીતે ઠીક કરું?
[વિદ્યાર્થી] તમે એક સ્ટેક માં ડાબી અને જમણી સાચવી રાખે છે.
[બોડેન] યાહ. તેથી દો તે બનાવે છે
સ્ટ્રક્ટ યાદી, નોડ * n એ, અને પછી નોડ આગામી **?
મને લાગે છે કે લલિત કામ કરે છે.
અહીં - અમે ઉપર ડાબી, અથવા let's જવા માંગો છો.
સ્ટ્રક્ટ યાદી યાદી =, તે શરૂ કરી શકશો
આ સ્ટ્રક્ટ યાદી છે.
યાદી * = NULL. જેથી અમારી સંલગ્ન યાદી જ હશે
subtrees કે અમે ઉપર છોડવામાં છે.
અમે હવે બાકી આડાશ જવું છે,
પરંતુ ત્યાર બાદ અમે ખચીત અધિકાર પર પાછા આવવાની જરૂર છે,
અમે અમારી સ્ટ્રક્ટ યાદી ની અંદર જમણી બાજુએ રાખી રહ્યા છીએ.
તો પછી અમે new_list અથવા સ્ટ્રક્ટ પડશે,
સ્ટ્રક્ટ યાદી *, new_list = malloc ((યાદી) sizeof).
હું ભૂલ ચકાસણી અવગણો જાઉં છું, પરંતુ તમે જો તે નલ જોવા માટે ચકાસો કરીશું.
આ નોડ તે માટે નિર્દેશ રહ્યું છે New_list -
ઓહ, કે શા માટે હું તે જોઈતું અહીં. તે બીજા સ્ટ્રક્ટ યાદી માટે નિર્દેશ બનશે.
કે માત્ર કેવી રીતે યાદીઓ વર્ક કડી થયેલ છે.
આ પૂર્ણાંક યાદીની લિંક જેવી જ છે
સિવાય અમે નોડ * સાથે રહ્યાં છો પૂર્ણાંક બદલીને.
તે બરાબર છે જ.
તેથી new_list, અમારા new_list નોડ ની કિંમત,
છે વર્તમાન-> અધિકાર હશે.
અમારા મૂલ્ય new_list-> આગામી અમારી મૂળ યાદી પ્રયત્ન રહ્યું છે,
અને પછી અમે અમારી યાદી સુધારવા માટે new_list નિર્દેશિત કરવા માટે જઈ રહ્યાં છો.
>> હવે અમે ખેંચીને વસ્તુઓ રીતે અમુક પ્રકારની જરૂર હોય,
જેમ અમે સમગ્ર ડાબી ઉપવૃક્ષ કાપવામાં આવ્યા છે.
હવે અમે સામગ્રી તેને બહાર ખેંચી જરૂર છે,
જેમ વર્તમાન નલ છે; અમે માત્ર ખોટા પરત કરવા નથી માંગતા.
અમે હવે અમારી નવી યાદી અંતે બહાર ખેંચી કરવા માંગો છો.
આમ એક અનુકૂળ માર્ગ - પણ વાસ્તવમાં, ત્યાં આમ ઘણી રીતે કરે છે.
કોઈપણ સૂચન હોય?
જ્યાં હું આ અથવા હું આ કેવી રીતે કરવું જોઈએ શું કરવું જોઈએ?
અમે ફક્ત બે મિનિટ છે, પણ કોઈ સૂચનો?
બદલે - એક માર્ગ બદલે અમારી સ્થિતિ હોવા છતાં,
અમે હાલમાં અંતે શોધી રહ્યાં છો તે શું નલ નથી,
તેના બદલે અમે જાઓ ચાલુ રાખવા સુધી અમારા યાદી પોતે નલ છે જઈ રહ્યાં છો.
તેથી જો અમારી યાદી થાય નલ છે,
પછી અમે વસ્તુઓ ચાલે છે માટે જુઓ, પર શોધો.
પરંતુ અર્થ એ થાય કે અમારી યાદીમાં પ્રથમ વસ્તુ માત્ર પ્રથમ નોડ પ્રયત્ન રહ્યું છે.
ખૂબ પ્રથમ વસ્તુ હશે - અમે લાંબા સમય સુધી કે જુઓ કરવાની જરૂર છે.
તેથી યાદી-> n એ અમારા વૃક્ષ હશે.
યાદી-> આગામી માટે નલ પ્રયત્ન રહ્યું છે.
અને હવે જ્યારે યાદી સમાન નલ નથી.
વર્તમાન અમારી યાદી માંથી કંઈક ખેંચી રહ્યું છે.
તેથી વર્તમાન સમાન યાદી-> n એ માટે જઈ રહ્યો છે.
અને પછી યાદી સમાન યાદી-> n એ માટે જઈ રહ્યો છે, અથવા યાદી-> આગામી.
તેથી જો વર્તમાન કિંમત કિંમત સમકક્ષ હોય છે.
હવે અમે બંને અમારા અધિકાર નિર્દેશક અને અમારી ડાબી નિર્દેશક ઉમેરી શકો છો
સુધી તેઓ નલ નથી.
અહીં નીચે, હું માનું અમે તે કર્યું છે કરીશું પ્રથમ સ્થાને છે.
જો (વર્તમાન-> અધિકાર =! NULL)
પછી અમે અમારી યાદી માં કે નોડ સામેલ થશે.
જો (વર્તમાન-> ડાબે), આ વધારાની કામગીરી થોડો છે, પરંતુ તે દંડ છે.
જો, (વર્તમાન-> ડાબી =! NULL)
અને અમે અમારી સાથે લિંક યાદી માં ડાબી દાખલ જઈ રહ્યાં છો,
અને તે પ્રયત્ન કરીશું.
અમે ભારપૂર્વક કહેવું - સુધી અમે અમારા યાદી કંઈક હોય છે,
અમે બીજા જોવા નોડ છે.
તેથી અમે તે ગાંઠ પર જુઓ,
અમે આગામી એક અમારી યાદી આગળ.
જો કે નોડ કિંમત અમે શોધી રહ્યાં છો તે છે, અમે સાચું પાછા આવી શકો છો.
બાકી બંને અમારી ડાબી અને જમણી subtrees દાખલ કરો,
સુધી તેઓ નલ નથી, અમારા યાદી માં
તેથી અમે ફરજ તેમના પર જાઓ.
તેથી જો તેઓ નલ, ન હતી
જો અમારા રુટ નિર્દેશક બે વસ્તુઓ પર ધ્યાન,
પછી પ્રથમ અમે કંઈક ખેંચાય બહાર છે તેથી અમારી યાદી થાય નલ છે.
અને પછી અમે બે વસ્તુઓ પાછા મૂકવા, તેથી હવે અમારી યાદી 2 માપ છે.
તો પછી અમે લૂપ માટે જઈ રહ્યાં છો બેક અપ અને અમે હમણાં જ ખેંચી રહ્યા છીએ,
ચાલો કહે, અમારા રુટ નોડ ડાબી નિર્દેશક.
અને જે હમણાં જ થઈ રહ્યું રાખવા પડશે; અમે અંત બધું પર રહ્યાં પડશે.
>> નોંધ કરો કે આ વધુ નોંધપાત્ર જટિલ હતી
ફરી યાદ આવવું ઉકેલ છે.
અને હું ઘણી વાર કહ્યું કર્યા છે
કે ફરી યાદ આવવું ઉકેલ સામાન્ય રીતે સામાન્ય ખૂબ ઉકેલ પુનરાવર્તન સાથે હોય છે.
અહીં આ છે બરાબર શું ફરી યાદ આવવું ઉકેલ કરી છે.
આ માત્ર ફેરફાર છે જે જગ્યાએ સર્વથા સ્ટેક ઉપયોગ, આ કાર્યક્રમ સ્ટેક છે
ગાંઠો શું તમે હજી પણ મુલાકાત લેવાની જરૂર રાખવામાં આવેલ તમારી માર્ગ તરીકે,
હવે તમે બાહ્ય રીતે સંકળાયેલી યાદી ઉપયોગ કરે છે.
બન્ને કિસ્સાઓમાં તમે ટ્રેક રાખવા થાય છે નોડ શું હજુ પણ મુલાકાત લીધી કરવાની જરૂર છે.
ફરી યાદ આવવું કિસ્સામાં તે માત્ર સરળ છે કારણ કે સ્ટેક
છે કાર્યક્રમ સ્ટેક તરીકે તમારા માટે અમલમાં મૂકી.
નોંધ કરો કે આ યાદીની લિંક, તે સ્ટેક છે.
ગમે અમે ફક્ત સ્ટેક પર મૂકી
તરત જ છે, આપણે શું માટે આ બોલ સ્ટેક ખેંચો આગામી મુલાકાત રહ્યા છીએ.
અમે સમય નથી, પરંતુ કોઈ પણ પ્રશ્ન છે?
[વિદ્યાર્થી, દુર્બોધ]
[બોડેન] યાહ. તેથી જો આપણે સંલગ્ન યાદી હોય છે,
વર્તમાન આ વ્યક્તિ માટે નિર્દેશ રહ્યું છે,
અને હવે અમે અમારા સંલગ્ન યાદી આગળ કરી રહ્યાં છે આ વ્યક્તિ પર ભાર મૂકે છે.
અમે તે લીટી માં યાદીની લિંક પર સરકાઉ કરી રહ્યાં છો.
અને પછી મને લાગ્યું કે અમે અમારા સંલગ્ન યાદી અને સામગ્રી મુક્ત કરીશું
એક વખત સાચી કે ખોટી પરત પહેલા, અમે જરૂર
અમારા યાદીની લિંક પર ફરી વળવું અને હંમેશા નીચે અહીં, હું માનું છું,
જો આપણે વર્તમાન અધિકાર ન હોય, તો તે ઉમેરો, જેથી હવે અમે મુક્ત કરવા માંગો છો
વર્તમાન કારણ કે, તો સાથે સાથે, અમે સંપૂર્ણપણે તેણે યાદી વિશે ભૂલી ગયા છો? યાહ.
જેથી અમે શું અહીં કરવા માંગો છો.
જ્યાં નિર્દેશક છે?
વર્તમાન પછી - અમે એક સ્ટ્રક્ટ યાદીમાં 10 * યાદી આગામી સમકક્ષ કરવા માંગો છો.
મફત યાદી, યાદી = કામચલાઉ નોકર.
અને કિસ્સામાં જ્યાં અમે સાચું પાછા, અમે ભારપૂર્વક કહેવું જરૂરી નથી
અમારા સંલગ્ન વસ્તુઓ ખાલી યાદી બાકીની બનાવ્યા.
ફરી યાદ આવવું ઉકેલ વિશે સરસ વસ્તુ વસ્તુઓ ખાલી છે
ફક્ત સ્ટેક કે જે તમને થશે બોલ ધાણી factorings થાય છે.
તેથી અમે કંઈક કે જે હાર્ડ-થી-લાગે કે લગભગ કોડ 3 રેખાઓ જેવા તેના પરથી ગઇ કર્યા છે
કંઈક કે જે મહત્વપૂર્ણ રીતે ઘણી વધારે છે કઠોર લાગે છે કે લગભગ કોડ રેખાઓ.
વધુ કોઈપણ પ્રશ્ન છે?
અધિકાર છે. અમે સારા છીએ. બાય!
[CS50.TV]