เชชเชฐเชฟเชเชฏ
เช เชฒเซเชเชฎเชพเช, เชนเซเช เชเชพเชฃเซเชคเชพ เชนเชซเชฎเซเชจ เช เชฒเซเชเซเชฐเชฟเชงเชฎ, เชคเซเชฎเช เชกเซเชเชพ เชเชฎเซเชชเซเชฐเซเชถเชจเชฎเชพเช เชคเซเชจเซ เชเชชเซเชฒเชฟเชเซเชถเชจ เชตเชฟเชถเซ เชตเชพเชค เชเชฐเซเชถ.
เชชเชฐเชฟเชฃเชพเชฎเซ, เช
เชฎเซ เชเช เชธเชฐเชณ เชเชฐเซเชเชพเชเชตเชฐ เชฒเชเซเชถเซเช. เช เชชเชนเซเชฒเซเชฅเซ เช เชฅเช เชเซเชเซเชฏเซเช เชเซ
เชฅเซเชกเซเช เชชเซเชฐเชคเชฟเชฌเชฟเชเชฌ
เชธเชพเชฎเชพเชจเซเชฏ เชเซเชเซเชธเซเช เชซเชพเชเชฒเชฎเชพเช, เชเช เช เชเซเชทเชฐ 8 เชฌเชฟเชเซเชธ (ASCII เชเชจเซเชเซเชกเชฟเชเช) เช เชฅเชตเชพ 16 (เชฏเซเชจเชฟเชเซเชก เชเชจเซเชเซเชกเชฟเชเช) เชธเชพเชฅเซ เชเชจเซเชเซเชก เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชเซ. เชเชเชณ, เช เชฎเซ ASCII เชเชจเซเชเซเชกเชฟเชเช เชชเชฐ เชตเชฟเชเชพเชฐ เชเชฐเซเชถเซเช. เชเชฆเชพเชนเชฐเชฃ เชคเชฐเซเชเซ, s1 = "SUSIE SAYS IT IS EASYn" เชถเชฌเซเชฆเชฎเชพเชณเชพ เชฒเซ. เชเซเชฒ เชฎเชณเซเชจเซ, เชฒเชพเชเชจเชฎเชพเช 22 เช เชเซเชทเชฐเซ เชเซ, เช เชฒเชฌเชคเซเชค, เชเชเซเชฏเชพเช เช เชจเซ เชจเชตเซ เชฒเชพเชเชจ เช เชเซเชทเชฐ - 'n' เชธเชนเชฟเชค. เช เชฒเชพเชเชจ เชงเชฐเชพเชตเชคเซ เชซเชพเชเชฒเชจเซเช เชตเชเชจ 22*8 = 176 เชฌเชฟเชเซเชธ เชนเชถเซ. เชชเซเชฐเชถเซเชจ เชคเชฐเชค เช เชเชฆเซเชญเชตเซ เชเซ: เชถเซเช 8 เช เชเซเชทเชฐเชจเซ เชเชจเซเชเซเชก เชเชฐเชตเชพ เชฎเชพเชเซ เชคเชฎเชพเชฎ 1 เชฌเชฟเชเซเชธเชจเซ เชเชชเชฏเซเช เชเชฐเชตเซ เชคเชฐเซเชเชธเชเชเชค เชเซ? เช เชฎเซ เชฌเชงเชพ ASCII เช เชเซเชทเชฐเซเชจเซ เชเชชเชฏเซเช เชเชฐเชคเชพ เชจเชฅเซ. เชเซ เชคเซเช เชนเซเชฏ เชคเซ เชชเชฃ, เชธเซเชฅเซ เชตเชงเซ เชตเชพเชฐเชเชตเชพเชฐ เชเชตเชคเชพ เช เชเซเชทเชฐ - S - เชถเชเซเชฏ เชคเซเชเชฒเซ เชเซเชเชเซ เชเซเชก เชเชชเชตเซ เชตเชงเซ เชคเชฐเซเชเชธเชเชเชค เชฐเชนเซเชถเซ, เช เชจเซ เชธเซเชฅเซ เชฆเซเชฐเซเชฒเชญ เช เชเซเชทเชฐ - T (เช เชฅเชตเชพ U, เช เชฅเชตเชพ 'n') - เชเซเชกเชจเซ เชตเชงเซ เช เชงเชฟเชเซเชค เชเชชเซ. เช เชนเชซเชฎเซเชจ เช เชฒเซเชเซเชฐเชฟเชงเชฎ เชเซ: เชคเชฎเชพเชฐเซ เชถเซเชฐเซเชทเซเช เชเชจเซเชเซเชกเชฟเชเช เชตเชฟเชเชฒเซเชช เชถเซเชงเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ, เชเซเชฎเชพเช เชซเชพเชเชฒ เชจเซเชฏเซเชจเชคเชฎ เชตเชเชจเชจเซ เชนเชถเซ. เชคเซ เชคเชฆเซเชฆเชจ เชธเชพเชฎเชพเชจเซเชฏ เชเซ เชเซ เชตเชฟเชตเชฟเชง เช เชเซเชทเชฐเซเชจเซ เชเซเชก เชฒเชเชฌเชพเช เช เชฒเช เชนเชถเซ - เช เช เชฒเซเชเซเชฐเชฟเชงเชฎเชจเซ เชเชงเชพเชฐ เชเซ.
เชเซเชกเชฟเชเช
เชถเชพ เชฎเชพเชเซ เช เชเซเชทเชฐ 'S' เชจเซ เชเซเชก เชจ เชเชชเซ, เชเชฆเชพเชนเชฐเชฃ เชคเชฐเซเชเซ, 1 เชฌเซเช เชฒเชพเชเชฌเซ: 0 เช เชฅเชตเชพ 1. เชคเซเชจเซ 1 เชฐเชนเซเชตเชพ เชฆเซ. เชชเชเซ เชฌเซเชเซเช เชธเซเชฅเซ เชตเชงเซ เชเซเชตเชพ เชฎเชณเชคเซเช เช เชเซเชทเชฐ - ' ' (เชธเซเชชเซเชธ) - เช เชฎเซ 0 เชเชชเซเชถเซเช. เชเชฒเซเชชเชจเชพ เชเชฐเซ, เชคเชฎเซ เชถเชฐเซ เชเชฐเซเชฏเซเช เชคเชฎเชพเชฐเชพ เชธเชเชฆเซเชถเชจเซ เชกเซเชเซเชก เชเชฐเซ - เชเชจเซเชเซเชกเซเชก เชธเซเชเซเชฐเชฟเชเช s1 - เช เชจเซ เชคเชฎเซ เชเซเช เชเซ เชเซ เชเซเชก 1 เชฅเซ เชถเชฐเซ เชฅเชพเชฏ เชเซ. เชคเซ, เชถเซเช เชเชฐเชตเซเช: เชถเซเช เชคเซ S เช เชเซเชทเชฐ เชเซ, เช เชฅเชตเชพ เชคเซ เชเซเช เช เชจเซเชฏ เช เชเซเชทเชฐ เชเซ, เชเซเชฎ เชเซ A? เชคเซเชฅเซ, เชเช เชฎเชนเชคเซเชตเชชเซเชฐเซเชฃ เชจเชฟเชฏเชฎ เชเชญเซ เชฅเชพเชฏ เชเซ:
เชเซเชเชชเชฃ เชเซเชก เชฌเซเชเชพเชจเซ เชเชชเชธเชฐเซเช เชนเซเชตเซ เชเซเชเช เชจเชนเซเช
เช เชจเชฟเชฏเชฎ เชเชฒเซเชเซเชฐเชฟเชงเชฎเชจเซ เชเชพเชตเซ เชเซ. เชคเซเชฅเซ, เชเซเชกเชจเซ เชฐเชเชจเชพ เชเชตเชฐเซเชคเชจ เชเซเชทเซเชเชเชฅเซ เชถเชฐเซ เชฅเชพเชฏ เชเซ, เชเซ เชฆเชฐเซเช เชชเซเชฐเชคเซเชเชจเซ เชเชตเชฐเซเชคเชจ (เชเชเชจเชพเชเชจเซ เชธเชเชเซเชฏเชพ) เชธเซเชเชตเซ เชเซ:
เชธเซเชฅเซ เชตเชงเซ เชเชเชจเชพเช เชงเชฐเชพเชตเชคเชพ เช เชเซเชทเชฐเซ เชธเซเชฅเซ เชเชเชพ เชธเชพเชฅเซ เชเชจเซเชเซเชก เชเชฐเซเชฒเชพ เชนเซเชตเชพ เชเซเชเช เชถเชเซเชฏ เชฌเชฟเชเซเชธเชจเซ เชธเชเชเซเชฏเชพ. เชนเซเช เชธเชเชญเชตเชฟเชค เชเซเชก เชเซเชทเซเชเชเซเชฎเชพเชเชฅเซ เชเชเชจเซเช เชเชฆเชพเชนเชฐเชฃ เชเชชเซเชถ:
เชคเซเชฅเซ เชเชจเซเชเซเชกเซเชก เชธเชเชฆเซเชถ เชเชจเชพ เชเซเชตเซ เชฆเซเชเชพเชถเซ:
10 01111 10 110 1111 00 10 010 1110 10 00 110 0110 00 110 10 00 1111 010 10 1110 01110
เชฎเซเช เชฆเชฐเซเช เช
เชเซเชทเชฐเชจเชพ เชเซเชกเชจเซ เชธเซเชชเซเชธ เชธเชพเชฅเซ เช
เชฒเช เชเชฐเซเชฏเชพ เชเซ. เชธเชเชเซเชเชฟเชค เชซเชพเชเชฒเชฎเชพเช เช เชเชฐเซเชเชฐ เชฌเชจเชถเซ เชจเชนเซเช!
เชชเซเชฐเชถเซเชจ เชเชญเซ เชฅเชพเชฏ เชเซ: เช เชฐเซเชเซ เชเซเชก เชธเชพเชฅเซ เชเซเชตเซ เชฐเซเชคเซ เชเชตเซเชฏเซ เชเซเชก เชเซเชฌเชฒ เชเซเชตเซ เชฐเซเชคเซ เชฌเชจเชพเชตเชตเซเช? เชเชจเซ เชจเซเชเซ เชเชฐเซเชเชพ เชเชฐเชตเชพเชฎเชพเช เชเชตเชถเซ.
เชนเชซเชฎเซเชจ เชตเซเชเซเชทเชจเซเช เชจเชฟเชฐเซเชฎเชพเชฃ
เช เชคเซ เชเซ เชเซเชฏเชพเช เชฆเซเชตเชฟเชธเชเชเซ เชถเซเชง เชตเซเชเซเชทเซ เชฌเชเชพเชตเชฎเชพเช เชเชตเซ เชเซ. เชเชฟเชเชคเชพ เชเชฐเชถเซ เชจเชนเซเช, เชคเชฎเชพเชฐเซ เช เชนเซเช เชชเชฆเซเชงเชคเชฟเช เชถเซเชงเชตเชพ, เชฆเชพเชเชฒ เชเชฐเชตเชพเชจเซ เช เชจเซ เชเชพเชขเซ เชจเชพเชเชตเชพเชจเซ เชเชฐเซเชฐ เชฐเชนเซเชถเซ เชจเชนเซเช. เช เชนเซเช เชเชพเชตเชพเชฎเชพเช เชตเซเชเซเชทเชจเซเช เชฎเชพเชณเชเซเช เชเซ:
public class Node {
private int frequence;
private char letter;
private Node leftChild;
private Node rightChild;
...
}
class BinaryTree {
private Node root;
public BinaryTree() {
root = new Node();
}
public BinaryTree(Node root) {
this.root = root;
}
...
}
เช เชธเชเชชเซเชฐเซเชฃ เชเซเชก เชจเชฅเซ, เชธเชเชชเซเชฐเซเชฃ เชเซเชก เชจเซเชเซ เชนเชถเซ.
เชตเซเชเซเชท เชฌเชจเชพเชตเชตเชพ เชฎเชพเชเซเชจเซเช เช เชฒเซเชเซเชฐเชฟเชงเชฎ เช เชนเซเช เชเซ:
- เชธเชเชฆเซเชถเชฎเชพเชเชฅเซ เชฆเชฐเซเช เช เชเซเชทเชฐ เชฎเชพเชเซ เชจเซเชก เชเชฌเซเชเซเชเซเช เชฌเชจเชพเชตเซ (เชฒเชพเชเชจ s1). เช เชฎเชพเชฐเชพ เชเชฟเชธเซเชธเชพเชฎเชพเช, เชคเซเชฏเชพเช 9 เชจเซเชกเซเชธ (เชจเซเชก เชเชฌเซเชเซเชเซเชเซเชธ) เชนเชถเซ. เชฆเชฐเซเช เชจเซเชกเชฎเชพเช เชฌเซ เชกเซเชเชพ เชซเซเชฒเซเชก เชนเซเชฏ เชเซ: เชชเซเชฐเชคเซเช เช เชจเซ เชเชตเชฐเซเชคเชจ
- เชฆเชฐเซเช เชจเซเชก เชจเซเชก เชฎเชพเชเซ เชเซเชฐเซ เชเชฌเซเชเซเชเซเช (เชฌเชพเชเชจเชฐเซ เชเซเชฐเซ) เชฌเชจเชพเชตเซ. เชจเซเชก เชตเซเชเซเชทเชจเซเช เชฎเซเชณ เชฌเชจเซ เชเชพเชฏ เชเซ.
- เช เชตเซเชเซเชทเซเชจเซ เชชเซเชฐเชพเชงเชพเชจเซเชฏเชคเชพ เชเชคเชพเชฐเชฎเชพเช เชฆเชพเชเชฒ เชเชฐเซ. เชเชตเชฐเซเชคเชจ เชเซเชเชฒเซ เชเชเซ เชเซ, เชคเซเชเชฒเซ เช เชเซเชฐเชคเชพ เชตเชงเชพเชฐเซ เชเซ. เชเชฎ, เชฌเชนเชพเชฐ เชเชพเชขเชคเซ เชตเชเชคเซ, เชธเซเชฅเซ เชเชเซ เชเชตเชฐเซเชคเชจ เชธเชพเชฅเซเชจเซเช เชตเซเชเซเชท เชนเชเชฎเซเชถเชพ เชชเชธเชเชฆ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชเซ.
เชเชเชณ, เชคเชฎเชพเชฐเซ เชจเซเชเซเชจเชพ เชเชเซเชฐเซเชฏ เชฐเซเชคเซ เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ:
- เชชเซเชฐเชพเชงเชพเชจเซเชฏเชคเชพ เชเชคเชพเชฐเชฎเชพเชเชฅเซ เชฌเซ เชตเซเชเซเชทเซ เชชเซเชจเชเชชเซเชฐเชพเชชเซเชค เชเชฐเซ เช เชจเซ เชคเซเชฎเชจเซ เชจเชตเชพ เชจเซเชก (เช เชเซเชทเชฐ เชตเชฟเชจเชพ เชจเชตเชพ เชฌเชจเชพเชตเซเชฒ เชจเซเชก) เชจเชพ เชฌเชพเชณเชเซ เชฌเชจเชพเชตเซ. เชจเชตเชพ เชจเซเชกเชจเซ เชเชตเชฐเซเชคเชจ เชฌเซ เชตเชเชถเช เชตเซเชเซเชทเซเชจเซ เชซเซเชฐเซเชเซเชตเชจเซเชธเซเชเชจเชพ เชธเชฐเชตเชพเชณเชพ เชเซเชเชฒเซ เชเซ.
- เช เชจเซเชก เชฎเชพเชเซ, เช เชจเซเชก เชชเชฐ เชฎเซเชณเชตเชพเชณเซเช เชตเซเชเซเชท เชฌเชจเชพเชตเซ. เช เชตเซเชเซเชทเชจเซ เช เชเซเชฐเชคเชพ เชเชคเชพเชฐเชฎเชพเช เชชเชพเชเซเช เชฆเชพเชเชฒ เชเชฐเซ. (เชตเซเชเซเชทเชจเซ เชจเชตเซ เชเชตเชฐเซเชคเชจ เชนเซเชตเชพเชฅเซ, เชคเซ เชฎเซเชเชพเชญเชพเชเซ เชเชคเชพเชฐเชฎเชพเช เชจเชตเซ เชเชเซเชฏเชพเช เชชเซเชฐเชตเซเชถ เชเชฐเชถเซ)
- เชเซเชฏเชพเช เชธเซเชงเซ เชเช เชตเซเชเซเชท เชเชคเชพเชฐเชฎเชพเช เชฌเชพเชเซ เชจ เชฐเชนเซ เชคเซเชฏเชพเช เชธเซเชงเซ เชชเชเชฒเชพเช 1 เช เชจเซ 2 เชเชพเชฒเซ เชฐเชพเชเซ - เชนเชซเชฎเซเชจ เชตเซเชเซเชท
เชฒเชพเชเชจ s1 เชชเชฐ เช เช เชฒเซเชเซเชฐเชฟเชงเชฎเชจเซ เชตเชฟเชเชพเชฐ เชเชฐเซ:
เช
เชนเซเช เชชเซเชฐเชคเซเช "lf" (เชฒเชพเชเชจเชซเซเชก) เชจเชตเซ เชฒเซเชเซ เชฆเชฐเซเชถเชพเชตเซ เชเซ, "sp" (เชธเซเชชเซเชธ) เช เชธเซเชชเซเชธ เชเซ.
เชชเชเซ เชถเซเช เชเซ?
เช เชฎเชจเซ เชนเชซเชฎเซเชจ เชตเซเชเซเชท เชฎเชณเซเชฏเซเช. เชฌเชฐเชพเชฌเชฐ. เช เชจเซ เชคเซเชจเซ เชธเชพเชฅเซ เชถเซเช เชเชฐเชตเซเช? เชคเซเช เชคเซเชจเซ เชฎเชซเชคเชฎเชพเช เชฒเซเชถเซ เชจเชนเซเช. เช เชจเซ เชชเชเซ, เชคเชฎเชพเชฐเซ เชฎเซเชณเชฅเซ เชเชพเชกเชจเชพ เชชเชพเชเชฆเชกเชพ เชธเซเชงเซเชจเชพ เชคเชฎเชพเชฎ เชธเชเชญเชตเชฟเชค เชฐเชธเซเชคเชพเช เชถเซเชงเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ. เช เชฎเซ เชงเชพเชฐเชจเซ 0 เชฒเซเชฌเชฒ เชเชฐเชตเชพ เชฎเชพเชเซ เชธเชเชฎเชค เชเซเช เชเซ เชคเซ เชกเชพเชฌเชพ เชฌเชพเชณเช เชคเชฐเชซ เชฆเซเชฐเซ เชเชพเชฏ เช เชจเซ 1 เชเซ เชคเซ เชเชฎเชฃเซ เชคเชฐเชซ เชฆเซเชฐเซ เชเชพเชฏ. เชเชกเช เชถเชฌเซเชฆเซเชฎเชพเช เชเชนเซเช เชคเซ, เช เชธเชเชเซเชคเซเชฎเชพเช, เช เชเซเชทเชฐ เชเซเชก เช เชตเซเชเซเชทเชจเชพ เชฎเซเชณเชฅเซ เชชเชพเชเชฆเชกเชพ เชธเซเชงเซเชจเซ เชฎเชพเชฐเซเช เชเซ เชเซเชฎเชพเช เช เชธเชฎเชพเชจ เช เชเซเชทเชฐ เชเซ.
เชเชฎ, เชเซเชกเซเชธเชจเซเช เชเซเชฌเชฒ เชฌเชนเชพเชฐ เชเชตเซเชฏเซเช. เชจเซเชเชง เชเชฐเซ เชเซ เชเซ เชเชชเชฃเซ เช เชเซเชทเซเชเชเชจเซ เชงเซเชฏเชพเชจเชฎเชพเช เชฒเชเช, เชคเซ เชเชชเชฃเซ เชฆเชฐเซเช เช
เชเซเชทเชฐเชจเชพ "เชตเชเชจ" เชตเชฟเชถเซ เชจเชฟเชทเซเชเชฐเซเชท เชชเชฐ เชเชตเซ เชถเชเซเช - เช เชคเซเชจเชพ เชเซเชกเชจเซ เชฒเชเชฌเชพเช เชเซ. เชชเชเซ, เชธเชเชเซเชเชฟเชค เชธเซเชตเชฐเซเชชเชฎเชพเช, เชธเซเชฐเซเชค เชซเชพเชเชฒเชจเซเช เชตเชเชจ เชฅเชถเซ: 2 * 3 + 2 * 4 + 3 * 3 + 6 * 2 + 1 * 4 + 1 * 5 + 2 * 4 + 4 * 2 + 1 * 5 = 65 เชฌเชฟเชเซเชธ . เชถเชฐเซเชเชคเชฎเชพเช เชคเซเชจเซเช เชตเชเชจ 176 เชฌเชฟเชเซเชธ เชนเชคเซเช. เชคเซเชฅเซ, เช
เชฎเซ เชคเซเชจเซ 176/65 = 2.7 เชเชฃเซ เชเซเชเชฒเซเช เชเชเชพเชกเซ เชฆเซเชงเซเช เชเซ! เชชเชฐเชเชคเซ เช เชเช เชฏเซเชเซเชชเชฟเชฏเชพ เชเซ. เชเชตเซ เชเซเชฃเซเชคเซเชคเชฐ เชฎเชณเชตเชพเชจเซ เชถเชเซเชฏเชคเชพ เชจเชฅเซ. เชถเชพ เชฎเชพเชเซ? เช เชตเชฟเชถเซ เชฅเซเชกเซ เชตเชพเชฐ เชชเชเซ เชเชฐเซเชเชพ เชเชฐเชตเชพเชฎเชพเช เชเชตเชถเซ.
เชกเซเชเซเชกเชฟเชเช
เช เซเช เชเซ, เชเชฆเชพเช เชฌเชพเชเซเชจเซ เชธเซเชฅเซ เชธเชฐเชณ เชตเชธเซเชคเซ เชกเซเชเซเชกเชฟเชเช เชเซ. เชฎเชจเซ เชฒเชพเชเซ เชเซ เชเซ เชคเชฎเชพเชฐเชพเชฎเชพเชเชจเชพ เชเชฃเชพเช เช เชจเซเชฎเชพเชจ เชฒเชเชพเชตเซเชฏเซเช เชเซ เชเซ เชธเชเชเซเชเชฟเชค เชซเชพเชเชฒเชจเซ เชเซเชตเซ เชฐเซเชคเซ เชเชจเซเชเซเชก เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชนเชคเซ เชคเซ เช เชเชเซเชจเชพ เชเซเชเชชเชฃ เชธเชเชเซเชคเซ เชตเชฟเชจเชพ เชเชพเชฒเซ เชฌเชจเชพเชตเชตเซ เช เชถเชเซเชฏ เชเซ - เช เชฎเซ เชคเซเชจเซ เชกเซเชเซเชก เชเชฐเซ เชถเชเซเชถเซเช เชจเชนเซเช! เชนเชพ, เชนเชพ, เชฎเชพเชฐเชพ เชฎเชพเชเซ เช เชธเชฎเชเชตเซเช เช เชเชฐเซเช เชนเชคเซเช, เชชเชฃ เชฎเชพเชฐเซ เชเชฎเซเชชเซเชฐเซเชถเชจ เชเซเชฌเชฒ เชธเชพเชฅเซ เชเช เชเซเชเซเชธเซเช เชซเชพเชเชฒ table.txt เชฌเชจเชพเชตเชตเซ เชชเชกเชถเซ:
01110
00
A010
E1111
I110
S10
T0110
U01111
Y1110
'เช เชเซเชทเชฐ' "เช เชเซเชทเชฐ เชเซเชก" เชซเซเชฐเซเชฎเชฎเชพเช เชเซเชฌเชฒ เชเชจเซเชเซเชฐเซ. 01110 เชชเซเชฐเชคเซเช เชตเชเชฐเชจเซเช เชเซเชฎ เชเซ? เชตเชพเชธเซเชคเชตเชฎเชพเช, เชคเซ เชเช เชชเซเชฐเชคเซเช เชธเชพเชฅเซ เชเซ, เชฎเชพเชคเซเชฐ เชเชพเชตเชพ เชเซเชฒเซเชธ เชเซ เชเซเชจเซ เชเชชเชฏเซเช เชนเซเช เชซเชพเชเชฒเชฎเชพเช เชเชเชเชชเซเช เชเชฐเชคเซ เชตเชเชคเซ เชเชฐเซเช เชเซเช, เชจเซเชฏเซเชฒเชพเชเชจ เช เชเซเชทเชฐ - 'n' - เชจเชตเซ เชฒเชพเชเชจเชฎเชพเช เชฐเซเชชเชพเชเชคเชฐเชฟเชค เชฅเชพเชฏ เชเซ (เชญเชฒเซ เชคเซ เชเชฎเซ เชคเซเชเชฒเซเช เชฎเซเชฐเซเช เชฒเชพเชเซ). เชคเซเชฅเซ, เชเชชเชฐเชจเซ เชเชพเชฒเซ เชฒเซเชเซ เช เชเซเชก 01110 เชฎเชพเชเซเชจเซเช เช เชเซเชทเชฐ เชเซ. เชเซเชก 00 เชฎเชพเชเซ, เช เชเซเชทเชฐ เช เชฒเซเชเซเชจเซ เชถเชฐเซเชเชคเชฎเชพเช เชเช เชเชเซเชฏเชพ เชเซ. เชฎเชพเชฐเซ เชคเชฐเชค เช เชเชนเซเชตเซเช เชเซเชเช เชเซ เชเซเชฌเชฒ เชธเซเชเซเชฐ เชเชฐเชตเชพเชจเซ เช เชชเชฆเซเชงเชคเชฟ เชเชชเชฃเชพ เชเชพเชจ เชเซเชฃเชพเชเช เชฎเชพเชเซ เชธเซเชฅเซ เช เชคเชพเชฐเซเชเชฟเช เชนเซเชตเชพเชจเซ เชฆเชพเชตเซ เชเชฐเซ เชถเชเซ เชเซ. เชชเชฐเชเชคเซ เชคเซ เชธเชฎเชเชตเซเช เช เชจเซ เช เชฎเชฒเชฎเชพเช เชฎเซเชเชตเซเช เชธเชฐเชณ เชเซ. เชเชชเซเชเชฟเชฎเชพเชเชเซเชถเชจ เชตเชฟเชถเซเชจเซ เชเชฟเชชเซเชชเชฃเซเชเชฎเชพเช เชคเชฎเชพเชฐเซ เชญเชฒเชพเชฎเชฃเซ เชธเชพเชเชญเชณเซเชจเซ เชฎเชจเซ เชเชจเชเชฆ เชฅเชถเซ.
เช เชเซเชทเซเชเช เชธเชพเชฅเซ, เชกเซเชเซเชก เชเชฐเชตเซเช เชเซเชฌ เช เชธเชฐเชณ เชเซ. เชเชพเชฒเซ เชฏเชพเชฆ เชเชฐเซเช เชเซ เชเชจเซเชเซเชกเชฟเชเช เชฌเชจเชพเชตเชคเซ เชตเชเชคเซ เช เชฎเชจเซ เชเชฏเชพ เชจเชฟเชฏเชฎ เชฆเซเชตเชพเชฐเชพ เชฎเชพเชฐเซเชเชฆเชฐเซเชถเชจ เชเชชเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช:
เชเซเช เชเซเชก เชฌเซเชเชพเชจเซ เชเชชเชธเชฐเซเช เชจ เชนเซเชตเซ เชเซเชเช
เช เชคเซ เชเซ เชเซเชฏเชพเช เชคเซ เชธเซเชตเชฟเชงเชพเชเชจเช เชญเซเชฎเชฟเชเชพ เชญเชเชตเซ เชเซ. เช เชฎเซ เชเซเชฐเชฎเชถเช เชฅเซเชกเซเช-เชฅเซเชกเซเช เชตเชพเชเชเซเช เชเซเช, เช เชจเซ เชเชฒเชฆเซ เชชเชฐเชฟเชฃเชพเชฎเซ เชธเซเชเซเชฐเชฟเชเช เชกเซ, เชเซเชฎเชพเช เชฐเซเชก เชฌเชฟเชเซเชธเชจเซ เชธเชฎเชพเชตเซเชถ เชฅเชพเชฏ เชเซ, เชเซเชฐเซเชเซเชเชฐ เชเซเชฐเซเชเซเชเชฐเชจเซ เช เชจเซเชฐเซเชช เชเชจเซเชเซเชกเชฟเชเช เชธเชพเชฅเซ เชฎเซเชณ เชเชพเชฏ เชเซ, เช เชฎเซ เชคเชฐเชค เช เชเชพเชฃเซเช เชเซเช เชเซ เชเซเชฐเซเชเซเชเชฐ เชเซเชฐเซเชเซเชเชฐ (เช เชจเซ เชฎเชพเชคเซเชฐ เชคเซ เช!) เชเชจเซเชเซเชก เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช. เชเชเชณ, เช เชฎเซ เชกเซเชเซเชก เชธเซเชเซเชฐเชฟเชเช (เชกเซเชเซเชก เชเชฐเซเชฒ เชธเชเชฆเซเชถ เชงเชฐเชพเชตเชคเซ เชธเซเชเซเชฐเชฟเชเช) เชชเชฐ เช เชเซเชทเชฐ เชฒเชเซเช เชเซเช, d เชธเซเชเซเชฐเชฟเชเชเชจเซ เชซเชฐเซเชฅเซ เชธเซเช เชเชฐเซเช เชเซเช เช เชจเซ เชเชจเซเชเซเชก เชเชฐเซเชฒเซ เชซเชพเชเชฒเชจเซ เชเชเชณ เชตเชพเชเชเซเช เชเซเช.
ะ ะตะฐะปะธะทะฐัะธั
เชเชฐเซเชเชพเชเชตเชฐ เชฒเชเซเชจเซ เชฎเชพเชฐเชพ เชเซเชกเชจเซ เช เชชเชฎเชพเชจเชฟเชค เชเชฐเชตเชพเชจเซ เชธเชฎเชฏ เชเชตเซ เชเชฏเซ เชเซ. เชเชพเชฒเซ เชคเซเชจเซ เชเซเชฎเซเชชเซเชฐเซเชธเชฐ เชเชนเซเช.
เชชเซเชฐเชพเชฐเชเชญ. เชธเซ เชชเซเชฐเชฅเชฎ, เชเชชเชฃเซ เชจเซเชก เชตเชฐเซเช เชฒเชเซเช เชเซเช:
public class Node {
private int frequence;//ัะฐััะพัะฐ
private char letter;//ะฑัะบะฒะฐ
private Node leftChild;//ะปะตะฒัะน ะฟะพัะพะผะพะบ
private Node rightChild;//ะฟัะฐะฒัะน ะฟะพัะพะผะพะบ
public Node(char letter, int frequence) { //ัะพะฑััะฒะตะฝะฝะพ, ะบะพะฝััััะบัะพั
this.letter = letter;
this.frequence = frequence;
}
public Node() {}//ะฟะตัะตะณััะทะบะฐ ะบะพะฝัััััะพัะฐ ะดะปั ะฑะตะทัะผัะฝะฝัั
ัะทะปะพะฒ(ัะผ. ะฒััะต ะฒ ัะฐะทะดะตะปะต ะพ ะฟะพัััะพะตะฝะธะธ ะดะตัะตะฒะฐ ะฅะฐััะผะฐะฝะฐ)
public void addChild(Node newNode) {//ะดะพะฑะฐะฒะธัั ะฟะพัะพะผะบะฐ
if (leftChild == null)//ะตัะปะธ ะปะตะฒัะน ะฟัััะพะน=> ะฟัะฐะฒัะน ัะพะถะต=> ะดะพะฑะฐะฒะปัะตะผ ะฒ ะปะตะฒัะน
leftChild = newNode;
else {
if (leftChild.getFrequence() <= newNode.getFrequence()) //ะฒ ะพะฑัะตะผ, ะปะตะฒัะผ ะฟะพัะพะผะบะพะผ
rightChild = newNode;//ััะฐะฝะตั ัะพั, ั ะบะพะณะพ ะผะตะฝััะต ัะฐััะพัะฐ
else {
rightChild = leftChild;
leftChild = newNode;
}
}
frequence += newNode.getFrequence();//ะธัะพะณะพะฒะฐั ัะฐััะพัะฐ
}
public Node getLeftChild() {
return leftChild;
}
public Node getRightChild() {
return rightChild;
}
public int getFrequence() {
return frequence;
}
public char getLetter() {
return letter;
}
public boolean isLeaf() {//ะฟัะพะฒะตัะบะฐ ะฝะฐ ะปะธัั
return leftChild == null && rightChild == null;
}
}
เชนเชตเซ เชตเซเชเซเชท:
class BinaryTree {
private Node root;
public BinaryTree() {
root = new Node();
}
public BinaryTree(Node root) {
this.root = root;
}
public int getFrequence() {
return root.getFrequence();
}
public Node getRoot() {
return root;
}
}
เชชเซเชฐเชพเชงเชพเชจเซเชฏเชคเชพ เชเชคเชพเชฐ:
import java.util.ArrayList;//ะดะฐ-ะดะฐ, ะพัะตัะตะดั ะฑัะดะตั ะฝะฐ ะฑะฐะทะต ัะฟะธัะบะฐ
class PriorityQueue {
private ArrayList<BinaryTree> data;//ัะฟะธัะพะบ ะพัะตัะตะดะธ
private int nElems;//ะบะพะป-ะฒะพ ัะปะตะผะตะฝัะพะฒ ะฒ ะพัะตัะตะดะธ
public PriorityQueue() {
data = new ArrayList<BinaryTree>();
nElems = 0;
}
public void insert(BinaryTree newTree) {//ะฒััะฐะฒะบะฐ
if (nElems == 0)
data.add(newTree);
else {
for (int i = 0; i < nElems; i++) {
if (data.get(i).getFrequence() > newTree.getFrequence()) {//ะตัะปะธ ัะฐััะพัะฐ ะฒััะฐะฒะปัะตะผะพะณะพ ะดะตัะตะฒะฐ ะผะตะฝััะต
data.add(i, newTree);//ัะตะผ ัะฐัั. ัะตะบััะตะณะพ, ัะพ cะดะฒะธะณะฐะตะผ ะฒัะต ะดะตัะตะฒัั ะฝะฐ ะฟะพะทะธัะธัั
ัะฟัะฐะฒะฐ ะฝะฐ 1 ััะตะนะบั
break;//ะทะฐัะตะผ ััะฐะฒะธะผ ะฝะพะฒะพะต ะดะตัะตะฒะพ ะฝะฐ ะฟะพะทะธัะธั ัะตะบััะตะณะพ
}
if (i == nElems - 1)
data.add(newTree);
}
}
nElems++;//ัะฒะตะปะธัะธะฒะฐะตะผ ะบะพะป-ะฒะพ ัะปะตะผะตะฝัะพะฒ ะฝะฐ 1
}
public BinaryTree remove() {//ัะดะฐะปะตะฝะธะต ะธะท ะพัะตัะตะดะธ
BinaryTree tmp = data.get(0);//ะบะพะฟะธััะตะผ ัะดะฐะปัะตะผัะน ัะปะตะผะตะฝั
data.remove(0);//ัะพะฑััะฒะตะฝะฝะพ, ัะดะฐะปัะตะผ
nElems--;//ัะผะตะฝััะฐะตะผ ะบะพะป-ะฒะพ ัะปะตะผะตะฝัะพะฒ ะฝะฐ 1
return tmp;//ะฒะพะทะฒัะฐัะฐะตะผ ัะดะฐะปะตะฝะฝัะน ัะปะตะผะตะฝั(ัะปะตะผะตะฝั ั ะฝะฐะธะผะตะฝััะตะน ัะฐััะพัะพะน)
}
}
เชตเชฐเซเช เชเซ เชเซ เชนเชซเชฎเซเชจ เชตเซเชเซเชท เชฌเชจเชพเชตเซ เชเซ:
public class HuffmanTree {
private final byte ENCODING_TABLE_SIZE = 127;//ะดะปะธะฝะฐ ะบะพะดะธัะพะฒะพัะฝะพะน ัะฐะฑะปะธัั
private String myString;//ัะพะพะฑัะตะฝะธะต
private BinaryTree huffmanTree;//ะดะตัะตะฒะพ ะฅะฐััะผะฐะฝะฐ
private int[] freqArray;//ัะฐััะพัะฝะฐั ัะฐะฑะปะธัะฐ
private String[] encodingArray;//ะบะพะดะธัะพะฒะพัะฝะฐั ัะฐะฑะปะธัะฐ
//----------------constructor----------------------
public HuffmanTree(String newString) {
myString = newString;
freqArray = new int[ENCODING_TABLE_SIZE];
fillFrequenceArray();
huffmanTree = getHuffmanTree();
encodingArray = new String[ENCODING_TABLE_SIZE];
fillEncodingArray(huffmanTree.getRoot(), "", "");
}
//--------------------frequence array------------------------
private void fillFrequenceArray() {
for (int i = 0; i < myString.length(); i++) {
freqArray[(int)myString.charAt(i)]++;
}
}
public int[] getFrequenceArray() {
return freqArray;
}
//------------------------huffman tree creation------------------
private BinaryTree getHuffmanTree() {
PriorityQueue pq = new PriorityQueue();
//ะฐะปะณะพัะธัะผ ะพะฟะธัะฐะฝ ะฒััะต
for (int i = 0; i < ENCODING_TABLE_SIZE; i++) {
if (freqArray[i] != 0) {//ะตัะปะธ ัะธะผะฒะพะป ัััะตััะฒัะตั ะฒ ัััะพะบะต
Node newNode = new Node((char) i, freqArray[i]);//ัะพ ัะพะทะดะฐัั ะดะปั ะฝะตะณะพ Node
BinaryTree newTree = new BinaryTree(newNode);//ะฐ ะดะปั Node ัะพะทะดะฐัั BinaryTree
pq.insert(newTree);//ะฒััะฐะฒะธัั ะฒ ะพัะตัะตะดั
}
}
while (true) {
BinaryTree tree1 = pq.remove();//ะธะทะฒะปะตัั ะธะท ะพัะตัะตะดะธ ะฟะตัะฒะพะต ะดะตัะตะฒะพ.
try {
BinaryTree tree2 = pq.remove();//ะธะทะฒะปะตัั ะธะท ะพัะตัะตะดะธ ะฒัะพัะพะต ะดะตัะตะฒะพ
Node newNode = new Node();//ัะพะทะดะฐัั ะฝะพะฒัะน Node
newNode.addChild(tree1.getRoot());//ัะดะตะปะฐัั ะตะณะพ ะฟะพัะพะผะบะฐะผะธ ะดะฒะฐ ะธะทะฒะปะตัะตะฝะฝัั
ะดะตัะตะฒะฐ
newNode.addChild(tree2.getRoot());
pq.insert(new BinaryTree(newNode);
} catch (IndexOutOfBoundsException e) {//ะพััะฐะปะพัั ะพะดะฝะพ ะดะตัะตะฒะพ ะฒ ะพัะตัะตะดะธ
return tree1;
}
}
}
public BinaryTree getTree() {
return huffmanTree;
}
//-------------------encoding array------------------
void fillEncodingArray(Node node, String codeBefore, String direction) {//ะทะฐะฟะพะปะฝะธัั ะบะพะดะธัะพะฒะพัะฝัั ัะฐะฑะปะธัั
if (node.isLeaf()) {
encodingArray[(int)node.getLetter()] = codeBefore + direction;
} else {
fillEncodingArray(node.getLeftChild(), codeBefore + direction, "0");
fillEncodingArray(node.getRightChild(), codeBefore + direction, "1");
}
}
String[] getEncodingArray() {
return encodingArray;
}
public void displayEncodingArray() {//ะดะปั ะพัะปะฐะดะบะธ
fillEncodingArray(huffmanTree.getRoot(), "", "");
System.out.println("======================Encoding table====================");
for (int i = 0; i < ENCODING_TABLE_SIZE; i++) {
if (freqArray[i] != 0) {
System.out.print((char)i + " ");
System.out.println(encodingArray[i]);
}
}
System.out.println("========================================================");
}
//-----------------------------------------------------
String getOriginalString() {
return myString;
}
}
เชเซ เชเชจเซเชเซเชก/เชกเซเชเซเชก เชเชฐเซ เชเซ เชคเซ เชตเชฐเซเช:
public class HuffmanOperator {
private final byte ENCODING_TABLE_SIZE = 127;//ะดะปะธะฝะฐ ัะฐะฑะปะธัั
private HuffmanTree mainHuffmanTree;//ะดะตัะตะฒะพ ะฅะฐััะผะฐะฝะฐ (ะธัะฟะพะปัะทัะตััั ัะพะปัะบะพ ะดะปั ัะถะฐัะธั)
private String myString;//ะธัั
ะพะดะฝะพะต ัะพะพะฑัะตะฝะธะต
private int[] freqArray;//ัะฐััะพัะฐะฝะฐั ัะฐะฑะปะธัะฐ
private String[] encodingArray;//ะบะพะดะธัะพะฒะพัะฝะฐั ัะฐะฑะปะธัะฐ
private double ratio;//ะบะพัััะธัะธะตะฝั ัะถะฐัะธั
public HuffmanOperator(HuffmanTree MainHuffmanTree) {//for compress
this.mainHuffmanTree = MainHuffmanTree;
myString = mainHuffmanTree.getOriginalString();
encodingArray = mainHuffmanTree.getEncodingArray();
freqArray = mainHuffmanTree.getFrequenceArray();
}
public HuffmanOperator() {}//for extract;
//---------------------------------------compression-----------------------------------------------------------
private String getCompressedString() {
String compressed = "";
String intermidiate = "";//ะฟัะพะผะตะถััะพัะฝะฐั ัััะพะบะฐ(ะฑะตะท ะดะพะฑะฐะฒะพัะฝัั
ะฝัะปะตะน)
//System.out.println("=============================Compression=======================");
//displayEncodingArray();
for (int i = 0; i < myString.length(); i++) {
intermidiate += encodingArray[myString.charAt(i)];
}
//ะั ะฝะต ะผะพะถะตะผ ะฟะธัะฐัั ะฑะธั ะฒ ัะฐะนะป. ะะพััะพะผั ะฝัะถะฝะพ ัะดะตะปะฐัั ะดะปะธะฝั ัะพะพะฑัะตะฝะธั ะบัะฐัะฝะพะน 8=>
//ะฝัะถะฝะพ ะดะพะฑะฐะฒะธัั ะฝัะปะธ ะฒ ะบะพะฝะตั(ะผะพะถะฝะพ 1, ะฝะตั ัะฐะทะฝะธัั)
byte counter = 0;//ะบะพะปะธัะตััะฒะพ ะดะพะฑะฐะฒะปะตะฝะฝัั
ะฒ ะบะพะฝะตั ะฝัะปะตะน (ะฑะฐะนัะฐ ะฒ ะฟะพะปะฝะต ั
ะฒะฐัะธั: 0<=counter<8<127)
for (int length = intermidiate.length(), delta = 8 - length % 8;
counter < delta ; counter++) {//delta - ะบะพะปะธัะตััะฒะพ ะดะพะฑะฐะฒะปะตะฝะฝัั
ะฝัะปะตะน
intermidiate += "0";
}
//ัะบะปะตะธัั ะบะพะป-ะฒะพ ะดะพะฑะฐะฒะพัะฝัั
ะฝัะปะตะน ะฒ ะฑะธะฝะฐัะฝะพะผ ะฟัะตะดะฐััะฒะปะตะฝะธะธ ะธ ะฟัะพะผะตะถััะพัะฝัั ัััะพะบั
compressed = String.format("%8s", Integer.toBinaryString(counter & 0xff)).replace(" ", "0") + intermidiate;
//ะธะดะตะฐะปะธะทะธัะพะฒะฐะฝะฝัะน ะบะพัััะธัะธะตะฝั
setCompressionRatio();
//System.out.println("===============================================================");
return compressed;
}
private void setCompressionRatio() {//ะฟะพััะธัะฐัั ะธะดะตะฐะปะธะทะธัะพะฒะฐะฝะฝัะน ะบะพัััะธัะธะตะฝั
double sumA = 0, sumB = 0;//A-the original sum
for (int i = 0; i < ENCODING_TABLE_SIZE; i++) {
if (freqArray[i] != 0) {
sumA += 8 * freqArray[i];
sumB += encodingArray[i].length() * freqArray[i];
}
}
ratio = sumA / sumB;
}
public byte[] getBytedMsg() {//final compression
StringBuilder compressedString = new StringBuilder(getCompressedString());
byte[] compressedBytes = new byte[compressedString.length() / 8];
for (int i = 0; i < compressedBytes.length; i++) {
compressedBytes[i] = (byte) Integer.parseInt(compressedString.substring(i * 8, (i + 1) * 8), 2);
}
return compressedBytes;
}
//---------------------------------------end of compression----------------------------------------------------------------
//------------------------------------------------------------extract-----------------------------------------------------
public String extract(String compressed, String[] newEncodingArray) {
String decompressed = "";
String current = "";
String delta = "";
encodingArray = newEncodingArray;
//displayEncodingArray();
//ะฟะพะปััะธัั ะบะพะป-ะฒะพ ะฒััะฐะฒะปะตะฝะฝัั
ะฝัะปะตะน
for (int i = 0; i < 8; i++)
delta += compressed.charAt(i);
int ADDED_ZEROES = Integer.parseInt(delta, 2);
for (int i = 8, l = compressed.length() - ADDED_ZEROES; i < l; i++) {
//i = 8, ั.ะบ. ะฟะตัะฒัะผ ะฑะฐะนัะพะผ ั ะฝะฐั ะธะดะตั ะบะพะป-ะฒะพ ะฒััะฐะฒะปะตะฝะฝัั
ะฝัะปะตะน
current += compressed.charAt(i);
for (int j = 0; j < ENCODING_TABLE_SIZE; j++) {
if (current.equals(encodingArray[j])) {//ะตัะปะธ ัะพะฒะฟะฐะปะพ
decompressed += (char)j;//ัะพ ะดะพะฑะฐะฒะปัะตะผ ัะปะตะผะตะฝั
current = "";//ะธ ะพะฑะฝัะปัะตะผ ัะตะบัััั ัััะพะบั
}
}
}
return decompressed;
}
public String getEncodingTable() {
String enc = "";
for (int i = 0; i < encodingArray.length; i++) {
if (freqArray[i] != 0)
enc += (char)i + encodingArray[i] + 'n';
}
return enc;
}
public double getCompressionRatio() {
return ratio;
}
public void displayEncodingArray() {//ะดะปั ะพัะปะฐะดะบะธ
System.out.println("======================Encoding table====================");
for (int i = 0; i < ENCODING_TABLE_SIZE; i++) {
//if (freqArray[i] != 0) {
System.out.print((char)i + " ");
System.out.println(encodingArray[i]);
//}
}
System.out.println("========================================================");
}
}
เชเช เชตเชฐเซเช เชเซ เชซเชพเชเชฒเชฎเชพเช เชฒเชเชตเชพเชจเซ เชธเซเชตเชฟเชงเชพ เชเชชเซ เชเซ:
import java.io.File;
import java.io.PrintWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Closeable;
public class FileOutputHelper implements Closeable {
private File outputFile;
private FileOutputStream fileOutputStream;
public FileOutputHelper(File file) throws FileNotFoundException {
outputFile = file;
fileOutputStream = new FileOutputStream(outputFile);
}
public void writeByte(byte msg) throws IOException {
fileOutputStream.write(msg);
}
public void writeBytes(byte[] msg) throws IOException {
fileOutputStream.write(msg);
}
public void writeString(String msg) {
try (PrintWriter pw = new PrintWriter(outputFile)) {
pw.write(msg);
} catch (FileNotFoundException e) {
System.out.println("ะะตะฒะตัะฝัะน ะฟััั, ะธะปะธ ัะฐะบะพะณะพ ัะฐะนะปะฐ ะฝะต ัััะตััะฒัะตั!");
}
}
@Override
public void close() throws IOException {
fileOutputStream.close();
}
public void finalize() throws IOException {
close();
}
}
เชเช เชตเชฐเซเช เชเซ เชซเชพเชเชฒเชฎเชพเชเชฅเซ เชตเชพเชเชเชตเชพเชจเซ เชธเซเชตเชฟเชงเชพ เชเชชเซ เชเซ:
import java.io.FileInputStream;
import java.io.EOFException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.Closeable;
import java.io.File;
import java.io.IOException;
public class FileInputHelper implements Closeable {
private FileInputStream fileInputStream;
private BufferedReader fileBufferedReader;
public FileInputHelper(File file) throws IOException {
fileInputStream = new FileInputStream(file);
fileBufferedReader = new BufferedReader(new InputStreamReader(fileInputStream));
}
public byte readByte() throws IOException {
int cur = fileInputStream.read();
if (cur == -1)//ะตัะปะธ ะทะฐะบะพะฝัะธะปัั ัะฐะนะป
throw new EOFException();
return (byte)cur;
}
public String readLine() throws IOException {
return fileBufferedReader.readLine();
}
@Override
public void close() throws IOException{
fileInputStream.close();
}
}
เชธเชพเชฐเซเช, เช เชจเซ เชฎเซเชเซเชฏ เชตเชฐเซเช:
import java.io.File;
import java.nio.charset.MalformedInputException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Paths;
import java.util.List;
import java.io.EOFException;
public class Main {
private static final byte ENCODING_TABLE_SIZE = 127;
public static void main(String[] args) throws IOException {
try {//ัะบะฐะทัะฒะฐะตะผ ะธะฝััััะบัะธั ั ะฟะพะผะพััั ะฐัะณัะผะตะฝัะพะฒ ะบะพะผะฐะฝะดะฝะพะน ัััะพะบะธ
if (args[0].equals("--compress") || args[0].equals("-c"))
compress(args[1]);
else if ((args[0].equals("--extract") || args[0].equals("-x"))
&& (args[2].equals("--table") || args[2].equals("-t"))) {
extract(args[1], args[3]);
}
else
throw new IllegalArgumentException();
} catch (ArrayIndexOutOfBoundsException | IllegalArgumentException e) {
System.out.println("ะะตะฒะตัะฝัะน ัะพัะผะฐั ะฒะฒะพะดะฐ ะฐัะณัะผะตะฝัะพะฒ ");
System.out.println("ะงะธัะฐะนัะต Readme.txt");
e.printStackTrace();
}
}
public static void compress(String stringPath) throws IOException {
List<String> stringList;
File inputFile = new File(stringPath);
String s = "";
File compressedFile, table;
try {
stringList = Files.readAllLines(Paths.get(inputFile.getAbsolutePath()));
} catch (NoSuchFileException e) {
System.out.println("ะะตะฒะตัะฝัะน ะฟััั, ะธะปะธ ัะฐะบะพะณะพ ัะฐะนะปะฐ ะฝะต ัััะตััะฒัะตั!");
return;
} catch (MalformedInputException e) {
System.out.println("ะขะตะบััะฐั ะบะพะดะธัะพะฒะบะฐ ัะฐะนะปะฐ ะฝะต ะฟะพะดะดะตัะถะธะฒะฐะตััั");
return;
}
for (String item : stringList) {
s += item;
s += 'n';
}
HuffmanOperator operator = new HuffmanOperator(new HuffmanTree(s));
compressedFile = new File(inputFile.getAbsolutePath() + ".cpr");
compressedFile.createNewFile();
try (FileOutputHelper fo = new FileOutputHelper(compressedFile)) {
fo.writeBytes(operator.getBytedMsg());
}
//create file with encoding table:
table = new File(inputFile.getAbsolutePath() + ".table.txt");
table.createNewFile();
try (FileOutputHelper fo = new FileOutputHelper(table)) {
fo.writeString(operator.getEncodingTable());
}
System.out.println("ะััั ะบ ัะถะฐัะพะผั ัะฐะนะปั: " + compressedFile.getAbsolutePath());
System.out.println("ะััั ะบ ะบะพะดะธัะพะฒะพัะฝะพะน ัะฐะฑะปะธัะต " + table.getAbsolutePath());
System.out.println("ะะตะท ัะฐะฑะปะธัั ัะฐะนะป ะฑัะดะตั ะฝะตะฒะพะทะผะพะถะฝะพ ะธะทะฒะปะตัั!");
double idealRatio = Math.round(operator.getCompressionRatio() * 100) / (double) 100;//ะธะดะตะฐะปะธะทะธัะพะฒะฐะฝะฝัะน ะบะพัััะธัะธะตะฝั
double realRatio = Math.round((double) inputFile.length()
/ ((double) compressedFile.length() + (double) table.length()) * 100) / (double)100;//ะฝะฐััะพััะธะน ะบะพัััะธัะธะตะฝั
System.out.println("ะะดะตะฐะปะธะทะธัะพะฒะฐะฝะฝัะน ะบะพัััะธัะธะตะฝั ัะถะฐัะธั ัะฐะฒะตะฝ " + idealRatio);
System.out.println("ะะพัััะธัะธะตะฝั ัะถะฐัะธั ั ััะตัะพะผ ะบะพะดะธัะพะฒะพัะฝะพะน ัะฐะฑะปะธัั " + realRatio);
}
public static void extract(String filePath, String tablePath) throws FileNotFoundException, IOException {
HuffmanOperator operator = new HuffmanOperator();
File compressedFile = new File(filePath),
tableFile = new File(tablePath),
extractedFile = new File(filePath + ".xtr");
String compressed = "";
String[] encodingArray = new String[ENCODING_TABLE_SIZE];
//read compressed file
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!check here:
try (FileInputHelper fi = new FileInputHelper(compressedFile)) {
byte b;
while (true) {
b = fi.readByte();//method returns EOFException
compressed += String.format("%8s", Integer.toBinaryString(b & 0xff)).replace(" ", "0");
}
} catch (EOFException e) {
}
//--------------------
//read encoding table:
try (FileInputHelper fi = new FileInputHelper(tableFile)) {
fi.readLine();//skip first empty string
encodingArray[(byte)'n'] = fi.readLine();//read code for 'n'
while (true) {
String s = fi.readLine();
if (s == null)
throw new EOFException();
encodingArray[(byte)s.charAt(0)] = s.substring(1, s.length());
}
} catch (EOFException ignore) {}
extractedFile.createNewFile();
//extract:
try (FileOutputHelper fo = new FileOutputHelper(extractedFile)) {
fo.writeString(operator.extract(compressed, encodingArray));
}
System.out.println("ะััั ะบ ัะฐัะฟะฐะบะพะฒะฐะฝะฝะพะผั ัะฐะนะปั " + extractedFile.getAbsolutePath());
}
}
เชคเชฎเชพเชฐเซ เชเชพเชคเซ readme.txt เชธเซเชเชจเชพเช เชธเชพเชฅเซ เชซเชพเชเชฒ เชฒเชเชตเซ เชชเชกเชถเซ ๐
เชจเชฟเชทเซเชเชฐเซเชท
เชฎเชจเซ เชฒเชพเชเซ เชเซ เชเซ เชนเซเช เชเชเชฒเซเช เช เชเชนเซเชตเชพ เชฎเชพเชเชเชคเซ เชนเชคเซ. เชเซ เชคเชฎเชพเชฐเซ เชชเชพเชธเซ เชเซเชก, เช เชฒเซเชเซเชฐเชฟเชงเชฎ, เชธเชพเชฎเชพเชจเซเชฏ เชฐเซเชคเซ, เชเซเชเชชเชฃ เชเชชเซเชเชฟเชฎเชพเชเชเซเชถเชจเชฎเชพเช เชธเซเชงเชพเชฐเชพเชเชจเซ เชฎเชพเชฐเซ เช เชธเชฎเชฐเซเชฅเชคเชพ เชตเชฟเชถเซ เชเชเชเช เชเชนเซเชตเชพเชจเซเช เชนเซเชฏ, เชคเซ เชชเชเซ เชฒเชเชตเชพ เชฎเชพเชเซ เชจเชฟเชเชธเชเชเซเช. เชเซ เชฎเซเช เชเชเชเช เชธเชฎเชเชพเชตเซเชฏเซเช เชจเชฅเซ, เชคเซ เชเซเชชเชพ เชเชฐเซเชจเซ เชชเชฃ เชฒเชเซ. เชฎเชจเซ เชเชฟเชชเซเชชเชฃเซเชเชฎเชพเช เชคเชฎเชพเชฐเซ เชชเชพเชธเซเชฅเซ เชธเชพเชเชญเชณเชตเซเช เชเชฎเชถเซ!
PS
เชนเชพ, เชนเชพ, เชนเซเช เชนเชเซ เชชเชฃ เช
เชนเซเช เชเซเช, เชเชพเชฐเชฃ เชเซ เชนเซเช เชเซเชฃเชพเชเช เชตเชฟเชถเซ เชญเซเชฒเซ เชเชฏเซ เชจเชฅเซ. เชธเซเชเซเชฐเชฟเชเช s1 เชฎเชพเชเซ, เชเชจเซเชเซเชกเชฟเชเช เชเซเชทเซเชเชเชจเซเช เชตเชเชจ 48 เชฌเชพเชเชเซเชธ เชเซ - เชฎเซเชณ เชซเชพเชเชฒ เชเชฐเชคเชพเช เชเชฃเซเช เชตเชงเชพเชฐเซ, เช
เชจเซ เชคเซเช เชตเชงเชพเชฐเชพเชจเชพ เชถเซเชจเซเชฏ เชตเชฟเชถเซ เชญเซเชฒเซเชฏเชพ เชจเชฅเซ (เชเชฎเซเชฐเซเชฒเชพ เชถเซเชจเซเชฏเชจเซ เชธเชเชเซเชฏเชพ 7 เชเซ) => เชเชฎเซเชชเซเชฐเซเชถเชจ เชฐเซเชถเชฟเชฏเซ เชเช เชเชฐเชคเชพ เชเชเซ เชนเชถเซ: 176 /(65 + 48*8 + 7) = 0.38. เชเซ เชคเชฎเซ เชชเชฃ เช เชจเซเชเชงเซเชฏเซเช เชเซ, เชคเซ เชชเชเซ เชซเชเซเชค เชเชนเซเชฐเชพ เชชเชฐ เช เชจเชนเซเช, เชคเชฎเชพเชฐเซเช เชเชพเชฎ เชฅเช เชเชฏเซเช. เชนเชพ, เช เช
เชฎเชฒเซเชเชฐเชฃ เชจเชพเชจเซ เชซเชพเชเชฒเซ เชฎเชพเชเซ เช
เชคเซเชฏเชเชค เชฌเชฟเชจเชเชพเชฐเซเชฏเชเซเชทเชฎ เชนเชถเซ. เชชเชฐเชเชคเซ เชฎเซเชเซ เชซเชพเชเชฒเซเชจเซเช เชถเซเช เชฅเชพเชฏ เชเซ? เชซเชพเชเชฒเชจเซเช เชเชฆ เชเชจเซเชเซเชกเชฟเชเช เชเซเชทเซเชเชเชจเชพ เชเชฆ เชเชฐเชคเชพเช เชเชฃเซเช เชฎเซเชเซเช เชเซ. เช เชคเซ เชเซ เชเซเชฏเชพเช เช
เชฒเซเชเซเชฐเชฟเชงเชฎ เชเซเชเช เชคเซ เชชเซเชฐเชฎเชพเชฃเซ เชเชพเชฐเซเชฏ เชเชฐเซ เชเซ! เชเชฆเชพเชนเชฐเชฃ เชคเชฐเซเชเซ, เชฎเชพเชเซ
เชธเซเชฐเซเชธ: www.habr.com