创建哈夫曼树，并实现对其编码，包括以下功能： 1.输入要创建的哈夫曼树的结点数和各结点的权值。 2.建立哈夫曼树：根据输入的结点数和各结点的权值建哈夫曼树。 3.输出哈夫曼树。 4.对哈夫曼树进行编码，并输出其哈夫曼编码的C++代码

以下是实现哈夫曼树的C++代码，包括创建哈夫曼树和对其编码：

#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <unordered_map>

using namespace std;

// 定义哈夫曼树节点的结构体
struct HuffmanNode {
    int val;
    HuffmanNode* left;
    HuffmanNode* right;

    HuffmanNode(int v) : val(v), left(nullptr), right(nullptr) {}
};

// 定义哈夫曼树节点比较函数，用于优先队列
struct HuffmanNodeCmp {
    bool operator()(HuffmanNode* node1, HuffmanNode* node2) {
        return node1->val > node2->val;
    }
};

// 创建哈夫曼树
HuffmanNode* createHuffmanTree(int n, vector<int>& weights) {
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, HuffmanNodeCmp> pq;
    for (int i = 0; i < n; i++) {
        pq.push(new HuffmanNode(weights[i]));
    }

    while (pq.size() > 1) {
        HuffmanNode* left = pq.top();
        pq.pop();
        HuffmanNode* right = pq.top();
        pq.pop();
        HuffmanNode* parent = new HuffmanNode(left->val + right->val);
        parent->left = left;
        parent->right = right;
        pq.push(parent);
    }

    return pq.top();
}

// 输出哈夫曼树
void printHuffmanTree(HuffmanNode* root, int depth) {
    if (root == nullptr) {
        return;
    }

    printHuffmanTree(root->right, depth + 1);
    for (int i = 0; i < depth; i++) {
        cout << "    ";
    }
    cout << root->val << endl;
    printHuffmanTree(root->left, depth + 1);
}

// 对哈夫曼树进行编码
void encodeHuffmanTree(HuffmanNode* root, string code,
                       unordered_map<int, string>& encodeMap) {
    if (root == nullptr) {
        return;
    }

    if (root->left == nullptr && root->right == nullptr) {
        encodeMap[root->val] = code;
    }

    encodeHuffmanTree(root->left, code + "0", encodeMap);
    encodeHuffmanTree(root->right, code + "1", encodeMap);
}

int main() {
    int n;
    cout << "请输入哈夫曼树的结点数：" << endl;
    cin >> n;

    vector<int> weights(n);
    cout << "请输入哈夫曼树各结点的权值：" << endl;
    for (int i = 0; i < n; i++) {
        cin >> weights[i];
    }

    HuffmanNode* root = createHuffmanTree(n, weights);
    cout << "哈夫曼树如下：" << endl;
    printHuffmanTree(root, 0);

    unordered_map<int, string> encodeMap;
    encodeHuffmanTree(root, "", encodeMap);

    cout << "哈夫曼编码如下：" << endl;
    for (auto it : encodeMap) {
        cout << it.first << "：" << it.second << endl;
    }

    return 0;
}

以上代码中，我们首先定义了一个哈夫曼树节点的结构体 `HuffmanNode`，包含了节点的权值、左右子树指针等信息。为了方便建立哈夫曼树，我们定义了一个比较函数 `HuffmanNodeCmp`，用于优先队列中的节点排序。

在 `createHuffmanTree` 函数中，我们首先将所有节点按照权值从小到大放入优先队列 `pq` 中。然后每次从队列中取出两个权值最小的节点，合并成一个新节点，将其放回队列中。最终队列中只剩下一个节点，即为哈夫曼树的根节点。

在 `printHuffmanTree` 函数中，我们采用中序遍历的方式输出哈夫曼树，使用递归实现。

在 `encodeHuffmanTree` 函数中，我们采用前序遍历的方式对哈夫曼树进行编码。如果遍历到叶子节点，则将该节点的编码存储到哈希表 `encodeMap` 中。

最后，在 `main` 函数中，我们先输入哈夫曼树的结点数和各结点的权值，然后调用 `createHuffmanTree` 函数建立哈夫曼树，并输出哈夫曼树。接着，我们调用 `encodeHuffmanTree` 函数对哈夫曼树进行编码，并输出编码结果。