[Powered by Google Translate] [Walkthrough - პრობლემა Set 6]
[Zamyla Chan - ჰარვარდის უნივერსიტეტი]
[ეს არის CS50. - CS50.TV]
>> Hello, ყველას, და მივესალმები რომ Walkthrough 6: Huff'n Puff.
In Huff'n Puff რას ვაკეთებთ იქნება საქმე Huffman შეკუმშული ფაილი
და შემდეგ puffing უკან up, ასე decompressing ის,
ასე, რომ ჩვენ შეგვიძლია თარგმნოთ 0S და 1s, რომ მომხმარებლის გვიგზავნის
და დააკონვერტიროთ ის ისევ ორიგინალური ტექსტი.
Pset 6 იქნება საკმაოდ მაგარი იმიტომ, რომ თქვენ აპირებს ვხედავთ რამოდენიმე ინსტრუმენტი
რომ თქვენ გამოყენებული pset 4 და 5 pset და სახის აერთიანებს მათთვის 1 საკმაოდ აკურატული კონცეფცია
როდესაც თქვენ მოვიდა დაფიქრდით.
>> ასევე, სავარაუდოდ, pset 4 და 5 იყო ყველაზე რთული psets რომ გვქონდა შესთავაზოს.
ასე რომ ამიერიდან, ჩვენ გვაქვს ამ 1 მეტი pset დო,
და შემდეგ რომ ჩვენ შესახებ, რომ პროგრამირება.
ასე მივულოცო თქუენგან მისაღებად მეტი უმძიმესი კეხი წელს CS50.
>> მოძრავი ამისთვის Huff'n Puff, ჩვენი ყუთისთვის ამ pset ვაპირებთ იყოს Huffman ხეები,
ასე გაგება არა მარტო როგორ ბინარული ხეები მუშაობა არამედ კონკრეტულად Huffman ხეები,
როგორ ისინი აშენდა.
და შემდეგ ჩვენ ვაპირებთ აქვს ბევრი განაწილების კოდი ამ pset,
და ჩვენ მოვალთ ვხედავთ, რომ რეალურად ზოგიერთი კოდი
ჩვენ შეიძლება ვერ შეძლებს კარგად ესმით არ არის,
და ასე იმ იქნება. გ ფაილები, მაგრამ შემდეგ მათი თანმხლები. თ ფაილები
მოგვცემს საკმარისი გაგება, რომ ჩვენ გვჭირდება ისე, რომ ჩვენ ვიცით, თუ როგორ ამ ფუნქციების მუშაობა
ან თუნდაც რას უნდა გავაკეთოთ, - მათი მასალები და შედეგები -
მაშინაც კი, თუ ჩვენ არ ვიცით, რა ხდება შავი ყუთი
ან არ მესმის რა ხდება შავი ყუთი ფარგლებში.
და მაშინ საბოლოოდ, როგორც ყოველთვის, საქმე გვაქვს ახალი მონაცემები სტრუქტურების,
კონკრეტული ტიპის კვანძების რომ წერტილი გარკვეული რამ,
და ა.შ. აქ მქონე კალამი და ქაღალდი არა მარტო დიზაინის პროცესში
და როდესაც თქვენ ცდილობთ გაერკვნენ, თუ როგორ თქვენი pset უნდა იმუშაოს
არამედ დროს გამართვის.
თქვენ შეგიძლიათ GDB ერთად თქვენი კალამი და ქაღალდი, ხოლო თქვენ მიიღოს ქვემოთ რა ღირებულებები,
სადაც თქვენი ისრებით მათ მიუთითებს, და რამ, როგორიცაა, რომ.
>> პირველი მოდით შევხედოთ Huffman ხეები.
Huffman ხეები არიან ბინარული ხეები, რაც იმას ნიშნავს, რომ თითოეული კვანძის მხოლოდ 2 შვილი.
In Huffman ხეები დამახასიათებელი ის არის, რომ ყველაზე ხშირი ღირებულებები
წარმოდგენილია fewest ბიტი.
ჩვენ ვნახეთ ლექციების მაგალითები Morse კოდი, რომელიც სახის კონსოლიდირებული გარკვეული ასოებით.
თუ თქვენ ცდილობთ თარგმნოს ან E, მაგალითად,
თქვენ თარგმნიან, რომ ხშირად, ასე რომ ნაცვლად, რომელმაც უნდა გამოიყენოს სრული კომპლექტი ბიტი
გამოყოფილი, რომ ჩვეულებრივი მონაცემები ტიპის, თქვენ შეკუმშოს ის ქვემოთ ნაკლები,
და მერე იმ წერილებს, რომლებიც წარმოდგენილია ნაკლებად ხშირად წარმოდგენილი აღარ ბიტი
იმიტომ, რომ თქვენ ვერ ახერხებს, რომ როდესაც თქვენ მოხდეს გარეთ სიხშირეები, რომ იმ წერილების გამოჩნდება.
ჩვენ გვყავს იგივე იდეა აქ Huffman ხეები
აქ ვაკეთებთ ჯაჭვის, სახის გეზი მისაღებად გარკვეული სიმბოლო.
და მაშინ გმირები, რომლებსაც აქვთ ყველაზე სიხშირე
ვაპირებთ იყოს წარმოდგენილი fewest ბიტი.
>> ისე, რომ თქვენ მშენებლობას Huffman ხე
არის მიერ განთავსების ყველა გმირები რომ კონტექსტიდან
და გაანგარიშების მათი სიხშირე, თუ როგორ ხშირად ისინი გამოჩნდება.
ეს შეიძლება იყოს გრაფი რამდენჯერ საზრისში გამოჩნდება
ან იმის პროცენტული გარეთ ყველა გმირები რამდენი თითოეული ჩანს.
და ასე თუ რას აკეთებთ არის კიდევ თქვენ ყველა იმ mapped out,
მაშინ გადახედეთ 2 ყველაზე დაბალი სიხშირეების და შემდეგ შეუერთდება მათ, როგორც ძმა
აქ მაშინ მშობელი კვანძი აქვს სიხშირე რომელიც თანხა მისი 2 შვილი.
და მაშინ მიერ კონვენციის ვთქვა, რომ მარცხენა კვანძში,
თქვენ დაიცვას, რომ შემდეგი 0 ფილიალი,
და შემდეგ rightmost კვანძში არის 1 ფილიალში.
როგორც ვნახეთ Morse კოდი, ერთი GOTCHA იყო, რომ თითქოს მხოლოდ beep და beep
ეს იყო ორაზროვანი.
ეს შეიძლება იყოს 1 ასო ან შეიძლება იყოს თანმიმდევრობა 2 წერილებს.
და მერე რა Huffman ხეები არ არის, რადგან ის მიერ ბუნების გმირები
ან ჩვენი საბოლოო ფაქტობრივი გმირები მყოფი ბოლო კვანძების შესახებ ფილიალი -
ჩვენ ეხება იმ როგორც ფოთლები - ძალით რომ იქ არ შეიძლება იყოს რაიმე გაურკვევლობა
თვალსაზრისით, რომელიც წერილში თქვენ ცდილობთ encode ერთად სერია ბიტი
რადგან არსად გასწვრივ ბიტი, რომ წარმოადგენენ 1 წერილი
თქვენ ექმნებათ სხვა მთელი წერილი, და იქ არ იქნება არც ერთი გაურკვევლობა არსებობს.
მაგრამ ჩვენ წასვლას მაგალითები, რომ თქვენ ბიჭები შეიძლება რეალურად ვხედავთ, რომ
ნაცვლად us მხოლოდ გეუბნებოდით, რომ მართალია.
>> მოდით შევხედოთ მარტივ მაგალითს Huffman ხე.
მაქვს სიმებიანი აქ რომ არის 12 სიმბოლომდე.
მე 4 როგორც, 6 BS და 2 Cs.
ჩემი პირველი ნაბიჯი იქნება ითვლიან.
რამდენჯერ ამჯამად გამოჩნდება? როგორც ჩანს 4 ჯერ სიმებიანი.
B ჩანს 6 ჯერ, და C ჩნდება 2 ჯერ.
ბუნებრივია, მე ვაპირებ ვთქვა მე გამოყენებით B ყველაზე ხშირად,
ამიტომ მინდა წარმოადგენენ B ერთად fewest რაოდენობის ბიტი, fewest ხმების 0S და 1s.
და მაშინ მე ასევე აპირებს ველოდოთ C მოითხოვოს საუკეთესო ოდენობით 0S და 1s ისევე.
პირველი რა გავაკეთე აქ მე განთავსებული მათ აღმავალი შეკვეთა თვალსაზრისით სიხშირე.
ჩვენ ვხედავთ, რომ C და, ამ ეტაპზე ეს 2 ყველაზე დაბალი სიხშირეების.
ჩვენ ვქმნით მშობელი კვანძი, და რომ მშობელს კვანძის ამჯამად არ აქვს წერილს ასოცირდება იგი,
მაგრამ ჯერ აქვს სიხშირე, რომელიც თანხას.
თანხა ხდება 2 + 4, რომელიც 6.
შემდეგ მივყვებით მარცხენა ფილიალში.
თუ ჩვენ იმ 6 კვანძში, მაშინ ჩვენ დაიცვას 0 მისაღებად C
და შემდეგ 1 მისაღებად ა
ასე რომ ახლა გვაქვს 2 კვანძების.
ჩვენ გვყავს ღირებულება 6 და შემდეგ ჩვენ ასევე გვაქვს სხვა კვანძის ღირებულების 6.
და ასე იმ 2 არა მხოლოდ 2 ყველაზე დაბალი არამედ მხოლოდ 2 რომ დარჩა,
ამიტომ ჩვენ შეუერთდეს იმ მეორე მშობელს, რომლის თანხა მყოფი 12.
ასე რომ აქ ჩვენ გვაქვს ჩვენი Huffman ხე
აქ მოხვედრა B, რომ მხოლოდ bit 1
და მაშინ მისაღებად გვექნებოდა 01 და შემდეგ C მქონე 00.
ასე რომ აქ ჩვენ ვხედავთ, რომ ძირითადად ჩვენ წარმოადგენს ამ chars არც 1 ან 2 ბიტი
სადაც B, როგორც იწინასწარმეტყველა, აქვს მაინც.
და შემდეგ ჩვენ ელოდა C ჰქონდეს საუკეთესო, მაგრამ რადგან ასეთი მცირე Huffman ხე,
მაშინ ასევე წარმოდგენილია 2 ბიტი ნაცვლად სადღაც შუა.
>> უბრალოდ წასვლა მეორეზე მარტივი მაგალითი Huffman ხე,
ამბობენ თქვენ გაქვთ სტრინგს "Hello."
რასაც თქვენ აკეთებთ არის პირველი თქვენ ვიტყოდი რამდენჯერ ამჯამად H გამოჩნდება ამ?
H ჩანს ერთხელ და მერე ვებ ჩანს ერთხელ და მერე ჩვენ გვაქვს ლ გამოჩენა ორჯერ
და პ გამოჩენა ერთხელ.
და ასე შემდეგ ჩვენ ველით, რომელიც წერილში წარმოდგენილია სულ მცირე რაოდენობის ბიტი?
[სტუდენტი] ლ. >> ლ. Yeah. ლ არის სწორი.
ჩვენ ველოდებით ლ უნდა წარმოდგენილია სულ მცირე რაოდენობის ბიტი
რადგან ლ გამოიყენება ყველაზე სტრინგს "Hello."
რა მე ვაპირებ ახლა არის შესამუშაევბლად ამ კვანძების.
მაქვს 1, რომელიც H, ხოლო შემდეგ კიდევ 1, რომელიც ვებ და შემდეგ 1, რომელიც o -
ახლავე მე აყენებს მათ მიზნით - და შემდეგ 2, რომელიც ლ.
მაშინ მე ვიტყვი, ისე, რომ მე აშენება Huffman ხე უნდა ვიპოვოთ 2 კვანძების ერთად მაინც სიხშირეები
და მათი ძმა შექმნით მშობელი კვანძი.
აქ ჩვენ გვაქვს 3 კვანძების ყველაზე დაბალი სიხშირე. ისინი ყველა 1.
ასე რომ აქ ვირჩევთ რომელი ჩვენ ვაპირებთ დაუკავშირონ პირველი.
ვთქვათ მე აირჩიოს H და ვებ.
თანხა 1 + 1 არის 2, მაგრამ ამ კვანძის ამჯამად არ აქვს წერილს ასოცირდება იგი.
უბრალოდ ფლობს ღირებულება.
ახლა ჩვენ შევხედოთ შემდეგი 2 ყველაზე დაბალი სიხშირეების.
სწორედ 2 და 1. რომელიც შეიძლება არც იმ 2, მაგრამ მე ვაპირებ აირჩიოს ამ ერთი.
თანხა 3.
და მაშინ საბოლოოდ, მე მხოლოდ 2 მარცხენა, ასეა, მაშინ რომ ხდება 5.
მაშინ აქ, როგორც მოსალოდნელია, თუ შეავსოთ კოდირების რომ,
1s ყოველთვის სწორი ფილიალი და 0S are მარცხენაში.
მაშინ ჩვენ გვაქვს ლ წარმოდგენილია მხოლოდ 1 ბიტიანი და შემდეგ o მიერ 2
და შემდეგ ვებ მიერ 2 და შემდეგ H მოდის ქვემოთ 3 ბიტი.
ასე რომ თქვენ შეგიძლიათ გადასცემს ამ გაგზავნა "Hello" ნაცვლად რეალურად გამოყენებით გმირები
მხოლოდ 0S და 1s.
თუმცა, გავიხსენოთ, რომ რამდენიმე შემთხვევა გვქონდა კავშირები ჩვენი სიხშირე.
ჩვენ შეგვეძლო ან შეუერთდა H და o პირველი იქნებ.
ან მაშინ მოგვიანებით, როდესაც ჩვენ გვქონდა ლ წარმოდგენილია 2
ასევე შეუერთდა ერთი წარმოდგენილია 2, შეიძლება არ უკავშირდება არც ერთ.
>> და ამრიგად, როდესაც თქვენ გააგზავნით 0S და 1s, რომ რეალურად არ იძლევა გარანტიას
რომ მიმღებს შეუძლია სრულად წაიკითხოთ თქვენი გაგზავნა უფლება off bat
იმიტომ, რომ ისინი შეიძლება არ იცის, რომელი გადაწყვეტილება თქვენ გააკეთა.
ასე რომ, როდესაც ჩვენ საქმე Huffman შეკუმშვა,
როგორღაც უნდა ვუთხრათ მიმღები ჩვენი გაგზავნა რამდენად გადავწყვიტეთ -
მათ უნდა იცოდნენ გარკვეული დამატებითი ინფორმაცია
გარდა შეკუმშული გაგზავნა.
მათ უნდა გაიგონ, რა ხე რეალურად გამოიყურება,
როგორ ჩვენ რეალურად გააკეთა იმ გადაწყვეტილებებს.
>> აქ ჩვენ მხოლოდ აკეთებს მაგალითები ეფუძნება რეალურ რაოდენობა,
მაგრამ ზოგჯერ ასევე შეგიძლიათ აქვს Huffman ხე
ეფუძნება სიხშირის რომელზეც წერილების გამოჩნდება, და ეს ზუსტად იგივე პროცესი.
აქ მე გამოხატავს იგი თვალსაზრისით პროცენტული ან ფრაქციის,
და ა.შ. აქ ზუსტად იგივე რამ.
მე 2 ყველაზე დაბალი, მთლიანობაში მათ, მომდევნო 2 ყველაზე დაბალი, მთლიანობაში მათ,
სანამ მე სრული ხე.
მიუხედავად იმისა, რომ ჩვენ შეგვიძლია ამის გაკეთება ნებისმიერ შემთხვევაში, როდესაც ჩვენ საქმე პროცენტული,
ეს ნიშნავს, რომ ჩვენ გამყოფი რამ და საქმე decimals ან საკმაოდ floats
თუ ჩვენ ფიქრი მონაცემები სტრუქტურების ხელმძღვანელი.
რა ვიცით მოძრავი?
რა არის საერთო პრობლემა, როდესაც ჩვენ საქმე მოძრავი?
[სტუდენტი] Imprecise არითმეტიკული. >> Yeah. ორაზროვნება.
გამო მცურავი პუნქტიანი ორაზროვნება, ამ pset ისე, რომ ჩვენ დავრწმუნდეთ,
რომ ჩვენ არ დავკარგოთ რაიმე ღირებულებები, მაშინ ჩვენ რეალურად უნდა საქმე რაოდენობა.
ასე რომ, თუ თქვენ ფიქრი Huffman კვანძში, თუ ვიხსენებთ, რათა სტრუქტურა აქ,
თუ გადავხედავთ მწვანე პირობა მას სიხშირე ასოცირდება იგი
ისევე, როგორც ეს მიუთითებს კვანძის მის მარცხენა ისევე როგორც კვანძის თავისი უფლება.
, შემდეგ კი წითელი პირობა არსებობს ასევე აქვს ხასიათი მათთან ასოცირებული.
ჩვენ არ ვაპირებთ ცალკე პირობა ამისთვის მშობლები და შემდეგ საბოლოო კვანძების,
რომელიც ჩვენ ეხება როგორც ფოთლები, არამედ იმ იქნება უბრალოდ უნდა NULL მნიშვნელობას.
ყველა კვანძის გვექნება ხასიათი, სიმბოლო იმისა, რომ რომ კვანძის წარმოადგენს,
მაშინ სიხშირე, ისევე როგორც მომცეთ მისი მარცხენა ბავშვი ისევე როგორც მისი სწორი შვილი.
ფოთლები, რომლებიც ზუსტად იმ ბოლოში, ასევე აქვს node პოინტერები
მათი მარცხენა და მათი უფლება, მაგრამ რადგან იმ ღირებულებებს არ მიუთითებს ფაქტობრივი კვანძების,
რა მათი ღირებულება იქნება? >> [სტუდენტი] null. >> Null. სწორედ.
აი მაგალითი, თუ როგორ შეიძლება წარმოადგენდეს სიხშირით მოძრავი,
მაგრამ ჩვენ ვაპირებთ იყოს საქმე იგი მთელი რიცხვები,
ასე რომ ყველა მე შეცვალოთ მონაცემები ტიპის არსებობს.
>> მოდით რა, რომ ცოტა მეტი კომპლექსი მაგალითად.
მაგრამ ახლა, რომ ჩვენ გავაკეთეთ მარტივი პირობა, უბრალოდ იგივე პროცესი.
თქვენთვის 2 ყველაზე დაბალი სიხშირეების, მთლიანობაში სიხშირეები
და ეს ახალი სიხშირე თქვენი მშობელი კვანძი,
რომელიც შემდეგ მიუთითებს მისი მარცხენა 0 ფილიალი და უფლება 1 ფილიალში.
თუ ჩვენ გვაქვს სტრიქონი "ეს არის cs50," მაშინ ჩვენ ითვლიან რამდენჯერ არის T აღნიშნული,
თ აღნიშნული, i, s, c, 5, 0.
აბა რა მე აქ არის წითელი კვანძების უბრალოდ დარგეს,
მე ვუთხარი მე ვაპირებ, რომ ამ სიმბოლოების საბოლოოდ ბოლოში ჩემი ხე.
ეს არის შეზღუდული იქნება ყველა ფოთლები.
აბა რა გავაკეთე არის მე დახარისხებული მათ მიერ სიხშირით აღმავალი შეკვეთა,
და ეს არის ფაქტიურად ისე, რომ pset კოდი აკეთებს
არის ეს ჯიშები ის მიერ სიხშირე და შემდეგ ანბანური.
ასე რომ მას აქვს ნომრები და შემდეგ ალფავიტის მიხედვით სიხშირე.
აბა რა მინდა გააკეთოთ მინდა იპოვოს 2 ყველაზე დაბალი. სწორედ 0 და 5.
მინდა დასასრულს მათ, და რომ 2. მერე გააგრძელებს, იპოვეთ შემდეგი 2 ყველაზე დაბალი.
ეს ის ორი 1s, და შემდეგ იმ გახდეს 2 ასევე.
ახლა მე ვიცი, რომ ჩემი შემდეგი ნაბიჯი იქნება გაწევრიანების ყველაზე დაბალი ნომერი,
რაც T, 1 და შემდეგ ვირჩევთ ერთ კვანძების, რომელსაც აქვს 2 როგორც სიხშირე.
ასე რომ აქ გვაქვს 3 ვარიანტი.
რა მე გაკეთებას აპირებს slide მხოლოდ ვიზუალურად rearrange მათ თქვენთვის
ასე რომ თქვენ ხედავთ, როგორ მე მშენებლობის it up.
რა კოდი და თქვენი განაწილების კოდი აპირებს იქნება შეუერთდეს T ერთი
ერთად 0 და 5 კვანძში.
ასე რომ მაშინ ეს თანხები დან 3 და შემდეგ ჩვენ ვაგრძელებთ პროცესს.
2 და 2 ახლა არის ყველაზე დაბალი, ასე მაშინ ის თანხა 4.
ყველას შემდეგ აქამდე? Okay.
შემდეგ რომ გვაქვს 3 და 3 რომ უნდა დაემატოს up,
ამიტომ, კიდევ ერთხელ მე უბრალოდ გადართვის ასე რომ თქვენ შეგიძლიათ ნახოთ ვიზუალურად ისე, რომ არ მიიღოთ ძალიან ბინძურ.
მაშინ ჩვენ გვაქვს 6, და მაშინ ჩვენი საბოლოო ნაბიჯი არის, რომ ჩვენ მხოლოდ 2 კვანძების
ჩვენ მთლიანობაში იმ მიიღოს root ჩვენი ხე, რომელიც 10.
და ნომერი 10 აზრი რადგან თითოეული კვანძის წარმოდგენილია,
მათი ღირებულება, მათი სიხშირე ნომერი, იყო რამდენჯერ ისინი გამოჩნდნენ სიმებიანი,
და მაშინ ჩვენ გვყავს 5 სიმბოლოების ჩვენი სიმებიანი, ასე რომ აზრი.
თუ გადავხედავთ up, როგორ გვინდა რეალურად encode ის,
როგორც მოსალოდნელი იყო, მე და s, რომელიც გამოჩნდება ყველაზე ხშირად
წარმოდგენილია fewest რაოდენობის ბიტი.
>> ფრთხილად აქ.
In Huffman ხეები შემთხვევაში რეალურად საკითხები.
ზედა S განსხვავებულია, ვიდრე ამას s.
თუ ჩვენ გვქონდა "ეს არის CS50" ერთად ასოებით, მაშინ ამას s მხოლოდ ორჯერ გამოჩნდება,
იქნებოდა კვანძში, 2, როგორც მისი ღირებულება და შემდეგ ზედა S რომ იყოს მხოლოდ ერთხელ.
ასეა, მაშინ თქვენი ხე შეიცვლებოდა სტრუქტურების იმიტომ, რომ თქვენ რეალურად აქვს ზედმეტი ფოთოლი აქ.
მაგრამ თანხა მაინც იყოს 10.
რაც ჩვენ რეალურად უნდა მოუწოდებდა ჯამი,
გარდა ამისა ყველა ითვლის.
>> ახლა, ჩვენ დაფარული Huffman ხეები, ჩვენ შეგვიძლია ჩაყვინთვის შევიდა Huff'n Puff, pset.
ჩვენ ვაპირებთ დავიწყოთ მონაკვეთზე კითხვები,
და ეს ხდება მისაღებად თქვენ მიჩვეული ერთად ორობითი ხეები და როგორ ფუნქციონირებს გარშემო, რომ:
ხატვის კვანძების შექმნა თქვენი საკუთარი typedef struct ამისთვის კვანძში,
და ხედავს, თუ როგორ შეიძლება ჩადეთ შევიდა ორობითი ხე, ერთი რომ დახარისხებული,
traversing, და რამ, როგორიცაა, რომ.
რომ ცოდნა ნამდვილად აპირებს დაგეხმაროთ როცა თქვენ ჩაყვინთვის შევიდა Huff'n Puff ნაწილი
საქართველოს pset.
სტანდარტულ გამოცემას pset, თქვენი ამოცანაა განახორციელოს Puff,
და Hacker ვერსია თქვენი ამოცანაა განახორციელოს დათუნა დათო დავით მგელაძე.
რა დათუნა დათო დავით მგელაძე არ არის სჭირდება ტექსტი და მერე ითარგმნება იგი 0S და 1s,
ასე პროცესი, რომელიც ჩვენ ზემოთ, სადაც ჩვენ დათვლილი სიხშირეები
და შემდეგ გააკეთა ხე და შემდეგ თქვა: "როგორ მივიღო T?"
T წარმოდგენილია 100, რამ, როგორიცაა, რომ
და შემდეგ დათუნა დათო დავით მგელაძე დასჭირდება ტექსტი და შემდეგ გამომავალი რომ ორობითი.
არამედ იმიტომ, რომ ჩვენ ვიცით, რომ ჩვენ გვინდა, დავუშვებთ, რომ ჩვენი მიმღების გაგზავნა
ხელახლა ზუსტად იგივე ხე, იგი ასევე მოიცავს ინფორმაციას სიხშირე ითვლის.
შემდეგ Puff ჩვენ მოცემულია ორობითი ფაილის 0S და 1s
და მიეცა ასევე ინფორმაციას სიხშირეები.
ჩვენ ვთარგმნით ყველა იმ 0S და 1s დააბრუნებდა ორიგინალური გაგზავნა რომ იყო,
ამიტომ ჩვენ decompressing რომ.
თუ თქვენ აკეთებთ სტანდარტული გამოცემა, თქვენ არ გჭირდებათ განახორციელოს დათუნა დათო დავით მგელაძე,
ასე მაშინ შეგიძლიათ უბრალოდ გამოიყენოთ პერსონალის განხორციელების დათუნა დათო დავით მგელაძე.
არსებობს ინსტრუქცია სპეც შესახებ, თუ როგორ უნდა გავაკეთოთ, რომ.
თქვენ შეგიძლიათ აწარმოებს პერსონალის განხორციელების დათუნა დათო დავით მგელაძე საფუძველზე გარკვეული ტექსტური ფაილი
და შემდეგ გამოიყენოთ, რომ გამომავალი როგორც თქვენი შეყვანის to Puff.
>> როგორც აღვნიშნე ადრე, ჩვენ გვაქვს უამრავი განაწილების კოდი ეს ერთი.
მე ვაპირებ დაიწყება გადის ეს.
მე ვაპირებ დახარჯვა ყველაზე მეტად დროს. თ ფაილები
რადგან. გ ფაილი, რადგან ჩვენ გვაქვს. თ
და რომ გვაძლევს პროტოტიპები ფუნქციები,
ჩვენ სრულად არ უნდა გაიგონ, ზუსტად -
თუ თქვენ არ მესმის რა ხდება. გ ფაილები, მაშინ არ ინერვიულოთ ძალიან ბევრი,
მაგრამ ნამდვილად ცდილობენ მიიღონ look რადგან ეს შესაძლოა გარკვეული მინიშნებები
და ეს სასარგებლო მისაღებად გამოიყენება კითხულობს სხვა ადამიანების კოდი.
>> ეძებს huffile.h, in კომენტარები იგი აცხადებს ფენა აბსტრაქცია ამისთვის Huffman კოდირებული ფაილი.
თუ ვეშვებით, ჩვენ ვხედავთ, რომ არსებობს მაქსიმუმ 256 სიმბოლიკა, რომ ჩვენ ალბათ საჭიროა კოდები.
ეს მოიცავს ყველა ასო ანბანი - ზედა და ამას -
და შემდეგ სიმბოლიკა და ნომრები და ა.შ.
მაშინ აქ გვაქვს ჯადოსნური ხმების იდენტიფიცირება Huffman კოდირებული ფაილის.
ფარგლებში Huffman კოდი ისინი აპირებენ აქვს გარკვეული Magic ნომერი
ასოცირდება header.
ეს შეიძლება გამოიყურებოდეს მხოლოდ შემთხვევითი Magic ნომერი,
მაგრამ თუ თქვენ ნამდვილად თარგმნოს იგი ASCII, მაშინ იგი რეალურად შელოცვების გარეთ დათუნა დათო დავით მგელაძე.
აქ struct ამისთვის Huffman-კოდირებით ფაილი.
აქ ყველა ამ მახასიათებლით ასოცირდება დათუნა დათო დავით მგელაძე ფაილი.
მაშინ ქვემოთ აქ გვაქვს header for დათუნა დათო დავით მგელაძე ფაილი, ასე რომ ჩვენ მას Huffeader
ნაცვლად დასძინა ზედმეტი თ, რადგან ეს ხმები იმავე მაინც.
Cute.
ჩვენ გვყავს Magic ხმების ასოცირდება იგი.
თუ ეს ფაქტობრივი დათუნა დათო დავით მგელაძე ფაილი, ის იქნება ნომერი up ზემოთ, ამ ჯადოსნური ერთი.
და მერე ექნება მასივი.
ამიტომ თითოეული სიმბოლო, რომლის არსებობს 256,
ის აპირებს ჩამოვთვალოთ რა სიხშირეზე იმ სიმბოლიკა შიგნით დათუნა დათო დავით მგელაძე ფაილი.
და მაშინ საბოლოოდ, ჩვენ გვაქვს ჯამი სიხშირეების,
რომელიც უნდა იყოს თანხა იმ სიხშირეებზე.
ასე რომ რა Huffeader არის.
მაშინ ჩვენ გვაქვს გარკვეული ფუნქციების, რომ დაბრუნების შემდეგი წვლილი დათუნა დათო დავით მგელაძე ფაილი
ასევე წერს მწირი დათუნა დათო დავით მგელაძე ფაილი და შემდეგ ამ ფუნქციის აქ, hfclose,
რომ რეალურად ხურავს დათუნა დათო დავით მგელაძე ფაილი.
მანამდე, საქმე გვქონდა სწორი უბრალოდ fclose,
მაგრამ როდესაც თქვენ დათუნა დათო დავით მგელაძე ფაილი, ნაცვლად fclosing ეს
თქვენ მას რეალურად აპირებს არის hfclose და hfopen იგი.
ეს ის კონკრეტული ფუნქციების დათუნა დათო დავით მგელაძე ფაილი, რომელიც ჩვენ ვაპირებთ იყოს საქმე.
მაშინ აქ ვკითხულობთ header და შემდეგ წერენ header.
>> მხოლოდ კითხულობს. თ ფაილის შეგვიძლია სახის მისაღებად გრძნობა რა დათუნა დათო დავით მგელაძე მაინც შეიძლება,
რა მახასიათებლები მას, გარეშე რეალურად შესვლის huffile.c,
რომელიც, თუ ჩვენ ჩაყვინთვის წელს, იქნება ცოტა უფრო რთული.
მას აქვს ყველა ფაილის I / O აქ საქმე პოინტერები.
აქ ჩვენ ვხედავთ, რომ როდესაც ჩვენ მოვუწოდებთ hfread, მაგალითად, დღემდე საქმე fread.
ჩვენ არ მოშორების ამ ფუნქციების მთლიანად, მაგრამ ჩვენ გაგზავნის იმ იქნას მოვლა
შიგნით დათუნა დათო დავით მგელაძე ფაილის ნაცვლად აკეთებს ყველა ის საკუთარ თავს.
შეგიძლიათ მოგერიდებათ სკანირების მეშვეობით თუ თქვენ ცნობისმოყვარე
და წავიდეთ და კანი ფენის უკან ცოტა.
>> შემდეგი ფაილის, რომ ჩვენ ვაპირებთ შევხედოთ არის tree.h.
მანამდე Walkthrough სლაიდები განვაცხადეთ ველოდოთ Huffman კვანძში
და ჩვენ მივიღეთ typedef struct კვანძში.
ჩვენ ველით, რომ მას აქვს სტრატეგია, სიხშირე, და შემდეგ 2 კვანძის ვარსკვლავს.
ამ შემთხვევაში იმას თუ რას ვაკეთებთ ეს არის არსებითად იგივე
გარდა ნაცვლად კვანძის ჩვენ ვაპირებთ მოვუწოდებთ მათ ხეები.
ჩვენ გვყავს ფუნქცია რომ როცა რეკავთ მიიღოს ხე ის დააბრუნებს თქვენ ხე მაჩვენებელი.
თავში Speller, როდესაც მიღების ახალი კვანძში
თქვენ თქვით კვანძის * ახალი სიტყვა = malloc (sizeof) და რამ, როგორიცაა, რომ.
ძირითადად, mktree იქნება საქმე, რომ თქვენთვის.
ანალოგიურად, როდესაც გსურთ ამოიღონ ხე,
ასე რომ არსებითად გამონთავისუფლების ხე როდესაც თქვენ გაკეთდეს ეს,
ნაცვლად ღიად მოუწოდებდა უფასოდ, რომ თქვენ რეალურად მხოლოდ აპირებს გამოიყენოს ფუნქცია rmtree
სადაც თქვენ კორიდორი მომცეთ, რომ ხე და შემდეგ tree.c იზრუნებს რომ თქვენთვის.
>> ჩვენ შევისწავლით tree.c.
ჩვენ ველით, რომ იგივე ფუნქციები გარდა დაინახოს განხორციელება ისევე.
როგორც ველოდით, როცა რეკავთ mktree ეს mallocs ზომის ხე შევიდა მაჩვენებელი,
initializes ყველა ფასეულობები NULL ღირებულება, ასე 0S ან NULLs,
და შემდეგ დააბრუნებს მომცეთ, რომ ხე, რომ თქვენ უბრალოდ malloc'd თქვენ.
აქ როცა რეკავთ ამოიღონ ხე იგი პირველი იღებს დარწმუნებული, რომ თქვენ არ ორმაგი ათავისუფლებს.
იგი ქმნის დარწმუნებულია, რომ თქვენ ნამდვილად აქვს ხე რომ გსურთ ამოიღონ.
აქ იმიტომ ხე ასევე მოიცავს მისი შვილი,
რა ეს იმას თუ არა რეკურსიული მოუწოდებს ამოიღონ ხე მარცხენა კვანძის ხე
ასევე უფლება კვანძში.
სანამ ათავისუფლებს მშობელს, რომელიც მას სჭირდება, რათა ბავშვებს ასევე.
მშობელი ასევე ურთიერთშემცვლელნი ის root.
პირველი მშობელი, ასე მოსწონს დიდი დიდი დიდი დიდი ბაბუა
ან ბებია ხე, პირველი ჩვენ უნდა გავათავისუფლოთ ქვემოთ დონეზე პირველი.
ამიტომ traverse ბოლოში, უფასო იმ და შემდეგ დავბრუნდებით up, უფასო იმ ა.შ.
ასე რომ ხე.
>> ახლა ჩვენ შევხედოთ ტყეში.
ტყე, სადაც თქვენ მიიტანეთ ყველა თქვენი Huffman ხეები.
ის ამბობდა, რომ ჩვენ ვაპირებთ აქვს რაღაც მოუწოდა ნაკვეთი
რომელიც შეიცავს მომცეთ ხე ასევე მომცეთ ნაკვეთი მოუწოდა შემდეგი.
რა სტრუქტურა აქვს ამ სახის გამოიყურებოდეს?
იგი სახის ამბობს, რომ იქ.
მარჯვენა აქ.
უკავშირდება სიაში.
ჩვენ ვხედავთ, რომ როდესაც გვაქვს ნაკვეთი ეს მოსწონს უკავშირდება სიაში ნაკვეთები.
ტყის განისაზღვრება, როგორც უკავშირდება სიაში ნაკვეთები,
და ა.შ. სტრუქტურა ტყე ჩვენ უბრალოდ აპირებს მომცეთ ჩვენი პირველი ნაკვეთი
და რომ მიწის ნაკვეთი ხის ფარგლებში, ან საკმაოდ მიუთითებს ხე
და შემდეგ მიუთითებს შემდეგი ნაკვეთი, ა.შ. და ა.შ..
იმისათვის, რომ ტყის მოვუწოდებთ mkforest.
მაშინ ჩვენ გვაქვს საკმაოდ სასარგებლო ფუნქციები აქ.
ჩვენ გვყავს აირჩიოთ სადაც თქვენ გაივლის ტყეში და შემდეგ დაბრუნებული მნიშვნელობა არის ხე *,
მომცეთ ხე.
რა არჩევანი გავაკეთებ არის ის წავა ტყეში, რომ თქვენ მიუთითებს
მაშინ ამოიღონ ხეს ყველაზე დაბალი სიხშირის, რომ ტყის
და შემდეგ მოგცემთ მომცეთ, რომ ხე.
ერთხელ თქვენ მოვუწოდებთ აირჩიოთ, ხე არ არსებობს ტყის უქმნით,
მაგრამ დაბრუნებული მნიშვნელობა არის მომცეთ, რომ ხე.
მაშინ თქვენ გაქვთ ქარხანა.
იმ პირობით, რომ თქვენ კორიდორი მომცეთ ხე, რომელსაც აქვს არასამთავრობო 0 სიხშირე,
რა მცენარეული გავაკეთებ არის დასჭირდება ტყის, მიიღოს ხე, და მცენარეთა რომ ხე შიგნით ტყეში.
აქ rmforest.
მსგავსი ამოიღონ ხე, რომლებიც ძირითადად გათავისუფლდეს ყველა ჩვენი ხეები ჩვენთვის,
ამოიღონ ტყის will უფასო ყველაფერი შეიცავს, რომ ტყეში.
>> თუ გადავხედავთ შევიდა forest.c, ჩვენ ველით, რომ ნახოთ მინიმუმ 1 rmtree ბრძანება იქ,
რადგან თავისუფალი მეხსიერების ტყეში თუ ტყეში აქვს ხეები მას,
მაშინ საბოლოოდ თქვენ აპირებს ამოიღონ იმ ხეები ძალიან.
თუ გადავხედავთ შევიდა forest.c, ჩვენ გვაქვს ჩვენი mkforest, რომელიც, როგორც ჩვენ მოველით.
ჩვენ malloc რამ.
ჩვენ ინიციალიზაცია პირველი ნაკვეთი ტყეში როგორც NULL რადგან ცარიელი დასაწყისისთვის,
მაშინ ჩვენ ვხედავთ არჩევანი, რომელიც ბრუნდება ხე ყველაზე დაბალი წონა, ყველაზე დაბალი სიხშირე,
და შემდეგ იღებს მოშორება კონკრეტულ კვანძში, რომელიც მიუთითებს, რომ ხე და შემდეგი ერთი,
ასე სჭირდება, რომ გარეთ უკავშირდება სიაში ტყეში.
და მერე აქ გვაქვს მცენარე, რომელიც ჩანართები ხე შევიდა უკავშირდება სიაში.
რა ტყის ამჯამად არის ლამაზად ინახავს დახარისხებული ჩვენთვის.
და მაშინ საბოლოოდ, ჩვენ გვაქვს rmforest და, როგორც მოსალოდნელია, რომ ჩვენ გვაქვს rmtree მოუწოდა იქ.
>> ეძებს განაწილების კოდი ჯერჯერობით huffile.c ალბათ ბევრად უმძიმესი იმის გაგება,
ხოლო სხვა ფაილი თავად იყო საკმაოდ მარტივი დაიცვას.
ჩვენი ცოდნა მაჩვენებლებისა და დაკავშირებული სიები და ასეთი,
ჩვენ შეგვეძლო მოჰყვება კარგად.
მაგრამ ყველა ჩვენ გვჭირდება ნამდვილად დავრწმუნდეთ, რომ ჩვენ კარგად გვესმის არის. თ ფაილები
იმიტომ, რომ თქვენ უნდა იყოს მოუწოდებდა იმ ფუნქციებს, რომლებიც ეხება იმ დაბრუნების ღირებულებების,
ასე დარწმუნდით, რომ თქვენ მთლიანად აცნობიერებთ რა ქმედება უნდა შესრულდეს
როცა მოვუწოდებთ ერთი იმ ფუნქციებს.
მაგრამ რეალურად გაგება შიგნით ეს არ არის საკმაოდ საჭირო იმიტომ რომ ჩვენ გვაქვს იმ. თ files.
ჩვენ გვყავს 2 მეტი ფაილი დარჩა ჩვენი სადისტრიბუციო კოდი.
>> მოდით შევხედოთ ნაგავსაყრელი.
ნაგავსაყრელი თავისი კომენტარი აქ იღებს Huffman-შეკუმშული ფაილი
და შემდეგ ითარგმნება და dumps ყველა მისი შინაარსი out.
აქ ჩვენ ვხედავთ, რომ ის მოუწოდებდა hfopen.
ეს არის სახის რეზერვირება შეიტანოს * input = fopen,
და მაშინ კორიდორი ინფორმაციას.
თითქმის იდენტურია გარდა ნაცვლად ფაილი * თქვენ გადადის Huffile;
ნაცვლად fopen თქვენ გადადის hfopen.
აქ ვკითხულობთ header პირველი, რაც სახის მსგავსი, თუ როგორ ვკითხულობთ header
ამისთვის Bitmap ფაილი.
იმას თუ რას ვაკეთებთ აქ ამოწმებს, რომ ნახოთ თუ არა თავსართი ინფორმაცია
შეიცავს უფლება Magic ნომერი, რომელიც მიუთითებს, რომ ეს ფაქტობრივი დათუნა დათო დავით მგელაძე ფაილი,
შემდეგ ყველა ეს ამოწმებს, რათა დავრწმუნდეთ, რომ ფაილი, რომ ჩვენ ღია არის ფაქტობრივი huffed ფაილი ან არ.
რა ეს იმას არის ის შედეგები სიხშირეთა ყველა სიმბოლიკა რომ ვხედავთ
ფარგლებში ტერმინალში შევიდა გრაფიკული მაგიდასთან.
ეს ნაწილი იქნება სასარგებლო.
მას აქვს ცოტა და ნათქვამია ცოტა ნელა შევიდა ცვლადი ბიტიანი და შემდეგ ბეჭდავს ის.
ასე რომ მე რომ მოვუწოდო ნაგავსაყრელი on hth.bin, რომელიც არის შედეგი huffing ფაილი
გამოყენებით პერსონალის გადაწყვეტა, მე ამ.
ეს outputting ყველა ამ სიმბოლოებს და შემდეგ აყენებს სიხშირე, რომლის დროსაც ისინი გამოჩნდება.
თუ გადავხედავთ, მათი უმრავლესობა 0S გარდა ამ: H, რომელიც, როგორც ჩანს ორჯერ,
და მაშინ T, რომელიც, როგორც ჩანს ერთხელ.
და მერე აქ გვაქვს ფაქტობრივი გაგზავნა in 0S და 1s.
თუ დავაკვირდებით hth.txt, რომელიც სავარაუდოდ ორიგინალური გაგზავნა, რომელიც huffed,
ჩვენ ველით, რომ რამდენიმე HS და ც იქ.
კერძოდ, ჩვენ ველით, რომ ნახოთ მხოლოდ 1 T და 2 HS.
აქ ვართ hth.txt. ეს მართლაც აქვს HTH.
შედის, თუმცა ჩვენ ვერ ვხედავთ მას, არის სტრიქონების გადატანით ხასიათი.
დათუნა დათო დავით მგელაძე ფაილი hth.bin ასევე კოდირების სტრიქონების გადატანით ხასიათი ისევე.
აქ იმიტომ, რომ ჩვენ ვიცით, რომ ბრძანება HTH და შემდეგ სტრიქონების გადატანით,
ვხედავთ, რომ ალბათ H წარმოდგენილია მხოლოდ ერთი 1
და მაშინ T ალბათ 01 და შემდეგ შემდეგი H არის 1 ასევე
და მაშინ ჩვენ გვაქვს სტრიქონების გადატანით მიერ მითითებულ ორ 0S.
ზემოთ.
>> და მაშინ საბოლოოდ, რადგან ჩვენ საქმე გვაქვს მრავალი. C და. თ ფაილი
ჩვენ ვაპირებთ აქვს საკმაოდ კომპლექსური არგუმენტი შემდგენელი,
და ა.შ. აქ გვაქვს Makefile ხდის ნაგავსაყრელი თქვენთვის.
მაგრამ რეალურად, თქვენ უნდა წავიდეთ შესახებ მიღების თქვენი საკუთარი puff.c ფაილი.
Makefile პრაქტიკულად არ გაუმკლავდეთ მიღების puff.c თქვენთვის.
ჩვენ ტოვებს, რომ თქვენი გადასაწყვეტია შეცვალონ Makefile.
როდესაც გადიხარ ბრძანება მოსწონს ყველა, მაგალითად, ის გააკეთებს ყველა მათგანი თქვენთვის.
შეგიძლიათ შეხედოთ მაგალითები Makefile წარსულში pset
ასევე აპირებს off ამ ერთი, რომ ნახოთ, თუ როგორ შეიძლება იყოს შეუძლია თქვენი Puff ფაილი
მიერ რედაქტირების ამ Makefile.
სწორედ ამის შესახებ ჩვენი სადისტრიბუციო კოდი.
>> ერთხელ ჩვენ მიღებული მეშვეობით რომ, მაშინ აქ არის კიდევ ერთი შეხსენება
, როგორ ვაპირებთ იყოს საქმე Huffman კვანძების.
ჩვენ არ ვაპირებთ უნდა მოუწოდებდა მათ კვანძების უქმნით, ჩვენ ვაპირებთ იყოს მოუწოდებდა მათ ხეები
სადაც ჩვენ ვაპირებთ იყოს წარმოადგენენ თავიანთ სიმბოლოდ ერთად char,
მათი სიხშირე, რაოდენობის შემთხვევები, ერთად მთელი რიცხვი.
ჩვენ გამოყენებით, რადგან ეს მას უფრო ზუსტი, ვიდრე float.
და მაშინ ჩვენ გვაქვს სხვა მომცეთ მარცხენა ბავშვის ასევე უფლება შვილი.
ტყის, როგორც ვნახეთ, მხოლოდ დაკავშირებული ჩამონათვალი ხეები.
საბოლოო ჯამში, როცა ჩვენ ვაშენებთ ჩვენი დათუნა დათო დავით მგელაძე ფაილი,
გვინდა ჩვენი ტყეში შეიცავდეს მხოლოდ 1 ხე -
1 ხე, 1 root მრავალი შვილი.
მანამდე, როცა ჩვენ უბრალოდ ჩვენი Huffman ხეები,
ჩვენ დავიწყეთ მიერ დებს ყველა კვანძების გადატანა ჩვენი ეკრანზე
და ამბობდა ჩვენ ვაპირებთ, რომ ამ კვანძების,
საბოლოოდ ისინი იქნება ფოთლები, და ეს არის მათი სიმბოლო, ეს მათი სიხშირე.
ჩვენი ტყე თუ ჩვენ უბრალოდ უნდა 3 წერილებს, რომ ტყეში 3 ხეები.
ხოლო შემდეგ ჩვენ კი, როდესაც ჩვენ დამატებული პირველი მშობელს,
ჩვენ მივიღეთ ტყეში 2 ხეები.
ჩვენ ამოღებულ 2 იმ ბავშვებს ჩვენი ტყის და შემდეგ შეცვალა იგი მშობელი კვანძი
რომ ჰქონდა იმ 2 კვანძების როგორც ბავშვები.
და მაშინ საბოლოოდ, ჩვენი ბოლო ნაბიჯისთვის, რომ ჩვენი მაგალითი როგორც, BS და Cs
იქნებოდა, რათა საბოლოო მშობელს,
და ასე შემდეგ, რომ ჩვენი სულ გრაფი ხეები ტყეში 1.
ამჯამად ყველას ვხედავ, თუ როგორ დაიწყოს გარეთ მრავალი ხეები თქვენს ტყის
და დასრულდება up ერთად 1? Okay. ზემოთ.
>> რა უნდა გავაკეთოთ ამისთვის Puff?
რა უნდა გავაკეთოთ არის უზრუნველყოს, რომ, როგორც ყოველთვის, მათ მოგვცეს უფლება გაცნობის შეყვანის
ასე, რომ ჩვენ შეგვიძლია რეალურად აწარმოებს პროგრამა.
ამ შემთხვევაში ისინი აპირებენ გვაძლევს შემდეგ მათი პირველი ბრძანება ხაზი არგუმენტი
2 მეტი: ფაილი რომ ჩვენ გვინდა decompress და გამოშვებულ დეკომპრესია ფაილი.
მაგრამ ერთხელ ჩვენ დავრწმუნდეთ, რომ ისინი გაივლიან us სწორი ოდენობით ღირებულებების,
გვსურს დავრწმუნდეთ, რომ შეყვანის არის დათუნა დათო დავით მგელაძე ფაილი ან არ.
და მერე კიდევ ჩვენ გარანტიას, რომ დათუნა დათო დავით მგელაძე ფაილი, მაშინ ჩვენ გვსურს ავაშენოთ ჩვენი ხე,
დაამყარონ ხე ისეთი, რომ სიას ხე რომ ადამიანი, რომელიც გაგზავნილი გაგზავნა აშენდა.
შემდეგ ჩვენ ვაშენებთ ხე, მაშინ ჩვენ შეგვიძლია გავუმკლავდეთ 0S და 1s, რომ ძალაში შევიდა,,
დაიცვას იმ გასწვრივ ჩვენი ხე რადგან იდენტური,
და მერე წერენ, რომ შეტყობინება, ინტერპრეტაცია ბიტი დააბრუნებდა სიმბოლო.
და შემდეგ დასასრულს, რადგან ჩვენ საქმე გვაქვს პოინტერები აქ,
ჩვენ გვინდა დავრწმუნდეთ, რომ ჩვენ არ გვაქვს რაიმე მეხსიერების გაჟონვის
და რომ ჩვენ თავისუფალი ყველაფერი.
>> უზრუნველყოფა სათანადო გამოყენების ძველი ქუდი ჩვენთვის ახლა.
ჩვენ მიიღოს შეყვანის, რომელიც იქნება სახელით ფაილი Puff,
და მაშინ ჩვენ დააკონკრეტა გამომუშავება,
ასე სახელით ფაილი puffed გამომუშავება, რომელიც იქნება ტექსტური ფაილი.
სწორედ გამოყენება. და ახლა გვსურს დავრწმუნდეთ, რომ შეყვანის არის huffed თუ არა.
ფიქრი თავში, იქ იყო არაფერი განაწილების კოდი, რომელიც შესაძლოა დაგვეხმაროს
გაგებით თუ არა ფაილი huffed თუ არა?
იყო ინფორმაცია huffile.c შესახებ Huffeader.
ჩვენ ვიცით, რომ ყველა დათუნა დათო დავით მგელაძე ფაილის Huffeader ასოცირდება იგი ჯადოსნური ნომერი
ასევე მასივი სიხშირეები თითოეული სიმბოლო
ასევე ჯამი.
ჩვენ ვიცით, რომ, მაგრამ ჩვენ ასევე მონაწილეობა peek at dump.c,
რომელშიც იგი კითხულობს შევიდა დათუნა დათო დავით მგელაძე ფაილი.
და ასე გავაკეთოთ, რომ მას მოუწია შეამოწმოს თუ არა ეს მართლაც huffed თუ არა.
ასე რომ ალბათ ჩვენ შეგვიძლია გამოვიყენოთ dump.c როგორც სტრუქტურა ჩვენი puff.c.
თავში pset 4 როდესაც გვქონდა ფაილი copy.c რომ გადაწერილი წელს RGB საწოლიანი
და ჩვენ განმარტა, რომ ამისთვის Whodunit და შემცირება,
ანალოგიურად, რას შეეძლო მხოლოდ ბრძანების შესრულება, როგორიცაა CP dump.c puff.c
და გამოყენება ზოგიერთი კოდი არსებობს.
თუმცა, ეს არ იქნება, როგორც პირდაპირი of პროცესი
ამისთვის თარგმნის თქვენს dump.c შევიდა puff.c,
მაგრამ მაინც ეს გაძლევთ სადღაც უნდა დაიწყოს
თუ როგორ უნდა უზრუნველყოს, რომ შეყვანის ფაქტობრივად huffed ან არ
ასევე რამდენიმე სხვა რამ.
ჩვენ უზრუნველყო სათანადო გამოყენება და დარწმუნდა, რომ შეყვანის არის huffed.
ყოველ ჯერზე, რომ ჩვენ გავაკეთეთ, რომ ჩვენ გავაკეთეთ ჩვენი სათანადო შეცდომა შემოწმებისას,
ასე დაბრუნების და წასვლის ფუნქცია თუ მარცხი ხდება, თუ არა რაიმე პრობლემა.
>> ეხლა ჩვენ გვინდა გავაკეთოთ არის აშენება ფაქტობრივი ხე.
თუ გადავხედავთ ტყეში, არის 2 ძირითადი ფუნქციები
რომ ჩვენ ვაპირებთ სურს გახდეს ძალიან ნაცნობია.
არსებობს ლოგიკური ფუნქცია მცენარეთა რომ მცენარეთა არასამთავრობო 0 სიხშირე ხის შიგნით ჩვენი ტყეში.
და ასე რომ თქვენ კორიდორი მომცეთ ტყის და მომცეთ ხე.
სწრაფი შეკითხვა: რამდენი ტყეების იქნება თქვენ გაქვთ როდესაც თქვენ აშენებთ Huffman ხე?
ჩვენი ტყე მოსწონს ჩვენი ტილო, არა?
ამიტომ ჩვენ მხოლოდ გვექნება 1 ტყე, მაგრამ ჩვენ ვაპირებთ რამდენიმე ხე.
ასე რომ სანამ მოვუწოდებთ მცენარე, თქვენ სავარაუდოდ აპირებს გვსურს თქვენი ტყეში.
არსებობს ბრძანება, რომ თუ შევისწავლით forest.h, თუ როგორ შეგიძლიათ ტყეში.
შეგიძლიათ დარგე ხე. ჩვენ ვიცით, როგორ უნდა გავაკეთოთ, რომ.
და მაშინ ასევე აირჩიოთ ხის ტყიდან,
მოხსნის ხეს ყველაზე დაბალი წონის და გაწვდით მომცეთ რომ.
ფიქრი თავში, როცა ვაკეთებდით მაგალითები თავს,
როდესაც ჩვენ ხატვის ის, ჩვენ უბრალოდ უბრალოდ დასძინა ბმულები.
მაგრამ აქ ნაცვლად მხოლოდ დასძინა კავშირები,
ვფიქრობ მას უფრო როგორც თქვენ მოხსნის 2 იმ კვანძების და შემდეგ შეცვალა იგი მეორე.
გამოხატოს, რომ თვალსაზრისით კრეფა და სარგავი,
თქვენ კრეფა 2 ხეები და შემდეგ ჩადების მეორე ხე
რომ აქვს იმ 2 ხეები რომ თქვენ აღებული როგორც ბავშვები.
აშენება Huffman ნაძვის ხე, თქვენ ამ სიმბოლიკა და სიხშირეების მიზნით
რადგან Huffeader იძლევა, რომ თქვენ,
გაძლევთ მასივი სიხშირეები.
ასე რომ თქვენ შეგიძლიათ წავიდეთ წინ და უბრალოდ იგნორირება არაფერი 0 მასში
იმიტომ, რომ ჩვენ არ გვინდა 256 ფოთლები დასასრულს იგი.
ჩვენ მხოლოდ გვინდა ხმების ფოთლები, რომლებიც გმირები
რომ ფაქტობრივად გამოყენებული ფაილი.
შეგიძლიათ წაიკითხოთ იმ სიმბოლიკა, და თითოეული იმ სიმბოლოების რომ აქვს არასამთავრობო 0 სიხშირეების,
იმ ვაპირებთ იყოს ხე.
რა შეგიძლიათ გააკეთოთ, არის ყველა დროის წაიკითხონ არასამთავრობო 0 სიხშირე სიმბოლო,
შეგიძლიათ მცენარე, რომ ხე ტყე.
ერთხელ თქვენ მცენარე ხეები ტყეში, თქვენ შეგიძლიათ შეუერთდება იმ ხეები, როგორც ძმა,
ასე ბრუნდება დარგვა და კრეფა, სადაც თქვენ შეარჩიო 2 და შემდეგ მცენარეთა 1,
აქ რომ 1 რომ თქვენ ქარხანა მშობელი 2 შვილი რომ თქვენ აიყვანეს.
ასეა, მაშინ თქვენი ბოლოს შედეგი იქნება ერთი ხე თქვენს ტყეში.
ასე თქვენ ავაშენოთ თქვენი ხე.
>> არსებობს რამდენიმე რამ, რომ შეიძლება გადასვლა არასწორი აქ
რადგან ჩვენ საქმე გვაქვს ახალ ხეები და საქმე მაჩვენებლებისა და რამ, როგორიცაა, რომ.
სანამ როცა საქმე გვქონდა პოინტერები,
როდესაც ჩვენ malloc'd გვინდოდა დარწმუნდით რომ იგი არ დაგვაბრუნონ NULL მაჩვენებელი ღირებულება.
ამრიგად, რამდენიმე ნაბიჯები ამ პროცესში იქ ვაპირებთ იყოს რამდენიმე შემთხვევა
სადაც თქვენი პროგრამა ვერ ჩავარდება.
რა გსურთ გააკეთოთ თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ გაუმკლავდეს იმ შეცდომებს,
და სპეც ნათქვამია გაუმკლავდეს მათ gracefully,
ამიტომ მინდა ამობეჭდოთ შეტყობინება მომხმარებლის ეუბნებოდა მათ, თუ რატომ პროგრამა დაეტოვებინა
და შემდეგ სწრაფად დატოვა იგი.
ამისათვის შეცდომის გამოტანას, გვახსოვდეს, რომ გსურთ შეამოწმეთ იგი
თითოეული დრო, რომ იქ შეიძლება იყოს უკმარისობა.
თითოეული დრო, რომ თქვენ მიღების ახალი კურსორი
თქვენ გვინდა დავრწმუნდეთ, რომ წარმატებული.
სანამ რასაც ჩვენ გამოყენებული უნდა გააკეთოთ მიიღოს ახალი კურსორი და malloc ის,
და მაშინ ჩვენ შეამოწმოს თუ არა, რომ კურსორი არის NULL.
ასე რომ იქნება გარკვეული შემთხვევები, როდესაც თქვენ შეგიძლიათ უბრალოდ რომ,
მაგრამ ზოგჯერ თქვენ რეალურად მოუწოდებდა ფუნქცია
და შიგნით რომ ფუნქცია, რომ ერთი რომ აკეთებს mallocing.
ამ შემთხვევაში, თუკი ჩვენ ვიხსენებთ ზოგიერთი ფუნქციების კოდი,
ზოგი მათგანი ლოგიკური ფუნქციები.
In რეზიუმე შემთხვევაში, თუ გვაქვს ლოგიკური ფუნქცია მოუწოდა foo,
ძირითადად, შეიძლება ვივარაუდოთ, რომ გარდა აკეთებს რასაც foo აკეთებს,
რადგან ლოგიკური ფუნქცია, ის დააბრუნებს true ან false -
ჭეშმარიტია თუ წარმატებული, ცრუ თუ არა.
ასე რომ ჩვენ გვინდა შევამოწმოთ თუ არა დაბრუნების ღირებულება foo არის ჭეშმარიტი ან ცრუ.
თუ ეს ყალბი, რაც იმას ნიშნავს, რომ ჩვენ ვაპირებთ გსურთ ბეჭდვა რაღაც გაგზავნა
და შემდეგ დატოვა პროგრამა.
რაც ჩვენ გვსურს რომ არის შეამოწმოს დაბრუნების ღირებულება foo.
თუ foo დააბრუნებს false, მაშინ ჩვენ ვიცით, რომ შეგვექმნა რაღაც შეცდომა
და ჩვენ გვჭირდება დატოვა ჩვენი პროგრამა.
გზა ამის არის აქვს მდგომარეობა სადაც ფაქტობრივი ფუნქცია თავისთავად თქვენი მდგომარეობა.
Say foo იღებს in x.
ჩვენ შეგვიძლია აქვს როგორც პირობით, თუ (foo (x)).
ძირითადად, ეს ნიშნავს, რომ თუ ბოლომდე შესრულებაში foo ის დააბრუნებს ასეა,
მაშინ ჩვენ შეგვიძლია გავაკეთოთ, რადგან ფუნქცია უნდა შეაფასოს foo
რათა შეაფასოს მთელი მდგომარეობა.
ასე რომ მაშინ ასე შეგიძლიათ გააკეთოთ რაიმე, თუ ფუნქცია დააბრუნებს true და წარმატებული.
მაგრამ როდესაც თქვენ შეცდომა შემოწმება, თქვენ მხოლოდ გსურთ გასვლა, თუ თქვენი ფუნქცია დააბრუნებს false.
რა შეიძლება გავაკეთოთ მხოლოდ დაამატოთ == ყალბი ან უბრალოდ დაამატოთ bang თვალწინ იგი
და მაშინ აქვს, თუ (! foo).
ფარგლებში, რომ ორგანოს, რომ მდგომარეობა თქვენ ექნება ყველა შეცდომის გამოტანას,
ამიტომ მინდა, "შექმნა ვერ ამ ხეს" და შემდეგ დაბრუნდნენ 1 ან რამე მაგდაგვარს.
რა, რომ ასეა, თუმცა, ის არის, რომ მიუხედავად იმისა, foo დაბრუნდა ცრუ -
Say foo ბრუნდება ნამდვილი.
მერე შენ არ უნდა მოვუწოდებთ foo ერთხელ. სწორედ საერთო misconception.
რადგან ეს იყო თქვენს მდგომარეობა უკვე შეაფასა,
ასე რომ თქვენ უკვე გაქვთ შედეგი თუ თქვენ იყენებთ მიიღოს ხე ან რამე მაგდაგვარს
ან მცენარეული ან არჩევანი ან რამე.
ეს უკვე, რომ ღირებულება. უკვე შესრულებული.
ასე რომ სასარგებლო გამოიყენოს ლოგიკური ფუნქციების მდგომარეობა
რადგან თუ არა თქვენ ნამდვილად შეასრულოს ორგანოს მარყუჟის,
იგი ახორციელებს ფუნქციას მაინც.
>> ჩვენი მეორე ბოლო ნაბიჯი წერს შეტყობინება ფაილი.
ერთხელ ჩვენ ავაშენებთ Huffman ხე, მაშინ წერილობით შეტყობინება ფაილი საკმაოდ მარტივია.
ეს საკმაოდ მარტივია ახლა უბრალოდ მიჰყევით 0S და 1s.
და ა.შ. მიერ კონვენციის ჩვენ ვიცით, რომ Huffman ხე 0S მიუთითებს დაუტოვებიათ
და 1s მიუთითოს უფლება.
ასე რომ თუ თქვენ წაიკითხონ ნელ bit, ყოველ ჯერზე, რომ თქვენ გაქვთ 0
თქვენ დაიცვას მარცხენა ფილიალის, შემდეგ კი ყოველ დროს, თქვენ წაიკითხონ 1
თქვენ აპირებს დაიცვას უფლება ფილიალში.
და მაშინ ვაპირებთ გავაგრძელოთ სანამ არ მოხვდა ფოთოლი
რადგან ფოთლები იქნება დასასრულს ფილიალში.
როგორ შეგვიძლია ვუთხრათ თუ არა ჩვენ მოხვდა ფოთოლი თუ არა?
ჩვენ ვთქვით, სანამ.
[სტუდენტი] თუ მითითებები null. >> Yeah.
ჩვენ შეგვიძლია ვუთხრათ, თუ ჩვენ მოხვდა ფოთოლი თუ მითითებას ორივე მარცხენა და მარჯვენა ხეები არიან null.
Perfect.
ჩვენ ვიცით, რომ ჩვენ გვინდა, წაიკითხონ ნელ bit ჩვენს დათუნა დათო დავით მგელაძე ფაილი.
როგორც დავინახეთ, მანამდე dump.c, რაც გააკეთეს არის მათ წაიკითხონ ნელ bit შევიდა დათუნა დათო დავით მგელაძე ფაილი
და მხოლოდ დაბეჭდილი რა იმ ბიტი იყო.
ჩვენ არ ვაპირებთ უნდა აკეთებს, რომ. ჩვენ ვაპირებთ იყოს თავისსავე რომ ცოტა უფრო რთული.
მაგრამ რა შეგვიძლია გავაკეთოთ არის შეგვიძლია ცოტა კოდი რომ წერია, რათა bit.
აქ მთელი bit წარმოადგენს მიმდინარე ცოტა რომ ჩვენ შესახებ.
ეს ზრუნავს iterating ყველა ბიტი ფაილში სანამ არ მოხვდა ფაილის ბოლოში.
დაყრდნობით, რომ, მაშინ თქვენ აპირებს სურთ გარკვეული სახის iterator
to traverse თქვენი ხე.
და შემდეგ ეფუძნება თუ არა ცოტა არის 0 ან 1,
თქვენ აპირებს გვინდა ან გადაადგილება რომ iterator მარცხნივ ან გადაიტანთ უფლება
ყველა გზა სანამ არ მოხვდა ფოთოლი, ამიტომ ყველა გზა მანამდე კვანძის რომ თქვენ შესახებ
არ აღვნიშნო, რომ აღარ კვანძების.
რატომ ვერ ვაკეთებთ ამას Huffman ფაილის მაგრამ არა Morse კოდი?
რადგან Morse კოდი იქ ცოტა გაურკვევლობა.
ჩვენ შეიძლება იყოს, როგორიცაა, OH დაველოდოთ, ჩვენ მოხვდა წერილში გზაზე, იქნებ ეს ჩვენი წერილი,
ხოლო თუ ჩვენ გაგრძელდა ოდნავ აღარ, მაშინ ჩვენ არ მოხვდა სხვა წერილში.
მაგრამ ეს არ მოხდება იმ Huffman კოდირების,
ამიტომ ჩვენ შეგვიძლია დანარჩენი დავრწმუნდი, რომ ერთადერთი გზა, რომ ჩვენ ვაპირებთ მოხვდა ხასიათი
არის თუ რომ კვანძის მარცხენა და მარჯვენა ბავშვები null.
>> და ბოლოს, გვინდა უფასო ყველა ჩვენი მეხსიერება.
ჩვენ გვინდა, რომ ორივე ახლოს დათუნა დათო დავით მგელაძე ფაილი რომ ჩვენ საქმე გვაქვს
ასევე ამოიღონ ყველა ხეები ჩვენს ტყეში.
ეფუძნება თქვენი განხორციელება, თქვენ ალბათ აპირებს მინდა მოვუწოდო ამოიღონ ტყის
ნაცვლად რეალურად გადის ყველა ხეები თავს.
მაგრამ თუ გააკეთა რაიმე დროებითი ხეები, თქვენ გსურთ, რომ გასათავისუფლებლად.
თქვენ იცით თქვენი კოდი საუკეთესო, ასე რომ თქვენ იცით, სადაც თქვენ გამოყოფის მეხსიერება.
და ასე თუ, იწყება კი კონტროლის F'ing ამისთვის malloc,
ხედავს ნებისმიერ malloc და დარწმუნებულიყო, რომ თქვენ უფასო ყველა იმ
მაგრამ მაშინ უბრალოდ გადის თქვენი კოდი,
გაგება სადაც თქვენ ალბათ გამოყოფილი მეხსიერება.
ჩვეულებრივ შეიძლება უბრალოდ, ვამბობთ, "დასასრულს ფაილის მე უბრალოდ აპირებს ამოიღონ ტყის ჩემი ტყის,"
ასე ძირითადად მიანიშნა, რომ მეხსიერება, უფასო, რომ,
"და შემდეგ მე ასევე აპირებს დახუროს ფაილი და შემდეგ ჩემი პროგრამა აპირებს დატოვა."
მაგრამ ის არის, რომ მხოლოდ დრო, რომ თქვენი პროგრამა დაჭრის?
არა, რადგან ხანდახან შეიძლება ყოფილიყო შეცდომა, რაც მოხდა.
იქნებ ვერ გახსნა ფაილი ან ჩვენ ვერ სხვა ხე
ან რაღაც შეცდომა მოხდა მეხსიერების გამოყოფის პროცესს და ამიტომ დაბრუნდა null.
შეცდომა მოხდა და მერე დავბრუნდით და გასვლა.
ასე რომ მაშინ გვინდა დავრწმუნდეთ, რომ ნებისმიერი ვადებში რომ თქვენი პროგრამას შეუძლია დატოვა,
გსურთ უფასო ყველა თქვენი მეხსიერება არსებობს.
ეს არ არის მხოლოდ იქნება ზუსტად იმ დასასრულს მთავარი ფუნქცია, რომ თავი დაანებონ თქვენი კოდი.
გსურთ ვიხსენებთ ყველა ინსტანციის, რომ თქვენი კოდი პოტენციურად შესაძლოა დაბრუნდეს ნაადრევად
და მაშინ უფასო რასაც მეხსიერების აზრი.
ამბობენ თქვენ დაურეკა მიიღოს ტყის და რომ დაბრუნდა ყალბი.
მაშინ თქვენ ალბათ არ გადაიტანოთ თქვენი ტყის
რადგან არ აქვს ტყის ამჟამად.
მაგრამ ყველა წერტილი კოდი, სადაც თქვენ შეიძლება დაბრუნდეს ნაადრევად
თქვენ გვინდა დავრწმუნდეთ, რომ თქვენ გასათავისუფლებლად შესაძლო მეხსიერება.
>> ასე რომ, როდესაც ჩვენ საქმე გამონთავისუფლების მეხსიერება და პოტენციური მქონე ტბები,
ჩვენ გვინდა არა მხოლოდ ჩვენი გადაწყვეტილება და ჩვენი ლოგიკა
არამედ გამოიყენოს Valgrind განსაზღვრის ჩვენ გათავისუფლდეს ყველა ჩვენი მეხსიერების სწორად თუ არა.
თქვენ შეგიძლიათ ან აწარმოებს Valgrind on Puff და შემდეგ თქვენ უნდა ასევე მსგავ
უფლება ხმების ბრძანება ხაზი არგუმენტები Valgrind.
თქვენ შეგიძლიათ აწარმოებს, მაგრამ გამომავალი ოდნავ cryptic.
ჩვენ მიღებული bit გამოიყენება იგი Speller, მაგრამ ჩვენ ჯერ კიდევ უფრო მეტი დახმარება,
ასე შემდეგ გაშვებული იგი კიდევ რამდენიმე დროშები მოსწონს გაჟონვის-შეამოწმოთ = სრული,
რომ სავარაუდოდ მოგვცემს უფრო გამოსადეგი გამომავალი on Valgrind.
>> შემდეგ კიდევ ერთი სასარგებლო tip როცა თქვენ გამართვის არის diff ბრძანება.
შეგიძლიათ პერსონალის განხორციელების დათუნა დათო დავით მგელაძე, აწარმოებს რომ ტექსტური ფაილი,
და შემდეგ დაბეჭდავს მას ორობითი ფაილი, ორობითი დათუნა დათო დავით მგელაძე ფაილი, უნდა იყოს კონკრეტული.
მაშინ, თუ თქვენ აწარმოებს თქვენი საკუთარი puff რომ ორობითი ფაილი,
მაშინ იდეალურად, თქვენი outputted ტექსტური ფაილი იქნება იდენტური
თავდაპირველი ერთი, რომ თქვენ გაიარა სისტემაში
აქ მე გამოყენებით hth.txt როგორც მაგალითად, და ეს ერთი ისაუბრა თქვენს სპეც.
სწორედ სიტყვასიტყვით უბრალოდ HTH და შემდეგ სტრიქონების გადატანით.
მაგრამ ნამდვილად გრძნობენ თავისუფალი და თქვენ ნამდვილად წახალისებული გამოიყენოს აღარ მაგალითები
თქვენი ტექსტური ფაილი.
>> თქვენ შეგიძლიათ კიდევ მიიღოს ესროლეს იქნებ compressing და შემდეგ decompressing
ზოგიერთი ფაილი, რომელიც თქვენ გამოიყენება Speller მოსწონს ომისა და მშვიდობის
ან Jane Austen ან რამე მაგდაგვარს - იქნებოდა სახის cool - ან Austin Powers,
სახის საქმე უფრო დიდი ფაილი, რადგან ჩვენ არ მოხდება ქვემოთ იგი
თუ ჩვენ გამოიყენება შემდეგი ინსტრუმენტი აქ, ls-l.
ჩვენ გამოიყენება ls, რომლებიც ძირითადად ჩამოთვლილია ყველა შინაარსი ჩვენს მიმდინარე დირექტორია.
გადადის დროშა-მ რეალურად აჩვენებს ზომა იმ ფაილი.
თუ თქვენ გავლა pset Spec, ის რეალურად დადის თქვენ მეშვეობით შექმნით ორობითი ფაილი,
საქართველოს huffing, და ხედავთ, რომ ძალიან მცირე ფაილები
სივრცეში ღირებულება compressing და თარგმნა ყველა ამ ინფორმაციის
ყველა სიხშირეებს და რამ, როგორიცაა, რომ outweighs ფაქტობრივი სარგებელი
საქართველოს compressing ფაილის პირველი ადგილი.
მაგრამ თუ თქვენ გაუშვით ზოგიერთ აღარ ტექსტური ფაილები, მაშინ თქვენ ალბათ ხედავთ, რომ თქვენ დაიწყოს მიიღოს გარკვეული სარგებელი
წელს compressing იმ ფაილებს.
>> და მაშინ საბოლოოდ, ჩვენ გვაქვს ჩვენი ძველი PAL GDB, რომელიც აუცილებლად აპირებს მოდის მოსახერხებელი ძალიან.
>> გვაქვს რაიმე შეკითხვა დათუნა დათო დავით მგელაძე ხეები ან პროცესის ალბათ მიღების ხეები
ან ნებისმიერ სხვა შეკითხვებს Huff'n Puff?
Okay. მე დარჩენა გარშემო ამისთვის bit.
>> ყველას დიდი მადლობა. ეს იყო Walkthrough 6. და კარგი იღბალი.
>> [CS50.TV]