[Powered by Google Translate] [Walkthrough - પ્રોબ્લેમ 6 સેટ]
[Zamyla ચાન - હાર્વર્ડ યુનિવર્સિટી]
[આ CS50 છે. - CS50.TV]
>> હેલો, દરેકને, અને 6 Walkthrough સ્વાગત છે: Huff'n દોડ્યા પછી એકદમ હાંફવું.
Huff'n દોડ્યા પછી એકદમ હાંફવું શું આપણે કરી રહ્યા છે એક હફમેનના કોમ્પ્રેસ્ડ ફાઇલ સાથે વ્યવહાર કરવામાં રહ્યું છે
અને તે પછી તેને ફરીથી અપ puffing છે, તેથી તેને decompressing,
જેથી અમે 0s અને 1 સે કે વપરાશકર્તા અમને મોકલે માંથી અનુવાદ કરી શકો છો
અને તે મૂળ લખાણ પાછું ફેરવી શકાય છે.
Pset માટે 6 સરસ પ્રયત્ન રહ્યું છે કારણ કે તમે સાધનો કેટલાક જોવા જઈ રહ્યાં છો
કે તમે તેમને 1 સુંદર સુઘડ ખ્યાલ માં સંયોજિત 4 pset અને 5 pset અને પ્રકારનો ઉપયોગ
જ્યારે તમે એના વિશે વિચારો આવે છે.
>> પણ, દાવાપૂર્વક, 4 અને 5 pset સૌથી પડકારરૂપ psets કે અમે ઓફર કરે હતો હતી.
તેથી હવે, અમને સી માં આ 1 વધુ pset હોય છે,
અને પછી તે પછી અમે વેબ પ્રોગ્રામીંગ પર છો.
તેથી તમે જાતે CS50 માં અઘરી ખૂંધ કે ઢેકો પર મેળવવા માટે અભિનંદન.
>> Huff'n દોડ્યા પછી એકદમ હાંફવું માટે ખસેડવું, આ pset માટે અમારા શોધો માટે હફમેનના વૃક્ષો હશે આવે છે,
તેથી જ કેવી રીતે દ્વિસંગી વૃક્ષો પણ કામ ખાસ હફમેનના વૃક્ષો સમજવા માટે,
તેઓ કેવી રીતે નિર્માણ કરી રહ્યાં છો.
અને પછી અમે આ pset વિતરણ કોડ ઘણો જઈ રહ્યાં છો,
અને અમે તે ખરેખર કોડ જોઇ કેટલાક આવવું પડશે
અમે સંપૂર્ણપણે હજુ સુધી સમજી શકે નહિં,
અને તેથી તે આ સી. ફાઈલો હશે, પરંતુ તે પછી તેની સાથે ક. ફાઇલો
અમને પૂરતી સમજ કે અમે જરૂર છે કે જેથી આપણે જાણીએ છીએ કે કેવી રીતે તે વિધેયો કામ આપશે
અથવા ઓછામાં ઓછું તેઓ કરવા માનવામાં આવે છે શું - તેમની ઇનપુટ્સ અને આઉટપુટ -
પણ જો આપણે જાણતા નથી શું બ્લેક બોક્સ થઇ રહ્યું છે તે
સમજી નથી અથવા તો બ્લેક બોક્સ શું અંદર ચાલી રહ્યું છે તે.
અને પછી છેવટે હંમેશની જેમ, અમે નવી માહિતી માળખાં સાથે વ્યવહાર કરવામાં આવે છે,
નોડ કે જે ચોક્કસ પ્રકારની ચોક્કસ વસ્તુઓ માટે નિર્દેશ,
અને તેથી અહીં નથી અને માત્ર ડિઝાઈન પ્રક્રિયા માટે પેન કાગળ કર્યા
અને તમે બહાર આકૃતિ કેવી રીતે તમારા pset કામ કરીશું પ્રયાસ કરી રહ્યા છો ત્યારે
પણ ડિબગીંગ દરમ્યાન.
તમે તમારી પેન અને કાગળ સાથે GDB ધરાવે છે જ્યારે તમે નીચે લઇ કિંમતો શું છે શકે છે,
તમારા તીરો, જ્યાં પોઇન્ટ છે અને તે જેવી વસ્તુઓ.
>> પ્રથમ ચાલો હફમેનના વૃક્ષો જુઓ.
હફમેનના વૃક્ષો દ્વિસંગી વૃક્ષો છે, જેનો અર્થ છે કે દરેક નોડ માત્ર 2 સંતાનો છે.
હફમેનના વૃક્ષો માં લાક્ષણિકતા એ છે કે મોટા ભાગના વારંવાર કિંમતો
આવે છે સૌથી ઓછા બિટ્સ દ્વારા રજૂ કરે છે.
અમે મોર્સ કોડ વ્યાખ્યાન ઉદાહરણો માટે, એકત્રિત પ્રકારની છે કે જે અમુક પત્રો જોવા મળી હતી.
જો તમે એક અથવા ઉદાહરણ તરીકે ઇ, અનુવાદ કરવાનો પ્રયાસ કરી રહ્યાં છો,
તમે જે ઘણીવાર અનુવાદ કરી રહ્યાં છો, તેથી બદલે માટે બીટ્સ સંપૂર્ણ સેટ ઉપયોગ કર્યા
કે સામાન્ય માહિતી પ્રકાર માટે ફાળવવામાં, તો તમે તેને સંકુચિત ઓછા કરવા માટે નીચે,
અને પછી તે અક્ષરો જે રજૂ થાય છે ઓછી વખત લાંબા સમય સુધી બિટ્સ સાથે રજૂ થાય છે
કારણ કે તમે તે પરવડી જ્યારે તમે આવૃત્તિઓ કે તે અક્ષરો દેખાય તોલવું કરી શકો છો.
અમે એ જ વિચાર અહીં છે હફમેનના વૃક્ષો માં
અમે સાંકળ છે, પથ એક પ્રકારની ચોક્કસ અક્ષરો મેળવવા જ્યાં બનાવે છે.
અને પછી જે પાત્રો સૌથી આવર્તન ધરાવે છે
આવે છે સૌથી ઓછા બિટ્સ સાથે રજૂ હશે.
>> જે રીતે તમે એક હફમેનના વૃક્ષ રચવા
અક્ષરો કે લખાણ દેખાશે તમામ મૂકીને છે
અને તેમના હુમલાઓનું ગણતરી, ઘણી વખત તેઓ કેવી રીતે દેખાય છે.
આ ક્યાં તો કેટલી વખત તે અક્ષરો દેખાય ગણતરી હોઈ શકે છે
અથવા કદાચ બધા અક્ષરો કેટલા દરેક એક દેખાય બહાર એક ટકા.
અને જેથી તમે શું છે એકવાર તમે તે મેપ બહાર બધી,
પછી તમે 2 નીચા આવર્તનના જોવા માટે અને પછી તેમને ભાઈ તરીકે જોડાવા
પછી જ્યાં પિતૃ ગાંઠ આવૃત્તિ કે જેની તેની 2 બાળકોના રકમ છે.
અને તમે સંમેલન દ્વારા પછી કહે છે કે ડાબી નોડ,
તમે 0 શાખા અનુસરીને કે અનુસરો,
અને પછી જમણીબાજુનીસ્થિતિ ગાંઠની 1 શાખા છે.
આપણે મોર્સ કોડ માં જોયું, તે એક gotcha હતો કે જો તમે માત્ર એક બીપ Comment અને બીપ Comment હતી
તે અસ્પષ્ટ હતો.
તે ક્યાં તો 1 પત્ર હોઈ શકે છે અથવા તે કરી શકે 2 અક્ષરોના ક્રમ હોઈ શકે છે.
અને તેથી હફમેનના વૃક્ષો કરે છે શું છે તે અક્ષરો સ્વભાવ દ્વારા કારણ કે
અથવા અમારી અંતિમ વાસ્તવિક શાખા પર છેલ્લા ગાંઠો છે અક્ષરો -
અમે પાન તરીકે લોકો માટે નો સંદર્ભ લો - કે સદ્ગુણ દ્વારા કોઇ અસ્પષ્ટતા ન હોઈ શકે
શરતો પત્ર જે તમે બિટ્સ ની શ્રેણી સાથે બેવડી પ્રયાસ કરી રહ્યા છો માં
કારણ કે બિટ્સ કે 1 પત્ર પ્રતિનિધિત્વ સાથે ક્યાંય
તમે અન્ય સંપૂર્ણ પત્ર મળે છે, અને કોઇ મૂંઝવણ ત્યાં હશે નહિં.
પરંતુ અમે ઉદાહરણો જાય છે કે તમે ગાય્ઝ ખરેખર જોઈ શકો છો કરીશું કે
બદલે અમને હમણાં જ તમને કહેવાની કે જે સાચું છે.
>> ચાલો એક હફમેનના વૃક્ષ એક સરળ ઉદાહરણ જુઓ.
હું અહીં એક શબ્દમાળા કે 12 અક્ષર લાંબો છે.
હું જેમ, 6 bs અને 2 સીએસ 4 છે.
મારી પ્રથમ પગલું ગણતરી હશે.
કેટલી વખત એ દેખાતું નથી? તે શબ્દમાળા માં 4 વખત દેખાય છે.
બી 6 વખત દેખાય છે, અને C 2 વખત દેખાય છે.
કુદરતી રીતે, હું કહેવા હું બી ઉપયોગ કરું છું, મોટે ભાગે જાઉં છું,
તેથી હું બિટ્સ ના સૌથી ઓછા નંબર, 0s અને 1 સે ના સૌથી ઓછા નંબર સાથે બી પ્રતિનિધિત્વ કરવા માંગો છો.
અને પછી હું પણ સી 0s અને 1 સે સૌથી જથ્થો જરૂર તેમજ અપેક્ષા જાઉં છું.
પ્રથમ હું શું અહીં કર્યું હું આવર્તન દ્રષ્ટિએ ચડતા ક્રમમાં છે તેમને મૂકવામાં આવે છે.
અમે જુઓ કે સી અને એ, તે અમારી 2 નીચા આવર્તનના છે.
અમે પિતૃ નોડ બનાવવા માટે, અને તે કે પિતૃ નોડ તેની સાથે સંકળાયેલ પત્ર નથી,
પરંતુ તે એક આવર્તન, જે રકમ હોય છે.
આ રકમ + 2 4, જે 6 છે બને છે.
તો પછી અમે ડાબી શાખા અનુસરો.
જો અમે કે જે 6 નોડ હતા, તો પછી અમે 0 અનુસરવા સી મેળવવા કરશે
અને 1 પછી એ મેળવવા માટે
તેથી હવે અમે 2 ગાંઠો હોય છે.
અમે 6 કિંમત હોય છે અને તે પછી અમે પણ 6 કિંમત સાથે અન્ય નોડ છે.
અને તેથી 2 નહિં કે જે માત્ર સૌથી નીચો 2 પણ ફક્ત 2 કે છોડી મૂકવામાં આવે છે,
તેથી અમે અન્ય પિતૃ દ્વારા તે આ રકમ 12 હોવા સાથે, જોડાઓ.
અહીં આપણે હફમેનના વૃક્ષ હોય છે
જ્યાં બી મેળવવા માટે, કે જે ફક્ત 1 બીટ હશે
અને પછી એ વિચાર અમે 01 હોય છે અને તે પછી થશે સી 00 હોય છે.
અહીં અમે જુઓ કે મૂળભૂત રીતે આપણે ક્યાં 1 અથવા 2 બીટ્સ સાથે આ અક્ષરો રજૂ કરી રહ્યા છીએ
જ્યાં બી, આગાહી, ઓછામાં ઓછી હોય છે.
અને પછી અમે સી સૌથી વધુ હોય તેવી અપેક્ષા હતી, પરંતુ કારણ કે તે આવા નાના હફમેનના વૃક્ષ છે,
પછી એ પણ 2 તરીકે મધ્યમાં ક્યાંક વિરોધ બિટ્સ દ્વારા રજૂ થાય છે.
>> ફક્ત હફમેનના વૃક્ષ બીજા સરળ ઉદાહરણ પર જાઓ,
કહેવું તમે શબ્દમાળા ધરાવે છે "હેલો."
તમે શું પ્રથમ છે તમે કહ્યું કેટલી વખત એચ આ દેખાતું નથી?
એચ દેખાય વાર અને પછી ઈ દેખાય વાર અને પછી અમે બે વખત દેખાય છે l છે
અને ઓ વાર દેખાય છે.
અને તેથી તો અમે અપેક્ષા પત્ર જે બિટ્સ ના ઓછામાં ઓછા નંબર દ્વારા રજૂ માટે?
[વિદ્યાર્થી] l. >> L. યાહ. l અધિકાર છે.
અમે l બિટ્સ ના ઓછામાં ઓછા નંબર દ્વારા રજૂ એવી અપેક્ષા રાખે છે
કારણ કે l સૌથી શબ્દમાળા ઉપયોગ થાય છે "હેલો."
મારે શું હવે કરવા જાઉં છું આ ગાંઠો દોરવા છે.
હું 1 છે, કે જે એચ છે, અને પછી 1 અન્ય, જે ઈ છે તો પછી અને 1 એ છે, કે જે ઓ છે -
હમણાં હું તેમને ક્રમમાં મૂકી રહ્યો છું - અને પછી 2, કે જે l છે.
પછી હું કહું છું કે જે રીતે હું હફમેનના વૃક્ષ બીલ્ડ કરવા માટે ઓછામાં ઓછું આવર્તન સાથે 2 ગાંઠો શોધે છે
અને તેમને પિતૃ નોડ બનાવીને ભાઈ બનાવે છે.
અહીં અમે સૌથી ઓછી આવૃત્તિ સાથે 3 ગાંઠો હોય છે. તેઓ 1 બધા છો.
અહીં અમે પસંદ કરો કે જે એક આપણે પ્રથમ લિંક રહ્યા છીએ.
હવે કહો કે હું એચ અને ઈ પસંદ કરો.
1 ની રકમ + 1 2 છે, પરંતુ આ નોડ તેની સાથે સંકળાયેલ પત્ર નથી.
તે ફક્ત કિંમત ધરાવે છે.
હવે અમે આગામી 2 નીચા આવર્તનના જુઓ.
કે 2 અને 1 છે. કે 2 તે ક્યાં હોઇ શકે છે, પણ હું આ એક પસંદ કરો જાઉં છું.
આ રકમ 3 છે.
અને પછી છેવટે હું ફક્ત 2 ડાબી હોય છે, તેથી તો પછી તે 5 બની જાય છે.
પછી અહીં, ઈચ્છિત તરીકે, જો હું તે માટે એન્કોડિંગ ભરો,
1 સે હંમેશા અધિકાર શાખા અને 0s છે ડાબી એક છે.
પછી અમે 2 દ્વારા માત્ર 1 અને પછી બિટ ઓ દ્વારા રજૂ l છે
અને પછી 2 દ્વારા ઈ અને પછી એચ 3 બિટ્સ માટે નીચે પડે છે.
તેથી તમે આ સંદેશો પ્રસારિત "હેલો" ને બદલે હકીકતમાં અક્ષરોનો ઉપયોગ
માત્ર 0s અને 1 સે દ્વારા.
જોકે યાદ રાખો કે ઘણા કિસ્સાઓમાં આપણે આવૃત્તિ સાથે જોડાણ કર્યું.
અમે ક્યાં તો એચ અને ઓ પ્રથમ કદાચ છે જોડાયા શકે છે.
અથવા ત્યાર બાદ જ્યારે અમે 2 દ્વારા રજૂ l હતી
તેમજ એક 2 દ્વારા રજૂ જોડાયા, અમે એક ક્યાં કડી થયેલ હોઈ શકે છે.
>> અને એટલે જ્યારે તમે મોકલો 0s અને 1 સે, કે જે વાસ્તવમાં બાંહેધરી નથી આપતું
કે પ્રાપ્તકર્તા સંપૂર્ણપણે બેટ બોલ અધિકાર તમારો સંદેશ વાંચી શકે છે
કારણ કે તેઓ જાણતા ન શકે નિર્ણય કે જે તમે બનાવી હતી.
તેથી જ્યારે અમે હફમેનના સંકોચન સાથે કામ કરીએ છીએ,
કોઈક અમે અમારા સંદેશો મેળવનાર અમે કેવી રીતે નક્કી કર્યું કહેવું હોય -
તેઓ વધારે માહિતી માટે અમુક પ્રકારના જાણવાની જરૂર છે
સંકુચિત સંદેશા માટે વધુમાં છે.
તેઓ સમજવા માટે વૃક્ષ શું ખરેખર આના જેવું દેખાય છે જરૂર છે,
અમે કેવી રીતે વાસ્તવમાં તે નિર્ણયો કર્યા છે.
>> અહીં અમે ફક્ત વાસ્તવિક ગણતરી પર આધારિત ઉદાહરણો કરી રહ્યા હતા,
પરંતુ ક્યારેક તમે પણ હફમેનના વૃક્ષ થઈ શકે છે
આવર્તન પર આધારિત છે કે અક્ષરો દેખાય છે, અને તે ચોક્કસ જ પ્રક્રિયા છે.
અહીં હું તે ટકાવારી અથવા અપૂર્ણાંક દ્રષ્ટિએ વ્યકત છું,
અને તેથી અહીં ચોક્કસ જ વાત.
હું 2 સૌથી નીચો તેમને સરવાળો, આગામી સૌથી નીચો 2, તેમને સરવાળો શોધવા માટે,
ત્યાં સુધી હું સંપૂર્ણ વૃક્ષ હોય છે.
તેમ છતાં અમે તે કાં તો તે રીતે, જ્યારે અમે ટકાવારી સાથે કામ કરીએ છીએ કરી શકે છે,
તેનો અર્થ એ કે અમે વસ્તુઓ વિભાજન કરી રહ્યાં છો અને દશાંશ સાથે વ્યવહાર અથવા બદલે તરે
જો અમે માથામાં માહિતી માળખાં વિશે વિચારી રહ્યાં છો.
અમે શું ફ્લોટ્સ વિશે જાણો છો?
એક સામાન્ય સમસ્યા જ્યારે અમે ફ્લોટ્સ સાથે વ્યવહાર કરી રહ્યા છો શું છે?
[વિદ્યાર્થી] અશુદ્ધ અંકગણિત. >> યાહ. અશુદ્ધિ.
અપૂર્ણાંક બિંદુ અશુદ્ધિ કારણે, આ pset માટે કે જેથી અમે ખાતરી કરો
કે અમે કોઈ કિંમતો ગુમાવી નથી, તો પછી અમે ખરેખર ગણના સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો.
તેથી જો તમે હફમેનના નોડ લાગે છે, જો તમે માળખું માટે અહીં જોવા હતા,
જો તમે ગ્રીન મુદ્દાઓ જુઓ તે તેની સાથે સંકળાયેલ આવર્તન ધરાવે છે
તેમજ તેની ડાબી નોડ તેમજ તેની જમણી નોડ નિર્દેશ કરે છે.
અને પછી લાલ મુદ્દાઓ પણ તેમની સાથે સંકળાયેલ પાત્ર હોય છે.
અમે પછી અને માતા - પિતા અંતિમ ગાંઠો માટે અલગ મુદ્દાઓ બનાવી નથી જઈ રહ્યાં છો,
જે અમે પાન તરીકે નો સંદર્ભ લો, પરંતુ તે માત્ર નલ કિંમતો હશે.
દરેક નોડ માટે અમે એક અક્ષર, તો સંજ્ઞા કે જે નોડ રજૂ પડશે,
પછી તેમજ તેની ડાબી તેમજ તેના અધિકાર બાળક બાળક માટે નિર્દેશક આવૃત્તિ છે.
પાંદડા, જે ખૂબ જ તળિયે છે પણ નોડ પોઇંટરો હશે
તેમની ડાબી અને તેમના અધિકાર છે, પરંતુ તે કિંમતો વાસ્તવિક ગાંઠો નથી પોઇન્ટ છે, કારણ
તેમની કિંમત શું હશે? >> [વિદ્યાર્થી] NULL. >> NULL. બરાબર.
અહીં તમે કેવી રીતે ફ્લોટ્સ માં આવર્તન પ્રતિનિધિત્વ કરી શકે છે તેનું ઉદાહરણ છે,
પણ અમે તેની સાથે પૂર્ણાંકો સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો,
તેથી હું કર્યું છે દશાંશ માહિતી પ્રકાર ત્યાં બદલો.
>> ચાલો થોડો જટીલ ઉદાહરણ વધુ પર જાઓ.
પરંતુ હવે અમે સરળ મુદ્દાઓ કર્યું છે, તે માત્ર એ જ પ્રક્રિયા છે.
તમે 2 નીચા આવર્તનના શોધવા માટે, આવૃત્તિઓ સરવાળો
અને જે તમારા પિતૃ નોડને નવા આવૃત્તિ છે,
જે પછી 0 અને 1 શાખા સાથે યોગ્ય શાખા સાથે તેના ડાબા નિર્દેશ કરે છે.
જો અમે શબ્દમાળા "આ cs50 છે," હોય તો પછી અમે ગણતરી કેટલી વખત ટી ઉલ્લેખ કર્યો છે,
ક ઉલ્લેખ કર્યો છે, આઇ, એસ, સી, 5, 0.
પછી હું અહીં કર્યું શું લાલ ગાંઠો હું હમણાં જ વાવેતર સાથે છે,
મેં કહ્યું હતું કે હું આ અક્ષરો મારા વૃક્ષ નીચે છેવટે હોય જાઉં છું.
તે માટે પાંદડા તમામ હશે આવે છે.
પછી મેં શું છે હું ચડતા ક્રમમાં આવૃત્તિ દ્વારા તેમને સૉર્ટ કરેલ
અને આ ખરેખર એ રીતે કે pset કોડ તે કરે છે
આવર્તન દ્વારા તેને પ્રકારની છે અને પછી મૂળાક્ષરોની છે.
તેથી તે નંબરો પ્રથમ અને પછી મૂળાક્ષરોના ક્રમમાં છે કે આવૃત્તિ દ્વારા.
પછી હું કરશે શું છે મને સૌથી ઓછી 2 મળશે. કે 0 અને 5 છે.
હું તેમને સરવાળો, અને થશે કે 2 છે. પછી હું ચાલુ રાખવા માટે, આગલા 2 સૌથી નીચો મળશે.
તે બે 1 સે છે, અને પછી તે 2 તેમજ બની જાય છે.
હવે હું જાણું છું કે મારા આગળનું પગલું એ સૌથી નીચો નંબર જોડાયા કરી રહ્યું છે,
જે ટી છે, 1 છે, અને પછી એક નોડ કે જે આવૃત્તિ 2 પ્રમાણે હોય પસંદ કરીને.
અહીં અમે 3 વિકલ્પો હોય છે.
મારે શું સ્લાઇડ માટે કરવા જાઉં છું ફક્ત દૃષ્ટિની છે તેમને તમે ફરીથી ગોઠવવા
જેથી તમે જોઈ શકો છો કે હું કેવી રીતે તે મકાન છું છે.
કોડ અને તમારા વિતરણ કોડ શું રહ્યું છે ટી એક જોડાવા આવશે
0 ની અને 5 નોડ છે.
તેથી પછી તે 3 થી સંક્ષિપ્તમાં કહેવાયું હતું, અને તે પછી અમે પ્રક્રિયા ચાલુ રાખો.
આ 2 અને 2 હવે સૌથી નીચો છે, તેથી તે પછી 4 તે રકમ.
દરેક વ્યક્તિને અત્યાર સુધી નીચેના? ઠીક છે.
પછી તે પછી અમે 3 અને 3 તે ઉમેરો કરવાની જરૂર હોય,
જેથી ફરીથી હું હમણાં જ તે સ્વિચ છું કે જેથી તમે દૃષ્ટિની જેથી જુઓ કે તે ખૂબ અવ્યવસ્થિત ન મળી નથી કરી શકો છો.
તો પછી અમે 6 એક છે, અને તે પછી અમારા અંતિમ પગલું હવે એ છે કે અમે માત્ર 2 ગાંઠો હોય છે
અમે તે સંક્ષેપમાં અમારા વૃક્ષ છે, જે 10 છે જે રુટ બનાવે છે.
અને 10 નંબર અર્થમાં બનાવે છે કારણ કે દરેક નોડ રજૂ,
તેમની કિંમત, તેમના આવૃત્તિ નંબર હતો કેટલી વખત તેઓ શબ્દમાળા માં દેખાયા હતા,
અને પછી અમે અમારી શબ્દમાળામાં 5 અક્ષરો છે, તેથી તે અર્થમાં બનાવે છે.
જો અમે અમે કેવી રીતે વાસ્તવમાં તે બેવડી કરશે ઉપર જુઓ,
ઈચ્છિત તરીકે, તો હું અને ઓ, કે જે મોટે ભાગે દેખાશે
છે બિટ્સ ના સૌથી ઓછા નંબર દ્વારા રજૂ કરે છે.
>> સાવચેત અહીં રહો.
હફમેનના વૃક્ષો માં કેસ ખરેખર બાબતો.
એક મોટા એસ એક લોઅરકેસ ઓ કરતાં અલગ છે.
જો આપણે મૂડી અક્ષરો સાથે "આ CS50 છે", પછી નાના ઓ માત્ર બે વખત દેખાય છે,
2 તેની કિંમત તરીકે સાથે નોડ હશે, અને પછી એસ મોટા માત્ર એક વાર જ હશે.
તેથી પછી તમારા વૃક્ષ માળખાં બદલવા કારણ કે તમે ખરેખર વધારાનો પર્ણ અહીં હશે.
પરંતુ રકમ હજુ 10 હશે.
કે અમે ખરેખર શું પછી ચકાસણીની કૉલ કરી રહ્યા છીએ,
આ ગુનામાં તમામ વધુમાં.
>> હવે અમે હફમેનના વૃક્ષો આવરી લીધી છે, અમે Huff'n દોડ્યા પછી એકદમ હાંફવું છે, pset માં ડાઇવ કરી શકો છો.
અમે પ્રશ્નો વિભાગ સાથે શરૂ જઈ રહ્યાં છો,
અને આ વિચાર તમે બાઈનરી વૃક્ષો અને તે આસપાસ કામ કેવી રીતે પરિચિત રહ્યું છે:
રેખાંકન ગાંઠો, નોડ માટે તમારા પોતાના typedef સ્ટ્રક્ટ બનાવવા માટે,
અને જોઈ તમે કેવી રીતે દ્વિસંગી વૃક્ષ, એક કે છટણી છે દાખલ કરી શકે છે,
તે છે, અને તે જેવી વસ્તુઓ સરકાઉ.
જ્ઞાન કે ચોક્કસપણે તમને જ્યારે તમે Huff'n દોડ્યા પછી એકદમ હાંફવું ભાગ માં ડાઈવ મદદ રહ્યું છે
આ pset છે.
આ pset પ્રમાણભૂત આવૃત્તિ, તમારા કાર્ય માટે દોડ્યા પછી એકદમ હાંફવું અમલમાં છે,
અને હેકર આવૃત્તિ તમારા કાર્ય માટે મિજાજ અમલમાં છે.
રીસ શું કરે છે તે લખાણ લે છે અને પછી તેને 0s અને 1 સે રૂપાંતર
જેથી પ્રક્રિયા કે અમે ઉપર હતી જ્યાં અમે ફ્રીક્વન્સીઝ ગણાશે
અને પછી વૃક્ષ કરી અને પછી જણાવ્યું હતું કે, "હું ટી કેવી રીતે મેળવી શકું?"
ટી 100 દ્વારા રજૂ થાય છે, તે જેવી વસ્તુઓ,
અને પછી મિજાજ લખાણ અને પછી આઉટપુટ દ્વિસંગી કે લેશે.
પણ કારણ કે આપણે જાણીએ છીએ કે અમે સંદેશો અમારી પ્રાપ્તકર્તા પરવાનગી આપવા માંગો છો
માટે ચોક્કસ જ વૃક્ષ ખુશ થવું, તે આવૃત્તિ ગણતરીઓ વિશે જાણકારી સમાવે છે.
પછી દોડ્યા પછી એકદમ હાંફવું સાથે અમે 0s અને 1 સે એક દ્વિસંગી ફાઈલ આપવામાં આવે છે
અને પણ ફ્રિક્વન્સીના વિશે જાણકારી આપવામાં આવે છે.
અમે મૂળ સંદેશ કે હતો તે 0s અને 1 સે પાછા બધા અનુવાદ કરો,
તેથી અમે તે decompressing કરી રહ્યાં છો.
જો તમે પ્રમાણભૂત આવૃત્તિ કરી રહ્યા છીએ, તમે મિજાજ અમલ કરવાની જરૂર નથી,
જેથી તે પછી તમે માત્ર મિજાજ ના સ્ટાફ અમલીકરણ વાપરી શકો છો.
ત્યાં સ્પેક કેવી રીતે કરે છે કે શું કરવું તેના પર સૂચનો છે.
તમે અમુક ચોક્કસ લખાણ ફાઈલ પર રીસ ના સ્ટાફ અમલીકરણ ચલાવી શકો છો
અને પછી એ તમારા ઈનપુટ તરીકે કે આઉટપુટ વાપરવા માટે દોડ્યા પછી એકદમ હાંફવું.
>> હું પહેલાં તમારો ઉલ્લેખ કર્યો છે, અમે આ માટે વિતરણ કોડ ઘણો હોય છે.
હું તેને પસાર થઇ શરૂ જાઉં છું.
હું પર સમય મોટા ભાગનો જાઉં છું ક ફાઈલો છે.
કારણ કે સી. ફાઈલોમાં કારણ કે, અમે ક. છે
અને તે અમને વિધેયોને પ્રોટોટાઇપ સાથે પૂરી પાડે છે,
અમે સંપૂર્ણપણે બરાબર સમજી જરૂર નથી -
જો તમે સમજી શક્યા નથી શું પર કેચ. ફાઈલો ચાલી રહ્યું છે, પછી ખૂબ જ ચિંતા કરશો નહીં,
પરંતુ નિશ્ચિતપણે એક નજર પ્રયાસ કારણ કે તેમાં કેટલીક સંકેતો આપી શકે છે
અને તે અન્ય લોકોની કોડ reading માટે ઉપયોગ કરો ઉપયોગી છે.
>> Huffile.h અંતે છીએ, ટિપ્પણીઓ તેને હફમેનના કોડેડ ફાઈલો માટે અમૂર્તનો સ્તર જાહેર.
જો અમે નીચે જાય છે, અમે જુઓ કે ત્યાં 256 પ્રતીકો મહત્તમ કે અમે કોડ માટે જરૂર પડી શકે છે છે.
મોટા અને નાના - આ મૂળાક્ષરો તમામ અક્ષરો સમાવે છે -
અને પછી સંજ્ઞાઓ અને નંબરો, વગેરે
પછી અહીં અમે જાદુ ફાઇલ હફમેનના કોડેડ ઓળખવા નંબર હોય છે.
એક હફમેનના કોડ અંદર તેઓ ચોક્કસ જાદુ નંબર હોય રહ્યા છીએ
હેડર સાથે સંકળાયેલું છે.
આ માત્ર એક રેન્ડમ જાદુ નંબર લાગતો શકે છે,
પરંતુ જો તમે ખરેખર તે ASCII અનુવાદિત, પછી તે ખરેખર બહાર મિજાજ બેસે.
અહીં અમે એક ફાઇલ હફમેનના-encoded માટે સ્ટ્રક્ટ છે.
ત્યાં આ રીસ ફાઈલ સાથે સંકળાયેલ લાક્ષણિકતાઓ બધા છે.
પછી નીચે અહીં આપણે એક મિજાજ ફાઈલ માટે હેડર હોય છે, તેથી અમે તેને Huffeader કૉલ
તેના બદલે વધારાની ક ઉમેરવા કારણ કે આ તે જ રીતે લાગે છે.
ક્યૂટ.
અમે એક જાદુ તેની સાથે સંકળાયેલ નંબર હોય છે.
જો તે એક વાસ્તવિક મિજાજ ફાઈલ છે, તે નંબર ઉપર ઉપર હોવી જોઈએ, આ જાદુ એક બનશે.
અને પછી તેને ઝાકઝમાળ રહેશે.
તેથી દરેક પ્રતીક છે, જે ત્યાં 256 છે,
તે યાદી તે પ્રતીકો આવૃત્તિ શું મિજાજ ફાઈલ અંદર છે બનશે.
અને પછી છેવટે, અમે ફ્રીક્વન્સીઝ માટે ચકાસણીની હોય છે,
જે તે ફ્રીક્વન્સીઝ સરવાળા પ્રયત્ન કરીશું.
જેથી એક Huffeader શું છે.
પછી અમે કેટલીક વિધેયો કે જે મિજાજ ફાઈલ આગામી બીટ પાછા છે
તેમજ મિજાજ ફાઈલ માટે થોડી લખે છે, અને પછી આ કાર્ય અહીં, hfclose,
કે જે વાસ્તવમાં મિજાજ ફાઈલ બંધ કરે છે.
પહેલાં, અમે કોઈ રન નોંધાયો માત્ર fclose સાથે વ્યવહાર કરવામાં આવી હતી,
પરંતુ જ્યારે તમે એક મિજાજ ફાઈલ હોય, તો તેના બદલે fclosing ઓફ
તમે ખરેખર કરવા જઈ રહ્યાં છો શું છે hfclose અને તે hfopen.
જે લોકો આ રીસ ફાઇલો ચોક્કસ કાર્યો કે અમે સાથે કામ કરી રહ્યા છીએ છે.
પછી અહીં અમે હેડરમાં વાંચો અને પછી હેડર લખો.
>> આ ક. ફાઈલ વાંચવાથી દ્વારા જસ્ટ અમે મિજાજ ફાઈલ શું હોઈ શકે એક અર્થમાં વિચાર પ્રકારની કરી શકો છો,
લાક્ષણિકતાઓ તે વાસ્તવમાં huffile.c જવા વિના છે,
જે, જો આપણે માં ડાઇવ માટે થોડી વધુ જટિલ હોઇ રહ્યું છે.
તે ફાઈલ I / O અહીં પોઇન્ટર સાથે વ્યવહાર તમામ ધરાવે છે.
અહીં અમે જુઓ કે જ્યારે અમે hfread કૉલ, દાખલા તરીકે, તે હજુ પણ fread સાથે વ્યવહાર છે.
અમે તે વિધેયો છૂટકારો સંપૂર્ણપણે ન મળી રહ્યા છે, પરંતુ અમે તે મોકલી રહ્યાં છો કરવા માટે કાળજી લેવામાં આવે
તે જાતને તમામ કરી બદલે મિજાજ ફાઈલ અંદર.
તમે આ મારફતે સ્કેન નિઃસંકોચ જો તમે વિચિત્ર છો કરી શકો છો
અને જાઓ અને પાછળ સ્તર થોડો છાલ.
>> આગળની ફાઈલ કે અમે જોવા જઈ રહ્યાં છો tree.h. છે
માં પહેલાં Walkthrough સ્લાઇડ્સ અમે જણાવ્યું હતું કે અમે હફમેનના નોડ અપેક્ષા
અને અમે typedef સ્ટ્રક્ટ નોડ કરી હતી.
અમે તે પ્રતીક છે, આવૃત્તિ, અને પછી 2 નોડ તારાઓ પાસે અપેક્ષા રાખીએ છીએ.
આ કિસ્સામાં અમે કરી રહ્યા છીએ શું છે આ અનિવાર્યપણે છે તે જ
તેના બદલે ગાંઠની સિવાય અમે તેમને વૃક્ષો કહી રહ્યા છીએ.
અમે એક કાર્ય છે કે જ્યારે તમે વૃક્ષ બનાવે કહી તે તમને એક વૃક્ષ નિર્દેશક આપે છે.
સ્પેલર પાછળ, જ્યારે તમે એક નવો નોડ બની ગઇ હતી
તમે કહ્યું હતું કે નોડ * નવો શબ્દ = (sizeof) malloc અને તે જેવી વસ્તુઓ.
હકીકતે, mktree કે સાથે તમારા માટે વ્યવહાર કરી રહ્યું છે.
એ જ રીતે, જ્યારે તમે એક વૃક્ષ દૂર કરવા માંગો છો
જેથી જરૂરીયાતમાં વૃક્ષ જ્યારે તમે તેની સાથે પૂર્ણ કરી મુક્ત છે,
તેના બદલે બાહ્ય પર મફત ફોન, તમે ખરેખર માત્ર રહ્યાં છો એ વિધેય rmtree ઉપયોગ જઈને
જ્યાં તમે નિર્દેશક કે વૃક્ષ પસાર અને પછી tree.c કે તમે કાળજી લેશે.
>> અમે tree.c. તપાસ
અમે અમલ તેમજ જુઓ સિવાય જ કાર્યો અપેક્ષા.
આપણે અપેક્ષિત, જ્યારે તમે mktree કહી તે નિર્દેશક એક વૃક્ષ માપ mallocs,
આ NULL કિંમત છે, તેથી 0s અથવા NULLs માટે કિંમતો તમામ પ્રારંભ,
અને પછી તે વૃક્ષ માટે નિર્દેશક આપે છે કે જે તમે હમણાં જ તમે malloc'd કર્યું છે.
અહીં તમે જ્યારે વૃક્ષ દૂર કરવા કહી તે પ્રથમ ખાતરી કરો કે તમે ડબલ નથી ખાલી કરી રહ્યાં છો બનાવે છે.
તે ખાતરી કરો કે તમે ખરેખર એક વૃક્ષ કે જે તમે દૂર કરવા માંગો તો બનાવે છે.
અહીં કારણ કે એક વૃક્ષ પણ તેના બાળકો સમાવેશ થાય છે,
આ શું કરે છે તે recursively વૃક્ષ ડાબી નોડ પર વૃક્ષ દૂર કરવા કહે છે
તેમજ યોગ્ય નોડ તરીકે.
તે પહેલાં પિતૃ મુક્ત કરે છે, તે બાળકો તેમજ મુક્ત કરવાની જરૂર છે.
પિતૃ પણ છે મૂળ સાથે વિનિમયક્ષમ.
મહાન-મહાન-મહાન-પરદાદા જેવા કે જેથી પ્રથમ પિતૃ,
અથવા દાદી વૃક્ષ, પ્રથમ અમે નીચે સ્તર પ્રથમ મુક્ત હોય છે.
જેથી નીચે પસાર, મફત તે અને પછી પાછા આવો અપ, મફત તે વગેરે,
જેથી વૃક્ષ છે.
>> હવે અમે વન જુઓ.
વન છે કે જ્યાં તમે તમારા હફમેનના વૃક્ષો બધા મૂકો.
એ કહ્યા છે કે અમે કંઈક જઈ રહ્યાં છો કહેવાતા પ્લોટ
કે એક વૃક્ષ પર એક નિર્દેશક તેમજ આગામી કહેવાય પ્લોટ માટે નિર્દેશક ધરાવે છે.
શું માળખું જેવા દેખાવ આ પ્રકારની કરે છે?
તે પ્રકારની છે કે ત્યાં કહે બનાવ્યા.
અહીં બનાવ્યા.
એક કડી થયેલ યાદી.
અમે જુઓ કે જ્યારે અમે પ્લોટ હોય તે પ્લોટ એક કડી થયેલ યાદી જેવું છે.
એક વન પ્લોટ એક કડી થયેલ યાદી તરીકે વ્યાખ્યાયિત થયેલ છે,
અને તેથી વન માળખું છે અમે અમારા પ્રથમ પ્લોટ માટે કરી રહ્યાં છો એક નિર્દેશક હોય જઈને
અને તે પ્લોટ તેની અંદર એક વૃક્ષ હોય અથવા તેના બદલે એક વૃક્ષ નિર્દેશ
અને પછી આગામી પ્લોટ નિર્દેશ પર તેથી અને તેથી આગળ.
એક વન બનાવવા અમે mkforest કૉલ કરો.
પછી અમે કેટલીક ખૂબ ઉપયોગી કાર્યો અહીં છે.
અમે પસંદ હોય છે જ્યાં તમે એક વન પાસ કરો અને પછી પરત કિંમત એક વૃક્ષ * છે,
એક વૃક્ષ પર એક નિર્દેશક.
ચૂંટેલા કરશે શું છે તે જંગલ જવા કરશે કે તમે પોઇન્ટ કરી રહ્યાં છો
પછી સૌથી નીચા આવૃત્તિ સાથે જંગલ માંથી એક વૃક્ષ દૂર
અને પછી તમે તે વૃક્ષ માટે નિર્દેશક આપે છે.
એકવાર તમે પસંદ કૉલ, વૃક્ષ જંગલ માં હવે અસ્તિત્વમાં રહેશે,
પરંતુ વળતર કિંમત છે કે જે વૃક્ષ માટે નિર્દેશક છે.
પછી તમે પ્લાન્ટ ધરાવે છે.
કે તમે નિર્દેશક એક વૃક્ષ કે જે આવૃત્તિ બિન 0 ધરાવે છે પસાર છે,
પ્લાન્ટ કરશે શું છે તે જંગલ લાગી, વૃક્ષ લઈ જશે, અને વનસ્પતિ કે વન વૃક્ષ અંદર.
અહીં અમે rmforest છે.
માટે વૃક્ષ છે, જે મૂળભૂત રીતે આપણા માટે અમારા વૃક્ષો તમામ મુક્ત દૂર સમાન,
વન દૂર મફત કે જંગલ માં સમાયેલ બધું છે.
>> જો અમે forest.c તપાસ, અમે ત્યાં ઓછામાં ઓછા 1 rmtree આદેશ જુઓ અપેક્ષા કરીશું,
કારણ કે જંગલમાં મુક્ત મેમરી જો વન તેને વૃક્ષો ધરાવે છે,
પછી છેવટે તમે તે વૃક્ષો ખૂબ દૂર હોય રહ્યા છીએ.
જો અમે forest.c તપાસ, અમે અમારી mkforest, કે જે અમે અપેક્ષા હોય છે.
અમે વસ્તુઓ malloc.
અમે NULL તરીકે જંગલ માં પ્રથમ પ્લોટ પ્રારંભ કારણ કે તે ખાલી છે સાથે શરૂ કરવા માટે,
તો પછી અમે પિક, જે સૌથી ઓછા વજન સાથે વૃક્ષ આપે સૌથી નીચો આવૃત્તિ જોવા માટે,
અને પછી તે ખાસ નોડ છૂટકારો મળે છે કે જે વૃક્ષ પોઇન્ટ અને આગામી એક,
તેથી તે જંગલ સંકળાયેલા યાદી બહાર લઈ જશે.
અને પછી અહીં અમે પ્લાન્ટ યાદીની લિંક એક વૃક્ષ દાખલ જે હોય છે.
વન શું છે એ નથી કે તે સરસ રીતે રાખે છે તે આપણા માટે સોર્ટ થાય છે.
અને પછી છેવટે, અમે rmforest હોય છે અને, જેમ અપેક્ષા, અમે ત્યાં કહેવાય rmtree છે.
>> વિતરણ કોડ અંતે અત્યાર સુધી છીએ, huffile.c દૂર સમજવા માટે ખૂબ સખત દ્વારા સંભાવના હતી,
અન્ય ફાઇલો જ્યારે પોતાને સુંદર અનુસરવા માટે સરળ હતા.
પોઇંટરો અને સંલગ્ન યાદીઓ અને આવા અમારી જ્ઞાન સાથે,
અમે ખૂબ સારી રીતે અનુસરવા સક્ષમ હતા.
પરંતુ તમામ અમે ખરેખર ખાતરી કરો કે અમે સંપૂર્ણપણે સમજી કરવાની જરૂર છે તે ક. ફાઈલો છે
કારણ કે તમે તે વિધેયો કૉલ શકાય છે, તે વળતર કિંમતો સાથે વ્યવહાર કરવાની જરૂર હોય,
જેથી ખાતરી કરો કે તમે સંપૂર્ણપણે સમજી ક્રિયા શું કરી રહ્યું છે
જ્યારે તમે એક તે વિધેયોને કૉલ કરો.
પરંતુ ખરેખર તે અંદર સમજવામાં ખૂબ જરૂરી છે કારણ કે અમે તે હોય છે. નથી ક ફાઈલો છે.
અમે 2 આપણા વિતરણ કોડ બાકી ફાઈલો હોય.
>> ચાલો ડમ્પ જુઓ.
તેના ટિપ્પણી દ્વારા અહીં ડમ્પ ફાઈલ હફમેનના-સંકુચિત લે છે
અને પછી ભાષાંતર અને બધી સામગ્રી ડમ્પ આઉટ.
અહીં અમે જુઓ કે તે hfopen ફોન છે.
આ * ઇનપુટ = fopen ફાઇલ પ્રતિબિંબ પ્રકારની છે,
અને તે પછી તમને માહિતી પસાર કરે છે.
તેના બદલે એક ફાઇલ * તમે Huffile માં પસાર કરી રહ્યાં છે સિવાય લગભગ સમાન છે;
તેના બદલે fopen તમે hfopen માં પસાર કરી રહ્યાં છે.
અહીં અમે હેડર પ્રથમ વાંચી છે, કે જે પ્રકારની છે અમે કેવી રીતે હેડરમાં વાંચવા માટે સમાન
એક બીટમેપ ફાઇલ માટે.
અમે અહીં શું કરી રહ્યા છે તે જોવા માટે ચકાસે છે કે શું હેડર જાણકારી
જમણી જાદુ નંબર છે કે જે સૂચવે છે કે તે એક વાસ્તવિક મિજાજ ફાઈલ છે સમાવે છે,
તો પછી આ તપાસમાં તમામ ખાતરી કરો કે જે ફાઈલ કે અમે ઓપન ખરેખર huffed ફાઇલ અથવા નથી.
કરે છે શું છે તે પ્રતીકો છે કે અમે જોઈ શકો છો તમામ આવૃત્તિઓ આઉટપુટો
ગ્રાફિકલ કોષ્ટકમાં ટર્મિનલ અંદર.
આ ભાગ માટે ઉપયોગી હોઈ રહ્યું છે.
તે થોડી છે અને ચલ બીટ માં ક્રમેક્રમે વાંચો અને પછી તેને છાપે આઉટ.
તેથી જો હું hth.bin છે, કે જે ફાઈલ huffing પરિણામ છે ડમ્પ કહી હતી
સ્ટાફ રીતનો ઉપયોગ કરીને, હું આ વિચાર કરશે.
આ અક્ષરો તમામ outputting છે અને પછી આવૃત્તિ કે જેની પર તેઓ દેખાય મૂકવા.
જો અમે જુઓ, તેમાંના મોટા ભાગના આ સિવાય 0s છે: એચ, જે બે વખત દેખાય છે,
અને પછી ટી, જે એક વખત દેખાય છે.
અને પછી અહીં અમે 0s અને 1 સે વાસ્તવિક સંદેશ છે.
જો અમે hth.txt જોવા છે, જે કદાચ મૂળ સંદેશો કે huffed હતું,
અમે ત્યાં કેટલાક HS અને TS જુઓ અપેક્ષા.
ખાસ કરીને, અમે ફક્ત 1 T અને 2 HS જુઓ અપેક્ષા.
અહીં અમે hth.txt છે. તે ખરેખર HTH છે.
તેમાં સમાવેશ થાય છે, જોકે અમે તેને જોઈ શકે છે, એક NEWLINE પાત્ર છે.
આ રીસ ફાઈલ hth.bin પણ NEWLINE પાત્ર છે તેમજ એન્કોડિંગ.
અહીં આપણે જાણીએ છીએ કારણ કે તે ક્રમમાં HTH અને પછી NEWLINE છે,
અમે તે કદાચ એચ રજૂ થાય છે માત્ર એક 1 દ્વારા જોઈ શકો છો
અને પછી ટી કદાચ 01 અને પછી આગામી એચ 1 છે તેમજ
અને પછી અમે બે 0s દ્વારા સૂચવાયેલ NEWLINE છે.
સરસ.
>> અને પછી છેવટે, કારણ કે અમે બહુવિધ સી. સાથે કામ કરીએ છીએ અને. ક ફાઇલો,
અમે કમ્પાઇલર એક સુંદર જટિલ દલીલ છે જઈ રહ્યાં છો,
અને તેથી અહીં અમે મેકફાઇલ Language જે તમારા માટે ડમ્પ બનાવે છે.
પરંતુ, વાસ્તવમાં, તમે તમારી પોતાની puff.c ફાઈલ બનાવવા જઈ છે.
આ મેકફાઇલ Language ખરેખર તમારા માટે puff.c બનાવવા સાથે કામ કરી શકતું નથી.
અમે તે છોડી રહ્યા છો અપ તમે મેકફાઇલ Language ફેરફાર કરો.
જ્યારે તમે તે બધા જેવા આદેશ દાખલ કરો, ઉદાહરણ તરીકે, તમે તે બધા કરશે.
માટે ભૂતકાળમાં pset માંથી મેકફાઇલ Language ઉદાહરણો જોવા નિઃસંકોચ
તેમજ આ એક બંધ જઈને જોવા માટે તમે કેવી રીતે તમારા દોડ્યા પછી એકદમ હાંફવું ફાઈલ કરી શકે છે
આ મેકફાઇલ Language ફેરફાર કરીને.
તે અમારી વિતરણ કોડ માટે તેના વિશે છે.
>> એકવાર અમે તે મારફતે મેળવેલ કર્યો છે, તો અહીં માત્ર બીજું રિમાઇન્ડર છે
કેવી રીતે અમે હફમેનના ગાંઠો સાથે વ્યવહાર કરવામાં જઈ રહ્યાં છો.
અમે તેમને ગાંઠો કૉલ કરી હવે નથી જઈ રહ્યાં છો; અમે તેમને ફોન કરી વૃક્ષો જઈ રહ્યાં છો
, જ્યાં અમે ઘરનાં પરચૂરણ કામો તેમના પ્રતીક રજૂ કરી રહ્યા છીએ
તેમની આવૃત્તિ, ઘટનાઓની પૂર્ણાંક સાથે સંખ્યા.
અમે તે ઉપયોગ કરી રહ્યાં છો કારણ કે તે વધુ એક ફ્લોટ કરતાં ચોક્કસ છે.
અને પછી અમે ડાબી તેમજ યોગ્ય બાળક બાળક બીજા નિર્દેશક હોય છે.
એ ફોરેસ્ટ, આપણે જોયું, માત્ર વૃક્ષો સંકળાયેલી યાદી છે.
આખરે, જ્યારે અમે અમારી મિજાજ ફાઈલ નિર્માણ કરી રહ્યાં છો,
અમે અમારા જંગલ માત્ર 1 વૃક્ષ સમાવતું કરવા માંગો છો -
1 વૃક્ષ, ઘણા બાળકો સાથે 1 રુટ.
અગાઉ જ્યારે અમે અમારા હફમેનના વૃક્ષો બની ગઇ હતી પર,
અમે અમારા સ્ક્રીન પર ગાંઠો તમામ મૂકીને બહાર શરૂ
કહેતા અને અમે આ ગાંઠો હોય છે જઈ રહ્યાં છો,
આખરે તેઓ પાંદડા પ્રયત્ન જઈ રહ્યાં છો, અને આ તેમના પ્રતીક છે, આ તેમના હુમલાઓનું છે.
અમારા જંગલ માં જો આપણે માત્ર 3 અક્ષર છે, કે જે 3 વૃક્ષો એક વન છે.
અને પછી આપણે પર જાઓ, જ્યારે અમે પ્રથમ પિતૃ ઉમેર્યું હતું કે,
અમે 2 વૃક્ષો વન કરી હતી.
અમે અમારા જંગલ માંથી 2 તે બાળકો દૂર કરો અને પછી તે પિતૃ નોડ સાથે બદલી
કે બાળકો પેલા 2 ગાંઠો હતી.
અને છેલ્લે પછી, અમારી જેમ bs સાથે અમારી ઉદાહરણ બનાવવા સાથે છેલ્લું પગલું, અને CS
માટે અંતિમ પિતૃ બનાવવા હશે,
અને તેથી પછી તે 1 થી અમારી જંગલમાં વૃક્ષો કુલ ગણતરી મળશે.
નથી દરેક લોકોને જોવા તમે કેવી રીતે બહુવિધ વૃક્ષો સાથે તમારા વન શરૂ
અને 1 અંત? ઠીક છે. સરસ.
>> માટે અમે શું દોડ્યા પછી એકદમ હાંફવું માટે શું જરૂરી છે?
અમે જરૂર શું છે તેની ખાતરી છે કે, હંમેશા તેઓ અમને ઇનપુટ જમણી પ્રકાર આપી
જેથી અમે ખરેખર કાર્યક્રમ ચલાવી શકો છો.
આ કિસ્સામાં તેઓ અમને તેમની પ્રથમ દલીલ આદેશ લીટી પછી બક્શી જઈ રહ્યાં છો
વધુ 2: ફાઈલ કે અમે વિસંકુચિત અને decompressed ફાઈલ નું આઉટપુટ કરવા માંગો છો.
પરંતુ એક વાર અમે ખાતરી કરો કે તેઓ અમને કિંમતો જમણી રકમ પાસ કરો,
અમે ખાતરી કરવા માટે કે જે ઇનપુટ એક મિજાજ ફાઈલ નથી અથવા કરવા માંગો છો.
અને પછી એક વાર અમે ગેરેંટી છે કે તે રીસ ફાઈલ છે, તો પછી અમે અમારી વૃક્ષ બીલ્ડ કરવા માંગો છો,
અપ જેવી છે કે તે વૃક્ષ કે વ્યક્તિ સંદેશ મોકલ્યો બાંધવામાં સાથે બંધબેસે વૃક્ષ બનાવે છે.
તો પછી અમે વૃક્ષ બીલ્ડ કરવા, પછી અમે સાથે 0s અને 1 સે કે તેઓ માં પસાર વ્યવહાર કરી શકો છો
અમારા વૃક્ષ સાથે તે અનુસરે છે, કારણ કે તે સમાન છે,
અને પછી તે સંદેશ લખી આઉટ બિટ્સ અક્ષરો પાછું અર્થઘટન.
અને પછી ઓવરને અંતે કારણ કે અમે પોઇન્ટર સાથે અહીં કામ કરીએ છીએ,
અમે ખાતરી કરવા માટે કે અમે કોઈ મેમરી લીક્સ ન હોય બનાવવા માંગો છો
અને કે અમે મુક્ત બધું.
>> યોગ્ય વપરાશ તેની ખાતરી હવે દ્વારા આપણા માટે જૂના ટોપી છે.
અમે એક ઇનપુટ લઇ, કે જે ફાઈલ નામ દોડ્યા પછી એકદમ હાંફવું પ્રયત્ન રહ્યું છે,
અને પછી અમે એક આઉટપુટ સ્પષ્ટ કરવા માટે,
જેથી puffed આઉટપુટ, કે જે લખાણ ફાઈલ હશે ફાઈલના નામ.
કે વપરાશ છે. અને હવે અમે તેની ખાતરી કરવા માટે કે જે ઇનપુટ huffed અથવા ન કરવા માંગો છો.
પાછા વિચારવાનો, ત્યાં વિતરણ કોડ કે જે અમને મદદ કરી શકે છે પણ હતો
સમજ્યા કે ફાઈલને huffed છે અથવા નથી?
ત્યાં huffile.c માં Huffeader વિશે જાણકારી હતી.
અમે જાણીએ છીએ કે દરેક મિજાજ ફાઈલ એ જાદુ નંબર સાથે તેની સાથે સંકળાયેલ Huffeader છે
તેમજ દરેક પ્રતીક માટે ફ્રીક્વન્સીઝ ઝાકઝમાળ
તેમજ ચકાસણીની તરીકે.
અમે તે જાણો છો, પરંતુ અમે પણ dump.c ખાતે ડોકિયું લીધો,
જેમાં તે એક મિજાજ ફાઇલમાં વાંચી રહ્યા હતા.
અને તે શું છે, કે જેથી તે તપાસો કે શું તે ખરેખર huffed અથવા ન હતો.
તેથી કદાચ અમે માળખું તરીકે dump.c અમારા puff.c. માટે ઉપયોગ કરી શકે છે
4 pset પાછા જ્યારે અમે ફાઇલ copy.c કે RGB triples માં તેની નકલ કરી હતી
અને અમે ગૂઢ રહસ્યની અથવા ડિટેક્ટિવ વાર્તા કે નાટક અને કદ બદલવા માટે કે અર્થઘટન,
એ જ રીતે, તમે કરી શકે શું માત્ર cp dump.c puff.c જેવા આદેશ ચલાવો છે
અને ત્યાં કોડ કેટલાક વાપરો.
જો કે, તે એક પ્રક્રિયા સરળ નથી ચાલી રહ્યું છે
puff.c તમારી dump.c અનુવાદ માટે
પરંતુ ઓછામાં ઓછા તે તમે ક્યાંક આપે શરૂ
કેવી રીતે ખાતરી કરવા માટે કે જે ઇનપુટ વાસ્તવમાં અથવા ન huffed પર
તેમજ કેટલાક અન્ય બાબતો છે.
અમે યોગ્ય વપરાશ ખાતરી છે અને ખાત્રી કરે છે કે ઇનપુટ huffed છે.
દરેક સમય કે અમે કર્યું છે કે અમે અમારી યોગ્ય ભૂલ ચકાસણી કરવામાં આવે છે,
જેથી પરત અને કાર્ય છોડી જો અમુક નિષ્ફળતા જોવા મળે છે, જો ત્યાં એક સમસ્યા છે.
>> હવે અમે કરવા માંગો છો શું છે તે વાસ્તવિક વૃક્ષ બનાવે છે.
જો અમે વન માં જુઓ, ત્યાં 2 મુખ્ય કાર્યો છે
કે અમે સાથે ખૂબ જ પરિચિત બનવા માગો છો જઈ રહ્યાં છો.
ત્યાં બુલિયન કાર્ય પ્લાન્ટ છે કે છોડ એક બિન -0 અમારા જંગલ અંદર આવર્તન વૃક્ષ.
અને તેથી તમે એક નિર્દેશક માં વન અને એક વૃક્ષ પર એક નિર્દેશક પસાર.
ઝડપી પ્રશ્ન: ઘણા કેવી રીતે જંગલો તમે જ્યારે તમે હફમેનના વૃક્ષ બીલ્ડ કરી રહ્યા છો પડશે?
અમારા જંગલ અમારા કેનવાસ જેવા અધિકાર છે?
તેથી અમે ફક્ત 1 જંગલ હોય રહ્યા છીએ, પણ અમે ઘણા વૃક્ષો હોય રહ્યા છીએ.
તેથી તે પહેલાં તમે પ્લાન્ટ કહી, તો તમે કદાચ તમારા વન બનાવવા માંગો છો જઈ રહ્યાં છો.
ત્યાં તે માટે આદેશ છે, જો તમે કેવી રીતે તમે એક વન કરી શકો છો પર forest.h તપાસ.
તમે એક વૃક્ષ રોપણી કરી શકો છો. અમે જાણીએ છીએ કે કેવી રીતે કરે છે કે શું કરવું.
અને પછી તમે પણ જંગલ માંથી એક વૃક્ષ પસંદ કરી શકો છો,
સૌથી નીચો વજન સાથે વૃક્ષ દૂર અને તમે આપ્યા છે કે જે નિર્દેશક.
જ્યારે અમે ઉદાહરણો કરી જાતને હતા પાછા વિચારવાનો,
જ્યારે અમે તેને ચિત્રકામની હતા, અમે ફક્ત લિંક્સને ફક્ત ઉમેર્યા છે.
પરંતુ અહીં બદલે માત્ર લિંક્સ ઉમેરીને,
તે વધુ લાગે છે કારણ કે તમે 2 તે ગાંઠો દૂર કરી રહ્યાં છે અને પછી તેને એક અન્ય દ્વારા બદલીને.
માટે ચૂંટવું અને વાવણી દ્રષ્ટિએ કે વ્યક્ત,
તમે 2 વૃક્ષો ચૂંટવું કરી રહ્યાં છો અને પછી બીજા વૃક્ષ રોપણ
તે 2 વૃક્ષો કે જે તમે બાળકો તરીકે ચૂંટી છે.
માટે હફમેનના વૃક્ષ બીલ્ડ કરવા, તમે તે ક્રમમાં અને પ્રતીકો આવૃત્તિ વાંચી શકે છે
કારણ કે Huffeader તમે તે આપે છે,
તમે ફ્રીક્વન્સીઝ ઝાકઝમાળ આપે છે.
જેથી તમે આગળ વધો અને માત્ર 0 સાથે તે પણ અવગણી શકો છો
કારણ કે અમે તેને ઓવરને અંતે 256 પાંદડા નથી માંગતા.
અમે ફક્ત પાંદડાં કે અક્ષરો છે સંખ્યા માંગો છો
કે જે વાસ્તવમાં ફાઈલ વપરાય છે.
તમે તે પ્રતીકોમાં વાંચી શકે છે, અને તે પ્રતીકો છે કે બિન 0 ફ્રીક્વન્સીઝ હોય દરેક,
તે માટે વૃક્ષો હશે આવે છે.
તમે શું કરી શકો છો તે દરેક સમયે તમે એક આવર્તન બિન 0 પ્રતીક માં વાંચો છે,
તમે જંગલ કે વૃક્ષ રોપણી કરી શકો છો.
એકવાર તમે જંગલમાં વૃક્ષો રોપણી, તમે ભાઇ પેલા ઝાડ જોડાવા કરી શકો છો,
તેથી વાવણી અને ચૂંટવું જ્યાં તમે પસંદ 2 અને પછી 1 પ્લાન્ટ પર પાછા જવાનું,
જ્યાં જે 1 કે જે તમે છોડ 2 બાળકો કે તમે લેવામાં ઓફ પિતૃ છે.
તેથી પછી તમારી અંતિમ પરિણામ તમારા જંગલમાં એક વૃક્ષ પ્રયત્ન રહ્યું છે.
કે કેવી રીતે તમે તમારા વૃક્ષ બનાવે છે.
>> ઘણા વસ્તુઓ છે કે જે ખોટી અહીં જાઓ શકે છે
કારણ કે અમે નવા વૃક્ષો બનાવે છે અને કે જેવા અને પોઇંટરો વસ્તુઓ સાથે વ્યવહાર સાથે વ્યવહાર કરી રહ્યા છો.
જ્યારે અમે પોઇન્ટર સાથે વ્યવહાર કરવામાં આવી હતી તે પહેલાં,
જ્યારે પણ આપણે malloc'd અમે ખાતરી કરો કે તે અમને NULL નિર્દેશક કિંમત આપ્યા નથી માગતા હતા.
તેથી આ પ્રક્રિયા અંદર અનેક પગલાં અંતે ત્યાં ઘણા કિસ્સાઓ હોઈ જવું છે
તમારા કાર્યક્રમ જ્યાં નિષ્ફળ થઇ શકે છે.
તમે કરવા માંગો છો શું છે તમે ખાતરી કરો કે તમે તે ભૂલો હેન્ડલ બનાવવા માંગો છો,
અને સ્પેક માં તેને પ્રભાવશાળીપણે હેન્ડલ કહે છે,
જેથી બહાર વપરાશકર્તા માટે એક સંદેશ તેમને કહેવાની શા માટે કાર્યક્રમ છોડવાનો છે છાપી માંગો
અને પછી તરત તેને છોડી દીધું.
આ ભૂલ નિયંત્રણમાં કરી યાદ રાખો કે તમે તેને ચેક કરવા માંગો છો
દરેક એક સમય કે ત્યાં નિષ્ફળતા હોઈ શકે છે.
દરેક એક સમય કે તમે નવી નિર્દેશક બનાવી રહ્યા છો
તમે તેની ખાતરી કરવા માટે કે જે સફળ છે બનાવવા માંગો છો.
અમે શું વપરાય છે નવા નિર્દેશક અને તે malloc બનાવવા પહેલાં,
અને પછી અમે તપાસો કે શું નિર્દેશક NULL છે.
તેથી ત્યાં કેટલાક ઉદાહરણો છે જ્યાં તમે હમણાં જ આવું કરી શકે જવું છે,
પરંતુ ક્યારેક તમે ખરેખર કાર્ય કૉલ કરી રહ્યાં છો
અને તે કાર્ય અંદર, કે જે એક કે mallocing કરી રહ્યો છે.
તે કિસ્સામાં, જો અમે કેટલાક કાર્યોને પાછળ કોડ અંદર જુઓ,
તેમાંના કેટલાક બુલિયન વિધેયો છે.
અમૂર્ત કિસ્સામાં જો અમે બુલિયન foo કહેવાય કાર્ય હોય છે,
મૂળભૂત રીતે, અમે કરવાનું ગમે foo કરે વધુમાં કે ધારણ કરી શકે છે,
કારણ કે તે એક બુલિયન કાર્ય છે, તે સાચી કે ખોટી આપે છે -
જો સાચું સફળ, ખોટી જો નહિં.
તેથી અમે કે કેમ તેની તપાસ foo પરત કિંમત સાચી કે ખોટી છે કરવા માંગો છો.
જો તે ખોટા છે, કે જે અર્થ એ છે કે અમે સંદેશ અમુક પ્રકારના પ્રિન્ટ માંગો છો જઈ રહ્યાં છો
અને પછી કાર્યક્રમ છોડી દીધું.
અમે કરવા માંગો છો શું છે foo પરત કિંમત ચકાસો.
જો foo ખોટા આપે છે, તે પછી આપણે જાણીએ છીએ કે અમે ભૂલ, અમુક પ્રકારની આવી
અને અમે અમારા કાર્યક્રમ બંધ કરવાની જરૂર.
એ આ કરવા માટે રસ્તો એક એવી સ્થિતિ છે જ્યાં વાસ્તવિક કાર્ય પોતે તમારી સ્થિતિ છે હોય છે.
કહેવું foo એક્સ લે.
અમે જો શરત તરીકે કરી શકો છો (foo (x)).
મૂળભૂત રીતે, તેનો અર્થ એ કે જો foo ચલાવવા ઓવરને અંતે તે વાત સાચી આપે,
તો પછી અમે આવું કારણ કે કાર્ય માટે foo મૂલ્યાંકન શકે છે
ઓર્ડર સમગ્ર પરિસ્થિતિ મૂલ્યાંકન માટે.
તેથી પછી તે કેવી રીતે તમે કંઈક જો કાર્ય સાચું આપે છે અને સફળ છે.
પરંતુ જ્યારે તમે ભૂલ ચકાસણી કરશો, તમે ફક્ત બહાર નીકળવા જો તમારા કાર્ય ખોટા આપે છે કરવા માંગો છો.
તમે કરી શકે શું માત્ર ઉમેરવા એક == ખોટા અથવા માત્ર તે સામે બેંગ ઉમેરો
અને પછી તમે જો (foo!) હોય છે.
કે શરત છે કે શરીરની અંદર તમે ભૂલ નિયંત્રણમાં તમામ હોવી જોઈએ,
જેથી ગમે, "આ વૃક્ષ બનાવી શકાયું" અને પછી 1 અથવા કે કંઈક આવો.
કે શું કરે છે, જોકે, તે ભલે foo ખોટા ફર્યા છે -
કહેવું foo સાચું આપે છે.
તો પછી તમારે foo ફરી કૉલ નથી. કે સામાન્ય ખોટો ખ્યાલ છે.
કારણ કે તે તમારા શરત હતી, તે પહેલેથી જ મૂલ્યાંકન છે,
જેથી તમે પહેલાથી જ પરિણામ હોય છે જો તમે વૃક્ષ અથવા તે કંઈક બનાવવા ઉપયોગ કરી રહ્યાં છો
અથવા પ્લાન્ટ અથવા ચૂંટેલા અથવા કંઈક.
તે પહેલાથી જ તે મૂલ્ય છે. તે પહેલાથી જ ચલાવવામાં છે.
તેથી તે ઉપયોગી છે તે શરત તરીકે બુલિયન કાર્યો ઉપયોગ
કારણ કે કે વાસ્તવમાં લૂપ શરીર તમને ન ચલાવો,
તે કાર્ય રીતે ચલાવે છે.
>> અમારા છેલ્લા પગલું બીજા ફાઈલ સંદેશ લખી રહ્યો છે.
એકવાર અમે હફમેનના વૃક્ષ બીલ્ડ કરવા, પછી ફાઇલ સંદેશ લખી ખૂબ સરળ છે.
તે ખૂબ સરળ હવે માત્ર આ 0s અને 1 સે અનુસરો.
અને તેથી અમે સંમેલન દ્વારા જાણો છો કે હફમેનના વૃક્ષ 0s બાકી સૂચવે છે
અને 1 સે અધિકાર દર્શાવે છે.
તેથી પછી જો તમે ક્રમેક્રમે માં વાંચો, તે દરેક સમયે તમે એક 0 વિચાર
તમે ડાબી શાખા અનુસરો, અને પડશે પછી દરેક વખતે તમે 1 માં વાંચો
તમે જમણી શાખા અનુસરો રહ્યા છીએ.
અને પછી તમે ચાલુ રાખવા જઈ રહ્યાં છો ત્યાં સુધી તમે એક પર્ણ ફટકો
કારણ કે પાંદડા માટે શાખાઓ ઓવરને અંતે હશે આવે છે.
અમે શું આપણે એક પર્ણ નથી અથવા ફટકો કર્યું છે કે કેવી રીતે કહી શકે છે?
અમે પહેલાં જણાવ્યું હતું.
[વિદ્યાર્થી] જો પોઇંટરો NULL છે. >> યાહ.
અમે જો આપણે એક પર્ણ ફટકો કર્યા છે જો બન્ને ડાબી અને જમણી વૃક્ષો માટે પોઇંટરો NULL છે કહી શકે છે.
પરફેક્ટ.
અમે જાણીએ છીએ કે અમે ક્રમેક્રમે અમારા મિજાજ ફાઈલ માં વાંચવા માંગો છો.
આપણે dump.c પહેલા થયો હતો, તેઓ શું કર્યું છે તેઓ ક્રમેક્રમે માં મિજાજ ફાઇલમાં વાંચો
અને માત્ર છપાયેલ તે બિટ્સ શું હતા.
અમે તે કરી શકાતી નથી જઈ રહ્યાં છો. અમે કંઈક કે જે થોડી વધુ જટિલ છે કરી શકાય જઈ રહ્યાં છો.
પરંતુ અમે શું કરી શકો છો છે અમે કોડ કે બીટ કે બીટ માં વાંચો લઈ શકો છો.
અહીં અમે પૂર્ણાંક વર્તમાન બીટ કે અમે છો રજૂ બીટ છે.
આ ફાઈલમાં બિટ્સ તમામ વારો કાળજી લે ત્યાં સુધી તમે આ ફાઈલ ઓવરને નહીં.
પર આધારિત છે, પછી તમે iterator કેટલાક પ્રકારની માંગો છો જઈ રહ્યાં છો
તમારા વૃક્ષ પસાર થાય છે.
અને પછી કે શું બીટ 0 અથવા 1 પર આધારિત છે,
તમે ક્યાં તો ડાબી કે iterator ખસેડવા અથવા તે યોગ્ય ખસેડવા માંગો છો જઈ રહ્યાં છો
બધી ત્યાં સુધી તમે એક પર્ણ ફટકો રસ્તો છે, તેથી તમામ રીતે નોડ કે જે તમે છો ત્યાં સુધી
કોઈ વધુ ગાંઠો નિર્દેશ નથી.
અમે હફમેનના ફાઈલ નથી પરંતુ મોર્સ કોડ સાથે શા માટે આ કરી શકો છો?
કારણ કે મોર્સ કોડ ત્યાં સંદિગ્ધતા એક બીટ છે.
અમે જેમ, ઓહ રાહ હોઇ શકે છે, અમે માર્ગ સાથે એક પત્ર ફટકો છે, જેથી કદાચ આ અમારી પત્ર છે,
જ્યારે જો આપણે માત્ર થોડોક લાંબો સમય ચાલુ રહી, તો પછી અમે બીજા પત્ર ફટકો હોત.
પરંતુ તે માટે થાય છે હફમેનના એન્કોડિંગ નથી ચાલી રહ્યું છે,
તેથી અમે ખાતરી કરો કે માત્ર રસ્તો છે કે અમે જઈ રહ્યાં છો, એક અક્ષર હિટ આરામ કરી શકો છો
જો કે નોડ ડાબી અને જમણી બાળકો NULL છે.
>> છેલ્લે, અમે અમારા મેમરી બધા મુક્ત કરવા માંગો છો.
અમે બંને નજીક મિજાજ ફાઈલ કરવા માંગો છો કે અમે સાથે વ્યવહાર કર્યો છે
તેમજ અમારા જંગલ માં વૃક્ષો બધા દૂર કરો.
તમારા અમલીકરણ પર આધાર રાખીને, તમે કદાચ કરવા માંગો છો જઈ રહ્યાં છો માટે વન દૂર કૉલ
બદલે વાસ્તવમાં જાતે વૃક્ષો બધા પસાર થઇ.
પરંતુ જો તમે કોઈ કામચલાઉ વૃક્ષો બનાવી, તમે તે મુક્ત કરવા માંગો છો પડશે.
તમે તમારો કોડ શ્રેષ્ઠ ખબર છે, તેથી તમે જાણો છો કે જ્યાં તમે મેમરી allocating કરી રહ્યાં છો.
અને તેથી જો તમે જાય છે, પણ malloc માટે F'ing નિયંત્રણ દ્વારા શરૂ કરવા માટે,
જોયા જ્યારે તમે malloc અને તેની ખાતરી કરીને કે જે તમને બધી મુક્ત
પરંતુ તે પછી ફક્ત તમારા કોડ પસાર થઇ,
સમજ્યા કે જ્યાં તમે મેમરી ફાળવવામાં હોઈ શકે છે.
સામાન્ય રીતે તમે માત્ર કહેવું, શકે "ફાઈલ અંતે હું માત્ર મારા વન પર જંગલ દૂર કરવા જઈ રહ્યો છું,"
જેથી મૂળભૂત કે મેમરી સાફ કરો, મફત છે કે,
"અને પછી હું પણ ફાઇલ બંધ કરો અને પછી મારું કાર્યક્રમ છોડવાનો રહ્યું છે જાઉં છું."
પરંતુ તે જ સમયે તમારા કાર્યક્રમ સરખેસરખા છે?
ના, કારણ કે ઘણી વખત ભૂલ કે બન્યું હોઇ શકે છે.
કદાચ અમે ફાઈલ ખોલવા કે અમે અન્ય વૃક્ષ ન કરી શકે
અથવા ભૂલ અમુક પ્રકારના મેમરી ફાળવણી પ્રક્રિયા થયું અને તેથી તે NULL ફર્યા.
એક ભૂલ આવી અને તે પછી અમે પાછા ફર્યા અને છોડી દીધું.
તેથી તો તમે ખાતરી કરો કે કોઇ પણ શક્ય સમય છે કે જે તમારા કાર્યક્રમ બહાર નીકળવા શકે બનાવવા માંગો છો,
તમે તમારા મેમરી બધા ત્યાં મુક્ત કરવા માંગો છો.
તે માત્ર મુખ્ય કાર્ય કે તમે તમારા કોડ બહાર નીકળવા ખૂબ જ ઓવરને અંતે નથી ચાલી રહ્યું છે.
તમે દરેક ઉદાહરણ પર પાછા જોવા માંગો છો કે તમારો કોડ સંભવિત અકાળે પાછા શકે છે
અને પછી મુક્ત મેમરી ગમે અર્થમાં બનાવે છે.
માનો કે તમને કહેવામાં આવે હતું વન બનાવવા અને કે ખોટા ફર્યા.
પછી તમે કદાચ તમારા જંગલ દૂર કરવાની જરૂર પડશે
કારણ કે તમે હજુ સુધી વન નથી.
પરંતુ કોડ દરેક સમયે જ્યાં તમે અકાળે પાછા શકે છે
તમે ખાતરી કરો કે તમે કોઇ પણ શક્ય મેમરી મુક્ત બનાવવા માંગો છો.
>> તેથી, જ્યારે અમે મેમરી મુક્ત કરીને સાથે કામ કરી રહ્યાં છે અને સંભવિત લીક્સ કર્યા
અમે માત્ર અમારી ચુકાદો અને અમારા તર્કશાસ્ત્ર ઉપયોગ કરવા માંગો છો
પણ નક્કી કરે છે કે અમે અમારી મેમરી બધા મુક્ત કર્યા છે યોગ્ય રીતે નથી અથવા Valgrind વાપરો.
તમે ક્યાં તો દોડ્યા પછી એકદમ હાંફવું પર Valgrind રન કરી શકો છો અને પછી તમે પણ પસાર છે
આદેશ વાક્ય દલીલો જમણી નંબર Valgrind છે.
કે જે તમને સ્કોર શકે છે, પરંતુ એ આઉટપુટ થોડી છુપાયેલું છે.
અમે સ્પેલર સાથે તે વપરાતુ બીટ મેળવેલ છે, પરંતુ અમે હજુ થોડી વધુ સહાયની જરૂર છે,
જેથી તે પછી તે લીક તપાસો = સંપૂર્ણ જેવા થોડા વધુ ફ્લેગ સાથે ચલાવી રહ્યા હોય,
કે કદાચ અમને Valgrind પર કેટલાક વધુ મદદરૂપ આઉટપુટ આપશે.
>> પછી અન્ય ઉપયોગી ટિપ જ્યારે તમે ડિબગીંગ કરી રહ્યા છો તે ભેદ આદેશ છે.
તમે મિજાજ ની સ્ટાફ અમલીકરણ ઍક્સેસ ચલાવી શકો છો, કે જે લખાણ ફાઈલ પર,
અને પછી તે બાઈનરી ફાઈલ છે, દ્વિસંગી મિજાજ ફાઈલ માટે બનાવવામાં માટે ચોક્કસ છે.
પછી જો તમે કે દ્વિસંગી ફાઇલ પર તમારી પોતાની દોડ્યા પછી એકદમ હાંફવું ચલાવવા માટે,
પછી તે આદર્શ રીતે, તમારા outputted લખાણ ફાઈલ માટે સમાન હોવું રહ્યું છે
મૂળ કે તમે સાઇન પસાર
અહીં હું ઉદાહરણ તરીકે hth.txt ઉપયોગ કરું છું, અને તે તમારા સ્પેક માં વિશે વાત કરી એક છે.
જે શબ્દશઃ છે માત્ર HTH અને પછી NEWLINE.
પરંતુ ચોક્કસપણે મફત લાગે અને તમે નિશ્ચિતપણે લાંબા સમય સુધી ઉદાહરણો ઉપયોગ પ્રોત્સાહન આપવામાં આવે છે
તમારા લખાણ ફાઈલ છે.
>> તમે પણ કદાચ કોમ્પ્રેસ ખાતે શોટ લેવા કરી શકો છો અને પછી decompressing
યુદ્ધ અને શાંતિ જેમ ફાઈલો કે જે તમે સ્પેલર ઉપયોગમાં કેટલીક
અથવા ઑસ્ટિન જેન અથવા તે કંઈક - કે જે ઠંડી પ્રકારની હશે - અથવા ઓસ્ટિન પાવર્સ,
મોટી ફાઈલો સાથે વ્યવહાર પ્રકારની કારણ કે અમે નીચે તેને આવશે
જો અમે આગામી અહીં સાધન, ls-l ઉપયોગ થાય છે.
અમે ls, કે જે મૂળભૂત રીતે અમારી વર્તમાન ડિરેક્ટરીમાં બધા સમાવિષ્ટો યાદી આપે છે ઉપયોગ કરી રહ્યા છો.
ધ્વજ-l માં પસાર વાસ્તવમાં તે ફાઈલો માપ દર્શાવે છે.
જો તમે pset સ્પેક મારફતે જાઓ, તે ખરેખર તમે બાઈનરી ફાઈલ બનાવવા સુધી લઈ,
તે huffing, અને તમે ખૂબ નાની ફાઇલો માટે કે જુઓ
તે કોમ્પ્રેસ અને તે તમામ માહિતી અનુવાદ ની જગ્યા કિંમત
બધી જ વસ્તુઓ અને ફ્રિકવન્સીમાં ના વાસ્તવિક લાભ outweighs
પ્રથમ સ્થાને ફાઇલ કોમ્પ્રેસ છે.
પરંતુ જો તમે તેને અમુક સમય સુધી લખાણ ફાઈલો પર ચાલે છે, તો પછી તમે જોઈ શકો કે તમે અમુક લાભ શરૂ
તે ફાઈલો કોમ્પ્રેસ છે.
>> અને પછી છેવટે, અમે અમારી જૂની પળ GDB, કે જે ચોક્કસપણે માટે હાથમાં પણ આવી રહ્યું છે હોય છે.
>> અમે મિજાજ વૃક્ષો અથવા પ્રક્રિયા પર કોઇ પ્રશ્નો હોય, કદાચ વૃક્ષો બનાવવા
અથવા Huff'n દોડ્યા પછી એકદમ હાંફવું પર કોઈપણ અન્ય પ્રશ્નો છે?
ઠીક છે. હું આસપાસ થોડી રહેવાની પડશે.
>> આભાર, દરેકને. આ 6 Walkthrough હતી. અને નસીબ સારા.
>> [CS50.TV]