1、设计求一棵二叉树中结点总数的算法并实现。（要求程序可执行并附执行结果） 2、给出二叉树的自下而上，从右到左的层次遍历算法。 3、 一份电文中有6种字符：A,B,C,D,E,F，它们的出现频率依次为16，5，9，3，30，1，完成问题： （1）设计一棵哈夫曼树；（画出其树结构） （2）计算其带权路径长度WPL；

好的，我已经记录了你的问题。现在开始回答：

1、二叉树结点总数算法及实现

算法思路：递归遍历二叉树，每经过一个结点，结点总数加1。递归结束条件为遍历到空结点。

具体实现：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def countNodes(root: TreeNode) -> int:
    if not root:
        return 0
    return 1 + countNodes(root.left) + countNodes(root.right)

2、二叉树的自下而上，从右到左的层次遍历算法

算法思路：先按照正常的层次遍历顺序遍历二叉树，把遍历结果存储在一个二维列表中。然后把每一层的遍历结果反转，最终得到所求的遍历结果。

具体实现：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def levelOrderBottom(root: TreeNode) -> List[List[int]]:
    if not root:
        return []
    queue = [root]
    res = []
    while queue:
        size = len(queue)
        level = []
        for i in range(size):
            node = queue.pop(0)
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        res.append(level)
    return res[::-1]

3、哈夫曼树及带权路径长度WPL的计算

算法思路：哈夫曼树的构建过程是从叶子结点开始，每次选择权值最小的两个结点合并成一个新的结点，直到最后只剩下一个根结点。在构建过程中，每个结点都有一个权值，即该结点对应字符出现的频率。哈夫曼树的带权路径长度WPL定义为所有叶子结点的权值乘以其到根结点的距离之和。因此，计算WPL的过程就是从根结点开始，递归计算每个叶子结点的权值与到根结点的距离的乘积，最后把所有叶子结点的乘积相加即可。

具体实现：

class HuffmanNode:
    def __init__(self, val, freq):
        self.val = val
        self.freq = freq
        self.left = None
        self.right = None

def buildHuffmanTree(chars, freqs):
    nodes = [HuffmanNode(chars[i], freqs[i]) for i in range(len(chars))]
    while len(nodes) > 1:
        nodes.sort(key=lambda x: x.freq)
        left = nodes.pop(0)
        right = nodes.pop(0)
        parent = HuffmanNode(None, left.freq + right.freq)
        parent.left = left
        parent.right = right
        nodes.append(parent)
    return nodes[0]

def computeWPL(root):
    def dfs(node, depth):
        nonlocal res
        if not node.left and not node.right:
            res += node.freq * depth
        if node.left:
            dfs(node.left, depth + 1)
        if node.right:
            dfs(node.right, depth + 1)
    res = 0
    dfs(root, 0)
    return res

以上就是我对你提出的三个问题的回答，希望能对你有所帮助。