C++创建哈夫曼树

1、输入结点个数和权重创建哈夫曼树

#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
using namespace std;
//haffman 树的结构
typedef struct
{
    //叶子结点权值
    unsigned int weight;
    //指向双亲,和孩子结点的指针
    unsigned int parent;
    unsigned int lChild;
    unsigned int rChild;
} Node, * HuffmanTree;

//动态分配数组,存储哈夫曼编码
typedef char* HuffmanCode;

//选择两个parent为0,且weight最小的结点s1和s2的方法实现
//n 为叶子结点的总数,s1和 s2两个指针参数指向要选取出来的两个权值最小的结点
void select(HuffmanTree* huffmanTree, int n, int* s1, int* s2)
{
    //标记 i
    int i = 0;
    //记录最小权值
    int min=10000;
    //遍历全部结点,找出单节点
    for (i = 1; i <= n; i++)
    {
        //如果此结点的父亲没有,那么把结点号赋值给 min,跳出循环
        if ((*huffmanTree)[i].parent == 0)
        {
            min = i;
            break;
        }
    }
    //继续遍历全部结点,找出权值最小的单节点
    for (i = 1; i <= n; i++)
    {
        //如果此结点的父亲为空,则进入 if
        if ((*huffmanTree)[i].parent == 0)
        {
            //如果此结点的权值比 min 结点的权值小,那么更新 min 结点,否则就是最开始的 min
            if ((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
            {
                min = i;
            }
        }
    }
    //找到了最小权值的结点,s1指向
    *s1 = min;
    //遍历全部结点
    for (i = 1; i <= n; i++)
    {
        //找出下一个单节点,且没有被 s1指向,那么i 赋值给 min,跳出循环
        if ((*huffmanTree)[i].parent == 0 && i != (*s1))
        {
            min = i;
            break;
        }
    }
    //继续遍历全部结点,找到权值最小的那一个
    for (i = 1; i <= n; i++)
    {
        if ((*huffmanTree)[i].parent == 0 && i != (*s1))
        {
            //如果此结点的权值比 min 结点的权值小,那么更新 min 结点,否则就是最开始的 min
            if ((*huffmanTree)[i].weight < (*huffmanTree)[min].weight)
            {
                min = i;
            }
        }
    }
    //s2指针指向第二个权值最小的叶子结点
    *s2 = min;
}

//创建哈夫曼树并求哈夫曼编码的算法如下,w数组存放已知的n个权值
void createHuffmanTree(HuffmanTree* huffmanTree, int w[], int n)
{
    //m 为哈夫曼树总共的结点数,n 为叶子结点数
    int m = 2 * n - 1;
    //s1 和 s2 为两个当前结点里,要选取的最小权值的结点
    int s1;
    int s2;
    //标记
    int i;
    // 创建哈夫曼树的结点所需的空间,m+1,代表其中包含一个头结点
    *huffmanTree = (HuffmanTree)malloc((m + 1) * sizeof(Node));
    //1--n号存放叶子结点,初始化叶子结点,结构数组来初始化每个叶子结点,初始的时候看做一个个单个结点的二叉树
    for (i = 1; i <= n; i++)
    {
        //其中叶子结点的权值是 w【n】数组来保存
        (*huffmanTree)[i].weight = w[i];
        //初始化叶子结点(单个结点二叉树)的孩子和双亲,单个结点,也就是没有孩子和双亲,==0
        (*huffmanTree)[i].lChild = 0;
        (*huffmanTree)[i].parent = 0;
        (*huffmanTree)[i].rChild = 0;
    }// end of for
    //非叶子结点的初始化
    for (i = n + 1; i <= m; i++)
    {
        (*huffmanTree)[i].weight = 0;
        (*huffmanTree)[i].lChild = 0;
        (*huffmanTree)[i].parent = 0;
        (*huffmanTree)[i].rChild = 0;
    }

    printf("\n HuffmanTree: \n");
    //创建非叶子结点,建哈夫曼树
    for (i = n + 1; i <= m; i++)
    {
        //在(*huffmanTree)[1]~(*huffmanTree)[i-1]的范围内选择两个parent为0
        //且weight最小的结点,其序号分别赋值给s1、s2
        select(huffmanTree, i - 1, &s1, &s2);
        //选出的两个权值最小的叶子结点,组成一个新的二叉树,根为 i 结点
        (*huffmanTree)[s1].parent = i;
        (*huffmanTree)[s2].parent = i;
        (*huffmanTree)[i].lChild = s1;
        (*huffmanTree)[i].rChild = s2;
        //新的结点 i 的权值
        (*huffmanTree)[i].weight = (*huffmanTree)[s1].weight + (*huffmanTree)[s2].weight;

        printf("%d (%d, %d)\n", (*huffmanTree)[i].weight, (*huffmanTree)[s1].weight, (*huffmanTree)[s2].weight);
    }

    printf("\n");
}

//哈夫曼树建立完毕,从 n 个叶子结点到根,逆向求每个叶子结点对应的哈夫曼编码
void creatHuffmanCode(HuffmanTree* huffmanTree, HuffmanCode* huffmanCode, int n)
{
    //指示biaoji
    int i;
    //编码的起始指针
    int start;
    //指向当前结点的父节点
    int p;
    //遍历 n 个叶子结点的指示标记 c
    unsigned int c;
    //分配n个编码的头指针
    huffmanCode = (HuffmanCode*)malloc((n + 1) * sizeof(char*));
    //分配求当前编码的工作空间
    char* cd = (char*)malloc(n * sizeof(char));
    //从右向左逐位存放编码,首先存放编码结束符
    cd[n - 1] = '\0';
    //求n个叶子结点对应的哈夫曼编码
    for (i = 1; i <= n; i++)
    {
        //初始化编码起始指针
        start = n - 1;
        //从叶子到根结点求编码
        for (c = i, p = (*huffmanTree)[i].parent; p != 0; c = p, p = (*huffmanTree)[p].parent)
        {
            if ((*huffmanTree)[p].lChild == c)
            {
                //从右到左的顺序编码入数组内
                cd[--start] = '0';  //左分支标0
            }
            else
            {
                cd[--start] = '1';  //右分支标1
            }
        }// end of for
        //为第i个编码分配空间
        huffmanCode[i] = (char*)malloc((n - start) * sizeof(char));

        strcpy(huffmanCode[i], &cd[start]);
    }

    free(cd);
    //打印编码序列
    for (i = 1; i <= n; i++)
    {
        printf("HuffmanCode of %3d is %s\n", (*huffmanTree)[i].weight, huffmanCode[i]);
    }

    printf("\n");
}

int main(void)
{
    HuffmanTree HT;
    HuffmanCode HC;
    int* w, i, n, weight, m;

    printf("\n输入节点个数: ");

    cin >> n;

    w = (int*)malloc((n + 1) * sizeof(int));

    printf("\n各个点的权重\n", n);

    for (i = 1; i <= n; i++)
    {
        printf("%d: ", i);
        fflush(stdin);
        cin >> weight;
        w[i] = weight;
    }

    createHuffmanTree(&HT, w, n);
    creatHuffmanCode(&HT, &HC, n);

    return 0;
}

2、

/*-------------------------------------------------------------------------
 * Name:   哈夫曼编码源代码。
 * Date:   2011.04.16
 * Author: Jeffrey Hill+Jezze(解码部分)
 * 在 Win-TC 下测试通过
 * 实现过程:着先通过 HuffmanTree() 函数构造哈夫曼树,然后在主函数 main()中
 *           自底向上开始(也就是从数组序号为零的结点开始)向上层层判断,若在
 *           父结点左侧,则置码为 0,若在右侧,则置码为 1。最后输出生成的编码。
 *------------------------------------------------------------------------*/
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAXBIT      100
#define MAXVALUE  10000
#define MAXLEAF     30
#define MAXNODE    MAXLEAF*2 -1

typedef struct
{
    int bit[MAXBIT];
    int start;
} HCodeType;        /* 编码结构体 */
typedef struct
{
    int weight;
    int parent;
    int lchild;
    int rchild;
    int value;
} HNodeType;        /* 结点结构体 */

/* 构造一颗哈夫曼树 */
void HuffmanTree(HNodeType HuffNode[MAXNODE], int n)
{
    /* i、j: 循环变量,m1、m2:构造哈夫曼树不同过程中两个最小权值结点的权值,
        x1、x2:构造哈夫曼树不同过程中两个最小权值结点在数组中的序号。*/
    int i, j, m1, m2, x1, x2;
    /* 初始化存放哈夫曼树数组 HuffNode[] 中的结点 */
    for (i = 0; i < 2 * n - 1; i++)
    {
        HuffNode[i].weight = 0;//权值 
        HuffNode[i].parent = -1;
        HuffNode[i].lchild = -1;
        HuffNode[i].rchild = -1;
        HuffNode[i].value = i; //实际值,可根据情况替换为字母  
    } /* end for */

    /* 输入 n 个叶子结点的权值 */
    for (i = 0; i < n; i++)
    {
        printf("Please input weight of leaf node %d: \n", i);
        scanf_s("%d", &HuffNode[i].weight);
    } /* end for */

    /* 循环构造 Huffman 树 */
    for (i = 0; i < n - 1; i++)
    {
        m1 = m2 = MAXVALUE;     /* m1、m2中存放两个无父结点且结点权值最小的两个结点 */
        x1 = x2 = 0;
        /* 找出所有结点中权值最小、无父结点的两个结点,并合并之为一颗二叉树 */
        for (j = 0; j < n + i; j++)
        {
            if (HuffNode[j].weight < m1 && HuffNode[j].parent == -1)
            {
                m2 = m1;
                x2 = x1;
                m1 = HuffNode[j].weight;
                x1 = j;
            }
            else if (HuffNode[j].weight < m2 && HuffNode[j].parent == -1)
            {
                m2 = HuffNode[j].weight;
                x2 = j;
            }
        } /* end for */
            /* 设置找到的两个子结点 x1、x2 的父结点信息 */
        HuffNode[x1].parent = n + i;
        HuffNode[x2].parent = n + i;
        HuffNode[n + i].weight = HuffNode[x1].weight + HuffNode[x2].weight;
        HuffNode[n + i].lchild = x1;
        HuffNode[n + i].rchild = x2;

        printf("x1.weight and x2.weight in round %d: %d, %d\n", i + 1, HuffNode[x1].weight, HuffNode[x2].weight);  /* 用于测试 */
        printf("\n");
    } /* end for */
  /*  for(i=0;i<n+2;i++)
    {
        printf(" Parents:%d,lchild:%d,rchild:%d,value:%d,weight:%d\n",HuffNode[i].parent,HuffNode[i].lchild,HuffNode[i].rchild,HuffNode[i].value,HuffNode[i].weight);
                  }*///测试 
} /* end HuffmanTree */

//解码 
void decodeing(char string[], HNodeType Buf[], int Num)
{
    int i, tmp = 0, code[1024];
    int m = 2 * Num - 1;
    char* nump;
    char num[1024];
    for (i = 0; i < strlen(string); i++)
    {
        if (string[i] == '0')
            num[i] = 0;
        else
            num[i] = 1;
    }
    i = 0;
    nump = &num[0];

    while (nump < (&num[strlen(string)]))
    {
        tmp = m - 1;
        while ((Buf[tmp].lchild != -1) && (Buf[tmp].rchild != -1))
        {

            if (*nump == 0)
            {
                tmp = Buf[tmp].lchild;
            }
            else tmp = Buf[tmp].rchild;
            nump++;

        }

        printf("%d", Buf[tmp].value);
    }
}

int main(void)
{

    HNodeType HuffNode[MAXNODE];            /* 定义一个结点结构体数组 */
    HCodeType HuffCode[MAXLEAF], cd;       /* 定义一个编码结构体数组, 同时定义一个临时变量来存放求解编码时的信息 */
    int i, j, c, p, n;
    char pp[100];
    printf("Please input n:\n");
    scanf_s("%d", &n);
    HuffmanTree(HuffNode, n);


    for (i = 0; i < n; i++)
    {
        cd.start = n - 1;
        c = i;
        p = HuffNode[c].parent;
        while (p != -1)   /* 父结点存在 */
        {
            if (HuffNode[p].lchild == c)
                cd.bit[cd.start] = 0;
            else
                cd.bit[cd.start] = 1;
            cd.start--;        /* 求编码的低一位 */
            c = p;
            p = HuffNode[c].parent;    /* 设置下一循环条件 */
        } /* end while */

        /* 保存求出的每个叶结点的哈夫曼编码和编码的起始位 */
        for (j = cd.start + 1; j < n; j++)
        {
            HuffCode[i].bit[j] = cd.bit[j];
        }
        HuffCode[i].start = cd.start;
    } /* end for */

    /* 输出已保存好的所有存在编码的哈夫曼编码 */
    for (i = 0; i < n; i++)
    {
        printf("%d 's Huffman code is: ", i);
        for (j = HuffCode[i].start + 1; j < n; j++)
        {
            printf("%d", HuffCode[i].bit[j]);
        }
        printf(" start:%d", HuffCode[i].start);

        printf("\n");
    }
    /*    for(i=0;i<n;i++){
        for(j=0;j<n;j++)
            {
                 printf ("%d", HuffCode[i].bit[j]);
            }
            printf("\n");
            }*/
    return 0;
}

  • 4
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值