1. #include <stdlib.h>
2. #include <iostream>
3. #include <stdio.h>
4.  
5. using namespace std;
6.  
7. struct element_zrodla
8. {
9.         int symbol;
10.         int frequency;
11. };
12.  
13. struct element_zrodla model[256];
14. int licznik_symboli = 0;
15.  
16. int nazwa_pliku_Huffman(char *nazwa_pliku, char *rozszerzenie, char *nazwa_pliku_z_nowym_rozszerzeniem)
17. {
18.         int i = 0;
19.         int n = 0;
20.         for (i = 0; i<35; i++)
21.         {
22.                 nazwa_pliku_z_nowym_rozszerzeniem[i] = 0;
23.         }
24.         while ((nazwa_pliku[n] != 46) && (nazwa_pliku[n] != ''))
25.         {
26.                 n++;
27.         }
28.         for (i = 0; i<n; i++)
29.         {
30.                 nazwa_pliku_z_nowym_rozszerzeniem[i] = nazwa_pliku[i];
31.         }
32.         nazwa_pliku_z_nowym_rozszerzeniem[i] = 46;
33.         n = 0;
34.         i++;
35.         while (rozszerzenie[n] != '')
36.         {
37.                 nazwa_pliku_z_nowym_rozszerzeniem[i] = rozszerzenie[n];
38.                 i++;
39.                 n++;
40.         }
41.         return 0;
42. }
43. int utworz_model_niepelny_Huffman(struct element_zrodla model[], struct element_zrodla model_pelny[256])
44. {
45.         int n = 0;
46.         for (int i = 0; i<256; i++)
47.         {
48.                 if (model_pelny[i].frequency>0)
49.                 {
50.                         model[n].symbol = model_pelny[i].symbol;
51.                         model[n].frequency = model_pelny[i].frequency;
52.                         n++;
53.                 }
54.         }
55.         return n;
56. }
57. int oblicz_model_Huffman(char *nazwa_pliku, char *nazwa_pliku_model, char *nazwa_pliku_wynik, struct element_zrodla model[])
58. {
59.         int liczba_znakow = 0;
60.         int n = 0;
61.         unsigned char BUFOR_WEJSCIOWY[1000];
62.         struct element_zrodla model_pelny[256];
63.         for(int i = 0; i < 256; i++)
64.         {
65.                 model_pelny[i].symbol = i;
66.                 model_pelny[i].frequency = 0;
67.         }
68.         FILE *plik;
69.         plik = fopen(nazwa_pliku,"rb");
70.         if(plik == NULL)
71.         {
72.                 cout <<"Nie udalo sie otworzyc pliku zrodlowego"<<endl;
73.                 exit(0);
74.         }
75.         else
76.         {
77.             cout <<"nOdczytuje plik zrodlowy"<<endl;
78.                 while(n = fread(BUFOR_WEJSCIOWY, sizeof(unsigned char), 1000, plik))
79.                 {
80.                         for(int j = 0; j < n; j++)
81.                         {
82.                                 model_pelny[BUFOR_WEJSCIOWY[j]].frequency++;
83.                         }
84.                         liczba_znakow += n;
85.                 }
86.                 cout << "nW pliku wejsciowym bylo  " << liczba_znakow  << " znakow "<<endl;
87.                 fclose(plik);
88.                 plik = fopen(nazwa_pliku_wynik, "wb");
89.                 if(plik == NULL)
90.                 {
91.                         cout << "Nie mozna otworzyc pliku " << nazwa_pliku <<endl;
92.                         exit(0);
93.                 }
94.                 else
95.                 {
96.                         fprintf(plik, "%d n", liczba_znakow);
97.                         fclose(plik);
98.                 }
99.                 licznik_symboli = utworz_model_niepelny_Huffman(model, model_pelny);
100.                 plik = fopen(nazwa_pliku_model, "wb");
101.                 if(plik == NULL)
102.                 {
103.                         cout << "Nie mozna otworzyc pliku " <<nazwa_pliku_model <<endl;
104.                         exit(0);
105.                 }
106.                 else
107.                 {
108.                         for(int k = 0; k < licznik_symboli; k++)
109.                         {
110.                                 fprintf(plik, "%d %d n", model[k].symbol, model[k].frequency);
111.                         }
112.                         fclose(plik);
113.                 }
114.         }
115.         return 0;
116. }
117.  
118. int funkcja_porownujaca(const void *element1, const void *element2)
119. {
120.         const struct element_zrodla *p1 = (const struct element_zrodla*) element1;
121.         const struct element_zrodla *p2 = (const struct element_zrodla*) element2;
122.         if ((p1->frequency) == (p2->frequency)) return 0;
123.         else if ((p1->frequency)<(p2->frequency)) return 1;
124.         else return -1;
125. }
126. int posortuj_model_Huffmana(struct element_zrodla model[], int liczba_elementow, char*plik_model_posortowany)
127. {
128.         qsort(model, liczba_elementow, sizeof(struct element_zrodla), funkcja_porownujaca);
129.         FILE *plik;
130.         plik = fopen(plik_model_posortowany, "wb");
131.         if (plik == NULL)
132.         {
133.                 cout << "Blad w trakcie otwierania pliku do zapisu posortowanego modelu" <<endl;
134.                 exit(0);
135.         }
136.         else
137.         {
138.                 for (int i = 0; i<liczba_elementow; i++)
139.                 {
140.                         fprintf(plik, "%d %dn", model[i].symbol, model[i].frequency);
141.                 }
142.                 fclose(plik);
143.         }
144. }
145.  
146. struct galaz_drzewa
147. {
148.         int ojciec;
149.         int potomek1;
150.         int potomek2;
151. };
152.  
153. struct element_tablicy
154. {
155.         int symbol;
156.         unsigned char slowo[4];
157.         int liczba_bitow;
158. };
159.  
160. struct galaz_drzewa drzewo_kodowania[255];
161. struct element_tablicy tablica_kodowania[256];
162. struct element_tablicy tablica_kodowania_odczytana[256];
163.  
164. int utworz_drzewo(struct element_zrodla model[], struct galaz_drzewa drzewo[], int liczba_symboli, char* plik_drzewa, char* plik_mod_model)
165. {
166.         int licznik_pomocniczy = liczba_symboli;
167.         int licznik_symboli = liczba_symboli;
168.         int licznik_elementow_drzewa = 0;
169.         int licznik_dodanych = 0;
170.         int i = 0;
171.         for(i = 0; i<liczba_symboli - 1; i++)
172.         {
173.                 drzewo[i].ojciec = 256 + i;
174.                 drzewo[i].potomek1 = model[liczba_symboli - 1 - i].symbol;
175.                 drzewo[i].potomek2 = model[liczba_symboli - 2 - i].symbol;
176.                 model[liczba_symboli - 2 - i].symbol = 256 + i;
177.                 model[liczba_symboli - 2 - i].frequency = model[liczba_symboli - 2 - i].frequency + model[liczba_symboli - 1 - i].frequency;
178.                 licznik_symboli--;
179.                 licznik_elementow_drzewa++;
180.                 qsort(model, licznik_symboli, sizeof(struct element_zrodla), funkcja_porownujaca);
181.                 licznik_dodanych++;
182.         }
183.         FILE *plik;
184.         plik = fopen(plik_mod_model, "wb");
185.         if (plik == NULL)
186.         {
187.                 cout << "Blad w trakcie otwierania pliku ze zmodyfikowanym modelem" <<endl;
188.                 exit(0);
189.         }
190.         else
191.         {
192.                 for (i = 0; i<liczba_symboli; i++)
193.                 {
194.                         fprintf(plik, "%d %dn", model[i].symbol, model[i].frequency);
195.                 }
196.                 fclose(plik);
197.         }
198.         plik = fopen(plik_drzewa, "a+");
199.         if (plik == NULL)
200.         {
201.                 cout << "Blad w trakcie otwierania pliku z drzewem " <<endl;
202.         exit(0);
203.         }
204.         else
205.         {
206.                 fprintf(plik, "%d n", licznik_dodanych);
207.                 for (i = 0; i<licznik_elementow_drzewa; i++)
208.                 {
209.                         fprintf(plik, "%d %d %d n", drzewo[i].ojciec, drzewo[i].potomek1, drzewo[i].potomek2);
210.                 }
211.                 fclose(plik);
212.         }
213. }
214.  
215. int utworz_tablice_kodowania(struct galaz_drzewa drzewo[], int liczba_symboli, struct element_tablicy tablica[], char *nazwa_pliku_tablicy, char* nazwa_pliku_tablicy_mod)
216. {
217.         int liczba_drzewa = liczba_symboli - 2;
218.         int licznik_tablicy = 0;
219.         int ojciec;
220.         int indeks_ojca_tablica;
221.         int liczba_bajtow;
222.         int liczba_bitow;
223.         int jedynka = 1;
224.         unsigned char bajty[4];
225.  
226.         for (int i = 0; i<2 * liczba_symboli; i++)
227.         {
228.                 tablica[i].symbol = 0;
229.                 tablica[i].liczba_bitow = 0;
230.                 for (int j = 0; j<4; j++)
231.                 {
232.                         tablica[i].slowo[j] = 0;
233.                 }
234.         }
235.         tablica[licznik_tablicy].symbol = drzewo[liczba_drzewa].ojciec;
236.         while (liczba_drzewa + 1)
237.         {
238.                 ojciec = drzewo[liczba_drzewa].ojciec;
239.                 tablica[licznik_tablicy + 1].symbol = drzewo[liczba_drzewa].potomek1;
240.                 tablica[licznik_tablicy + 2].symbol = drzewo[liczba_drzewa].potomek2;
241.                 indeks_ojca_tablica = -1;
242.                 for (int i = 0; i<licznik_tablicy + 1; i++)
243.                 {
244.                         if ((tablica[i].symbol) == (ojciec))
245.                         {
246.                                 indeks_ojca_tablica = i;
247.                                 break;
248.                         }
249.                 }
250.                 if (indeks_ojca_tablica == -1)
251.                 {
252.                         cout <<"Blad tworzenia tablicy kodowania" <<endl;
253.                         exit(0);
254.                 }
255.                 else
256.                 {
257.                         for (int i = 0; i<4; i++)
258.                         {
259.                                 tablica[licznik_tablicy + 1].slowo[i] = tablica[indeks_ojca_tablica].slowo[i];
260.                 tablica[licznik_tablicy + 2].slowo[i] = tablica[indeks_ojca_tablica].slowo[i];
261.                         }
262.                         liczba_bajtow = (tablica[indeks_ojca_tablica].liczba_bitow) / 8;
263.                         liczba_bitow = (tablica[indeks_ojca_tablica].liczba_bitow) % 8;
264.                         jedynka = 1;
265.                         jedynka = jedynka << 7 - liczba_bitow;
266.                         jedynka = tablica[indeks_ojca_tablica].slowo[liczba_bajtow] | jedynka;
267.                         tablica[licznik_tablicy + 1].slowo[liczba_bajtow] = jedynka;
268.                         tablica[licznik_tablicy + 1].liczba_bitow = tablica[indeks_ojca_tablica].liczba_bitow + 1;
269.                         tablica[licznik_tablicy + 2].liczba_bitow = tablica[indeks_ojca_tablica].liczba_bitow + 1;
270.                         licznik_tablicy = licznik_tablicy + 2;
271.                         liczba_drzewa--;
272.                 }
273.         }
274.         FILE *plik;
275.         plik = fopen(nazwa_pliku_tablicy, "wb");
276.         if (plik == NULL)
277.         {
278.                 cout << "Blad w trakcie otwierania pliku z tablica kodowania" <<endl;
279.                 exit(0);
280.         }
281.         else
282.         {
283.                 for (int i = 0; i<2 * liczba_symboli - 1; i++)
284.                 {
285.                         for (int j = 0; j<4; j++)
286.                         {
287.                                 bajty[j] = tablica[i].slowo[j];
288.                         }
289.                         fprintf(plik, "%d %d %d %d %d %dn", tablica[i].symbol, bajty[0], bajty[1], bajty[2], bajty[3], tablica[i].liczba_bitow);
290.                 }
291.                 fclose(plik);
292.         }
293.         plik = fopen(nazwa_pliku_tablicy_mod, "wb");
294.         if (plik == NULL)
295.         {
296.                 cout << "Blad w trakcie otwierania pliku z tablica kodowania" <<endl;
297.                 exit(0);
298.         }
299.         else
300.         {
301.                 for (int i = 0; i<2 * liczba_symboli - 1; i++)
302.                 {
303.                         if (tablica[i].symbol < 256)
304.                         {
305.                                 for (int j = 0; j < 4; j++)
306.                                 {
307.                                         bajty[j] = tablica[i].slowo[j];
308.                                 }
309.                                 fprintf(plik, "%d %d %d %d %d %dn", tablica[i].symbol, bajty[0], bajty[1], bajty[2], bajty[3], tablica[i].liczba_bitow);
310.                         }
311.                 }
312.                 fclose(plik);
313.         }
314. }
315. int odczytaj_tablice_kodowania(struct element_tablicy tablica_kodowania[], char* plik_mod_tablicy)
316. {
317.         int dlugosc_slowa;
318.         int bajty[4];
319.         int kod_znaku;
320.         int liczba_znakow = 0;
321.         FILE *plik;
322.         plik = fopen(plik_mod_tablicy, "rb");
323.         if (plik == NULL)
324.         {
325.                 cout << "Blad otwarcia pliku ze zmodyfikowana tablica kodowania" <<endl;
326.                 exit(0);
327.         }
328.         else
329.         {
330.                 while (fscanf(plik, "%d %d %d %d %d %d n", &kod_znaku, &bajty[0], &bajty[1], &bajty[2], &bajty[3], &dlugosc_slowa) != EOF)
331.                 {
332.                         if (dlugosc_slowa>0)
333.                         {
334.                                 tablica_kodowania[liczba_znakow].symbol = kod_znaku;
335.                                 tablica_kodowania[liczba_znakow].liczba_bitow = dlugosc_slowa;
336.                                 for (int i = 0; i<4; i++)
337.                                 {
338.                                         tablica_kodowania[liczba_znakow].slowo[i] = bajty[i];
339.                                 }
340.                                 liczba_znakow++;
341.                         }
342.                 }
343.                 fclose(plik);
344.                 printf("Odczytano %d znakow z pliku ze zmodyfikowana tablica kodowanian", liczba_znakow);
345.         }
346.         return liczba_znakow;
347. }
348.  
349. int kompresja_Huffman(struct element_tablicy tablica_kodowania[], char* plik_wejsciowy, char* plik_wynikowy, int liczba_elementow_tablicy)
350. {
351.         int n;
352.         int liczba_bitow_znaku;
353.         int suma_bitow=0;
354.         int kursor;
355.         int kursor_out;
356.         int liczba_pozostalych;
357.         int liczba_wolne_bity;
358.         int liczba_zak_symboli;
359.         int numer_slowa;
360.         int numer_bajtu;
361.         int dopisek;
362.         unsigned char maska;
363.         unsigned char znak;
364.         unsigned char bufor_wejsciowy[1000];
365.         unsigned char bufor_wyjsciowy[1000];
366.         unsigned char slowo_znaku[4];
367.         unsigned char bajt_out;
368.         FILE *plik;
369.         FILE *plik_out;
370.         plik_out = fopen(plik_wynikowy, "a+");
371.         if (plik_out == NULL)
372.         {
373.                 printf("Nie udalo sie otworzyc pliku wynikowegon");
374.                 exit(0);
375.         }
376.         plik = fopen(plik_wejsciowy, "rb");
377.         if (plik == NULL)
378.         {
379.                 printf("Nie udalo sie otworzyc pliku wejsciowegon");
380.                 exit(0);
381.         }
382.         kursor_out = 0;
383.         numer_slowa = 0;
384.         numer_bajtu = 0;
385.         bajt_out = 0;
386.         liczba_zak_symboli = 0;
387.         while (n = fread(bufor_wejsciowy, sizeof(unsigned char),1000, plik))
388.         {
389.                 for (int i = 0; i < n; i++)
390.                 {
391.                         znak = bufor_wejsciowy[i];
392.                         for (int j = 0; j < liczba_elementow_tablicy; j++)
393.                         {
394.                                 if (znak == tablica_kodowania[j].symbol)
395.                                 {
396.                                         for (int k = 0; k < 4; k++)
397.                                         {
398.                                                 slowo_znaku[k] = tablica_kodowania[j].slowo[k];
399.                                         }
400.                                         liczba_bitow_znaku = tablica_kodowania[j].liczba_bitow;
401.                                         suma_bitow = suma_bitow + liczba_bitow_znaku;
402.                                         kursor = 0;
403.                                         numer_slowa = 0;
404.                                         break;
405.                                 }
406.                         }
407.                         while (liczba_bitow_znaku > 0)
408.                         {
409.                                 liczba_pozostalych = 8 - kursor;
410.                                 if (liczba_pozostalych > liczba_bitow_znaku)
411.                                 {
412.                                         liczba_pozostalych = liczba_bitow_znaku;
413.                                 }
414.                                 liczba_wolne_bity = 8 - kursor_out;
415.                                 if (liczba_pozostalych < liczba_wolne_bity)
416.                                 {
417.                                         liczba_wolne_bity = liczba_pozostalych;
418.                                 }
419.                                 maska = ((255 >> kursor)&(255 << (8 - (kursor + liczba_wolne_bity))));
420.                                 dopisek = slowo_znaku[numer_slowa] & maska;
421.                                 dopisek = dopisek << kursor;
422.                                 dopisek = dopisek >> kursor_out;
423.                                 bajt_out = bajt_out | dopisek;
424.                                 kursor_out += liczba_wolne_bity;
425.                                 liczba_bitow_znaku -= liczba_wolne_bity;
426.                                 kursor += liczba_wolne_bity;
427.                                 liczba_pozostalych -= liczba_wolne_bity;
428.                                 if (liczba_pozostalych == 0)
429.                                 {
430.                                         numer_slowa++;
431.                                         kursor = 0;
432.                                         if (liczba_bitow_znaku >= 8)
433.                                         {
434.                                                 liczba_pozostalych = 8;
435.                                         }
436.                                         else
437.                                         {
438.                                                 liczba_pozostalych = liczba_bitow_znaku;
439.                                         }
440.                                 }
441.                                 if (kursor_out == 8)
442.                                 {
443.                                         fwrite(&bajt_out, sizeof(unsigned char), 1, plik_out);
444.                                         numer_bajtu++;
445.                                         kursor_out = 0;
446.                                         bajt_out = 0;
447.                                 }
448.                         }
449.                 liczba_zak_symboli++;
450.                 }
451.         }
452.         printf("Bajt wyjsciowy numer %d kod hec %x n", numer_bajtu, bajt_out);
453.         fwrite(&bajt_out, sizeof(unsigned char), 1, plik_out);
454.         printf("Liczba zakodowanych znakow pliku kompresowego: %dn", liczba_zak_symboli);
455.         printf("Liczba bajtow w pliku skompresowanym: %dn", numer_bajtu + 1);
456.         printf("Wskaznik upakowania: %5.1f procentn", 100 * (float)(numer_bajtu + 1) / (float)liczba_zak_symboli);
457.         fclose(plik);
458.         fclose(plik_out);
459.     return suma_bitow;
460. }
461. int dekompresja_Huffman(char *nazwa_pliku_skom, char *nazwa_pliku_dekom, char *nazwa_pliku_tree, struct galaz_drzewa drzewo_kodowania[])
462. {
463.         int n;
464.         int m;
465.         int ojciec;
466.         int potomek1;
467.         int potomek2;
468.         int ilosc_symboli;
469.         int rozmiar_drzewa;
470.         int licznik_drzewa;
471.         int suma_symboli;
472.         int suma_bitow;
473.         unsigned char bajt_wejsciowy;
474.         unsigned char bajt_wyjsciowy;
475.         unsigned char maska = 128;
476.         unsigned char bit;
477.         FILE *plik_dek = NULL;
478.         plik_dek = fopen(nazwa_pliku_dekom, "wb");
479.         if(plik_dek == NULL)
480.         {
481.                 printf("nBlad w trakcie otwierania pliku zdekodowanego do zapisun");
482.                 exit(0);
483.         }
484.         FILE *plik_tree = NULL;
485.         plik_tree = fopen(nazwa_pliku_tree, "rb");
486.         if(plik_tree == NULL)
487.         {
488.                 printf("nBlad w trakcie otwierania pliku z drzewem do odczytun");
489.                 exit(0);
490.         }
491.         FILE *plik = NULL;
492.         plik = fopen(nazwa_pliku_skom, "rb");
493.         if(plik == NULL)
494.         {
495.                 printf("nBlad w trakcie otwierania zakodowanego plikun");
496.                 exit(0);
497.         }
498.         else
499.         {
500.                 fscanf(plik_tree, "%dn %dn", &ilosc_symboli, &rozmiar_drzewa);
501.                 licznik_drzewa = 0;
502.                 for(int i = 0; i < rozmiar_drzewa; i++)
503.                 {
504.                         fscanf(plik_tree, "%d %d %dn", &ojciec, &potomek1, &potomek2);
505.                         drzewo_kodowania[licznik_drzewa].ojciec = ojciec;
506.                         drzewo_kodowania[licznik_drzewa].potomek1 = potomek1;
507.                         drzewo_kodowania[licznik_drzewa].potomek2 = potomek2;
508.                         licznik_drzewa++;
509.                 }
510.                 suma_symboli = 0;
511.                 suma_bitow = 0;
512.                 ojciec = drzewo_kodowania[rozmiar_drzewa - 1].ojciec;
513.                 potomek1 = drzewo_kodowania[rozmiar_drzewa - 1].potomek1;
514.                 potomek2 = drzewo_kodowania[rozmiar_drzewa - 1].potomek2;
515.                 while(suma_symboli < ilosc_symboli)
516.                 {
517.                         n = fread(&bajt_wejsciowy, sizeof(unsigned char), 1, plik);
518.                         if(n == 1)
519.                         {
520.                                 for(int j = 0; j < 8; j++)
521.                                 {
522.                                         bit = bajt_wejsciowy&maska;
523.                                         bajt_wejsciowy = bajt_wejsciowy<<1;
524.                                         suma_bitow++;
525.                                         if(bit)
526.                                         {
527.                                                 ojciec = potomek1;
528.                                         }
529.                                         else
530.                                         {
531.                                                 ojciec = potomek2;
532.                                         }
533.                                         if(ojciec < 256)
534.                                         {
535.                                                 bajt_wyjsciowy = ojciec;
536.                                                 fwrite(&bajt_wyjsciowy, sizeof(unsigned char), 1, plik_dek);
537.                                                 suma_symboli++;
538.                                                 licznik_drzewa = rozmiar_drzewa - 1;
539.                                                 ojciec = drzewo_kodowania[rozmiar_drzewa - 1].ojciec;
540.                                                 potomek1 = drzewo_kodowania[rozmiar_drzewa - 1].potomek1;
541.                                                 potomek2 = drzewo_kodowania[rozmiar_drzewa - 1].potomek2;
542.                                                 if(suma_symboli == ilosc_symboli)
543.                                                 {
544.                                                         break;
545.                                                 }
546.                                         }
547.                                         else
548.                                         {
549.                                                 m = rozmiar_drzewa - 1;
550.                                                 while(m >= 0)
551.                                                 {
552.                                                         if(drzewo_kodowania[m].ojciec == ojciec)
553.                                                         {
554.                                                                 licznik_drzewa = m;
555.                                                                 m = -1;
556.                                                         }
557.                                                         m = m - 1;
558.                                                 }
559.                                                 potomek1 = drzewo_kodowania[licznik_drzewa].potomek1;
560.                                                 potomek2 = drzewo_kodowania[licznik_drzewa].potomek2;
561.                                         }
562.                                 }
563.                         }
564.                 }
565.                 printf("nLiczba odczytanych bitow: %d, liczba zdekodowanych symboli %d.n", suma_bitow, suma_symboli);
566.                 fclose(plik);
567.                 fclose(plik_dek);
568.                 fclose(plik_tree);
569.                 return(suma_symboli);
570.         }
571. }
572. int main()
573. {
574.         int wybor;
575.         char znak;
576.         char nazwa_pliku[30];
577.         char nazwa_pliku_modelu[35];
578.         char nazwa_pliku_mod_modelu[35];
579.         char nazwa_pliku_sort[35];
580.         char nazwa_pliku_drzewo[35];
581.         char nazwa_pliku_tablicy[35];
582.         char nazwa_pliku_mod_tablicy[35];
583.         char nazwa_pliku_wynik[35];
584.         char nazwa_pliku_dekom[35];
585.         char rozszerzenie_modelu[] = "model";
586.         char rozszerzenie_mod_modelu[] = "modmodel";
587.         char rozszerzenie_sort[] = "sort";
588.         char rozszerzenie_drzewo[] = "tree";
589.         char rozszerzenie_tablicy[] = "tab";
590.         char rozszerzenie_mod_tablicy[] = "modtab";
591.         char rozszerzenie_wynik[] = "huff";
592.         char rozszerzenie_dekom[] = "dek.txt";
593.         int liczba_elementow_tablicy = 0;
594.         cout << "Teoria informacji i kodowania " <<endl;
595.         cout << "Kodowanie i dekodowanie metoda Huffmana" <<endl;
596.  
597.  
598.         do
599.         {
600.                 system("CLS");
601.  
602.                 cout << "Teoria informacji i kodowania" <<endl;
603.                 cout << "_____________________________" <<endl;
604.                 cout << "[1] Kompresja metoda Huffmana" <<endl;
605.                 cout << "[2] Dekompresja metoda Huffmana" <<endl;
606.                 cout << "[0] Wyjscie" <<endl;
607.                 cin >> wybor;
608.                 if(wybor == 1)
609.                 {
610.                 cout << "Podaj nazwe pliku do kompresji wraz z rozszerzeniem: " ;
611.                         scanf("%s", &nazwa_pliku);
612.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_modelu, nazwa_pliku_modelu);
613.                         printf("nNazwa pliku z modelem:                    %sn", nazwa_pliku_modelu);
614.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_sort, nazwa_pliku_sort);
615.                         printf("Nazwa pliku z posortowanym modelem:       %sn", nazwa_pliku_sort);
616.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_mod_modelu, nazwa_pliku_mod_modelu);
617.                         printf("Nazwa pliku ze zmod. modelem:             %sn", nazwa_pliku_mod_modelu);
618.  
619.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_drzewo, nazwa_pliku_drzewo);
620.                         printf("Nazwa pliku z drzewem kodowania:          %sn", nazwa_pliku_drzewo);
621.  
622.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_tablicy, nazwa_pliku_tablicy);
623.                         printf("Nazwa pliku z tablica kodowania:          %sn", nazwa_pliku_tablicy);
624.  
625.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_mod_tablicy, nazwa_pliku_mod_tablicy);
626.                         printf("Nazwa pliku ze zmod. tablica kodowania:   %sn", nazwa_pliku_mod_tablicy);
627.  
628.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_wynik, nazwa_pliku_wynik);
629.                         printf("Nazwa pliku wynikowego:                   %sn", nazwa_pliku_wynik);
630.                         oblicz_model_Huffman(nazwa_pliku, nazwa_pliku_modelu, nazwa_pliku_drzewo, model);
631.                         posortuj_model_Huffmana(model, licznik_symboli, nazwa_pliku_sort);
632.                         utworz_drzewo(model, drzewo_kodowania, licznik_symboli, nazwa_pliku_drzewo, nazwa_pliku_mod_modelu);
633.                         utworz_tablice_kodowania(drzewo_kodowania, licznik_symboli, tablica_kodowania, nazwa_pliku_tablicy, nazwa_pliku_mod_tablicy);
634.                         odczytaj_tablice_kodowania(tablica_kodowania, nazwa_pliku_mod_tablicy);
635.                         kompresja_Huffman(tablica_kodowania, nazwa_pliku, nazwa_pliku_wynik, licznik_symboli);
636.             cout <<endl;
637.                         system("PAUSE");
638.                 }
639.                 else if(wybor == 2)
640.                 {
641.                     cout << "nPodaj nazwe pliku do dekompresji wraz z rozszerzeniem: ";
642.                         scanf("%s", &nazwa_pliku);
643.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_drzewo, nazwa_pliku_drzewo);
644.                         printf("nNazwa pliku z drzewem kodowania:   %sn", nazwa_pliku_drzewo);
645.                         nazwa_pliku_Huffman(nazwa_pliku, rozszerzenie_dekom, nazwa_pliku_dekom);
646.                         printf("Nazwa pliku po dekompresji:        %sn", nazwa_pliku_dekom);
647.                         dekompresja_Huffman(nazwa_pliku, nazwa_pliku_dekom, nazwa_pliku_drzewo, drzewo_kodowania);
648.                         system("PAUSE");
649.                 }
650.     }while(wybor!=0);
651. }