类型定义哈夫曼树的存储结构循环x个结点,对比其 weght 值是否为最小且 parent 为 0,将其设为 minl 并赋值给 s1; 循环x个结点,对比其weght 值是小于minl 且 parent 为 0,将其设为min2 并赋值 给$2; 2)创建哈夫

曼树的过程中，对于每个字符，需要先计算其权重值，然后将其存储为一个叶子节点。接下来，需要按照权重值从小到大的顺序，将所有叶子节点放入一个优先队列中。

然后，从队列中取出两个权重值最小的节点，将其合并成一个新的父节点，并将父节点的权重值设为两个子节点的权重值之和。同时，将新的父节点加入队列中。

重复以上步骤，直到队列中只剩下一个节点，即为根节点，哈夫曼树的构建完成。

在存储结构中，每个节点需要记录其权重值、父节点的位置以及左右子节点的位置。可以使用一个数组来存储所有节点，其中下标代表节点的位置，数组中存储的是节点的信息。

具体来说，可以定义一个结构体来表示节点的信息，如下所示：

struct HuffmanNode {
    int weight; // 权重值
    int parent; // 父节点位置
    int left;   // 左子节点位置
    int right;  // 右子节点位置
};

然后，定义一个数组来存储所有节点：

HuffmanNode huffTree[MAX_NODE_NUM];

其中，`MAX_NODE_NUM`是预先定义的最大节点数。

在构建哈夫曼树的过程中，需要不断地取出队列中权重值最小的两个节点，合并成一个新的父节点，并将父节点加入队列。对于每个节点，需要记录其位置以及权重值，因此可以定义一个结构体来表示节点在队列中的信息，如下所示：

struct QueueNode {
    int pos;     // 节点位置
    int weight;  // 权重值
    bool operator<(const QueueNode& other) const {
        return weight > other.weight; // 重载运算符，按照权重值从小到大排序
    }
};

然后，定义一个优先队列来存储所有节点：

priority_queue<QueueNode> pq;

在构建哈夫曼树的过程中，可以先将所有叶子节点加入队列中：

for (int i = 0; i < n; i++) {
    huffTree[i].weight = weights[i];
    huffTree[i].parent = -1; // 初始时父节点为-1，表示该节点还没有父节点
    huffTree[i].left = -1;   // 初始时左子节点为-1，表示该节点是叶子节点
    huffTree[i].right = -1;  // 初始时右子节点为-1，表示该节点是叶子节点
    pq.push({i, weights[i]});
}

接下来，不断取出队列中权重值最小的两个节点，合并成一个新的父节点，并将父节点加入队列，直到队列中只剩下一个节点：

while (pq.size() > 1) {
    QueueNode node1 = pq.top(); pq.pop();
    QueueNode node2 = pq.top(); pq.pop();
    int pos1 = node1.pos;
    int pos2 = node2.pos;
    int parent = n; // 新的父节点的位置为n
    n++; // 更新节点数
    huffTree[pos1].parent = parent;
    huffTree[pos2].parent = parent;
    huffTree[parent].weight = node1.weight + node2.weight;
    huffTree[parent].left = pos1;
    huffTree[parent].right = pos2;
    pq.push({parent, huffTree[parent].weight});
}

最后，可以通过遍历树来获取每个字符的编码。具体来说，可以从叶子节点开始，沿着父节点不断向上遍历，记录经过的路径（0表示向左，1表示向右），直到根节点。得到的路径即为该字符的哈夫曼编码。