[Powered by Google Translate] [Walkthrough - Masalah Set 6]
[Zamyla Chan - Harvard University]
[Ini adalah CS50. - CS50.TV]
>> Halo, semua orang, dan selamat datang Walkthrough 6: Puff Huff'n.
Dalam Puff Huff'n apa yang kita lakukan akan berurusan dengan file terkompresi Huffman
dan kemudian terengah-engah kembali ke atas, sehingga dekompresi itu,
sehingga kita dapat menerjemahkan dari yang 0s dan 1s pengguna mengirimkan kami
dan mengubahnya kembali ke teks asli.
Pset 6 akan menjadi cukup keren karena Anda akan melihat beberapa alat
yang digunakan dalam pset 4 dan 5 pset dan jenis menggabungkan mereka ke dalam 1 konsep yang cukup rapi
ketika Anda datang untuk berpikir tentang hal itu.
>> Juga, bisa dibilang, pset 4 dan 5 adalah yang paling menantang psets bahwa kita harus tawarkan.
Jadi mulai sekarang, kita memiliki pset 1 lebih di C,
dan kemudian setelah itu kita akan melanjutkan ke pemrograman web.
Jadi selamat dirimu untuk mendapatkan lebih dari punuk terberat dalam CS50.
>> Pindah untuk Puff Huff'n, toolbox kami untuk pset ini akan menjadi pohon Huffman,
sehingga pemahaman tidak hanya bekerja bagaimana biner pohon tetapi juga secara khusus Huffman pohon,
bagaimana mereka dibangun.
Dan kemudian kita akan memiliki banyak kode distribusi di pset ini,
dan kami akan datang untuk melihat bahwa sebenarnya beberapa kode
kita tidak mungkin bisa memahami lagi,
sehingga mereka akan menjadi c file., tapi kemudian menyertainya h file.
akan memberi kita cukup memahami bahwa kita butuhkan sehingga kita tahu bagaimana fungsi-fungsi bekerja
atau setidaknya apa yang mereka lakukan - input dan output mereka -
bahkan jika kita tidak tahu apa yang terjadi di kotak hitam
atau tidak mengerti apa yang terjadi di dalam kotak hitam.
Dan akhirnya, seperti biasa, kita berhadapan dengan struktur data baru,
tipe tertentu dari node yang menunjuk ke hal-hal tertentu,
dan jadi di sini memiliki pena dan kertas tidak hanya untuk proses desain
dan ketika Anda mencoba untuk mencari tahu bagaimana pset Anda harus bekerja
tetapi juga selama debugging.
Anda dapat memiliki GDB bersama pena dan kertas saat Anda mencatat apa nilai-nilai yang,
di mana panah yang menunjuk, dan hal-hal seperti itu.
>> Pertama mari kita lihat pohon Huffman.
Pohon Huffman adalah pohon biner, yang berarti bahwa setiap node hanya memiliki 2 anak.
Dalam pohon Huffman karakteristik adalah bahwa nilai-nilai yang paling sering
diwakili oleh bit paling sedikit.
Kami melihat dalam contoh ceramah kode Morse, yang jenis konsolidasi beberapa surat.
Jika Anda mencoba untuk menerjemahkan A atau E, misalnya,
Anda menerjemahkan yang sering, jadi daripada harus menggunakan set lengkap bit
dialokasikan untuk tipe data yang biasa, Anda kompres ke sedikit,
dan kemudian surat-surat yang diwakili kurang sering diwakili dengan bit lebih lama
karena Anda mampu bahwa ketika Anda menimbang frekuensi yang huruf tersebut akan ditampilkan.
Kami memiliki ide yang sama di sini di pohon Huffman
di mana kita membuat rantai, semacam jalan untuk sampai ke karakter tertentu.
Dan kemudian karakter yang memiliki frekuensi yang paling
akan diwakili dengan bit paling sedikit.
>> Cara yang Anda membangun pohon Huffman
adalah dengan menempatkan semua karakter yang muncul dalam teks
dan menghitung frekuensi, seberapa sering mereka muncul.
Ini bisa berupa hitungan berapa kali huruf tersebut akan ditampilkan
atau mungkin persentase dari semua karakter berapa banyak masing-masing muncul.
Dan jadi apa yang Anda lakukan adalah setelah Anda memiliki semua itu keluar dipetakan,
maka Anda mencari 2 frekuensi terendah dan kemudian bergabung dengan mereka sebagai saudara kandung
mana maka simpul orangtua memiliki frekuensi yang merupakan jumlah dari 2 anak nya.
Dan kemudian Anda dengan konvensi mengatakan bahwa node kiri,
Anda mengikuti bahwa dengan mengikuti cabang 0,
dan kemudian simpul paling kanan adalah cabang 1.
Seperti yang kita lihat dalam kode Morse, yang satu gotcha adalah bahwa jika Anda memiliki hanya bip bip dan
itu ambigu.
Ini bisa berupa 1 huruf atau bisa menjadi urutan 2 huruf.
Dan jadi apa Huffman pohon dilakukan adalah karena dengan sifat karakter
atau akhir kami yang sebenarnya karakter menjadi node terakhir pada cabang -
kita merujuk kepada mereka sebagai daun - berdasarkan yang ada tidak bisa ambiguitas
dalam hal mana surat Anda mencoba untuk mengkodekan dengan rangkaian bit
karena tempat sepanjang bit yang mewakili 1 huruf
akan Anda temui lagi seluruh surat, dan tidak akan ada kebingungan di sana.
Tapi kita akan pergi ke contoh bahwa kalian benar-benar dapat melihat bahwa
bukannya kita hanya mengatakan bahwa itu benar.
>> Mari kita lihat contoh sederhana dari pohon Huffman.
Aku punya string di sini yang 12 karakter.
Saya memiliki 4 Seperti, 6 B, dan 2 Cs.
Langkah pertama saya akan menghitung.
Berapa kali A muncul? Tampaknya 4 kali dalam string.
B muncul 6 kali, dan C muncul 2 kali.
Tentu, aku akan mengatakan saya menggunakan B paling sering,
jadi saya ingin mewakili B dengan jumlah paling sedikit bit, jumlah paling sedikit 0s dan 1s.
Dan kemudian aku juga akan berharap C untuk meminta paling jumlah 0s dan 1s juga.
Pertama apa yang saya lakukan di sini adalah saya menempatkan mereka dalam urutan dalam hal frekuensi.
Kita melihat bahwa C dan A, mereka adalah 2 kami frekuensi terendah.
Kami membuat simpul orangtua, dan simpul orangtua tidak memiliki surat yang terkait dengan itu,
tetapi tidak memiliki frekuensi, yang merupakan penjumlahan.
Jumlahnya menjadi 2 + 4, yaitu 6.
Kemudian kita mengikuti cabang kiri.
Jika kita berada di simpul 6, maka kita akan mengikuti 0 untuk sampai ke C
dan kemudian 1 untuk sampai ke A.
Jadi sekarang kita memiliki 2 node.
Kami memiliki nilai 6 dan kemudian kita juga memiliki node lain dengan nilai 6.
Dan sehingga mereka 2 tidak hanya 2 terendah tetapi juga hanya 2 yang tersisa,
jadi kami bergabung dengan mereka oleh orang tua lain, dengan jumlah itu menjadi 12.
Jadi di sini kita memiliki pohon Huffman kami
di mana untuk sampai ke B, yang hanya akan menjadi bit 1
dan kemudian untuk mendapatkan ke A kita akan memiliki 01 dan kemudian C memiliki 00.
Jadi di sini kita melihat bahwa pada dasarnya kita mewakili karakter ini dengan baik 1 atau 2 bit
di mana B, seperti yang diperkirakan, memiliki sedikit.
Dan kemudian kami diharapkan C untuk memiliki paling, tapi karena itu seperti pohon kecil Huffman,
maka A juga diwakili oleh 2 bit sebagai lawan suatu tempat di tengah.
>> Hanya untuk pergi ke lain contoh sederhana pohon Huffman,
Katakanlah Anda memiliki string "Hello."
Apa yang Anda lakukan adalah pertama-tama Anda akan mengatakan berapa kali H muncul dalam hal ini?
H muncul sekali dan kemudian e muncul sekali dan kemudian kita memiliki l muncul dua kali
dan o muncul sekali.
Dan begitu kemudian kita berharap yang surat untuk diwakili oleh sedikitnya jumlah bit?
[Mahasiswa] l. >> L. Ya. l benar.
Kami berharap l untuk diwakili oleh sedikitnya jumlah bit
karena aku digunakan paling dalam string "Hello."
Apa yang akan saya lakukan sekarang adalah menarik keluar node tersebut.
Saya memiliki 1, yaitu H, dan kemudian lagi 1, yaitu e, dan kemudian 1, yaitu o -
sekarang saya menempatkan mereka dalam rangka - dan kemudian 2, yaitu l.
Lalu aku mengatakan cara yang saya membangun pohon Huffman adalah untuk menemukan 2 node dengan frekuensi paling
dan membuat mereka saudara dengan membuat simpul orangtua.
Di sini kita memiliki 3 node dengan frekuensi terendah. Mereka semua 1.
Jadi di sini kita memilih mana yang kita akan menghubungkan terlebih dahulu.
Katakanlah saya memilih H dan e.
Jumlah 1 + 1 adalah 2, tapi node ini tidak memiliki surat yang terkait dengannya.
Itu hanya memegang nilai.
Sekarang kita melihat 2 frekuensi terendah berikutnya.
Itu 2 dan 1. Itu bisa menjadi salah satu dari mereka 2, tapi aku akan memilih satu ini.
Jumlahnya adalah 3.
Dan akhirnya, saya hanya memiliki 2 kiri, sehingga kemudian yang menjadi 5.
Maka di sini, seperti yang diharapkan, jika saya mengisi pengkodean untuk itu,
1s selalu cabang kanan dan 0s adalah yang kiri.
Lalu kami memiliki l diwakili oleh hanya 1 bit dan kemudian o oleh 2
dan kemudian e oleh 2 dan kemudian H jatuh ke 3 bit.
Jadi Anda dapat mengirimkan pesan ini "Hello" bukan benar-benar menggunakan karakter
dengan hanya 0s dan 1s.
Namun, ingat bahwa dalam beberapa kasus kita memiliki hubungan dengan frekuensi kami.
Kita bisa bergabung dengan baik dan H o pertama mungkin.
Atau kemudian ketika kami memiliki l diwakili oleh 2
serta bergabung dengan salah satu diwakili oleh 2, kita bisa dikaitkan salah satu.
>> Dan jadi ketika Anda mengirim 0s dan 1s, yang benar-benar tidak menjamin
bahwa penerima sepenuhnya dapat membaca pesan Anda langsung dari kelelawar
karena mereka mungkin tidak tahu mana keputusan yang Anda buat.
Jadi ketika kita sedang berhadapan dengan kompresi Huffman,
entah bagaimana kita harus memberitahu penerima pesan kita bagaimana kita memutuskan -
Mereka perlu tahu beberapa jenis informasi tambahan
di samping pesan terkompresi.
Mereka perlu memahami apa pohon benar-benar tampak seperti,
bagaimana kita benar-benar membuat keputusan tersebut.
>> Di sini kami hanya melakukan contoh berdasarkan pada hitungan yang sebenarnya,
tapi kadang-kadang Anda juga dapat memiliki pohon Huffman
berdasarkan frekuensi di mana huruf muncul, dan itu adalah proses yang sama persis.
Di sini aku mengungkapkan hal itu dalam hal persentase atau pecahan,
dan jadi di sini hal yang sama.
Saya menemukan 2 terendah, jumlah mereka, 2 terendah berikutnya, jumlah mereka,
sampai aku memiliki pohon penuh.
Meskipun kita bisa melakukannya baik cara, ketika kita sedang berhadapan dengan persentase,
itu berarti kita membagi hal-hal dan berurusan dengan desimal atau lebih tepatnya mengapung
kalau kita berpikir tentang struktur data dari kepala.
Apa yang kita ketahui tentang mengapung?
Apa masalah umum ketika kita sedang berhadapan dengan mengapung?
[Mahasiswa] aritmatika tidak tepat. >> Ya. Ketidaktepatan.
Karena ketidaktepatan floating point, untuk pset ini sehingga kita pastikan
bahwa kita tidak kehilangan nilai-nilai, maka kita benar-benar akan berurusan dengan hitungan.
Jadi jika Anda adalah untuk memikirkan simpul Huffman, jika Anda melihat kembali ke struktur di sini,
jika Anda melihat yang hijau itu memiliki frekuensi yang terkait dengan itu
serta merujuk ke node ke kiri serta node ke kanan.
Dan kemudian yang merah ada juga memiliki karakter yang terkait dengan mereka.
Kami tidak akan membuat yang terpisah untuk orang tua dan kemudian node akhir,
yang kita sebut sebagai daun, melainkan mereka hanya akan memiliki nilai NULL.
Untuk setiap node kita akan memiliki karakter, simbol bahwa node yang mewakili,
maka frekuensi serta pointer ke anak kiri serta anak kanan.
Daun, yang berada di bagian paling bawah, juga akan memiliki pointer simpul
ke kiri dan ke kanan mereka, tapi karena nilai-nilai tersebut tidak menunjuk ke node yang sebenarnya,
apa yang akan menjadi nilai mereka? >> [Mahasiswa] NULL. >> NULL. Tepat.
Berikut adalah contoh bagaimana Anda mungkin mewakili frekuensi dalam mengapung,
tapi kita akan berurusan dengan itu dengan bilangan bulat,
jadi semua saya lakukan adalah mengubah jenis data yang ada.
>> Mari kita pergi ke sedikit lebih dari contoh yang kompleks.
Tapi sekarang bahwa kami telah melakukan yang sederhana, itu hanya proses yang sama.
Anda menemukan 2 frekuensi terendah, jumlah frekuensi
dan itulah frekuensi baru simpul orangtua Anda,
yang kemudian menunjuk ke kiri dengan cabang 0 dan kanan dengan cabang 1.
Jika kita memiliki string "Ini adalah cs50," maka kita menghitung berapa kali ini T disebutkan,
h disebutkan, i, s, c, 5, 0.
Lalu apa yang saya lakukan di sini adalah dengan node merah saya hanya ditanam,
Aku bilang aku akan memiliki karakter ini akhirnya di bawah pohon saya.
Bagi para akan semua daun.
Lalu apa yang saya lakukan adalah saya diurutkan berdasarkan frekuensi mereka dalam urutan,
dan ini sebenarnya adalah cara yang kode pset melakukannya
itu macam dengan frekuensi dan kemudian abjad.
Sehingga memiliki angka pertama dan kemudian menurut abjad frekuensi.
Lalu apa yang akan saya lakukan adalah saya akan menemukan 2 terendah. Itulah 0 dan 5.
Saya akan jumlah mereka, dan itu 2. Lalu aku akan terus, menemukan 2 terendah berikutnya.
Mereka adalah 1s dua, dan kemudian orang-orang menjadi 2 juga.
Sekarang aku tahu bahwa langkah berikutnya saya akan bergabung dengan angka terendah,
yang merupakan T, 1, dan kemudian memilih salah satu node yang memiliki 2 sebagai frekuensi.
Jadi di sini kita memiliki 3 pilihan.
Apa yang akan saya lakukan untuk slide hanya visual mengatur ulang mereka untuk Anda
sehingga Anda dapat melihat bagaimana saya membangun itu.
Apa kode dan kode distribusi Anda akan melakukan akan bergabung dengan salah satu T
dengan node 0 dan 5.
Jadi bahwa jumlah ke 3, dan kemudian kita melanjutkan proses.
The 2 dan 2 sekarang adalah yang terendah, sehingga kemudian mereka jumlah ke 4.
Semua orang mengikutinya begitu jauh? Oke.
Kemudian setelah itu kita memiliki 3 dan 3 yang perlu ditambahkan,
jadi sekali lagi aku hanya beralih sehingga Anda dapat melihat secara visual sehingga tidak terlalu berantakan.
Lalu kami memiliki 6, dan kemudian langkah terakhir kita sekarang bahwa kita hanya memiliki 2 node
kita menjumlahkan untuk membuat akar pohon kita, yaitu 10.
Dan nomor 10 masuk akal karena simpul masing-masing diwakili,
nilai mereka, jumlah frekuensi mereka, adalah berapa kali mereka muncul dalam string,
dan kemudian kita memiliki 5 karakter dalam string kami, sehingga masuk akal.
Jika kita melihat pada bagaimana kita benar-benar akan menyalinnya,
seperti yang diharapkan, i dan s, yang muncul paling sering
diwakili oleh jumlah paling sedikit bit.
>> Hati-hati di sini.
Dalam pohon Huffman kasus benar-benar penting.
S huruf besar berbeda dari s huruf kecil.
Jika kita memiliki "Ini adalah CS50" dengan huruf kapital, maka s huruf kecil hanya akan muncul dua kali,
akan menjadi node dengan 2 sebagai nilainya, dan kemudian huruf S hanya akan sekali.
Jadi pohon Anda akan mengubah struktur karena Anda benar-benar memiliki daun ekstra di sini.
Tapi jumlah itu masih akan menjadi 10.
Itulah apa yang kita benar-benar akan memanggil checksum,
penambahan semua penghitungan.
>> Sekarang kita telah membahas pohon Huffman, kita bisa menyelam ke Puff Huff'n, pset tersebut.
Kita akan mulai dengan bagian pertanyaan,
dan ini akan membuat Anda terbiasa dengan pohon-pohon biner dan cara mengoperasikan sekitar bahwa:
node menggambar, membuat struct sendiri typedef Anda untuk node,
dan melihat bagaimana Anda bisa memasukkan ke dalam pohon biner, salah satu yang diurutkan,
melintasi itu, dan hal seperti itu.
Bahwa pengetahuan pasti akan membantu Anda ketika Anda menyelam ke bagian Puff Huff'n
dari pset tersebut.
Dalam edisi standar pset, tugas Anda adalah untuk menerapkan Puff,
dan dalam versi hacker tugas Anda adalah untuk menerapkan Huff.
What Huff dilakukannya itu dibutuhkan teks dan kemudian menerjemahkannya ke dalam 0s dan 1s,
sehingga proses yang kita lakukan di atas mana kita menghitung frekuensi
dan kemudian membuat pohon dan kemudian berkata, "Bagaimana cara mendapatkan T?"
T diwakili oleh 100, hal-hal seperti itu,
dan kemudian Huff akan mengambil teks dan kemudian output yang biner.
Tapi juga karena kita tahu bahwa kita ingin mengizinkan penerima kami pesan
untuk menciptakan pohon yang sama persis, itu juga mencakup informasi tentang penghitungan frekuensi.
Kemudian dengan Puff kita diberi sebuah file biner 0s dan 1s
dan diberikan juga informasi tentang frekuensi.
Kami menerjemahkan semua orang kembali 0s dan 1s menjadi pesan asli yang,
jadi kita dekompresi itu.
Jika Anda melakukan edisi standar, Anda tidak perlu untuk mengimplementasikan Huff,
demikian maka Anda hanya dapat menggunakan implementasi staf Huff.
Ada petunjuk di spec tentang cara untuk melakukan itu.
Anda dapat menjalankan pelaksanaan staf Huff pada sebuah file teks tertentu
dan kemudian menggunakan output itu sebagai masukan Anda untuk Puff.
>> Seperti yang saya sebutkan sebelumnya, kita memiliki banyak kode distribusi untuk yang satu ini.
Aku akan mulai pergi melalui itu.
Aku akan menghabiskan sebagian besar waktu di. File h
karena dalam file c., karena kita memiliki. h
dan yang memberikan kita dengan prototipe dari fungsi,
kita tidak sepenuhnya perlu memahami persis -
Jika Anda tidak mengerti apa yang terjadi di dalam file c., Maka jangan khawatir terlalu banyak,
tapi pasti mencoba untuk melihat karena mungkin memberikan beberapa petunjuk
dan itu berguna untuk membiasakan diri membaca kode orang lain.
>> Melihat huffile.h, dalam komentar yang menyatakan lapisan abstraksi untuk Huffman-kode file.
Jika kita turun, kita melihat bahwa ada maksimal 256 simbol bahwa kita mungkin perlu kode untuk.
Ini mencakup semua huruf abjad ini - huruf besar dan huruf kecil -
dan kemudian simbol dan nomor, dll
Maka di sini kita memiliki angka ajaib mengidentifikasi file-kode Huffman.
Dalam kode Huffman mereka akan memiliki angka ajaib tertentu
terkait dengan header.
Ini mungkin terlihat seperti hanya nomor acak magis,
tetapi jika Anda benar-benar menerjemahkannya ke ASCII, maka benar-benar merinci HUFF.
Di sini kita memiliki struct untuk file Huffman-encoded.
Ada semua karakteristik yang berhubungan dengan file Huff.
Kemudian di sini kita memiliki header untuk file Huff, jadi kita menyebutnya Huffeader
bukannya menambahkan h ekstra karena kedengarannya sama pula.
Lucu.
Kami memiliki angka ajaib yang terkait dengannya.
Jika itu file Huff yang sebenarnya, itu akan menjadi nomor di atas, satu ini ajaib.
Dan kemudian akan memiliki array.
Jadi untuk setiap simbol, yang ada 256,
itu akan daftar apa frekuensi simbol-simbol berada dalam file Huff.
Dan akhirnya, kita memiliki checksum untuk frekuensi,
yang seharusnya menjadi jumlah frekuensi tersebut.
Jadi itulah yang Huffeader adalah.
Lalu kami memiliki beberapa fungsi yang mengembalikan bit berikutnya dalam file Huff
serta menulis sedikit ke file Huff, dan maka fungsi ini di sini, hfclose,
yang benar-benar menutup file Huff.
Sebelumnya, kita berurusan dengan lurus just fclose,
tetapi ketika Anda memiliki file Huff, bukan fclosing itu
apa yang Anda benar-benar akan lakukan adalah hfclose dan hfopen itu.
Mereka adalah fungsi spesifik ke file Huff bahwa kita akan berurusan dengan.
Maka di sini kita membaca di header dan kemudian menulis header.
>> Hanya dengan membaca file. H kita bisa mendapatkan jenis rasa apa file Huff mungkin,
apa karakteristik itu, tanpa benar-benar masuk ke huffile.c tersebut,
yang, jika kita menyelam dalam, akan menjadi sedikit lebih kompleks.
Ia memiliki semua file I / O di sini berurusan dengan pointer.
Di sini kita melihat bahwa ketika kita sebut hfread, misalnya, itu masih berurusan dengan fread.
Kami tidak menyingkirkan fungsi-fungsi sepenuhnya, tapi kami mengirim mereka untuk dijaga
dalam berkas Huff bukannya melakukan semua itu sendiri.
Anda dapat merasa bebas untuk memindai melalui ini jika Anda penasaran
dan pergi dan kupas lapisan kembali sedikit.
>> File berikutnya yang kita akan lihat adalah tree.h.
Sebelum di Walkthrough meluncur kami katakan kami berharap simpul Huffman
dan kami membuat simpul struct typedef.
Kami berharap untuk memiliki simbol, frekuensi, dan kemudian 2 bintang simpul.
Dalam hal ini apa yang kita lakukan ini pada dasarnya sama
kecuali bukan simpul kita akan memanggil mereka pohon.
Kami memiliki fungsi bahwa ketika Anda menelepon membuat pohon itu kembali Anda pointer pohon.
Kembali ke Speller, ketika Anda sedang membuat node baru
Anda mengatakan simpul * kata baru = malloc (sizeof) dan hal-hal seperti itu.
Pada dasarnya, mktree akan berurusan dengan itu untuk Anda.
Demikian pula, ketika Anda ingin menghapus sebuah pohon,
jadi itu pada dasarnya membebaskan pohon ketika Anda selesai dengan itu,
bukannya eksplisit panggilan gratis pada itu, Anda benar-benar hanya akan menggunakan fungsi rmtree
di mana Anda lulus dalam pointer ke pohon itu dan kemudian tree.c akan mengurus itu untuk Anda.
>> Kami melihat ke tree.c.
Kami berharap fungsi yang sama kecuali untuk melihat implementasi serta.
Seperti yang kita harapkan, ketika Anda menelepon mktree itu mallocs ukuran pohon ke pointer,
menginisialisasi semua nilai dengan nilai NULL, sehingga 0s atau NULLs,
dan kemudian mengembalikan pointer ke pohon bahwa Anda baru saja malloc'd kepada Anda.
Di sini ketika Anda menelepon menghapus pohon pertama kali memastikan bahwa Anda tidak membebaskan ganda.
Hal ini memastikan bahwa Anda benar-benar memiliki pohon yang ingin Anda hapus.
Di sini karena pohon juga termasuk anak-anaknya,
apa yang dilakukan adalah secara rekursif panggilan menghilangkan pohon pada node kiri pohon
serta node yang tepat.
Sebelum membebaskan orangtua, perlu untuk membebaskan anak-anak juga.
Induk juga dipertukarkan dengan akar.
Orang tua yang pertama, sehingga seperti besar-besar-besar-besar-kakek
atau pohon nenek, pertama kita harus membebaskan ke tingkat pertama.
Jadi melintasi ke bawah, bebas mereka, dan kemudian datang kembali, bebas mereka, dll
Jadi itulah pohon.
>> Sekarang kita melihat hutan.
Hutan adalah di mana Anda menempatkan semua pohon Huffman Anda.
Ini mengatakan bahwa kita akan memiliki sesuatu yang disebut plot
yang berisi pointer ke pohon serta pointer ke plot yang disebut selanjutnya.
Apa struktur melakukan semacam ini terlihat seperti?
Ini semacam mengatakan itu di sana.
Tepat di sini.
Sebuah linked list.
Kita melihat bahwa ketika kita memiliki plot itu seperti linked list dari plot.
Hutan didefinisikan sebagai linked list dari plot,
sehingga struktur hutan kita hanya akan memiliki pointer ke petak pertama kami
dan plot yang memiliki pohon dalam atau lebih menunjuk ke sebuah pohon
dan kemudian menunjuk ke plot selanjutnya, seterusnya, dan sebagainya.
Untuk membuat hutan kita sebut mkforest.
Lalu kami memiliki beberapa fungsi yang cukup berguna di sini.
Kami memiliki memilih di mana Anda lulus di hutan dan kemudian nilai kembali adalah * Pohon,
pointer ke pohon.
Apa yang akan lakukan adalah memilih akan masuk ke hutan yang Anda menunjuk ke
kemudian menghapus pohon dengan frekuensi terendah dari hutan yang
dan kemudian memberikan pointer ke pohon itu.
Setelah Anda memanggil memilih, pohon tidak akan ada di hutan lagi,
tetapi nilai pengembalian adalah pointer ke pohon itu.
Maka Anda memiliki tanaman.
Asalkan Anda lulus dalam pointer ke sebuah pohon yang memiliki frekuensi non-0,
apa tanaman akan lakukan itu akan mengambil hutan, mengambil pohon, dan tanaman yang pohon dalam hutan.
Di sini kita memiliki rmforest.
Mirip dengan menghilangkan pohon, yang pada dasarnya membebaskan semua pohon bagi kita,
menghapus hutan akan segala sesuatu yang bebas yang terkandung dalam hutan itu.
>> Jika kita melihat ke forest.c, kita akan mengharapkan untuk melihat setidaknya 1 perintah rmtree di sana,
karena untuk membebaskan memori di hutan jika hutan memiliki pohon di dalamnya,
maka akhirnya Anda akan harus menghapus pohon-pohon juga.
Jika kita melihat ke forest.c, kita memiliki mkforest kami, yang seperti yang kita harapkan.
Kami malloc hal.
Kami menginisialisasi plot pertama di hutan sebagai NULL karena kosong untuk memulai dengan,
maka kita lihat memilih, yang mengembalikan pohon dengan bobot terendah, frekuensi terendah,
dan kemudian menghilangkan simpul tertentu yang menunjuk ke pohon itu dan yang berikutnya,
sehingga dibutuhkan bahwa dari linked list dari hutan.
Dan maka di sini kita memiliki pabrik, yang menyisipkan pohon ke dalam linked list.
Apa hutan itu tidak baik menyimpannya diurutkan bagi kita.
Dan akhirnya, kita memiliki rmforest dan, seperti yang diharapkan, kami memiliki rmtree disebut di sana.
>> Melihat kode distribusi sejauh ini, huffile.c mungkin sejauh yang paling sulit untuk memahami,
sedangkan file lain sendiri cukup sederhana untuk mengikuti.
Dengan pengetahuan kita tentang pointer dan daftar terhubung dan semacamnya,
kami mampu mengikuti cukup baik.
Tapi semua kita harus benar-benar memastikan bahwa kita memahami adalah h file.
karena Anda harus memanggil fungsi tersebut, berhubungan dengan nilai-nilai kembali,
jadi pastikan bahwa Anda sepenuhnya memahami tindakan apa yang akan dilakukan
setiap kali Anda memanggil salah satu fungsi.
Tapi sebenarnya pemahaman di dalamnya tidak cukup diperlukan karena kita memiliki orang-orang. File h.
Kami memiliki 2 lebih file tersisa di kode distribusi kami.
>> Mari kita lihat di dump.
Dump oleh komentar yang di sini mengambil file Huffman-terkompresi
dan kemudian menerjemahkan dan pembuangan semua isinya keluar.
Di sini kita melihat bahwa itu memanggil hfopen.
Ini adalah jenis mirroring untuk mengajukan masukan * fopen =,
dan kemudian Anda lulus dalam informasi.
Ini hampir sama kecuali bukan file * Anda lewat di Huffile a;
bukannya fopen Anda lewat di hfopen.
Di sini kita membaca di header pertama, yang merupakan jenis mirip dengan bagaimana kita membaca di header
untuk file bitmap.
Apa yang kita lakukan di sini adalah memeriksa untuk melihat apakah informasi header
berisi angka ajaib yang tepat yang menunjukkan bahwa itu file Huff yang sebenarnya,
maka semua pemeriksaan ini untuk memastikan bahwa file yang kita buka adalah file huffed yang sebenarnya atau tidak.
Apa yang dilakukan adalah itu output frekuensi dari semua simbol-simbol yang bisa kita lihat
dalam terminal ke tabel grafis.
Bagian ini akan berguna.
Memiliki sedikit dan membaca sedikit demi sedikit ke dalam bit variabel dan kemudian mencetaknya.
Jadi jika saya memanggil dump pada hth.bin, yang merupakan hasil dari huffing file
menggunakan solusi staf, saya akan mendapatkan ini.
Ini keluaran semua karakter dan kemudian menempatkan frekuensi di mana mereka muncul.
Jika kita perhatikan, kebanyakan dari mereka adalah 0s kecuali ini: H, yang muncul dua kali,
dan kemudian T, yang muncul sekali.
Dan maka di sini kita memiliki pesan yang sebenarnya di 0s dan 1s.
Jika kita melihat hth.txt, yang diduga pesan asli yang gusar,
kami berharap untuk melihat beberapa Hs dan Ts di sana.
Secara khusus, kami berharap untuk melihat hanya 1 T dan 2 Hs.
Di sini kita berada dalam hth.txt. Ini memang memiliki HTH.
Termasuk di sana, meskipun kita tidak bisa melihatnya, adalah karakter baris baru.
The hth.bin File Huff juga pengkodean karakter baris baru juga.
Di sini karena kita tahu bahwa urutannya adalah HTH dan kemudian newline,
kita dapat melihat bahwa mungkin H diwakili oleh hanya 1 tunggal
dan kemudian T mungkin adalah 01 dan kemudian H berikutnya adalah 1 juga
dan kemudian kita memiliki newline ditunjukkan oleh dua 0s.
Cool.
>> Dan akhirnya, karena kita sedang berhadapan dengan beberapa. Dan c. H file,
kita akan memiliki argumen yang cukup kompleks ke compiler,
dan jadi di sini kita memiliki Makefile yang membuat dump untuk Anda.
Tapi sebenarnya, Anda harus pergi tentang membuat file sendiri puff.c Anda.
Makefile sebenarnya tidak berurusan dengan membuat puff.c untuk Anda.
Kami meninggalkan bahwa sampai Anda untuk mengedit Makefile.
Bila Anda memasukkan perintah seperti membuat semua, misalnya, itu akan membuat mereka semua untuk Anda.
Jangan ragu untuk melihat contoh Makefile dari pset masa lalu
serta pergi dari satu ini untuk melihat bagaimana Anda mungkin dapat membuat file Puff Anda
dengan mengedit Makefile ini.
Itu saja untuk kode distribusi kami.
>> Setelah kita sudah melalui itu, maka di sini hanya pengingat lain
bagaimana kita akan berurusan dengan node Huffman.
Kami tidak akan menyebut mereka node lagi; kita akan memanggil mereka pohon
di mana kita akan mewakili simbol mereka dengan char,
frekuensi, jumlah kejadian, dengan integer.
Kami menggunakan itu karena itu lebih tepat daripada pelampung.
Dan kemudian kita memiliki pointer ke anak kiri serta anak kanan.
Hutan, seperti yang kita lihat, hanya daftar link dari pohon.
Pada akhirnya, ketika kita membangun kami berkas Huff,
kami ingin hutan kita mengandung hanya 1 pohon -
1 pohon, 1 root dengan beberapa anak.
Sebelumnya ketika kami hanya membuat kami pohon Huffman,
kita mulai dengan menempatkan semua node ke layar kami
dan mengatakan kita akan memiliki node tersebut,
akhirnya mereka akan menjadi daun, dan ini adalah simbol mereka, ini adalah frekuensi mereka.
Di hutan kita jika kita hanya memiliki 3 huruf, itu adalah hutan pohon 3.
Dan kemudian ketika kami pergi, ketika kita menambahkan induk pertama,
kami membuat hutan 2 pohon.
Kami dihapus 2 dari mereka anak-anak dari hutan kami dan kemudian menggantinya dengan simpul orangtua
yang telah mereka 2 node sebagai anak-anak.
Dan akhirnya, kami lalu langkah dengan membuat contoh kita dengan As, B, dan C
akan membuat orangtua akhir,
dan sebagainya maka yang akan membawa jumlah total pohon di hutan untuk 1.
Apakah semua orang melihat bagaimana Anda mulai dengan beberapa pohon di hutan Anda
dan berakhir dengan 1? Oke. Cool.
>> Apa yang perlu kita lakukan untuk Puff?
Apa yang perlu kita lakukan adalah memastikan bahwa, seperti biasa, mereka memberi kita hak jenis masukan
sehingga kita dapat benar-benar menjalankan program.
Dalam hal ini mereka akan memberikan kami setelah pertama argumen mereka baris perintah
2 lagi: file yang kita inginkan untuk dekompresi dan output dari file didekompresi.
Tapi begitu kita pastikan bahwa mereka melewati kita dalam jumlah yang tepat dari nilai-nilai,
kami ingin memastikan bahwa input file Huff atau tidak.
Dan kemudian setelah kami menjamin bahwa itu file Huff, maka kita ingin membangun pohon kita,
membangun pohon sedemikian rupa sehingga cocok dengan pohon bahwa orang yang mengirim pesan dibangun.
Kemudian setelah kita membangun pohon, maka kita bisa berurusan dengan, 0s dan 1s yang mereka disahkan pada
mengikuti mereka sepanjang pohon kita karena itu identik,
dan kemudian menulis pesan itu, menafsirkan bit kembali ke karakter.
Dan kemudian di akhir karena kita sedang berhadapan dengan pointer di sini,
kami ingin memastikan bahwa kami tidak memiliki kebocoran memori
dan bahwa kita semuanya gratis.
>> Memastikan penggunaan yang tepat adalah topi tua bagi kita sekarang.
Kami mengambil sebuah input, yang akan menjadi nama file untuk membusungkan,
dan kemudian kita tentukan output,
sehingga nama file untuk output kembung, yang akan menjadi file teks.
Itu penggunaan. Dan sekarang kami ingin memastikan bahwa input huffed atau tidak.
Berpikir kembali, apakah ada sesuatu dalam kode distribusi yang mungkin bisa membantu kita
dengan memahami apakah sebuah berkas huffed atau tidak?
Ada informasi di huffile.c tentang Huffeader tersebut.
Kita tahu bahwa setiap file Huff memiliki Huffeader yang terkait dengan itu dengan angka ajaib
serta berbagai frekuensi untuk masing-masing simbol
serta checksum.
Kita tahu itu, tapi kami juga mengambil mengintip di dump.c,
di mana ia membaca ke file Huff.
Dan sehingga untuk melakukan itu, ia harus memeriksa apakah itu benar-benar huffed atau tidak.
Jadi mungkin kita bisa menggunakan dump.c sebagai struktur untuk puff.c. kami
Kembali ke pset 4 ketika kita memiliki file yang disalin copy.c dalam tiga kali lipat RGB
dan kami ditafsirkan bahwa untuk cerita detektif dan Resize,
sama, apa yang dapat Anda lakukan adalah hanya menjalankan perintah seperti cp dump.c puff.c
dan menggunakan beberapa kode di sana.
Namun, itu tidak akan menjadi seperti langsung dari proses
untuk menerjemahkan dump.c Anda ke puff.c,
tapi setidaknya itu memberi Anda tempat untuk memulai
tentang cara untuk memastikan bahwa input sebenarnya huffed atau tidak
serta beberapa hal lainnya.
Kami telah memastikan penggunaan yang tepat dan memastikan bahwa input huffed.
Setiap kali kita lakukan bahwa kita telah melakukan pengecekan error yang tepat kami,
jadi kembali dan berhenti fungsi jika beberapa kegagalan terjadi, jika ada masalah.
>> Sekarang apa yang ingin kita lakukan adalah membangun pohon yang sebenarnya.
Jika kita melihat di Hutan, terdapat 2 fungsi utama
bahwa kita akan ingin menjadi sangat akrab dengan.
Ada tanaman fungsi Boolean bahwa tanaman non-0 frekuensi pohon dalam hutan kami.
Dan jadi ada Anda lulus dalam pointer ke hutan dan pointer ke pohon.
Pertanyaan singkat: Berapa banyak hutan akan Anda miliki ketika Anda sedang membangun pohon Huffman?
Hutan kita seperti kanvas kami, kan?
Jadi kita hanya akan memiliki 1 hutan, tapi kami akan memiliki beberapa pohon.
Jadi sebelum Anda memanggil tanaman, Anda mungkin akan ingin membuat hutan Anda.
Ada perintah untuk itu jika Anda melihat ke forest.h mengenai bagaimana Anda dapat membuat hutan.
Anda dapat menanam pohon. Kita tahu bagaimana melakukan hal itu.
Dan kemudian Anda juga dapat memilih pohon dari hutan,
menghapus pohon dengan berat terendah dan memberikan Anda pointer untuk itu.
Berpikir kembali ke ketika kami melakukan contoh diri kita sendiri,
ketika kita sedang menggambar itu, kita hanya hanya menambahkan link.
Tapi di sini bukan hanya menambahkan link,
menganggapnya lebih sebagai Anda menghapus 2 orang node dan kemudian menggantinya dengan yang lain.
Untuk menyatakan bahwa dalam hal memilih dan menanam,
Anda memilih 2 pohon dan kemudian menanam pohon lain
yang memiliki orang-2 pohon yang Anda memilih sebagai anak-anak.
Untuk membangun pohon Huffman, Anda dapat membaca dalam simbol-simbol dan frekuensi dalam rangka
karena Huffeader memberikan itu kepada Anda,
memberi Anda sebuah array dari frekuensi.
Jadi Anda dapat melanjutkan dan hanya mengabaikan apapun dengan 0 di dalamnya
karena kita tidak ingin 256 daun pada akhir itu.
Kami hanya ingin jumlah daun yang karakter
yang benar-benar digunakan dalam file.
Anda dapat membaca dalam simbol-simbol, dan masing-masing dari simbol-simbol yang memiliki non-0 frekuensi,
Mereka adalah akan menjadi pohon.
Apa yang dapat Anda lakukan adalah setiap kali Anda baca dalam simbol frekuensi non-0,
Anda dapat menanam pohon di hutan.
Setelah Anda menanam pohon-pohon di hutan, Anda dapat bergabung dengan pohon-pohon sebagai saudara kandung,
sehingga akan kembali untuk menanam dan memetik di mana Anda memilih 2 dan kemudian tanaman 1,
mana yang 1 yang Anda tanaman adalah induk dari 2 anak yang memilih.
Jadi hasil akhir Anda akan menjadi satu pohon di hutan Anda.
Itulah cara Anda membangun pohon Anda.
>> Ada beberapa hal yang bisa salah di sini
karena kita sedang berhadapan dengan membuat pohon-pohon baru dan berurusan dengan pointer dan hal-hal seperti itu.
Sebelum ketika kita sedang berurusan dengan pointer,
setiap kali kita malloc'd kami ingin memastikan bahwa itu tidak kembali kami nilai pointer NULL.
Jadi pada beberapa langkah dalam proses ini ada akan menjadi beberapa kasus
di mana program Anda bisa gagal.
Apa yang ingin Anda lakukan adalah Anda ingin memastikan bahwa Anda menangani kesalahan-kesalahan,
dan di spec itu mengatakan untuk menangani mereka dengan anggun,
jadi seperti mencetak pesan ke pengguna memberitahu mereka mengapa program harus berhenti
dan kemudian segera berhenti itu.
Untuk melakukan hal ini penanganan error, ingat bahwa Anda ingin memeriksa
setiap saat bahwa mungkin ada kegagalan.
Setiap kali bahwa Anda membuat pointer baru
Anda ingin memastikan bahwa itu berhasil.
Sebelum apa yang kita digunakan untuk lakukan adalah membuat pointer baru dan malloc itu,
dan kemudian kita akan memeriksa apakah pointer yang NULL.
Jadi ada akan ada beberapa kejadian di mana Anda hanya dapat melakukan itu,
tapi kadang-kadang Anda benar-benar memanggil fungsi
dan dalam fungsi yang, itulah salah satu yang melakukan mallocing tersebut.
Dalam hal ini, jika kita melihat kembali ke beberapa fungsi dalam kode,
beberapa dari mereka adalah fungsi Boolean.
Dalam kasus abstrak jika kita memiliki fungsi Boolean yang disebut foo,
pada dasarnya, kita bisa berasumsi bahwa selain melakukan apapun foo tidak,
karena itu fungsi Boolean, ia mengembalikan true atau false -
benar jika berhasil, false jika tidak.
Jadi kita ingin memeriksa apakah nilai kembali dari foo benar atau salah.
Jika itu palsu, itu berarti bahwa kita akan ingin mencetak beberapa jenis pesan
dan kemudian keluar dari program.
Apa yang kita ingin lakukan adalah memeriksa nilai kembali dari foo.
Jika foo mengembalikan false, maka kita tahu bahwa kita mengalami beberapa jenis kesalahan
dan kita perlu berhenti program kami.
Sebuah cara untuk melakukan ini adalah memiliki kondisi di mana fungsi yang sebenarnya itu sendiri adalah kondisi Anda.
Katakanlah foo mengambil di x.
Kita dapat memiliki kondisi if (foo (x)).
Pada dasarnya, itu berarti jika pada akhir melaksanakan foo itu mengembalikan nilai true,
maka kita dapat melakukan ini karena fungsi harus mengevaluasi foo
dalam rangka untuk mengevaluasi kondisi seluruh.
Jadi itulah bagaimana Anda dapat melakukan sesuatu jika fungsi mengembalikan nilai true dan berhasil.
Tetapi ketika Anda sedang memeriksa kesalahan, Anda hanya ingin berhenti jika fungsi Anda kembali palsu.
Apa yang Anda bisa lakukan hanyalah menambahkan == palsu atau hanya menambahkan bang di depannya
dan kemudian Anda memiliki if (! foo).
Dalam tubuh kondisi bahwa Anda akan memiliki semua penanganan error,
jadi seperti, "Tidak bisa membuat pohon ini" dan kemudian kembali 1 atau sesuatu seperti itu.
Apa yang tidak, meskipun, adalah bahwa meskipun foo kembali palsu -
Katakanlah foo mengembalikan nilai true.
Maka Anda tidak perlu menelepon foo lagi. Itu kesalahpahaman umum.
Karena itu dalam kondisi Anda, itu sudah dievaluasi,
sehingga Anda sudah memiliki hasilnya jika Anda menggunakan make pohon atau sesuatu seperti itu
atau tanaman atau memilih atau sesuatu.
Ini sudah memiliki nilai itu. Ini sudah dijalankan.
Jadi berguna untuk menggunakan fungsi Boolean sebagai kondisi
karena apakah Anda benar-benar melaksanakan tubuh loop,
dijalankan fungsi pula.
>> Kedua kami untuk langkah terakhir adalah menulis pesan ke file.
Setelah kami membangun pohon Huffman, kemudian menulis pesan ke file tersebut cukup sederhana.
Ini cukup sederhana sekarang hanya mengikuti 0s dan 1s.
Dan sehingga dengan konvensi kita tahu bahwa dalam pohon Huffman 0s mengindikasikan kiri
dan 1s menunjukkan tepat.
Jadi jika Anda membaca sedikit demi sedikit, setiap kali Anda mendapatkan 0
Anda akan mengikuti cabang kiri, dan kemudian setiap kali Anda baca dalam 1
Anda akan mengikuti cabang kanan.
Dan kemudian Anda akan terus sampai anda menekan daun
karena daun akan berada di ujung cabang.
Bagaimana kita bisa mengatakan apakah kita telah memukul daun atau tidak?
Kami mengatakan itu sebelumnya.
[Mahasiswa] Jika pointer NULL. >> Ya.
Kita dapat mengetahui apakah kita sudah mencapai daun jika pointer ke pohon baik kiri dan kanan NULL.
Sempurna.
Kita tahu bahwa kita ingin membaca di sedikit demi sedikit ke dalam file Huff kami.
Seperti yang kita lihat sebelumnya di dump.c, apa yang mereka lakukan adalah mereka baca dalam sedikit demi sedikit ke dalam file Huff
dan hanya dicetak apa itu bit itu.
Kami tidak akan melakukan itu. Kami akan melakukan sesuatu yang sedikit lebih kompleks.
Tapi apa yang bisa kita lakukan adalah kita bisa mengambil sedikit kode yang dibaca ke dalam bit.
Di sini kita memiliki bit integer yang mewakili bit saat ini bahwa kita berada di.
Ini menangani iterasi semua bit dalam file sampai Anda mencapai akhir file.
Berdasarkan hal tersebut, maka Anda akan ingin memiliki beberapa jenis iterator
untuk melintasi pohon Anda.
Dan kemudian berdasarkan apakah bit adalah 0 atau 1,
Anda akan ingin pindahkan bahwa iterator ke kiri atau memindahkannya ke kanan
sepanjang jalan sampai Anda mencapai daun, sehingga semua jalan sampai simpul bahwa Anda berada di
tidak menunjuk ke node lagi.
Mengapa kita melakukan ini dengan file Huffman namun tidak kode Morse?
Karena dalam kode Morse ada sedikit ambiguitas.
Kita bisa seperti, oh tunggu, kami telah memukul surat sepanjang jalan, jadi mungkin ini adalah surat kami,
sedangkan jika kita terus hanya sedikit lebih lama, maka kita akan telah memukul surat lain.
Tapi itu tidak akan terjadi dalam pengkodean Huffman,
sehingga kita dapat yakin bahwa satu-satunya cara bahwa kita akan memukul karakter
adalah jika anak-anak yang node kiri dan kanan NULL.
>> Akhirnya, kami ingin membebaskan semua memori kita.
Kami ingin keduanya dekat file Huff bahwa kita sudah berhadapan dengan
serta menghapus semua pohon di hutan kita.
Berdasarkan implementasi Anda, Anda mungkin akan ingin menelepon menghapus hutan
bukan benar-benar akan melalui semua pohon sendiri.
Tetapi jika Anda membuat setiap pohon sementara, Anda akan ingin untuk membebaskan itu.
Anda tahu kode Anda yang terbaik, sehingga Anda tahu di mana Anda mengalokasikan memori.
Dan jadi jika Anda pergi, mulailah dengan bahkan Pengendalian f'ing untuk malloc,
melihat setiap kali Anda malloc dan memastikan bahwa Anda membebaskan semua itu
tapi kemudian hanya akan melalui kode Anda,
memahami di mana Anda mungkin telah dialokasikan memori.
Biasanya Anda hanya bisa mengatakan, "Pada akhir file aku hanya akan menghapus hutan di hutan saya,"
jadi pada dasarnya menghapus memori itu, bebas itu,
"Dan kemudian saya juga akan menutup file dan kemudian program saya akan berhenti."
Tapi apakah itu satu-satunya waktu bahwa program Anda berhenti?
Tidak, karena kadang-kadang mungkin ada kesalahan yang terjadi.
Mungkin kita tidak bisa membuka file atau kita tidak bisa membuat pohon lain
atau beberapa jenis kesalahan yang terjadi dalam proses alokasi memori dan jadi kembali NULL.
Sebuah kesalahan terjadi dan kemudian kita kembali dan berhenti.
Jadi Anda ingin memastikan bahwa setiap waktu mungkin bahwa program Anda dapat berhenti,
Anda ingin membebaskan semua memori Anda di sana.
Ini tidak hanya akan berada di akhir dari fungsi utama yang Anda berhenti kode Anda.
Anda ingin melihat kembali ke setiap contoh bahwa kode Anda berpotensi akan kembali prematur
dan kemudian bebas apapun memori masuk akal.
Katakanlah Anda sudah disebut membuat hutan dan kembali palsu.
Maka Anda mungkin tidak akan perlu menghapus hutan Anda
karena Anda tidak memiliki hutan belum.
Tetapi pada setiap titik dalam kode di mana Anda akan kembali prematur
Anda ingin memastikan bahwa Anda membebaskan memori yang mungkin.
>> Jadi ketika kita sedang berhadapan dengan membebaskan memori dan memiliki potensi kebocoran,
kita ingin tidak hanya menggunakan pertimbangan dan logika kita
tetapi juga menggunakan Valgrind untuk menentukan apakah kita telah membebaskan semua memori kita baik atau tidak.
Anda juga dapat menjalankan Valgrind pada Puff dan kemudian Anda harus juga lulus
nomor yang benar dari argumen baris perintah untuk Valgrind.
Anda dapat menjalankan itu, tapi output agak samar.
Kami telah mendapat sedikit terbiasa dengan Speller, namun kita masih membutuhkan bantuan sedikit lebih,
sehingga kemudian menjalankannya dengan bendera lagi seperti kebocoran-check = penuh,
yang mungkin akan memberi kita beberapa output lebih bermanfaat pada Valgrind.
>> Kemudian tip lain berguna ketika Anda debugging adalah perintah diff.
Anda dapat mengakses pelaksanaan staf dari Huff, menjalankan bahwa pada file teks,
dan kemudian output ke sebuah file biner, file biner Huff, untuk lebih spesifik.
Kemudian jika Anda menjalankan isapan Anda sendiri pada file biner,
maka idealnya, file teks outputted Anda akan menjadi identik
dengan yang asli yang Anda berlalu masuk
Di sini saya menggunakan hth.txt sebagai contoh, dan itulah yang dibicarakan di spec Anda.
Itu benar-benar hanya HTH dan kemudian baris baru.
Tapi yang pasti merasa bebas dan Anda pasti dianjurkan untuk menggunakan contoh lagi
untuk file teks Anda.
>> Anda bahkan dapat mengambil gambar di mungkin mengompresi dan kemudian dekompresi
beberapa file yang Anda gunakan dalam Speller seperti Perang dan Damai
atau Jane Austen atau sesuatu seperti itu - itu akan menjadi agak dingin - atau Austin Powers,
jenis berurusan dengan file yang lebih besar karena kita tidak akan datang ke sana
jika kita menggunakan alat berikutnya di sini, ls-l.
Kami sudah terbiasa dengan ls, yang pada dasarnya berisi semua isi dalam direktori kami saat ini.
Melewati di l bendera-benar menampilkan ukuran file tersebut.
Jika Anda pergi melalui spesifikasi pset, itu benar-benar menuntun Anda melalui penciptaan file biner,
huffing itu, dan Anda melihat bahwa untuk file yang sangat kecil
biaya ruang mengompresi dan menerjemahkan semua informasi yang
dari semua frekuensi, dan hal seperti itu melebihi manfaat yang sebenarnya
mengompresi file di tempat pertama.
Tetapi jika Anda menjalankannya pada beberapa file teks yang lebih panjang, maka Anda mungkin melihat bahwa Anda mulai mendapatkan beberapa keuntungan
dalam mengompresi file-file tersebut.
>> Dan akhirnya, kita memiliki GDB lama kita sobat, yang pasti akan berguna juga.
>> Apakah kita memiliki pertanyaan tentang pohon Huff atau proses mungkin membuat pohon
atau pertanyaan lain pada Puff Huff'n?
Oke. Saya akan tinggal di sekitar untuk sedikit.
>> Terima kasih, semua orang. Ini adalah Walkthrough 6. Dan semoga berhasil.
>> [CS50.TV]