哈夫曼圖片壓縮

本實驗構建最優二叉樹來實現哈夫曼編碼

使用VS2017完成

關於哈夫曼編碼的頭文件huffman.h

//huffman.h

#ifndef HUFFMAN_H
#define HUFFMAN_H
#define OK 1
#define SIZE 256
struct HTNode {
    int weight;//權值
    int parent;//父節點
    int lchild;//左孩子
    int rchild;//右孩子
};
typedef HTNode *HuffmanTree;//動態分配數組存儲Huffman樹
typedef char **HuffmanCode;//動態分配哈夫曼編碼表


//void PreorderTraverse(int root, HuffmanTree pHT);
int HuffmanCoding(HuffmanCode &pHC, HuffmanTree &pHT);
int Select(HuffmanTree pHT, int nSize);
void TestHufTree(HuffmanTree pHT);
void TestHufCode(int root, HuffmanTree pHT, HuffmanCode pHC);
void TestHufTreeN(int root, HuffmanTree pHT);

int HfmTree(HuffmanTree &pHT, int *w, int n);

#endif

相關實現huffman.cpp

//Huffman.cpp

#include<iostream>
#include<cstring>
#include"huffman.h"
#pragma warning( disable : 4996)
using namespace std;
/*
void PreorderTraverse(int root, HuffmanTree pHT)
{
    cout << pHT[root].weight << " ";//訪問節點
    if (pHT[root].lchild)//左孩子
    {
        PreorderTraverse(pHT[root].lchild, pHT);
    }
    if (pHT[root].rchild)//右孩子
    {
        PreorderTraverse(pHT[root].rchild, pHT);
    }
}
*/
int HuffmanCoding(HuffmanCode &pHC, HuffmanTree &pHT)
{
//    pHC = (HuffmanCode)malloc((SIZE + 1) * sizeof(char*));
    //無棧非遞歸遍歷 
    char cd[SIZE] = { '\0' };//記錄訪問路徑
    int cdlen = 0;//記錄當前路徑長度
    for (int i = 1; i < 512; i++)
    {
        pHT[i].weight = 0;//遍歷 Huffman樹時用作節點的狀態標志
    }

    int p = 2*SIZE-1;//根節點
    while (p != 0)
    {
        if (pHT[p].weight == 0)//向左
        {
            pHT[p].weight = 1;
            if (pHT[p].lchild != 0)
            {
                p = pHT[p].lchild;
                cd[cdlen++] = '0';
            }
            else if (pHT[p].rchild == 0)//登記葉子節點的字符編碼
            {
                pHC[p] = (char*)malloc((cdlen+1) * sizeof(char));
                cd[cdlen] = '\0';
                strcpy(pHC[p], cd);//復制編碼
            }
        }
        else if (pHT[p].weight == 1)//向右
        {
            pHT[p].weight = 2;
            if (pHT[p].rchild != 0)//右孩子為葉子節點
            {
                p = pHT[p].rchild;
                cd[cdlen++] = '1';
            }
        }
        else
        {
            //退回父節點，編碼長度減1
            pHT[p].weight = 0;
            p = pHT[p].parent;
            --cdlen;
        }
//        printf("*");
    }
    return OK;
}

int Select(HuffmanTree pHT, int nSize)
{
    int minValue = 0x7FFFFFFF;//最小值
    int min = 0;
    //找到最小權值的元素序號
    for (int i = 1; i <= nSize; i++)
    {
        if (pHT[i].parent == 0 && pHT[i].weight < minValue)
        {
            minValue = pHT[i].weight;
            min = i;
        }
    }
    return min;
}

void TestHufTree(HuffmanTree pHT)
{
    for (int i = 1; i < 2*SIZE; i++)
    {
        printf("pHT[%d]\t%d\t%d\t%d\t%d\n", i, pHT[i].weight, pHT[i].parent,pHT[i].lchild,pHT[i].rchild);
    }
}

int HfmTree(HuffmanTree &pHT, int *w, int n)
{
    int m = 2 * n - 1;
    pHT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));
    if (!pHT)
    {
        cerr << "內存分配失敗! " << endl;
        return -1;
    }
    //初始化樹
    HuffmanTree p = pHT + 1;//0號單元不使用
    for (int i = 0; i < m; i++)
    {
        p->weight = (i < n) ? w[i] : 0;
        p->parent = 0;
        p->lchild = 0;
        p->rchild = 0;
        p++;
    }
    for (int i = n + 1; i <= m; i++)
    {
        //第一個最小元素
        int s1 = Select(pHT, i - 1);//找出前i-1個中最小元素
        pHT[s1].parent = i;

        //第二個最小元素
        int s2 = Select(pHT, i - 1);
        pHT[s2].parent = i;

        pHT[i].weight = pHT[s1].weight + pHT[s2].weight;
        pHT[i].lchild = s1;
        pHT[i].rchild = s2;
    }
    return 0;
}

void TestHufCode(int root, HuffmanTree pHT, HuffmanCode pHC)
{
    if (pHT[root].lchild == 0 && pHT[root].rchild == 0)
    {
        printf("0x%02X %s\n", root - 1, pHC[root]);
    }
    if (pHT[root].lchild)//訪問左孩子
    {
        TestHufCode(pHT[root].lchild, pHT, pHC);
    }
    if (pHT[root].rchild)
    {
        TestHufCode(pHT[root].rchild, pHT, pHC);
    }
}

void TestHufTreeN(int root, HuffmanTree pHT)
{
    cout << pHT[root].weight << "\t"<<pHT[root].lchild<<"\t"<<pHT[root].rchild<<"\t"<<pHT[root].parent<<"\n";
    if (pHT[root].lchild != 0)
    {
        TestHufTreeN(pHT[root].lchild, pHT);
    }
    if (pHT[root].rchild != 0)
    {
        TestHufTreeN(pHT[root].rchild, pHT);
    }
}

壓縮相關操作的頭文件Compress.h

//Compress.h

#ifndef COMPRESS_H
#define COMPRESS_H
int Compress(const char *pFilename);
char Str2byte(const char *pBinStr);
int Encode(const char*pFilename, const HuffmanCode pHC, char *pBuffer, const int nSize);

struct HEAD
{
    char type[4];//文件類型
    int length;//原文件長度
    int weight[256];//權值數值
};
int WriteFile(const char*pFilename, const HEAD sHead, const char * pBuffer, const int nSize);
int InitHead(const char *pFilename, HEAD &sHead);
#endif

具體實現Compress.cpp

//Compress.cpp

#include"huffman.h"
#include"Compress.h"
#include<iostream>
#pragma warning( disable : 4996)
using namespace std;
//Compress
//InitHead
//Encode
//Str2byte
//WriteFile
char Str2byte(const char *pBinStr)
{
    char b = 0x00;
    for (int i = 0; i < 8; i++)
    {
        b = b << 1;
        if (pBinStr[i] == '1')
        {
            b = b | 0x01;
        }
    }
    return b;
}

int Compress(const char *pFilename)
{
    int weight[256] = { 0 };
    //以二進制打開文件
    FILE* in = fopen(pFilename, "rb");
    if (in == NULL)
    {
        cout << "Failed to open the file!" << endl;
        exit(0);
    }
    cout << "成功打開文件 " << pFilename << endl;
    int ch;
    while ((ch = getc(in)) != EOF)
    {
        weight[ch]++;
    }
    fclose(in);
    //cout << "Byte Weight" << endl;
    //for (int i = 0; i < SIZE; i++)
    //{
    //    printf("0x%02X %d\n", i, weight[i]);
    //}

    HuffmanTree hfmt;
    HfmTree(hfmt, weight, SIZE);
    cout << "成功生成哈夫曼樹" << endl;
//    TestHufTree(hfmt);
    //    TestHufTreeN(511, hfmt);
    HuffmanCode hfmc=(HuffmanCode)malloc((SIZE+1)*sizeof(char*));
//    for (int i = 1; i <= SIZE; i++)
//        hfmt[i].weight = weight[i - 1]
    //根據哈夫曼樹進行編碼
    HuffmanCoding(hfmc, hfmt);
    cout << "成功完成哈夫曼編碼" << endl;
//    cout << "先序遍歷哈夫曼樹輸出編碼信息：" << endl;
//    TestHufCode(2 * SIZE - 1, hfmt, hfmc);//測試哈夫曼編碼
//    cout << "壓縮后的文件編碼：" << endl;

    //計算編碼緩沖區大小
    int nSize = 0;
    for (int i = 0; i < 256; i++)
    {
        nSize += weight[i] * strlen(hfmc[i+1]);
    }
    nSize = (nSize % 8) ? nSize / 8 + 1 : nSize / 8;

//    cout <<"nSize = "<<nSize << endl << endl;

    //對原文件進行壓縮編碼
    char* pBuffer = NULL;
    pBuffer = (char *)malloc(nSize*sizeof(char));
    memset(pBuffer, 0, (nSize) * sizeof(char));
//    cout << "begin: " << strlen(pBuffer) << endl;
////    cout << "----";
//    int n;
//    cout << "input n:";
//    cin >> n;
    //將編碼寫入緩沖區
    Encode(pFilename, hfmc, pBuffer, nSize);
//    cout << "after: " << strlen(pBuffer) << endl;
//    cout << "len of puf  = " << strlen(pBuffer) << endl;
//    cout << "!pBuffer = " << !pBuffer << endl;
    if (!pBuffer)
    {
        cout << "!pBuffer = " << !pBuffer << endl;
        return -1;
    }
    cout << "\n壓縮完畢" << endl;
    //for (int i = 1; i < strlen(pBuffer); i++)
    //{
    //    printf("%d", pBuffer[i]);
    //}

    HEAD sHead;
    InitHead(pFilename, sHead);
    cout <<"原文件"<< pFilename<<"大小為：" << sHead.length << "Byte" << endl;
    int len_after = WriteFile(pFilename, sHead, pBuffer, nSize);
    cout << "大小為：" << len_after << "Byte \n頭文件sHead大小為：" << sizeof(sHead)<<"Byte"<<endl;
    cout << "壓縮比率：" << (double)len_after * 100 / sHead.length << "%" << endl;
    free(hfmt);
    free(hfmc);
    free(pBuffer);
    return OK;
}


int Encode(const char*pFilename, const HuffmanCode pHC, char *pBuffer, const int nSize)
{
    //開辟緩沖區
//    cout << "+++++";
    FILE* in = fopen(pFilename, "rb");
    if (in == NULL)
    {
        cout << "Failed to open the file!" << endl;
        exit(0);
    }
    pBuffer = (char*)malloc(nSize * sizeof(char));
    if (!pBuffer)
    {
        cerr << "開辟緩沖區失敗" << endl;
        return -1;
    }
    cout << "loading";
    int sign = 0;//用於控制小數點輸出
    char cd[SIZE] = { 0 };//工作區
    int pos = 0;//緩沖區指針
    int ch;
    //掃描文件，根據huffmman編碼表對其進行壓縮，壓縮結果暫存到緩沖區中
    while ((ch = getc(in)) != EOF)
    {
        if (sign % 1000 == 1)
            printf(".");
        sign++;
        strcat(cd, pHC[ch+1]);//從HC復制編碼串到cd


        //打印壓縮后的文件編碼
//        printf("%s", pHC[ch + 1]);


        //壓縮編碼
        while (strlen(cd) >= 8)
        {
            //截取字符串左邊的8個字符，編碼成字節
            pBuffer[pos++] = Str2byte(cd);
            //字符串整體左移8個字節
            for (int i = 0; i < SIZE - 8; i++)
            {
                cd[i] = cd[i + 8];
            }
        }
    }
    if (strlen(cd) > 0)
    {
        pBuffer[pos++] = Str2byte(cd);
    }
    fclose(in);
    //for (int i = 1; i < nSize; i++)
    //{
    //    printf("%d ", pBuffer[i]);
    //}
//    cout << endl<<"before: " << strlen(pBuffer) << endl;
    return OK;
}

int InitHead(const char *pFilename, HEAD &sHead)
{
    //初始化文件頭
    strcpy(sHead.type, "HUF");//文件類型
    sHead.length = 0;//原文件長度
    for (int i = 0; i < SIZE; i++)
    {
        sHead.weight[i] = 0;
    }
    FILE *in = fopen(pFilename, "rb");
    int ch;
    while ((ch = fgetc(in)) != EOF)
    {
        sHead.weight[ch]++;
        sHead.length++;
    }
    fclose(in);
    in = NULL;
    return OK;
}

int WriteFile(const char*pFilename, const HEAD sHead, const char * pBuffer, const int nSize)
{
    //生成文件名
    char filename[256] = { 0 };
    strcpy(filename, pFilename);
    strcat(filename, ".huf");
    //以二進制流形式打開文件
    FILE *out = fopen(filename, "wb");
    //寫文件頭
    fwrite(&sHead, sizeof(char), 1, out);
    //寫壓縮后的編碼
    fwrite(pBuffer, sizeof(char), nSize, out);
    //關閉文件，釋放文件指針
    fclose(out);
    out = NULL;
    cout << "生成壓縮文件：" << filename << endl;
    int len = sizeof(HEAD) + strlen(pFilename) + 1 + nSize;
    return len;
}

主函數Main.cpp

//Main.cpp

#include"huffman.h"
#include"Compress.h"
#include<iostream>
#include<cstdlib>
using namespace std;
#pragma warning( disable : 4996)

int main()
{
    cout << "= = = = = = = =Huffman 文件壓縮= = = = = = = =" << endl;
    cout << "請輸入文件名：";
    char filename[256];
    cin>>filename;
    Compress(filename);


//    system("pause");
    return 0;
}