เดเตปเดเตเดฐเดฟ
เด เดฒเตเดเดจเดคเตเดคเดฟเตฝ, เดเดพเตป เด เดฑเดฟเดฏเดชเตเดชเตเดเตเดจเตเดจ เดนเดซเตเดฎเดพเตป เด เตฝเดเตเดฐเดฟเดคเดคเตเดคเตเดเตเดเตเดฑเดฟเดเตเดเตเด เดกเดพเดฑเตเดฑ เดเดเดชเตเดฐเดทเดจเดฟเตฝ เด เดคเดฟเดจเตเดฑเต เดชเตเดฐเดฏเตเดเดคเตเดคเตเดเตเดเตเดฑเดฟเดเตเดเตเด เดธเดเดธเดพเดฐเดฟเดเตเดเตเด.
เดซเดฒเดฎเดพเดฏเดฟ, เดเดเตเดเตพ เดเดฐเต เดฒเดณเดฟเดคเดฎเดพเดฏ เดเตผเดเตเดเตเดตเตผ เดเดดเตเดคเตเด. เดเดคเต เดเดคเดฟเดจเดเด เดเดฃเตเดเดพเดฏเดฟเดเตเดเตเดฃเตเดเต
เดเดฐเต เดเตเดฑเดฟเดฏ เดชเตเดฐเดคเดฟเดซเดฒเดจเด
เดเดฐเต เดธเดพเดงเดพเดฐเดฃ เดเตเดเตเดธเตเดฑเตเดฑเต เดซเดฏเดฒเดฟเตฝ, เดเดฐเต เดชเตเดฐเดคเตเดเด 8 เดฌเดฟเดฑเตเดฑเตเดเตพ (ASCII เดเตปเดเตเดกเดฟเดเดเต) เด เดฒเตเดฒเตเดเตเดเดฟเตฝ 16 (เดฏเตเดฃเดฟเดเตเดกเต เดเตปเดเตเดกเดฟเดเดเต) เดเดชเดฏเตเดเดฟเดเตเดเต เดเตปเดเตเดกเต เดเตเดฏเตเดคเดฟเดฐเดฟเดเตเดเตเดจเตเดจเต. เด เดเตเดคเตเดคเดคเดพเดฏเดฟ, เดเดเตเดเตพ ASCII เดเตปเดเตเดกเดฟเดเดเต เดชเดฐเดฟเดเดฃเดฟเดเตเดเตเด. เดเดฆเดพเดนเดฐเดฃเดคเตเดคเดฟเดจเต, s1 = "SUSIE SAYS IT IS EASYn" เดเดจเตเดจ เดธเตเดเตเดฐเดฟเดเดเต เดเดเตเดเตเดเตเด. เดธเตโเดชเตเดฏเตโเดธเตเดเดณเตเด เดชเตเดคเดฟเดฏ เดฒเตเตป เดชเตเดฐเดคเตเดเด - 'n' เดเตพเดชเตเดชเตเดเต, เดคเตเตผเดเตเดเดฏเดพเดฏเตเด, เดตเดฐเดฟเดฏเดฟเตฝ 22 เดชเตเดฐเดคเตเดเดเตเดเตพ เดเดฃเตเดเต. เด เดฒเตเตป เด เดเดเตเดเดฟเดฏ เดซเดฏเดฒเดฟเดจเตเดฑเต เดญเดพเดฐเด 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" (linefeed) เดเดจเตเดจ เดเดฟเดนเตเดจเด เดเดฐเต เดชเตเดคเดฟเดฏ เดตเดฐเดฟเดฏเต เดธเตเดเดฟเดชเตเดชเดฟเดเตเดเตเดจเตเดจเต, "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, เดฑเตเดกเต เดฌเดฟเดฑเตเดฑเตเดเตพ เด เดเดเตเดเตเดจเตเดจ, เดชเตเดฐเดคเตเด เดชเตเดฐเดคเตเดเดคเตเดคเดฟเดจเต เด เดจเตเดฏเตเดเตเดฏเดฎเดพเดฏ เดเตปเดเตเดกเดฟเดเดเตเดฎเดพเดฏเดฟ เดชเตเดฐเตเดคเตเดคเดชเตเดชเตเดเตเดฎเตเดชเตเตพ, เดชเตเดฐเดคเตเด เดชเตเดฐเดคเตเดเด (เด เดคเต เดฎเดพเดคเตเดฐเด!) เดเตปเดเตเดกเต เดเตเดฏเตโเดคเดคเดพเดฏเดฟ เดเดเตเดเตพเดเตเดเต เดเดเดจเดเดฟ เด เดฑเดฟเดฏเดพเด. เด เดเตเดคเตเดคเดคเดพเดฏเดฟ, เดเดเตเดเตพ เดกเตเดเตเดกเต เดธเตเดเตเดฐเดฟเดเดเดฟเดฒเตเดเตเดเต เดชเตเดฐเดคเตเดเด เดเดดเตเดคเตเดจเตเดจเต (เดกเตเดเตเดกเต เดเตเดฏเตเดค เดธเดจเตเดฆเตเดถเด เด เดเดเตเดเดฟเดฏ เดธเตเดเตเดฐเดฟเดเดเต), 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 เดจเดฟเตผเดฆเตเดฆเตเดถเดเตเดเดณเตเดเต เดซเดฏเตฝ เดเดดเตเดคเตเดฃเตเดเดคเตเดฃเตเดเต ๐
เดคเตเดฐเตเดฎเดพเดจเด
เดเดพเตป เดชเดฑเดฏเดพเตป เดเดเตเดฐเดนเดฟเดเตเดเดคเต เด เดคเตเดฐเดฏเตเดฏเตเดณเตเดณเตเดตเตเดจเตเดจเต เดเดพเตป เดเดฐเตเดคเตเดจเตเดจเต. เดเตเดกเต, เด เตฝเดเตเดฐเดฟเดคเด, เดชเตเดคเตเดตเต, เดเดคเตเดเตเดเดฟเดฒเตเด เดเดชเตเดฑเตเดฑเดฟเดฎเตเดธเตเดทเดจเดฟเดฒเต เดฎเตเดเตเดเดชเตเดชเตเดเตเดคเตเดคเดฒเตเดเดณเตเดเต เดเดจเตเดฑเต เดเดดเดฟเดตเดฟเดฒเตเดฒเดพเดฏเตเดฎเดฏเตเดเตเดเตเดฑเดฟเดเตเดเต เดจเดฟเดเตเดเตพเดเตเดเต เดเดจเตเดคเตเดเตเดเดฟเดฒเตเด เดชเดฑเดฏเดพเดจเตเดฃเตเดเตเดเตเดเดฟเตฝ, เดเดดเตเดคเดพเตป เดฎเดเดฟเดเตเดเตเดฃเตเดเดคเดฟเดฒเตเดฒ. เดเดพเตป เดเดจเตเดคเตเดเตเดเดฟเดฒเตเด เดตเดฟเดถเดฆเตเดเดฐเดฟเดเตเดเดฟเดเตเดเดฟเดฒเตเดฒเตเดเตเดเดฟเตฝ, เดฆเดฏเดตเดพเดฏเดฟ เดเดดเตเดคเตเด. เด เดญเดฟเดชเตเดฐเดพเดฏเดเตเดเดณเดฟเตฝ เดจเดฟเดเตเดเดณเดฟเตฝ เดจเดฟเดจเตเดจเต เดเตเตพเดเตเดเดพเตป เดเดพเตป เดเดเตเดฐเดนเดฟเดเตเดเตเดจเตเดจเต!
เดชเดฟ.เดเดธเต
เด
เดคเต, เด
เดคเต, เดเดพเตป เดเดชเตเดชเตเดดเตเด เดเดตเดฟเดเตเดฏเตเดฃเตเดเต, เดเดพเดฐเดฃเด เดเดพเตป เดเตเดฃเดเดคเตเดคเตเดเตเดเตเดฑเดฟเดเตเดเต เดฎเดฑเดจเตเดจเดฟเดฒเตเดฒ. เดธเตเดเตเดฐเดฟเดเดเต s1-เดจเต, เดเตปเดเตเดกเดฟเดเดเต เดเตเดฌเดฟเดณเดฟเดจเต 48 เดฌเตเดฑเตเดฑเตเดเตพ เดญเดพเดฐเดฎเตเดฃเตเดเต - เดฏเดฅเดพเตผเดคเตเดฅ เดซเดฏเดฒเดฟเดจเตเดเตเดเดพเตพ เดตเดณเดฐเต เดเตเดเตเดคเดฒเดพเดฃเต, เด
เดงเดฟเด เดชเตเดเตเดฏเดเตเดเดณเตเดเตเดเตเดฑเดฟเดเตเดเต เด
เดตเตผ เดฎเดฑเดจเตเดจเดฟเดฒเตเดฒ (เดเตเตผเดคเตเดค เดชเตเดเตเดฏเดเตเดเดณเตเดเต เดเดฃเตเดฃเด 7 เดเดฃเต) => เดเดเดชเตเดฐเดทเตป เด
เดจเตเดชเดพเดคเด เดเดจเตเดจเดฟเตฝ เดเตเดฑเดตเดพเดฏเดฟเดฐเดฟเดเตเดเตเด: 176 /(65 + 48*8 + 7) = 0.38. เดจเดฟเดเตเดเตพ เดเดคเต เดถเตเดฐเดฆเตเดงเดฟเดเตเดเตเดเตเดเดฟเตฝ, เดฎเตเดเดคเตเดคเต เดฎเดพเดคเตเดฐเดฎเดฒเตเดฒ, เดจเดฟเดเตเดเตพ เดชเตเตผเดคเตเดคเดฟเดฏเดพเดเตเดเดฟ. เด
เดคเต, เดเตเดฑเดฟเดฏ เดซเดฏเดฒเตเดเตพเดเตเดเต เด เดจเดเดชเตเดชเดพเดเตเดเตฝ เดตเดณเดฐเต เดซเดฒเดชเตเดฐเดฆเดฎเดฒเตเดฒ. เดเดจเตเดจเดพเตฝ เดตเดฒเดฟเดฏ เดซเดฏเดฒเตเดเตพเดเตเดเต เดเดจเตเดคเต เดธเดเดญเดตเดฟเดเตเดเตเด? เดซเดฏเตฝ เดตเดฒเตเดชเตเดชเดเตเดเตพ เดเตปเดเตเดกเดฟเดเดเต เดชเดเตเดเดฟเดเดฏเตเดเต เดตเดฒเตเดชเตเดชเดคเตเดคเตเดเตเดเดพเตพ เดตเดณเดฐเต เดตเดฒเตเดคเดพเดฃเต. เดเดตเดฟเดเตเดฏเดพเดฃเต เด
เตฝเดเตเดฐเดฟเดคเด เดชเตเดฐเดตเตผเดคเตเดคเดฟเดเตเดเตเดจเตเดจเดคเต! เดเดฆเดพเดนเดฐเดฃเดคเตเดคเดฟเดจเต, เดตเตเดฃเตเดเดฟ
เด
เดตเดฒเดเดฌเด: www.habr.com