BaoCaoGT_HuffMan

DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

Huffman Coding GVHD : TS. Phạm Văn Chung Nhóm : Nguyễn Trung Dũng - 09256471 Phạm Minh Trị

- 09263311

Phạm Ngọc Minh Tân - 09257481

10

2Huffman Coding

LỜI CẢM ƠN Chúng em xin chân thành cảm ơn khoa Công Nghệ Thông Tin, trường ĐH Công Công Ngh ghiiệp Tp.HC p.HCM M đã tạo tạo điều điều kiện iện thuận lợi để chúng em được học tập. Chúng em xin gởi lời cảm ơn sâu sắc đến thầy TS.Phạm Văn Chung đã tận tình chỉ dạy , quan tâm sâu sắc, và hướng dẫn chúng em trong quá trình học tập và rèn luyện tại trường cũng như trong chính bộ môn này.

Giới thiệu sơ lược về tác giả Huffman Coding

Chúng em cũng xin chân thành cảm ơn những người đã chia sẻ kiến thức và kinh nghiệm để chúng em có thể nghiên cứu và tham khảo thêm. Dù đã cố gắng thực hiện trong khả năng và phạm vi cho phép nhưng chắc chắn sẽ không thể tránh khỏi những thiếu sót, kính mong nhận được sự chỉ bảo và góp ý của quý thầy cô và các bạn.

Thuật toán được đề xuất bởi David A. Huffman khi ông còn là sinh viên Ph.D.. tại MIT Ph.D MIT,, và công bố năm 1952 trong bài báo "A Method for the Construction of Minimum-Redundancy Codes". Sau này Huffman đã trở thành Một lần nữa , chúng em xin chân thành cảm một giảng viên ở MIT và sau đó ở khoa ơn. Khoa học máy tính của Đại học Tp.HCM 22/04/2010 California, Santa Cruz, Trường Kỹ nghệ Baskin (Baskin School of Engineering)

Phạm Ngọc Minh Tân


3Huffman Coding

LỜI NHẬN XÉT (Của giảng viên hướng dẫn) …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………………………………………………………………… …………………………………………………

GVHD

TS . Phạm Văn Chung


4Huffman Coding

Nội dung Nội dung.....................................................................................................................................4 Giới thiệu....................................................................................................................................6 Nguyên tắc của nén dữ liệu............................................................................................. ......6 Tầm quan trọng của nén dữ liệu trong truyền tin nối tiếp......................................................7 Phương pháp nén dữ liệu......................................................................................................7 Từ ASCII Coding Đến Huffman Coding.................................................................................7 Thuật Toán Huffman...............................................................................................................8 Tác giả....................................................................................................................................9 Dẫn nhập..................................................................................................................................10 Mã tiền tố (prefix-free binary code)......................................................................................10 Biểu diễn mã tiền tố trên cây nhị phân.................................................................................12 Mã tiền tố tối ưu....................................................................................................................12 Bài toán.................................................................................................................................12 Minh họa Huffman coding............................................................................................. .......13 Ví dụ..................................................................................................................................15 Giải thuật.................................................................................................................................. 16 Giải thuật tham lam..............................................................................................................16 Tại sao Huffman Coding là giải thuật tham lam ?................................................................17 Quá trình xây dựng cây Huffman.........................................................................................17 Minh họa quá trình xây dựng.......................................................................................... .....18 Kỹ thuật mã hóa Huffman căn bản.......................................................................................21 Hàng đợi có ưu tiên..............................................................................................................22 Hiện thực bằng Mã giả.............................................................................................................22 Nén file bằng mã Huffman....................................................................................................22 Tạo hàng đợi bằng đống (heap)..........................................................................................23 Xây dựng cây Huffman.........................................................................................................23 Xây dựng bộ mã...................................................................................................................24 Đánh giá chi phí giải thuật.......................................................................................................24 Chi phí cho xử lý heap (A)...................................................................................................24 Vậy chi phí cho xử lý heap là T(n)=O(logn).........................................................................25 Chi phí tạo Heap...................................................................................................................25 }............................................................................................................................................ 25 Chi phí tạo cây :....................................................................................................................25 DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

5Huffman Coding Các biến thể Huffman Coding..................................................................................................26 n-ary Huffman coding..........................................................................................................26 Adaptive Huffman coding.....................................................................................................27 Huffman template algorithm.................................................................................................27 Length-limited Huffman coding............................................................................................27 Huffman coding with unequal letter costs...........................................................................27 Optimal alphabetic binary trees (Hu-Tucker coding)...........................................................27 Ưu & Nhược điểm Huffman Coding........................................................................................27 Thuật toán Huffman có ưu điểm là hệ số nén tương đối cao, phương pháp thực hiện tương đối đơn giản, đòi hỏi ít bộ nhớ, có thể xây dựng dựa trên các mảng bé hơn 64KB. ................................................................................................................................27 Nhược điểm của nó là phải chứa cả bảng mã vào tập tin nén thì phía nhận mới có thể giải mã được do đó hiệu suất nén chỉ cao khi ta thực hiện nén các tập tin lớn. .............27 Ta chọn phương pháp nén Huffman vì tính đơn giản của nó hệ số nén lại cao. Nhược điểm của phương pháp nén này có thể khắc phục bằng cách thực hiện nén một lần nhiều tập tin chuẩn bị truyền, làm như vậy coi như chúng ta đang thực hiện nén một tập tin lớn................................................................................................................................28 Tài liệu tham khảo....................................................................................................................28 Entropic Coding and Compression ...................................................................................28 Huffman Encoding & Decoding by John Morris, 1998.....................................................28 http://en.wikipedia.org/wiki/Huffman_coding....................................................................28 http://vi.wikipedia.org/wiki/M%C3%A3_Huffman.............................................................28 http://www.animal.ahrgr.de...............................................................................................28

Phụ Lục Bảng 1 : So sảnh ASCII coding & 3 bit Coding.........................................................................8 Bảng 2: bảng so sánh mã hóa theo tần suất...........................................................................15 Hình 1 :Cây mã hóa của mã hóa ASCII...................................................................................10 Hình 2: Cây mã hóa character.................................................................................................11 Hình 3 : Cây nhị phân biểu diễn mã tiền tố..............................................................................12 Hình 4 : huffman code tree.......................................................................................................14


6Huffman Coding

Giới thiệu Nguyên tắc của nén dữ liệu Thông thường, hầu hết các tập tin trong máy tính có rất nhiều thông tin dư thừa, việc thực hiện nén tập tin thực chất là mã hoá lại các tập tin để loại bỏ các thông tin dư thừa. Nhìn chung không thể có phương phát nén tổng quát nào cho kết quả tốt đối với tất cả các loại tập tin vì nếu không ta sẽ áp dụng n lần phương pháp nén này để đạt được một tập tin nhỏ tuỳ ý! Kỹ thuật nén tập tin thường được áp dụng cho các tập tin văn bản (Trong đó có một số kí tự nào đó có xác suất xuất hiện nhiều hơn các kí tự khác), các tập tin ảnh bitmap (Mà có thể có những mảng lớn đồng nhất), các tập tin dùng để biểu diễn âm thanh dưới dạng số hoá và các tín hiệu tương tự (analog signal) DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

7Huffman Coding

khác (Các tín hiệu này có thể có các mẫu được lặp lại nhiều lần). Ðối với các tập tin nhị phân như tập tin chương trình thì sau khi nén cũng không tiết kiệm được nhiều. Ngoài ra, trong một số trường hợp để nâng cao hệ số nén người ta có thể bỏ bớt một số thông tin của tập tin (Ví dụ như kỹ thật nén ảnh JPEG).

Tầm quan trọng của nén dữ liệu trong truyền tin nối tiếp Trong kỹ thuật truyền tin nối tiếp, do các bit dữ liệu được truyền đi nối tiếp, lại bị giới hạn về dãi thông của kênh truyền và giới hạn về các chuẩn ghép nối...nên tốc độ truyền tin tương đối chậm. Ðể tăng tốc độ truyền ta có thể dùng nhiều phương pháp như sử dụng kỹ thuật điều chế pha nhiều mức, điều chế QAM, TCM... Nén dữ liệu trước khi truyền đi cũng là một trong các phương pháp nhằm tăng tốc độ truyền dữ liệu. Trong các modem hiện đại, việc thực hiện nén dữ liệu trước khi truyền đi có thể được thực hiện ngay trong modem theo các giao thức V42bis, MNP5. Phương pháp này đòi hỏi hai modem phải có cùng một giao thức nén dữ liệu, điều này nhiều khi khó thoã mãn. Có một phương pháp khác là thực hiện nén các tập tin ngay tại các máy vi tính trước khi truyền đi, tại các máy tính nhận, các tập tin lại được giải nén để phục hồi lại dạng ban đầu. Phương pháp này có ưu điểm là bên phát và bên thu chỉ cần có chung phần mềm nén và giải nén, ngoài ra còn có thể áp dụng được để truyền dữ liệu qua các modem không hỗ trợ nén dữ liệu hoặc truyền dữ liệu trực tiếp qua cổng COM của máy tính. Nhược điểm của phương pháp này là các máy vi tính phải tốn thêm thời gian nén và giải nén, nhưng do sự phát triển nhanh chóng của các bộ vi xử lý mà thời gian thực hiện nén và giải nén được giảm nhỏ hơn rất nhiều thời gian để truyền dữ liệu. Ví dụ, khi truyền một tập tin có kích thước là 100Kbyte với dạng thức của một SDU là: 8 bits dữ liệu, 2 bit STOP và 1 bit START, không dùng bit chẵn lẻ, tốc độ truyền là 9600bits/giây thì mất khoảng 120 giây, trong khi một máy vi tính với bộ vi xử lí 80386 có thể thực hiện nén tập tin trên xuống còn 50Kbyte chỉ mất chưa đến 10 giây

Phương pháp nén dữ liệu Có rất nhiều phương pháp nén dữ liệu và thuật toán nén dữ liệu . Nhưng trong bài viết này chỉ mô tả và đi chi tiết về thuật toán mã hóa mã Huffman.

Từ ASCII Coding Đến Huffman Coding Chúng ta sẽ xem làm thế nào chuỗi " go go gophers " được mã hóa trong ASCII, làm thế nào chúng ta có thể lưu các bit bằng cách sử dụng một chương trình mã hóa đơn giản, và cách mã hóa Huffman được sử dụng để nén dữ liệu với kết quả là tiết kiệm hơn nữa. Với một mã ASCII (8 bit cho mỗi ký tự) chuỗi 13 ký tự " go go gophers " đòi hỏi phải có 104 bit. Bảng dưới đây bên trái cho thấy các công việc mã hóa. DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

8Huffman Coding

Coding a message Bảng 1 : So sảnh ASCII coding & 3 bit Coding

ASCII coding char ASCII binary g 103 1100111 o 111 1101111 p 112 1110000 h 104 1101000 e 101 1100101 r 114 1110010 s 115 1110011 space 32 1000000

3-bit coding char code binary g 0 000 o 1 001 p 2 010 h 3 011 e 4 100 r 5 101 s 6 110 space 7 111

Chuỗi " go go gophers " sẽ được viết (kí hiệu bằng số) là 103 111 32 32 103 111 103 111 112 104 101 114 115. Mặc dù không dễ dàng con người có thể đọc và hiểu, điều này sẽ được viết lại như dòng sau đây của các bit (các không gian sẽ không được viết, chỉ cần của 0 và 1) 1100111 1101111 1100000 1100111 1101111 1000000 1100111 1101111 1110000 1101000 1100101 1110010 1110011 Vì chỉ có tám ký tự khác nhau trong " go go gophers ", có thể sử dụng chỉ có 3 bit để mã hóa các ký tự khác nhau. Chúng ta có thể, ví dụ, sử dụng mã hóa trong bảng bên phải ở trên, mặc dù là có thể mã hóa khác 3-bit. Bây giờ các chuỗi " go go gophers " sẽ được mã hóa là 0 1 7 0 1 7 0 1 2 3 4 5 6 hoặc, như bit: 000 001 111 000 001 111 000 001 010 011 100 101 110 111 Bằng cách sử dụng ba bit cho mỗi ký tự, chuỗi " go go gophers " sử dụng tổng cộng 39 bit thay vì 104 bit. Có thể tiết kiệm được nhiều bit hơn nếu chúng ta sử dụng ít hơn ba bit để mã hóa các ký tự như g, o, và không gian xảy ra thường xuyên và hơn ba bit để mã hóa các ký tự như e, p, h, r, và s xảy ra ít thường xuyên hơn trong " go go gophers ". Đây là ý tưởng cơ bản của mã hóa Huffman: để sử dụng số bit nhỏ cho ký tự có tần suất xuất hiện cao hơn. Chúng ta sẽ xem cách này được thực hiện bằng cách sử dụng một cây chứa ký tự ở các lá, và có đường dẫn từ gốc đến lá là đường dẫn cung cấp các chuỗi bit được sử dụng để mã hóa các ký tự.

Thuật Toán Huffman


9Huffman Coding

Các tập tin của máy tính được lưu dưới dạng các kí tự có chiều dài không đổi là 8 bits. Trong nhiều tập tin, xác suất xuất hiện các kí tự này là nhiều hơn các kí tự khác, từ đó ta thấy ngay rằng nếu chỉ dùng một vài bit để biểu diễn cho các kí tự có xác suất xuất hiện lớn và dùng nhiều bit hơn để biểu diễn cho các kí tự có xác suất xuất hiện nhỏ thì có thể tiết kiệm được độ dài tập tin một cách đáng kể. Ví dụ, để mã hoá một chuỗi như sau: "ABRACADABRA" Nếu mã hoá chuỗi trên trong dạng mã nhị phân 5 bit ta sẽ có dãy bit sau: 0000100010100100000100011000010010000001000101001000001 Ðể giải mã thông điệp này, chỉ đơn giản là đọc ra 5 bits ở từng thời điểm và chuyển đổi nó tương ứng với việc mã hoá nhị phân đã được định nghĩa ở trên. Trong mã chuẩn này, chữ D xuất hiện chỉ một lần sẽ cần số lượng bit giống chữ A xuất hiện nhiều lần. Ta có thể gán các chuỗi bit ngắn nhất cho các kí tự được dùng phổ biến nhất, giả sử ta gán: A là 0, B là 1, R là 01, C là 10 và D là 11 thì chuỗi trên được biễu diễn như sau: 0 1 01 0 10 0 11 0 1 01 0 Ví dụ này chỉ dùng 15 bits so với 55 bits như ở trên, nhưng nó không thực sự là một mã vì phải lệ thuộc vào khoảng trống để phân cách các kí tự. Nếu không có dấu phân cách thì ta không thể giải mã được thông điệp này. Ta cũng có thể chọn các từ mã sao cho thông điệp có thể được giải mã mà không cần dấu phân cách, ví dụ như: A là 11, B là 00, C là 010, D là 10 và R là 011, các từ mã này gọi là các từ mã có tính prefix (Không có từ mã nào là tiền tố của từ mã khác). Với các từ mã này ta có thể mã hoá thông điệp trên như sau: 1100011110101110110001111 Với chuỗi đã mã hoá này ta hoàn toàn có thể giải mã được mà không cần dấu phân cách. Nhưng bằng cách nào để tìm ra bảng mã một cách tốt nhất ? Trong khoa học máy tính và lý thuyết thông tin, mã Huffman là một thuật toán mã hóa dùng để nén dữ liệu. Nó dựa trên bảng tần suất xuất hiện các kí tự cần mã hóa để xây dựng một bộ mã nhị phân cho các kí tự đó sao cho dung lượng (số bít) sau khi mã hóa là nhỏ nhất.

Tác giả Thuật toán được đề xuất bởi David A. Huffman khi ông còn là sinh viên Ph.D. tại MIT, và công bố năm 1952 trong bài báo "A Method for the Construction of Minimum-Redundancy Codes". Sau này Huffman đã trở thành một giảng viên ở MIT DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

10Huffman Coding

và sau đó ở khoa Khoa học máy tính của Đại học California, Santa Cruz, Trường Kỹ nghệ Baskin ( Baskin School of Engineering ).

Dẫn nhập Mã tiền tố (prefix-free binary code) Để mã hóa các kí hiệu (kí tự, chữ số, ...) ta thay chúng bằng các xâu nhị phân, được gọi là từ mã của kí hiệu đó. Chẳng hạn bộ mã ASCII, mã hóa cho 256 kí hiệu là biểu diễn nhị phân của các số từ 0 đến 255, mỗi từ mã gồm 8 bít. Trong ASCII từ mã của kí tự "a" là 1100001, của kí tự "A" là 1000001. Trong cách mã hóa này các từ mã của tất cả 256 kí hiệu có độ dài bằng nhau (mỗi từ mã 8 bít). Nó được gọi là mã hóa với độ dài không đổi.

Hình 1 :Cây mã hóa của mã hóa ASCII

Cấu trúc của cây có thể được dùng để xác định mã hóa của lá bất kỳ bằng cách sử dụng theo quy ước cạnh 0 / 1 mô tả. Nếu chúng ta sử dụng một cây khác, chúng ta nhận được một mã hóa khác. Ví dụ, cây dưới bên phải


11Huffman Coding

char 'g' 'o' 'p' 'h' 'e' 'r' 's' ' '

binary 10 11 0100 0101 0110 0111 000 001

Hình 2: Cây mã hóa character

Sử dụng mã hóa này, " go go gophers " được mã hoá (không gian sẽ không xuất hiện trong các bitstream) như: 10 11 001 10 11 001 10 11 0100 0101 0110 0111 000 Khi mã hóa một tài liệu có thể không sử dụng đến tất cả 256 kí hiệu. Hơn nữa trong tài liệu chữ cái "a" chỉ có thể xuất hiện 1000000 lần còn chữ cái "A" có thể chỉ xuất hiện 2, 3 lần. Như vậy ta có thể không cần dùng đủ 8 bít để mã hóa cho một ký hiệu, hơn nữa độ dài (số bít) dành cho mỗi kí hiệu có thể khác nhau, kí hiệu nào xuất hiện nhiều lần thì nên dùng số bít ít, ký hiệu nào xuất hiện ít thì có thể mã hóa bằng từ mã dài hơn. Như vậy ta có việc mã hóa với độ dài thay đổi. Tuy nhiên, nếu mã hóa với độ dài thay đổi, khi giải mã ta làm thế nào phân biệt được xâu bít nào là mã hóa của ký hiệu nào. Một trong các giải pháp là dùng các dấu phẩy (",") hoặc một kí hiệu quy ước nào đó để tách từ mã của các kí tự đứng cạnh nhau. Nhưng như thế số các dấu phẩy sẽ chiếm một không gian đáng kể trong bản mã. Một cách giải quyết khác dẫn đến khái niệm mã tiền tố •

Mã tiền tố là bộ các từ mã của một tập hợp các kí hiệu sao cho từ mã của mỗi ký hiệu không là tiền tố (phần đầu) của từ mã một ký hiệu khác trong bộ mã ấy.

Đương nhiên mã hóa với độ dài không đổi là mã tiền tố. Ví dụ: Giả sử mã hóa từ "ARRAY", tập các ký hiệu cần mã hóa gồm 3 chữ cái "A","R","Y". •

•

Nếu mã hóa bằng các từ mã có độ dài bằng nhau ta dùng ít nhất 2 bit cho một chữ cái chẳng hạn "A"=00, "R"=01, "Y"=10. Khi đó mã hóa của cả từ là 0001010010. Để giải mã ta đọc hai bit một và đối chiếu với bảng mã. Nếu mã hóa "A"=0, "R"=01, "Y"=11 thì bộ từ mã này không là mã tiền tố ví từ mã của "A" là tiền tố của từ mã của "R". Để mã hóa cả từ ARRAY phải đặt dấu ngăn cách vào giữa các từ mã 0,01,01,0,11 DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

12Huffman Coding

•

Nếu mã hóa "A"=0, "R"=10, "Y"=11 thì bộ mã này là mã tiền tố. Với bộ mã tiền tố này khi mã hóa xâu "ARRAY" ta có 01010011.

Biểu diễn mã tiền tố trên cây nhị phân •

•

Nếu có một cây nhị phân n lá ta có thể tạo một bộ mã tiền tố cho n ký hiệu bằng cách đặt mỗi ký hiệu vào một lá. Từ mã của mỗi kí hiệu được được tạo ra khi đi từ gốc tới lá chứa ký hiệu đó, nếu đi qua cạnh trái thì ta thêm số 0, đi qua cạnh phải thì thêm số 1. Ví dụ: Cây 3 lá sau đây biểu diễn bộ mã của A,R,Y trong ví dụ trên

* 0/ \1 A * 0/ \1 R Y •

Từ mã của "A" là 0, của "R" là 10, của "Y" là 11 .

Mã tiền tố tối ưu Từ ví dụ trên thấy mã hóa của xâu "ARRAY" bằng mã độ dài cố định mất 10 bít, bằng mã tiền tố đã đưa ra mất 8 bit, tiết kiệm được 20%. Bài toán đặt ra là bộ mã tiền tố đã tối ưu chưa ?

Bài toán • •

Cho tập A các ký hiệu và trọng số (tần suất)của chúng. Tìm một bộ mã tiền tố với tổng độ dài mã hóa là nhỏ nhất.

Hình 3 : Cây nhị phân biểu diễn mã tiền tố


13Huffman Coding

Cây Huffman sinh ra từ xâu kí tự "this is an example of a huffman tree". Tổng số bit để mã hóa là 135, không kể các kí tự trống.

Minh họa Huffman coding Mã Huffman gán những mã hóa ngắn hơn với những yếu tố có tần suất xuất hiện cao, Nó không giống như mã hóa Block gán mã với độ dài khác nhau cho những yếu tố khác nhau. Với mã Huffman, những yếu tố có tần suất cao nhất thì được gán mã bit với độ dài ngắn nhất. Chìa khóa của việc giải mã Huffman là cây Huffman. Một cây Huffman là cây nhị phân đặc biệt được gọi là một “Trie” (Tạm dung trong bài A binary trie) . Một binary trie là một cây nhị phân với đại diện 0 cho nhánh trái và 1 cho nhánh phải. Những con số trên nút của the binary trie đại diện cho tổng tần số, F , của cây ví dụ bên dưới. Nút lá của binary trie đại diện cho yếu tố, e, yếu tố mã hóa. Những yếu tố được gán cho vị trí phù hợp trên binary trie trong quá trình mã hóa. Theo dõi ví dụ bên dưới Ghi chú : Khoảng trống (spaces) trong đoạn văn bản và trong mã hóa nhằm mục đích chỉ để đọc. Khoảng trống không quan tâm như một ký tự trong đoạn văn bản và bởi vậy nó không được mã hóa như một yếu tố trong đoạn văn bản. Nội dung văn bản được mã hóa dad ade fade bead ace dead cab bad fad cafe face Mã hóa Block 011 000 011 000 011 100 101 000 011 101 001 100 000 011 000 010 100 011 100 000 011 010 000 001 001 000 011 101 000 011 010 000 101 100 101 000 010 100 Mã hóa block trên là mã hóa độ dài cố định. Nếu đoạn vản bản chứa I yếu tố, mã hóa block yêu cầu log(i) bits để mã hóa mỗi yếu tố. Khoảng trắng được chèn giữa chuỗi của bits, đại diện cho mỗi ký tự trong cả mã hóa Block và mã hóa Huffman. Mã hóa Huffman 01 10 01 10 01 111 110 10 01 111 000 111 10 01 10 001 111 01 111 10 01 001 10 000 000 10 01 110 10 01 001 10 110 111 110 10 001 111


14Huffman Coding

Mã Huffman nén sử dụng cây Huffman. Minh họa cây bằng hình bên dưới

Hình 4 : huffman code tree

Mã hóa Huffman của đoạn văn bản dài 94 bits . Mã hóa block là 114 bits . mã hóa Huffman tiết kiệm hơn 20 bits . Tỷ lệ nén là 1.21:1 , tỷ lệ là 17.5%

Dữ liệu Input Bảng n chữ cái . Tập các trọng số (tần suất xuất hiện) tương ứng .

, i.e.


15Huffman Coding

Output Bộ mã trong đó ci là từ mã của

, là tập hợp các từ mã (codeword ) (nhị phân), .

Yêu cầu

Đặt với mọi bộ mã

là trọng số của bộ mã C . Điều kiện là: .

Ví dụ •

Trong ví dụ sau, với các tần số như trên mã 1 sẽ tốn không gian hơn mã 2.

Input Mã 1 Mã 2

Ký tự tần suất Từ mã Độ dài từ mã (bits) Từ mã Độ dài từ mã (bits)

a B c d e 0.10 0.15 0.30 0.16 0.29 1,00 000

001

010

011

110

3

3

3

3

3

000

001

10

01

11

3

3

2

2

2

3,00 2,25

Bảng 2: bảng so sánh mã hóa theo tần suất

Đối với bất kỳ mã đó là biunique, có nghĩa là mã duy nhất decodeable, tổng tần suất trên tất cả các ký hiệu lu ôn luôn nhỏ hơn hoặc bằng một. Trong ví dụ này, tổng hợp là đúng bằng một; kết quả là, các mã được gọi là một mã đầy đủ. Nếu điều này không phải là trường hợp, bạn luôn có thể lấy được một mã số tương đương bằng cách thêm các biểu tượng phụ (với tần xuất null), để làm cho toàn bộ mã trong khi vẫn giữ nó biunique. Theo định nghĩa của Shannon (1948), các nội dung thông tin (bit) của mỗi ký hiệu ai với tần suất :

Các entropy H (bit) là tổng trọng số, trên tất cả các ký hiệu với wi tần suất khác null , nội dung thông tin của mỗi ký hiệu:


16Huffman Coding

(Lưu ý: Một biểu tượng với tần suất bằng không đã không đóng góp cho entropy. Khi w = 0, là một hình thức không xác định; Vậy theo quy tắc L'Hôpital's:

.

Để đơn giản, các biểu tượng với tần suất bằng không bị loại ra ngoài của công thức trên.) Như một hệ quả của mã nguồn của định lý Shannon, entropy là một thước đo chiều dài từ mã nhỏ nhất, đó là trên lý thuyết có thể cho bảng chữ cái được với các trọng số liên quan. Trong ví dụ này, các trọng số từ mã có chiều dài trung bình là 2,25 bit / ký hiệu, chỉ hơi lớn hơn entropy tính của 2,205 bit cho mỗi ký hiệu. Vì vậy, không chỉ là tối ưu code này trong ý nghĩa rằng, không có mã khả thi khác thực hiện tốt hơn, nhưng nó là rất gần với giới hạn lý thuyết được thành lập theo Shannon. Lưu ý rằng, nói chung, một mã Huffman không cần phải là duy nhất, nhưng nó luôn luôn là một trong các mã giảm thiểu L (C).

Giải thuật Giải thuật tham lam Trong giải thuật tham lam giải bài toán xây dựng cây mã tiền tố tối ưu của Huffman, ở mỗi bước ta chọn hai chữ cái có tần số thấp nhất để mã hóa bằng từ mã dài nhất. Giả sử có tập A gồm n ký hiệu và hàm trọng số tương ứng W (i),i = 1..n. •

•

Khởi tạo: Tạo một rừng gồm n cây, mỗi cây chỉ có một nút gốc, mỗi nút gốc tương ứng với một kí tự và có trọng số là tần số/tần suát của kí tự đó W (i). Lăp: o Mỗi bước sau thực hiện cho đến khi rừng chỉ còn một cây: o Chọn hai cây có trong số ở gốc nhỏ nhất hợp thành một cây bằng cách thêm một gốc mới nối với hai gốc đã chọn. Trọng số của gốc mới bằng tổng trọng số của hai gốc tạo thành nó.

Như vậy ở mỗi bước số cây bớt đi một. Khi rừng chỉ còn một cây thì cây đó biểu diễn mã tiền tố tối ưu với các ký tự đặt ở các lá tương ứng. Ví dụ Cho bảng tần suất của 5 chữ cái A,B,C,D,E như sau tương ứng là 0.10; 0.15; 0.30; 0.16; 0.29


17Huffman Coding

A

B

C

D

E

0.10

0.15

0.30

0.16

0.29

Tại sao Huffman Coding là giải thuật tham lam ? Thuật toán Huffman là một ví dụ của thuật toán tham lam. Nó được gọi là tham lam, vì hai nút nhỏ nhất được lựa chọn tại mỗi bước, và kết quả quyết định này là cục bộ trong một cây mã hóa tối ưu trên toàn cục. Nhìn chung, các thuật toán tham lam sử dụng hạt nhỏ, hoặc cục bộ tối thiểu / tối đa để lựa chọn cho kết quả trong một toàn cục tối thiểu / tối đa. Ví dụ đổi tiền của Mỹ là một ví dụ của thuật toán tham lam. Đặt vấn đề: cung cấp cho sự thay đổi trong xu Mỹ cho bất kỳ số tiền (nhỏ hơn $ 1,00) bằng cách sử dụng số tiền cắc nhỏ nhất. Giải pháp (giả sử mệnh giá đồng tiền xu của $ 0,25, $ 0,10, $ 0,05, và 0,01 $, được gọi là quarters, dimes, nickels, and pennies) sử dụng đồng tiền cao nhất có giá trị mà bạn có thể có, và bạn có thể cho nhiều số của các số trong số trên. Lặp lại quá trình cho đến khi sự số tiền đúng bằng số tiền bạn muốn đổi. Ví dụ: đổi tiền cho $ 0,91. Sử dụng 3 / 4 (chúng ta có thể sử dụng đồng tiền cao nhất, và chúng ta có thể sử dụng như nhiều như ta cần). 0,91= 3*0,25 + 0,10 + 0,05 + 0,01 Kết quả là một tổng số với sáu đồng xu, nó không thể đổi cho $ 0,91 bằng cách sử dụng ít đồng tiền xu hơn. Các giải pháp / thuật toán là tham lam vì đồng tiền mệnh giá lớn nhất được chọn để sử dụng tại mỗi bước, và được sử dụng nhiều nhất như có thể. Bước này tại cục bộ tối ưu dẫn đến một giải pháp toàn cục tối ưu. Lưu ý rằng các thuật toán không làm việc với các mệnh giá khác nhau. Ví dụ, nếu không có nickels, thuật toán sẽ đổi cho $ 0,31 bằng cách sử dụng đồng quarters và sáu đồng pennies , tổng cộng bảy xu. Tuy nhiên, có thể sử dụng ba dimes và penny một, tổng cộng bốn xu. Điều này cho thấy các thuật toán tham lam không phải luôn luôn các thuật toán tối ưu.

Quá trình xây dựng cây Huffman Bước đầu tiên trong việc xây dựng mã Huffman là đếm số lần xuất hiện của mỗi kí tự trong tập tin sẽ được mã hoá. Bước tiếp theo là xây dựng một cây nhị phân với các tần số được chứa trong các nút. Hai nút có tấn số bé nhất được tìm thấy và một nút mới được tạo ra với hai nút con là các nút đó với giá trị tần số của nút mới bằng tổng tần suất của hai nút con. Tiếp theo hai nút mới với tần số nhỏ nhất lại được tìm thấy và một nút mới nữa lại được tao ra DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

18Huffman Coding

theo cách trên. Lặp lại như vậy cho đến khi tất cả các nút được tổ hợp thành một cây duy nhất. Sau khi có cây nhị phân, bảng mã Huffman được phát sinh bằng cách thay thế các tần số ở nút đáy bằng các kí tự tương ứng.

Minh họa quá trình xây dựng Chúng ta sẽ sử dụng chuỗi " go go gophers " làm ví dụ. Ban đầu chúng ta có những nút được hiển thị như bên dưới. Các nút được hiển thị với một trọng số, số đại diện cho số lần ký tự xuất hiện.

Chúng ta chọn hai nút tối thiểu. Có năm các nút với trọng lượng tối thiểu, nó không quan trọng mà chúng ta chọn hai. Trong một chương trình, xác định các khía cạnh của chương trình sẽ có hai lựa chọn, ví dụ, phần từ đầu và thứ 2 trong một mảng, hoặc các yếu tố được trả về bởi một hàng đợi ưu tiên. Chúng ta tạo ra một cây mới có gốc là tổng của trọng số các nút được chọn. Bây giờ chúng ta có một rừng với bảy cây như hiển thị dưới đây:

Chọn hai cây khác có trọng số hai như hình dưới. Hiện nay có sáu cây trong rừng cây mà ta sẽ xây dựng một cây mã hóa.

Một lần nữa chúng ta phải chọn hai cây có trọng số tối thiểu. Trọng số thấp nhất là nút ‘e’ / cây với trọng số bằng một. Có ba cây với trọng số hai, chúng ta có thể chọn bất kỳ để tạo ra một cây mới có trọng số sẽ là ba.


19Huffman Coding

Bây giờ có hai cây có trọng số bằng hai. Hợp chúng lại thành một cây mới có trọng số là bốn. Có bốn cây trái, một trong những cây có trọng số là bốn và ba với trọng số ba.

Hai cây tối thiểu (trọng số 3) được hợp lại thành một cây có trọng số là sáu. Trong biểu đồ dưới đây chúng ta chọn các cây g 'và' o ' (chúng ta có thể đã lựa chọn các cây ' g ' và cây 'e-' hoặc cây 'o' và cây 'e-'.) Có ba cây phía trái.

Các có trọng số

cây còn lại tối thiểu là ba và bốn,

lại thành trọng bảy, để lại còn hai cây.

hợp chúng một cây có lượng là


20Huffman Coding

Cuối cùng, hai cây còn lại được hợp thành một cây cuối cùng có trọng số là mười ba, tổng của hai trọng số sáu và bảy. Lưu ý rằng cây này có điểm khác nhau từ các cây chúng tôi được sử dụng để minh họa Huffman mã hóa ở trên, và các mẫu bit cho mỗi ký tự khác nhau, nhưng tổng số các bit được sử dụng để mã hóa " go go gophers " là như nhau.

Các ký tự mã hóa bởi cây cuối cùng là hiển thị dưới đây, một lần nữa, 0 được sử dụng cho các cạnh trái và 1 cho các cạnh bên phải. char Chuỗi "go go gopher " sẽ được mã hoá như 'g' minh họa dưới (với các khoảng trống sử 'o'

binary 00

'e' 101

01

'r' 1111

'p'

1110

's'1100

'h'

1101

' '100 DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

21Huffman Coding

dụng cho việc đọc dễ dàng hơn, các khoảng trống sẽ không xuất hiện trong mã hóa thực sự). 00 01 100 00 01 100 00 01 1110 1101 101 1111 1100 Một lần nữa, 37 bit được sử dụng để mã hóa " go go gopher ". Có một số cây có thế mã hóa 37-bit tối ưu cho " go go gopher ". Cây trên thực tế có các kết quả từ một chương trình thực hiện của thuật toán của Huffman sẽ giống nhau mỗi lần chạy chương trình là cho cùng một trọng số (việc tạo ra các cây không theo cách ngẫu nhiên).

Kỹ thuật mã hóa Huffman căn bản Kỹ thuật này thực hiện bằng cách tạo nút của cây nhị phân. Đó có thể chứa mảng có thứ tự, kích cỡ của chúng thì phụ thuộc vào số lượng ký hiệu. Ban đầu khởi tạo tất cả các nút đều là nút lá, chứa trong đó gồm, ký hiệu của chính nó và tần suất xuất hiện (frequency of appearance) của ký hiệu, liên kết đến nút cha là cách dễ dàng thực hiện bắt đầu từ nút lá. Nút trong (đỉnh trong) chứa ký hiệu f (tần suất xuất hiện), liên kết đến hai nút con và tùy ý liên kết đến nút cha khác. Như quy ước thông thường thì, bit ‘0’ đại diện cho nhánh con bên trái, bit ‘1’ đại diện cho nhánh con bên phải. Hoàn thành cây có hơn n nút lá và n-1 nút trong. Một cây Huffman bỏ qua những ký hiệu không dùng đến để kết quả là độ dài bộ mã được tối ưu nhất. Quá trình này về cơ bản bắt đầu với các nút lá có chứa các xác suất của các ký hiệu mà chúng đại diện, sau đó một nút mới với con là hai nút có xác suất nhỏ nhất được tạo ra, như vậy các nút mới xác suất bằng tổng xác suất của hai nút con. Vớihai nút trước đó sáp nhập vào một nút (như vậy, không xem xét chúng nữa), và với các nút mới được tiếp tục xem xét , thủ tục được lặp lại cho đến khi chỉ có một nút còn lại, cây Huffman. Các thuật toán xây dựng công trình đơn giản sử dụng một hàng đợi ưu tiên, với nút có tần suất thấp nhất được đưa ra ưu tiên cao nhất: 1. Tạo một nút lá cho mỗi ký hiệu và thêm nó vào hàng đợi ưu tiên. 2. Trong khi có nhiều hơn một nút trong hàng đợi:

Hủy bỏ hai nút ưu tiên cao nhất (có tần suất thấp nhất) từ hàng đợi  Tạo một nút mới là nút cha với hai nút con và có xác suất bằng tổng xác suất của hai nút con.  Thêm các nút mới vào hàng đợi. 3. Nút còn lại là nút gốc và cây hoàn tất. 

Từ hiệu quả ưu tiên hàng đợi, cấu trúc dữ liệu đòi hỏi O(log(n)) thời gian cho mỗi lần chèn, và cây có n lá sẽ có 2n-1 nút, thuật toán này hoạt động trong O (n log n) thời gian.


22Huffman Coding

Nếu các biểu tượng được sắp xếp theo xác suất, có một thời gian tuyến tính (O (n)) để tạo ra một cây Huffman sử dụng hai hàng đợi, một trong những đầu tiên có tần suất ban đầu (cùng với các con trỏ tới các lá có liên quan), và kết hợp tần suất (cùng với các con trỏ đến cây) được đặt ở phía sau của hàng đợi thứ hai. Điều này đảm bảo rằng tần suất thấp nhất là luôn luôn lưu giữ tại phía trước của một trong hai hàng đợi: 1. Bắt đầu với nhiều lá như là ký hiệu. 2. Xếp vào hàng tất cả các nút lá vào hàng đầu tiên (theo tần suất). 3. Trong khi có nhiều hơn một nút trong hàng đợi:  Rút khỏi hàng hai nút tần suất thấp nhất bằng cách kiểm tra phía trước của cả hai hàng đợi.  Tạo một nút mới , với hai nút chỉ gỡ bỏ như là nút con (hoặc nút có thể có nút con) và tổng tần suất của chúng như là tần suất mới.  Xếp vào hàng nút mới vào phía sau hàng thứ hai. 4. Các nút còn lại là nút gốc, cây hiện đã được tạo ra. Nói chung nó có lợi để giảm thiểu chiều dài từ mã. Ví dụ, một bộ đệm truyền nhận dữ liệu mã hoá Huffman có thể cần phải lớn hơn để đối phó với các ký hiệu đặc biệt, nếu cây là không cân bằng. Để giảm thiểu, đơn giản chỉ cần phá vỡ quan hệ giữa hàng đợi bằng cách chọn mục đầu tiên trong hàng đợi. Sửa đổi này sẽ giữ lại các tối ưu toán học của mã hóa Huffman trong khi cả hai giảm thiểu độ dài của mã ký tự dài nhất.

Hàng đợi có ưu tiên Trong mỗi bước của thuật toán xây dựng cây Huffman, ta luôn phải chọn ra hai gốc có trọng số nhỏ nhất. Để làm việc này ta sắp xếp các gốc vào một hàng đợi ưu tiên theo tiêu chuẩn trọng số nhỏ nhất. Một trong các cấu trúc dữ liệu thuận lợi cho tiêu chuẩn này là cấu trúc Heap (với phần tử có trọng số nhỏ nhất nằm trên đỉnh của Heap).

Hiện thực bằng Mã giả Nén file bằng mã Huffman Trong các bước trên, giả sử đã xây dựng được bộ mã Huffman của 256 ký hiệu có mã ASCII từ 0 đến 255 chứa trong mảng Code[1..256]. Việc nén file có thể phân tích sơ bộ như sau: 1. Đọc từng byte của file cần nén cho đến khi hết tệp, 2. Chuyển theo bộ mã thành xâu nhị phân, 3. Ghép với xâu nhị phân còn dư từ bước trước, 4. Nếu có đủ 8 bit trong xâu thì cắt ra tám bít đầu tiên ghi vào tệp nén. 5. Nếu đã hết tệp cần nén thì dừng. Trong đoạn mã giả dưới đây ta dựa trên một mảng các ký hiệu A[1..n] có tần suất tương ứng là W [1..n] DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

23Huffman Coding

Tạo hàng đợi bằng đống (heap) Ta tạo một đống trên cơ sở sắp xếp lại các chỉ số của A và W. Ta lưu trữ đống dưới dạng mảng, kí hiệu nó là Heap[1..n]. Trước hết đưa chỉ số của các chữ cái theo thứ tự ban đầu vào mảng Heap[1..n] với Heap[i]=i . với mọi i=1..n. Procedure DownHeap (List W,Int k,Int Count) { i:=k, v:=W(Heap(k)), j While 2*i<=Count { j:=2*i if j+1<= Count and W(Heap(j+1))>W(Heap(j)) then j:=j+1 if W(Heap(j))< v then Heap(i):=Heap(j) Int

else break i:=j } } Heap(j):=Heap(k)

Procedure MakeHeap (List W,Int n) { k For k:=int(n/2) downto 1 { DownHeap (W,k,n) } Int

Xây dựng cây Huffman Ta sẽ lưu trữ cấu trúc của cây mã Huffman vào một mảng. Cây Huffman gồm n lá mỗi lá chứa chỉ số của chữ cái tương ứng. Mỗi lần ghép 2 cây thành một ta phải thêm một đỉnh, như vậy cây biểu diễn mã Huffman gồm 2. n-1 đỉnh. Ta kí hiệu cây này là Huff [1..2n-1]. Vì mỗi gốc mới bổ sung đều có trọng số nên ta mở rộng mảng W [1..n] các trọng số thành mảng W' [1..2n+1]. Gọi m là số đỉnh của cây sẽ xây dựng. lúc đầu ta có n lá, đỉnh bổ sung lần đầu sẽ là n+1, lần thứ 2 là n+2, ... Khi lấy ra hai kí tự có tần số nhỏ nhất chẳng hạn kí tự thứ i làm con trái và kí tự thứ j làm con phải của đỉnh mới bổ sung có chỉ số m ta đặt Huff [i]=-m, Huff [j]=m. Procedure MakeTreeHuffman (List W,Int n) { Heap,Huff Int i,j,count:=n,m:=n MakeHeap(W) While Count >1 { i:=Heap(1) Heap(1):= Heap(count) Count:=Count-1 DownHeap(W,1,Count) j:=Heap(1) m:=m+1 List


24Huffman Coding

Huff(i):=-m Huff(j):=m W(m):=W(i)+W(j) Heap(1):=m DownHeap(W,1,Count) }

Return Huff }

Xây dựng bộ mã Sau khi cấu trúc của cây Huffman được lưu vào mảng Huff ta dễ dàng xây dựng mảng Code[1..n] cho bộ mã nhị phân tiền tố tối ưu của các kí tự A[1..n] Procedure CodingHuffman (List Huff, n){ k:=1,j While k<=n { Code(k):="" j:=Huff(k) While Abs(j)<=2*n-1 { If j>0 then Code(k)="1"+Code(k) else Code(k)="0"+Code(k) j:=Huff(abs(j)) } k:=k+1 } Return Code Int

}

Đánh giá chi phí giải thuật -Ta ký hiệu T(n) là hàm thời gian thực hiện một chương trình, trong đó n là kích thước độ lớn của dữ liệu vào, và T(n)≥ 0 , Với n ≥ 0

Chi phí cho xử lý heap (A) Procedure DownHeap (List W,Int k,Count) { [1] [2] [3] [4] [5] [6] [7]

i:=k, v:=W(Heap(k)), j While 2*i<=Count { j:=2*i if j+1<= Count and W(Heap(j+1))>W(Heap(j)) then j:=j+1 if W(Heap(j))< v then Heap(i):=Heap(j) Int

else break i:=j } } Heap(j):=Heap(k)

Chi phí cho xử lý heap với đoạn mã giả trên : DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

25Huffman Coding

Các lệnh gán dòng [1], [3], [7] tốn O(1) thời gian thực hiện. Các câu lệnh điều kiện dòng [4], [5] tốn O(1) thời gian thực hiện. Mỗi lần đi qua vòng lặp while thực hiện thì số k tăng lên gấp đôi, và số phần tử còn lại giảm 1 nửa. Lặp k lần Lặp lần 1 Lặp lần 2 ……………… Lặp lần k

Giá trị của k 1 2 …………….. k

Độ lớn danh sách con N/2-1=(N/2)-(2^0) với k=1 N/2-2=(N/2)-(2^1) với k=2 ---(N/2)-(2^(k-1))

Ta có bất đẳng thức : 2^(k-1) < N/2  Điều kiện k < 1+ logN  Số lệnh thực hiện không nhiều hơn 1+ logn (cơ số 2) với k bắt đầu = 1

Vậy chi phí cho xử lý heap là T(n)=O(logn) Chi phí tạo Heap Procedure MakeHeap (List W,Int n) { [1] [2] [3]

k For k:=int(n/2) downto 1 { DownHeap (W,k,n) Int

}

Dòng lệnh 3 gọi DownHeap, với k=n/2 >= 1 + logN , nên nó tốn O(1); Vòng lặp for dòng [3] chạy từ n/2 đến 1 vậy tốn O(n/2) 

Chi phí của giải thuật tạo Heap tốn T(n)=O(n/2).

Chi phí tạo cây : Procedure MakeTreeHuffman (List W,Int n) { [1] [2] [3] [4] [5] [6] [7] [8] [9]

Heap,Huff i,j,count:=n,m:=n MakeHeap(W) While Count >1 { i:=Heap(1) Heap(1):= Heap(count) Count:=Count-1 DownHeap(W,1,Count) j:=Heap(1) List Int


26Huffman Coding

[10] [11] [12] [13] [14] [15]

m:=m+1 Huff(i):=-m Huff(j):=m W(m):=W(i)+W(j) Heap(1):=m DownHeap(W,1,Count) }

Return Huff }

- Với đoạn mã giả trên, ta có chi phí tạo cây chi tiết như sau : Với lệnh gọi hàm DownHeap ở dòng [8] và [15] , mỗi dòng tốn chi phí O(logn) thời gian thực hiện. Với lệnh gọi hàm MakeHeap ở dòng [3] , ta tốn O(n/2) thời gian thực hiện. Các lệnh gán tại dòng [1], [2] tốn O(1) thời gian. Các lệnh gán và phép tính tại dòng [5], [6], [7], [9], [10], [11], [12], [13], [14] tốn O(1) thời gian. Vòng lập while dòng [4] , lặp từ n -> 1 tốn O(n), mà lệnh [8], [15] nằm trong vòng lặp, nên tốn chi phí O(n.logn) Vậy giải thuật tạo cây tốn : O(n/2 + n.logn) Chọn T(n) = nlogn 

Vậy Chi phí giải thuật tạo cây T(n) = nlogn

Các biến thể Huffman Coding Nhiều biến thể của mã hóa Huffman tồn tại, một số trong đó sử dụng một thuật toán giống Huffman, và những người khác trong đó tìm các mã tiền tố tối ưu (trong khi, ví dụ, đặt các hạn chế khác nhau về ouput). Lưu ý rằng, trong trường hợp thứ hai, phương pháp không cần phải giống được như Huffman, và quả thật vậy, thậm chí không cần phải có thời gian đa thức (polynomial time). Một danh sách dài các giấy tờ về mã hóa Huffman và các biến thể của nó được cho bởi "Mã và phân tích cây cho Lossless Source Encoding".

n-ary Huffman coding Các thuật toán n-ary Huffman sử dụng (0, 1, ... , N - 1) bảng chữ cái để mã hóa thông tin và xây dựng một cây n-ary. Cách tiếp cận này được coi là của Huffman trong bài báo gốc của ông. Cùng một thuật toán áp dụng như đối với hệ nhị phân (n bằng 2) mã, ngoại trừ các ký hiệu n ít nhất có thể xảy ra được lấy nhau, thay vì chỉ là 2 ít nhất DHTH5ALT – Phân Tích & Thiết Kế Giải Thuật

27Huffman Coding

có thể xảy ra. Lưu ý rằng đối với n lớn hơn 2, không phải tất cả các tập từ nguồn đúng có thể hình thành một cây n-ary cho mã hóa Huffman.

Adaptive Huffman coding Một biến thể được gọi là mã hóa Huffman tính toán tần suất động dựa trên các tần số gần đây thực tế trong chuỗi nguồn. Đây có một số liên quan gần gũi với thuật toán LZ. (LZ77 và LZ78 là tên hai thuật toán nén dữ liệu).

Huffman template algorithm Thông thường, trọng số được sử dụng trong việc triển khai của mã hóa Huffman đại diện cho số tần suất, nhưng các thuật toán ở trên không yêu cầu điều này, nó chỉ đòi hỏi một cách để sắp xếp trọng số và để thêm chúng. Các thuật toán cho phép Huffman mẫu một trong những loại sử dụng bất kỳ kiểu trọng số nào (chi phí, tần số, cặp trọng lượng, trọng lượng không số) và là một trong nhiều cách kết hợp các phương pháp (không chỉ cộng). thuật toán này có thể giải quyết vấn đề giảm thiểu khác, chẳng hạn như giảm thiểu mạch.

, một vấn đề đầu tiên áp dụng để thiết kế

Length-limited Huffman coding Hạn chế chiều dài mã hóa Huffman là một biến thể mà mục tiêu là vẫn còn để đạt được một độ dài tối thiểu độ dài trọng số, nhưng có một hạn chế khác mà độ dài của mỗi từ mã phải nhỏ hơn một hằng số cho trước. Các thuật toán package-merge giải quyết vấn đề này với một cách tiếp cận tham lam đơn giản, rất tương tự như được sử dụng bởi thuật toán của Huffman. Thời gian của nó phức tạp là O ( nL), với L là chiều dài tối đa của một từ mã. Không được biết đến thuật toán để giải quyết vấn đề này trong thời gian tuyến tính (linear) hoặc linearithmic , không giống như các presorted và không được chọn lọc vấn đề Huffman, tương ứng.

Huffman coding with unequal letter costs Optimal alphabetic binary trees (Hu-Tucker coding)

Ưu & Nhược điểm Huffman Coding Thuật toán Huffman có ưu điểm là hệ số nén tương đối cao, phương pháp thực hiện tương đối đơn giản, đòi hỏi ít bộ nhớ, có thể xây dựng dựa trên các mảng bé hơn 64KB. Nhược điểm của nó là phải chứa cả bảng mã vào tập tin nén thì phía nhận mới có thể giải mã được do đó hiệu suất nén chỉ cao khi ta thực hiện nén các tập tin lớn.


28Huffman Coding

Ta chọn phương pháp nén Huffman vì tính đơn giản của nó hệ số nén lại cao. Nhược điểm của phương pháp nén này có thể khắc phục bằng cách thực hiện nén một lần nhiều tập tin chuẩn bị truyền, làm như vậy coi như chúng ta đang thực hiện nén một tập tin lớn.

Tài liệu tham khảo Entropic Coding and Compression Huffman Encoding & Decoding by John Morris, 1998 http://en.wikipedia.org/wiki/Huffman_coding http://vi.wikipedia.org/wiki/M%C3%A3_Huffman http://www.animal.ahrgr.de


BaoCaoGT_HuffMan

Recommend Documents