- ํ์ผ ์คํ -> clean_text -> ์ฐ๊ธฐ ๋ชจ๋๋ก ํ์ผ ์คํ ํ ์ ์ฒ๋ฆฌ ๋ ๊ฒฐ๊ณผ๋ฅผ ํ์ผ์ ์์ฑ -> ํ์ผ ๋ซ๊ธฐ
import os
from re import findall, sub
print('\nํ์ฌ ๊ฒฝ๋ก :', os.getcwd())
#ํ์ผ ์คํ-str ํํ๋ก ๋ฐ์์ค๋ค
with open("/Users/kimnuri/PycharmProjects/ComputerAlgorithm/huffman/data/alice_in_wonderland.txt") as f:
content = " ".join([l.rstrip() for l in f])
#์ ์ฒ๋ฆฌ ์ํ ํจ์ ์ํ
def clean_text(content):
texts_re = content.lower() #์๋ฌธ์๋ก ๋ณ๊ฒฝ
texts_re2 = sub('[0-9]', '', texts_re) #์ซ์ ์ ๊ฑฐ
texts_re3 = sub('[\'`,.?!;:"\-\[\]]', '', texts_re2) #๋ฌธ์ฅ๋ถํธ ์ ๊ฑฐ
texts_re4 = sub('[@#$%^&*()]', '', texts_re3) #ํน์๋ฌธ์ ์ ๊ฑฐ
texts_re5 = sub('[๊ฐ-ํฃ]','',texts_re4) #ํ๊ธ ์ ๊ฑฐ
texts_re6 = texts_re5.replace(' ','') #white space ์ ๊ฑฐ
return texts_re6
print(clean_text(content))
#์์์ ์ฒ๋ฆฌ๋ ๊ฒฐ๊ณผ๋ฅผ ํ์ผ์ ๋ค์ ์จ์ค๋ค
texts2 = open('/Users/kimnuri/PycharmProjects/ComputerAlgorithm/huffman/data/alice_in_wonderland.txt',mode='w',encoding='UTF8')
texts2.write(clean_text(content))
texts2.close()import os
from re import findall, sub
#ํ์ผ ์คํ-str๊ตฌ์กฐ๋ก ๋ฐ์์จ๋ค
with open("/Users/kimnuri/PycharmProjects/ComputerAlgorithm/huffman/data/alice_in_wonderland.txt") as f:
content = " ".join([l.rstrip() for l in f])
Alphabet = 'abcdefghijklmnopqrstuvwxyz' #for๋ฌธ์์ ๋๋ฆฌ๊ธฐ ์ํจ๊ณผ ๋น๋์๋ฅผ ๊ณ์ฐํ๊ธฐ ์ํด ๋ฏธ๋ฆฌ ๋ฌธ์์ด์ ๋ง๋ค์ด์ค๋ค
texts_freq = [0] * 26
#์ํ๋ฒณ ๋น๋์ ๊ณ์ฐ
for al in content:
if al in Alphabet:
idx = Alphabet.find(al)
texts_freq[idx] += 1
#์ํ๋ฒณ ๋น๋์ ์ถ๋ ฅ
print("์ํ๋ฒณ ๋น๋์")
for i in range(0,26):
print(Alphabet[i], ":", texts_freq[i])
#ํ
์คํธ ๊ธธ์ด
print('texts ๊ธธ์ด =',len(content))๋จผ์ ์์ถ์ด๋ ์์ ์ด ์ ํ์ํ ๊น?
- ๋ฐ์ดํฐ์์ด ๋ง์ ํ์ผ์ ์์ถํ์ฌ ์ ์ฅ์ฅ์น์ ํจ์จ์ ์ผ๋ก ์ ์ฅ.
- ๋ฐ์ดํฐ์์ด ๋ง์ ํ์ผ์ ์์ถํ์ฌ ํต์ ๋คํธ์ํฌ๋ก ์ ๋ฌ.
- ์ฌ๋ฌ ๋ฐ์ดํฐ๋ค์ ๊ฐํธํ๊ณ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌ.
์ด๋ ๊ฒ ๋ฐ์ดํฐ์์ด ๋ง์ผ๋ฉด , ๋ฐ์ดํฐ ์ ์ก , ์ ์ฅ ๋ฑ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋๋ฐ ๋ถ๋ด์ด ๊ฐ๊ฒ ๋๋ค. ๊ทธ๋ ๊ธฐ์ ์์ถ์ด๋ผ๋ ์์ ์ด ํ์ํ๊ฒ์ด๋ค.
๋๋ JAVA๋ฅผ ํตํด ํํ๋ง ์ฝ๋๋ฅผ ๊ตฌํํ๋ ์ญํ ์ ๋งก์๋ค. ํผ์ํ๋๋ฐ ๋ฒ๊ฑฐ์์ด ์์ด, ํ์๋ค์ ๋์์ ๋ฐ๊ธฐ๋ ํ๊ณ , ์ฌ๋ฌ ๊นํ๋ธ , ์ ํ๋ธ , ๊ตฌ๊ธ์์ ๋ค๋ฅธ ์ฌ๋๋ค์ด ๊ตฌํํด๋์ ์ฝ๋๋ฅผ ๋ณด๋ฉด์ ๊ตฌํํด๋ณด์๋ค.
์ฐ๋ฆฌ ํ์ด ์์ถํด ๋ณผ ํ ์คํธ ํ์ผ์ '์ด์ํ ๋๋ผ์ ์๋ฆฌ์ค' ์๋ฌธํ์ด๋ค.
ํ์ง๋ง ๊ณต๋ฐฑ๊ณผ ํน์ ๋ฌธ์๊ฐ ๋ง์ , ์ด๋๋ก๋ ์์ถํจ์จ์ ๋ด๊ธฐ ํ๋ค ๊ฒ์ด๋ผ๊ณ ํ๋จํ์๋ค.
๊ทธ๋์ ๋จผ์ ๋ค๋ฅธ ํ์์ด ํน์๋ฌธ์์ ๊ณต๋ฐฑ์ ์ง์์ฃผ๋ ์๊ณ ๋ฆฌ์ฆ์ ํตํด ์๋ฌธ์ ๊ณต๋ฐฑ๊ณผ ํน์๋ฌธ์๋ฅผ ๋ชจ๋ ์ ๊ฑฐํ๋ค.
๋จผ์ ์ฃผ์ด์ง ํ ์คํธ์์ ๊ฐ ์๋ฌธ์์ ์ถํ ๋น๋์๋ฅผ ๊ตฌํ๋ค.
public static void numberoftexts(String src) {
// ์๋ฌธ์ ๋น๋ ์ ์กฐ์ฌ
try {
// ํ์ผ ๊ฐ์ฒด ์์ฑ
File file = new File(src);
// file์ ๋ํ ์
๋ ฅ ์คํธ๋ฆผ ์์ฑ
FileReader filereader = new FileReader(file);
// ์
๋ ฅ ๋ฒํผ ์์ฑ
BufferedReader bufReader = new BufferedReader(filereader);
String line;
// ํ์ผ ํ์ค์ฉ ์ฝ๊ธฐ
while ((line = bufReader.readLine()) != null) {
// ๋ฌธ์์ด์ ๋ฌธ์ ํ๋ํ๋ ํ์ธ
for (int i = 0; i < line.length(); i++) {
char temp = line.charAt(i);
// ํ์ฌ ๋ฌธ์๊ฐ ์ด๋ฏธ 1๋ฒ ์ด์ ๋ค์ด๊ฐ ์์ผ๋ฉด ๋ฌธ์์ ํด๋นํ๋ ๋น๋ ์ 1์ฆ๊ฐ
if (txt.containsKey(temp)) {
txt.put(temp, txt.get(temp) + 1);
} else {
txt.put(temp, 1);
}
}
}
// ์ฝ๊ธฐ ์ข
๋ฃ
bufReader.close(); ๊ฐ์ฅ ์์ ๋น๋์๋ฅผ ๊ฐ์ง๋ ๋ ธ๋ 2๊ฐ๋ฅผ ํฉ์ณ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ๋ง๋ ๋ค.
while(true) {
// ์ต์๊ฐ 2๊ฐ ์ถ์ถ
Node leftChild = mini.MinNode();
Node rightChild = mini.MinNode();
// ์ผ์ชฝ ๋
ธ๋์ ์ค๋ฅธ์ชฝ ๋
ธ๋๋ฅผ ๋ํ ๊ฐ์ ๋ฃ์ ๋ถ๋ชจ ๋
ธ๋ ์์ฑ
plusparent = new Node(leftChild.txt+rightChild.txt,'.');
plusparent.leftNode=leftChild;
plusparent.rightNode=rightChild;
// ํ์ด ๋น์ด์๋ค๋ฉด return
if(mini.isEmpty()) return;
// ์๋ก์ด ๋ถ๋ชจ ๋
ธ๋ ์ต์ํ์ ์ฝ์
mini.insert(plusparent);
}์ด ์์ ์ ๋ ธ๋๊ฐ 1๊ฐ ๋จ์๋๊น์ง ๋ฐ๋ณตํ๋ค.
์์ฑํ ํธ๋ฆฌ์ ์ผ์ชฝ ๊ฐ์ ์๋ 0, ์ค๋ฅธ์ชฝ ๊ฐ์ ์๋ 1
public static void HuffmanCode(Node root, int[] code, int idx) {
// ์ผ์ชฝ ๋
ธ๋๊ฐ ์๋ค๋ฉด ํํ๋ง ์ฝ๋๋ 0
if(root.leftNode != null) {
code[idx]=0;
// ๋ค์ ๋
ธ๋์ ํํ๋ง ์ฝ๋
HuffmanCode(root.leftNode, code, idx+1);
}
// ์ค๋ฅธ์ชฝ ๋
ธ๋๊ฐ ์๋ค๋ฉด ํํ๋ง ์ฝ๋๋ 1
if(root.rightNode !=null) {
code[idx]=1;
HuffmanCode(root.rightNode, code, idx+1);
}์ด๋ ๊ฒ ์ปดํ์ผ ํ์ฌ ์๋ฌธ์๋ค์ ๋น๋์ ๊ทธ์ ๋ง๊ฒ ํ ๋น๋ ์ด์ง์ฝ๋๋ฅผ ๊ตฌํ ์ ์๋ค.
๋น๋์๋ฅผ ์ธก์ ํ ๊ฒฐ๊ณผ.
์ด๊ฒ์ ์ด์ง์ฝ๋๋ฅผ ํ ๋น.
ํํ๋ง ์ฝ๋๋ ๋น๋์๊ฐ ๊ฐ์ฅ ๋์ ๋ฌธ์์ ๊ฐ์ฅ ์งง์ ์ฝ๋๋ฅผ ํ ๋นํ๊ณ , ๋น๋์๊ฐ ๋ฎ์ ๋ฌธ์์๋ ๊ธด ์ฝ๋๋ฅผ ํ ๋นํ์ฌ ์์ถ์ ํจ์จ์ฑ์ ๋์ธ๋ค
์ค์ ๋ก ๋น๋์๊ฐ 78๋ก ๊ฐ์ฅ ๋ฎ์ 'z'๋ 11์๋ฆฌ์ ๊ฐ์ฅ ๊ธด ์ฝ๋๋ฅผ ํ ๋น ๋ฐ์๊ณ
๋น๋์๊ฐ 13579๋ก ๊ฐ์ฅ ๋์ 'e'๋ 3์๋ฆฌ์ ๊ฐ์ฅ ์งง์ ์ฝ๋๋ฅผ ํ ๋น ๋ฐ์๋ค.
ํํ๋ง ์์ถ์ ํจ์จ์ฑ์ ์์๋ณด๊ธฐ ์ํด
ํํ๋ง ์์ถ์ ์์ถ๋ฅ ์ด ์ผ๋ง๋ ๋๋์ง ์์๋ณผ ๊ฒ์ด๋ค.
ํ
์คํธ ํ์ผ์ ์์ถํ๊ณ , ์์ถ๋ฅ ์ ๊ตฌํ๋๋ฐ
https://github.com/moomyung1013/Huffman-Coding ์ฐธ์กฐํ๋ค.
๋จผ์ ์ฐ๋ฆฌ ํ์ด ์์ถํ๊ธฐ๋ก ํ '์ด์ํ ๋๋ผ์ ์๋ฆฌ์ค' ์๋ฌธ ๋ฒ์ ์ด๋ค.
107,748byte -> 65,777byte ๋ก ํ์ผํฌ๊ธฐ๊ฐ ์ค์๋ค. ๋๋ต 40% ์์ถ์ด ๋ ์ ์ด๋ค.
๊ณผ์ฐ ์ด๋์ ๋ ํฌ๊ธฐ์ ํ์ผ์ ์์ถํ ๋ , ๊ฐ์ฅ ์์ถ๋ฅ ์ด ํด์ง ๊ถ๊ธํ์ฌ , ์์๋ก ๊ฐ์ ธ์จ 1KB , 5KB , 25KB , 50KB ํ ์คํธ ํ์ผ๋ค์ ํจ๊ป ๋น๊ตํด๋ณด์๋ค.
12,896byte -> 9,097byte (์ฝ 30% ์์ถ)
54,069byte -> 35,510byte (์ฝ 35% ์์ถ)
241.851byte -> 159,409byte (์ฝ 35% ์์ถ)
544,469byte -> 361,690byte (์ฝ 34% ์์ถ)
๋๋ต 30% ~ 40%์ ์์ถ๋ฅ ์ ๋ณด์ด๊ณ ์๋ค.
๊ทธ๋ํ๋ก ๋ํ๋ด ์ฝ๊ฒ ๋ณด๋ฉด ๊ฒฐ๊ตญ ์ฐ๋ฆฌ๊ฐ ์ฒ์์ ์์ถํ๋ 15KB์ '์ด์ํ ๋๋ผ์ ์๋ฆฌ์ค' ๊ฐ ๊ฐ์ฅ ๋์ ์์ถ๋ฅ ์ ๋ณด์๋ค. ํ์ง๋ง ๊ฐ์ ํฌ๊ธฐ์ ํ์ผ์ด๋ผ๋ ์์ถ๋ฅ ์ ์ถฉ๋ถํ ๋ฌ๋ผ์ง ์ ์๋ค. ํํ๋ง ์์ถ์ ์ต๋ 80%์ ์์ถ๋ฅ ๊น์ง ๋ณด์ฌ์ค๋ค๊ณ ํ๋ค. ์ด๋ ํ ์๋ฌธ์๊ฐ ์ผ๋ง๋ ๋น๋ฒํ๊ฒ ๋์ค๋๋์ ๋ฐ๋ผ ์์ถ๋ฅ ๋ํ ๋ฌ๋ผ ์ง ์ ์์ ๊ฒ ๊ฐ๋ค. ๋ค์์๋ ์ข ๋ ๋ฐ์ ํด , GUI๊น์ง ๊ตฌ์ฑ๋ ์์ถ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด๋ ๊ธฐํ๋ฅผ ๊ฐ์ง๊ณ ์ถ๋ค.
ํํ๋ง ์ฝ๋ ์ด์งํธ๋ฆฌ๋ ํ
์คํธ ์์ถ์ ์ํด ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ฌ์ฉ ๋น๋๊ฐ ๋์ผ๋ฉด ์์ ๋นํธ๋ก ๋ฎ์ผ๋ฉด ํฐ ๋นํธ๋ก ๋ณํํด์ ๋ํ๋ธ ํธ๋ฆฌ๋ค.
์ถํ ๋น๋๋ฅผ ๊ตฌํ์ผ๋ฉด ํํ๋ง ์ฝ๋์ ์
๋ ฅ์ํค๊ณ , ์
๋ ฅ์ํจ ํ
์คํธ๋ค์ด ๋ณํ๊ฐ์ ๊ฐ์ง๋ค.
Node leftChild = mini.MinNode();
Node rightChild = mini.MinNode();
plusparent = new Node(leftChild.txt+rightChild.txt,'.');
plusparent.leftNode=leftChild;
plusparent.rightNode=rightChild;
if(mini.isEmpty()) return;
mini.insert(plusparent);
}
์์ ์ฝ๋๋ก ํธ๋ฆฌ์ ์ผ์ชฝ์ 0, ์ค๋ฅธ์ชฝ์ 1์ ํ ๋นํ ์ด์ง์ฝ๋์ ๊ฐ์ ์๋์ ์ฌ์ง๊ณผ ๊ฐ๋ค.

๋ฐ๋ผ์ ์ด ์ด์ง์ฝ๋์ ํํ๋ง ํธ๋ฆฌ๋ฅผ ๊ทธ๋ ค๋ณด์๋ค.
์ ์ฌ์ง๊ณผ ๊ฐ์ด ์ฌ์ฉ ๋น๋๊ฐ ๋์ ๋ฌธ์๊ฐ ํธ๋ฆฌ์ ์๋ถ๋ถ์ ์๊ณ ๋ฎ์ ๋ฌธ์๊ฐ ํธ๋ฆฌ์ ์ ์ผ ๋ฐ๋ถ๋ถ์ ์๋ ๊ฒ์ ์ ์ ์๋ค.
ํํ๋ง ์ฝ๋์์ ์ฑ๋ฅ๋ถ์์ด๋ ๊ธฐ์กด์ ํ
์คํธ ํ์ผ์์ ์์ถํ๊ณ ๋ ํ์ ํ
์คํธ ํ์ผ์ด ์ผ๋ง๋งํผ ์ค์๋๊ฐ๋ฅผ ๋ํ๋ด๋ ๊ฒ์ด๋ค.
๊ธฐ์กด์ alice ํ
์คํธ ํ์ผ์์์ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ 107748์ด์๊ณ , ASCII ์ฝ๋๋ก ๋ํ๋ผ ์ 8bit๋ฅผ ๊ณฑํ 861984bit์ด๋ค.
ํํ๋ง ์ฝ๋์์๋ ๋ณํ๋ ๊ฐ์ด ๊ฐ๋ณ ๊ธธ์ด ์ฝ๋์ด๋ค. ์ด์ง์ฝ๋์ ๊ฐ์ ๊ฐ๊ฐ์ ๋น๋์๋ฅผ ๊ณฑํด์ ๋ํ์๋ ๊ฐ์ด 451520์ด ๋์๋ค.
451520 / 861984 *100 = 54 ์ ๋ ์ด๋ฏ๋ก ๋๋ต 46% ์ ๋ ์์ถ๋์๋ค.
์์์ ์ธ๊ธํ๋ฏ์ด ํํ๋ง ์๊ณ ๋ฆฌ์ฆ์ ์์ถ๋ฅ ์ด ์ผ์ ํ ๊ฒ์ด ์๋๋ผ ๊ฐ์ด ๋ณ๋์ด ๋๋ค.
๋ํ ์์ ํธ๋ฆฌ๋ฅผ ๊ตฌํํ์ ๋ ์ด์ง์ฝ๋๊ฐ ๋ค์ด๊ฐ ๋
ธ๋๋ค์ด ์์ ๋ง์ด ์์์๋ ๋ถ๊ตฌํ๊ณ ์ฝ๋๊ฐ ๊ธธ์ด์ง ๊ฒ ์ฒ๋ผ, ์๊ณ ๋ฆฌ์ฆ์ ์ง๋ ๋ฐฉ์์ ๋ฐ๋ผ ์ด์ง์ฝ๋์ ๊ฐ์ ์ค์ฌ์ ์์ถ๋ฅ ์ ๋์ผ ์ ์์ ๊ฒ์ด๋ค.
์ด๋ฒ ํํ๋ง ์์ถ ํ ๊ณผ์ ๋ฅผ ํ๊ธฐ ์ํด ๊ฐ์ฅ ๋จผ์ ํ ๊ฒ์ ๊ฐ์ ์ฌ์ฉํ๋ ์ธ์ด๊ฐ ๋ฌด์์ธ์ง ์์๋ณด๋ ๊ฒ์ด์๋ค.
๊ฐ์ python, java, c ๋ฑ ์๋ก ์ฌ์ฉํ๋ ์ธ์ด๊ฐ ๋ฌ๋ผ ๊ทธ์ ๋ง์ถฐ์ ์๋ก ํด์ผํ ํํธ๋ฅผ ๋๋๊ธฐ๋ก ํ๋ค.
๋ฌธ์ ํ์ผ์ ์ ์ฉํ๊ธฐ ์ฉ์ดํ python์ ์ฌ์ฉํ๋ ํ์ ๋ถ์ด ์ ์ฒ๋ฆฌ๋ฅผ ๋ด๋นํ๊ธฐ๋ก ํ๊ณ , java ์์
์ธ๋งํผ ์๊ณ ๋ฆฌ์ฆ์ java๋ฅผ ์ฌ์ฉํ๋ ํ์ ๋ถ์ด ๊ตฌํํ๊ธฐ๋ก ํ๋ค.
๊ณผ์ ๋ฅผ ํ๋ฉด์ ํ์ ๊ณต๋ถํ ๋ ๋ธ๋ก๊ทธ๋ ์ฑ
์ ์ ํ์๋ ์ฝ๋๋ฅผ ๋ณด๊ณ ๋๊ธฐ๋ ๊ฒ์ด ์๋ ์ง์ ์ฐพ์๋ณด๊ณ ์๊ฐํด๊ฐ๋ฉฐ ์ฝ๋๋ฅผ ๊ตฌํํ๋ค.
๋ํ ๊ตฌํํ ์ฝ๋๋ฅผ ์คํํด์ ์์ถ๋ฅ ์ ๊ณ์ฐํ๊ณ , ์ฑ๋ฅ๋ถ์๊ณผ ์ด์งํธ๋ฆฌ๋ฅผ ์ง์ ๊ทธ๋ ค๋ณด๋ฉด์ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ฉฐ ๋ณด์ถฉํ ๋ถ๋ถ์ ๋ค์ ์๊ฐํด๋ณผ ์ ์์๋ค.

