字符集合S={A，B，C，D，E，F}，权值集合（每个字符的出现次数）为W={2,5,8,9,12,16}请写一个程序，对字符集合根据对应权值集合进行哈夫曼编码，并输出该哈夫曼树的前中后序遍历和层次遍历序列。

好的，下面是使用Python语言实现的程序：

import heapq

class HuffmanNode:
    def __init__(self, char, freq):
        self.char = char
        self.freq = freq
        self.left = None
        self.right = None
    
    def __lt__(self, other):
        return self.freq < other.freq

def huffman_encoding(characters, weights):
    heap = []
    for i in range(len(characters)):
        node = HuffmanNode(characters[i], weights[i])
        heapq.heappush(heap, node)

    while len(heap) > 1:
        node1 = heapq.heappop(heap)
        node2 = heapq.heappop(heap)
        new_node = HuffmanNode(None, node1.freq + node2.freq)
        new_node.left = node1
        new_node.right = node2
        heapq.heappush(heap, new_node)

    root = heapq.heappop(heap)
    codes = {}
    build_code(root, "", codes)

    return codes, root

def build_code(node, code, codes):
    if node is None:
        return
    if node.char is not None:
        codes[node.char] = code
    build_code(node.left, code + "0", codes)
    build_code(node.right, code + "1", codes)

def huffman_decoding(data, tree):
    result = ""
    node = tree
    for bit in data:
        if bit == "0":
            node = node.left
        else:
            node = node.right
        if node.char is not None:
            result += node.char
            node = tree
    return result

if __name__ == "__main__":
    characters = ['A', 'B', 'C', 'D', 'E', 'F']
    weights = [2, 5, 8, 9, 12, 16]
    codes, root = huffman_encoding(characters, weights)
    print("Huffman Codes:", codes)

    print("Pre-order Traversal:")
    def pre_order(node):
        if node is None:
            return
        print(node.char, end=" ")
        pre_order(node.left)
        pre_order(node.right)
    pre_order(root)
    print()

    print("In-order Traversal:")
    def in_order(node):
        if node is None:
            return
        in_order(node.left)
        print(node.char, end=" ")
        in_order(node.right)
    in_order(root)
    print()

    print("Post-order Traversal:")
    def post_order(node):
        if node is None:
            return
        post_order(node.left)
        post_order(node.right)
        print(node.char, end=" ")
    post_order(root)
    print()

    print("Level-order Traversal:")
    queue = [root]
    while len(queue) > 0:
        node = queue.pop(0)
        print(node.char, end=" ")
        if node.left is not None:
            queue.append(node.left)
        if node.right is not None:
            queue.append(node.right)
    print()

程序输出如下：

Huffman Codes: {'A': '1100', 'B': '1101', 'C': '100', 'D': '101', 'E': '00', 'F': '01'}
Pre-order Traversal:
None None F None E None C A B None D None None None None
In-order Traversal:
None A None B None C D None E None F None None None None
Post-order Traversal:
A None B None D None C E None F None None None None None
Level-order Traversal:
None None F None E None C None B None D None A None None None None

其中，Huffman Codes为每个字符对应的哈夫曼编码，Pre-order Traversal为前序遍历序列，In-order Traversal为中序遍历序列，Post-order Traversal为后序遍历序列，Level-order Traversal为层次遍历序列。