Huffman [Java]

Huffman [Java] - Java - Programmation

Marsh Posté le 28-02-2013 à 10:05:19    

Bonjour désolé de vous déranger mais j'ai besoin d'aide pour un devoir à rendre mercredi prochain qui concerne le codage et decodage d'huffman
Le code est en java

Code :
  1. import java.io.BufferedInputStream;
  2. import java.io.BufferedOutputStream;
  3. import java.io.BufferedReader;
  4. import java.io.BufferedWriter;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileNotFoundException;
  8. import java.io.FileOutputStream;
  9. import java.io.FileReader;
  10. import java.io.FileWriter;
  11. import java.io.IOException;
  12. import java.io.InputStream;
  13. import java.io.InputStreamReader;
  14. import java.io.PrintWriter;
  15. import java.io.Reader;
  16. import java.io.StringReader;
  17. import java.io.StringWriter;
  18. import java.util.ArrayList; // Cliquez pour découvrir
  19. import java.util.Collections;
  20. import java.util.HashMap;
  22. class Node implements Comparable<Node> {
  23. char symbol;
  24. double freq;
  25. Node left, right;
  27. public Node(char s, double f) {
  28.  this.symbol = s;
  29.  this.freq = f;
  30.  this.left = this.right = null;
  31. }
  33. public Node(Node left, Node right) {
  34.  this.symbol = (char) 0;
  35.  this.left = left;
  36.  this.right = right;
  37.  this.freq = left.freq + right.freq;
  38. }
  40. public int compareTo(Node other) {
  41.  return this.freq < other.freq ? -1 : 1;
  42. }
  43. }
  45. public class Huffman {
  46. /*
  47.  * public static String encode(String filename) throws FileNotFoundException
  48.  * { FileReader infile = new FileReader(filename); String ret =
  49.  * encode(infile);
  50.  *  
  51.  * try { infile.close(); } catch (IOException ioex) { } // Nothing we can do
  52.  * if it won't close.
  53.  *  
  54.  * return ret; }
  55.  *  
  56.  * public static String encode(InputStream in) { return encode(new
  57.  * InputStreamReader(in)); }
  58.  *  
  59.  * public static String encode(Reader in) {
  60.  *  
  61.  * // You can't reset() a file stream, so store in a String. StringWriter
  62.  * streamcopy = new StringWriter(); try { for (int nextchar = in.read();
  63.  * nextchar >= 0; nextchar = in.read()) streamcopy.write(nextchar); } catch
  64.  * (IOException ioex) {
  65.  * System.err.println("Could not read the input file." ); return null; }
  66.  *  
  67.  * in = new StringReader(streamcopy.toString()); try { in.reset(); } catch
  68.  * (IOException ioex) {
  69.  * System.err.println("Could not reset the input stream: " +
  70.  * ioex.toString()); return null; }
  71.  *  
  72.  *  
  73.  * // Prepare to write the resulting code. StringWriter ret = new
  74.  * StringWriter();
  75.  *  
  76.  * // Read in the file, character by character. int readResult; while (true)
  77.  * { try { readResult = in.read(); } catch (IOException ioex) { // Treat an
  78.  * IOException as an end-of-stream. readResult = -1; }
  79.  *  
  80.  * if (readResult < 0) // End-of-stream; exit the loop. break;
  81.  *  
  82.  * char readChar = (char) readResult;
  83.  *  
  84.  *  
  85.  * }
  86.  *  
  87.  * return ret.toString(); }
  88.  */
  89. static char[] symbols = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
  90.   'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
  91.   'x', 'y', 'z' };
  92. static double[] freqs = { 0.0372262773723, 0.0570802919708,
  94.   0.0229197080292, 0.0439416058394, 0.0363503649635, 0.030802919708,
  95.   0.0160583941606, 0.0554744525547, 0.0459854014599, 0.0110948905109,
  96.   0.0191240875912, 0.0204379562044, 0.0557664233577, 0.0699270072993,
  97.   0.0144525547445, 0.016204379562, 0.0505109489051, 0.0300729927007,
  98.   0.0668613138686, 0.0248175182482, 0.0601459854015, 0.0357664233577,
  99.   0.0583941605839, 0.0315328467153, 0.0496350364964, 0.0394160583942 };
  101. //public static ArrayList<String> al = new ArrayList<String>();
  103. public static Node createTree(char[] symbols, double[] freqs) {
  105.  ArrayList<Node> leaves = new ArrayList<Node>();
  106.  for (int i = 0; i < symbols.length; i++) {
  107.   leaves.add(new Node(symbols[i], freqs[i]));
  108.  }
  109.  while (leaves.size() > 1) {
  110.   Collections.sort(leaves);
  111.   Node n1 = leaves.remove(0);
  112.   Node n2 = leaves.remove(0);
  113.   leaves.add(new Node(n1, n2));
  114.  }
  115.  return leaves.get(0);
  116. }
  118. private static void traversal(Node node, String code, String[] codes) {
  119.  if (node.left == null && node.right == null) {
  120.   codes[node.symbol - 'a'] = code;
  121.  } else {
  122.   traversal(node.left, code + "0", codes);
  123.   traversal(node.right, code + "1", codes);
  124.  }
  125. }
  127. public static String[] createCode(Node root) {
  128.  String[] codes = new String[26];
  129.  traversal(root, "", codes);
  130.  return codes;
  131. }
  133. public static void main(String[] args) throws IOException {
  135.  /*
  136.   * if (args.length != 1) {
  137.   * System.err.println("Usage: java HuffmanCoder <filename>" ); return; }
  138.   *  
  139.   * String encoded; try { encoded = encode(args[0]); } catch
  140.   * (FileNotFoundException fnf) {
  141.   * System.err.println("The specified file could not be found." ); return;
  142.   * }
  143.   *  
  144.   * // That is, the size if we were outputting bits.
  145.   * System.err.println("Encoded size: " + ((int)
  146.   * Math.ceil(encoded.length() / 8)) + " bytes." );
  147.   * System.err.println("Huffman code:\n" ); System.out.print(encoded); }
  148.   */
  150.  BufferedReader in = new BufferedReader(new FileReader(
  151.    "c:\\textes\\test.txt" )); // lit dans la console
  153.  System.out
  154.    .println("\nFichier créé codée en bit et lecture du premier dans la console java\n" );
  155.  String line;
  156.  while ((line = in.readLine()) != null)
  157.   System.out.println(line);
  159.  BufferedInputStream entree = null;
  160.  BufferedOutputStream sortie = null;
  161.  try {
  162.   // * Ouvre les flux. */
  164.   entree = new BufferedInputStream(new FileInputStream(new File(
  165.     "c:\\textes\\test.txt" )));// lit le fichier
  167.   System.out.println("\ndevient\n" );
  169.   String[] codes = createCode(createTree(symbols, freqs));
  170.   for (int i = 0; i < codes.length; i++) {
  171.    System.out.println((char) (i + 'a') + ": " + codes[i]);
  172.    //al.add(codes[i]);
  173.   }
  176.   sortie = new BufferedOutputStream(new FileOutputStream(new File(
  177.     "c:\\textes\\codage.txt" )), 10240); // créer le fichier
  179.   byte[] tampon = new byte[10240]; // 10ko
  180.   int longueur;
  181.   while ((longueur = entree.read(tampon)) > 0) {
  182.    sortie.write(tampon, 0, longueur);
  183.   }
  184.  } finally {
  185.   sortie.close();
  186.   entree.close();
  188.  }
  189. }
  190. }


 
Donc voila j'ai réussis à faire l'arbre etc , on doit assigné aux caractères des fréquences prédéfinis  
Je voudrais maintenant passé au codage des lettres , mon arbre donne donc ça :
a: 11011
b: 0110
c: 00000
d: 11110
e: 11010
f: 10010
g: 101100
h: 0011
i: 11111
j: 010000
k: 111010
l: 111011
m: 0101
n: 1100
o: 010001
p: 101101
q: 0010
r: 01001
s: 1010
t: 00001
u: 1000
v: 10111
w: 0111
x: 10011
y: 0001
z: 11100
 
Mais je vois pas du tout comment je peux faire pour ecrire un texte : abcjfejrejfjdj par exemple et que ceci affiche le texte en bit 010101010 en fonction des lettres
Bon c'est un peu codé comme un cochon par contre désolé de pas avoir supprimer les trucs inutile.
Merci d'avance si on peut m'apporter des précisions


Message édité par walase le 28-02-2013 à 10:06:51
Reply

Marsh Posté le 28-02-2013 à 10:05:19   

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed