เจเฉฐเจฆเจฐเจพเจเจผ
เจเจธ เจฒเฉเจ เจตเจฟเจ เจฎเฉเจ เจฎเจธเจผเจนเฉเจฐ เจนเจซเจฎเฉเจจ เจเจฒเจเฉเจฐเจฟเจฆเจฎ เจฌเจพเจฐเฉ เจเฉฑเจฒ เจเจฐเจพเจเจเจพ, เจจเจพเจฒ เจนเฉ เจกเจพเจเจพ เจเฉฐเจชเจฐเฉเจธเจผเจจ เจตเจฟเจ เจเจธเจฆเฉ เจตเจฐเจคเฉเจ เจฌเจพเจฐเฉ เจตเฉ.
เจจเจคเฉเจเฉ เจตเจเฉเจ, เจ
เจธเฉเจ เจเฉฑเจ เจธเจงเจพเจฐเจจ เจเจฐเจเฉเจตเจฐ เจฒเจฟเจเจพเจเจเฉเฅค เจเจธ เจฌเจพเจฐเฉ เจชเจนเจฟเจฒเจพเจ เจนเฉ เจเจฐเจเจพ เจเฉเจคเฉ เจเจพ เจเฉเฉฑเจเฉ เจนเฉ
เจเฉเจ เจตเจฟเจเจพเจฐ
เจเฉฑเจ เจจเจฟเจฏเจฎเจค เจเฉเจเจธเจ เจซเจพเจเจฒ เจตเจฟเฉฑเจ, เจเฉฑเจ เจ เฉฑเจเจฐ 8 เจฌเจฟเฉฑเจ (ASCII เจเจจเจเฉเจกเจฟเฉฐเจ) เจเจพเจ 16 (เจฏเฉเจจเฉเจเฉเจก เจเจจเจเฉเจกเจฟเฉฐเจ) เจจเจพเจฒ เจเจจเจเฉเจก เจเฉเจคเจพ เจเจพเจเจฆเจพ เจนเฉเฅค เจ เฉฑเจเฉ เจ เจธเฉเจ ASCII เจเฉฐเจเฉเจกเจฟเฉฐเจ 'เจคเฉ เจตเจฟเจเจพเจฐ เจเจฐเจพเจเจเฉเฅค เจเจฆเจพเจนเจฐเจจ เจฒเจ, s1 = โเจธเฉเจธเฉ เจเจนเจฟเฉฐเจฆเฉ เจนเฉ เจเจฟ เจเจน เจเจธเจพเจจ เจนเฉโ เจฒเจพเจเจจ เจฒเจเฅค เจฒเจพเจเจจ เจตเจฟเฉฑเจ เจเฉเฉฑเจฒ 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