C/C++ 数据结构与算法【哈夫曼树】 哈夫曼树详细解析【一样平常学习，考研 ...

哈夫曼树（最优二叉树）

1）基础概念

**路径：**从树中一个结点到另一个结点之间的分支构成这两个结点间的路径。
**结点的路径长度：**两结点间路径上的分支数。

**树的路径长度：**从树根到每一个结点的路径长度之和。记作：TL。

结点数目相同的二叉树中，完全二叉树是路径长度最短的二叉树。
**权：**将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权。
**结点的带权路径长度：**从根结点到该结点之间的路径长度与该结点的权的乘积。
**树的带权路径长度：**树中全部叶子结点的带权路径长度之和。

2）构造哈夫曼树

顺序存储结构——一维结构数组

（1）界说结构

1. typedef struct {
2.         int weight;
3.         int parent, lch, rch;
4. }HTNode, * HuffmanTree;
6. HuffmanTree H;

复制代码

（2）步骤：

• 初始化HT [1…2n-1]：lch = rch = parent = 0；
  
• 输入初始几个叶子结点：置HT[1…n]的 weight 值；
  
• 进行以下n-1次归并，依次产生n-1个结点HT，i = n + 1…2n-1：
  
  
  
  • 在HT[1…i-1]中选两个未被选过(从parent ==0 的结点中选)的weight最小的两个结点 HT[S1] 和 HT[S2]，s1、s2为两个最小结点下标；
    
  • 修改 HT[s1] 和 HT[s2] 的parent值：HT[s1].parent = i; HT[s2] .parent = i;
    
  • 修改新产生的HT：
    
  
  

1. HT[i].weight = HT[s1].weight + HT[s2].weight;
2. HTli].Ich = s1;
3. HT[i].rch = s2;

复制代码

1. void CreatHuffmanTree(HuffmanTree& HT, int n) { //构造哈夫曼树--哈夫曼算法
2.     if (n <= 1) return;
4.     int m = 2 * n - 1; // 数组共2n-1个元素
5.     HT = new HTNode[m + 1]; // 动态分配内存，0号单元未用，HT[m]表示根结点
7.     // 初始化2n-1个元素的lch、rch、parent为0
8.     for (int i = 1; i <= m; ++i) {
9.         HT[i].lch = HT[i].rch = HT[i].parent = 0;
10.     }
12.     // 输入前n个元素的weight值
13.     cout << "请输入" << n << "个字符的频率：" << endl;
14.     for (int i = 1; i <= n; ++i) {
15.         cin >> HT[i].weight;
16.     }
18.     // 构建哈夫曼树
19.     for (int i = n + 1; i <= m; i++) {
20.         int s1, s2;
21.         Select(HT, i - 1, s1, s2);
23.         HT[s1].parent = i;
24.         HT[s2].parent = i;
26.         HT[i].lch = s1;
27.         HT[i].rch = s2;
28.         HT[i].weight = HT[s1].weight + HT[s2].weight;
29.     }
30. }

复制代码

（3）总代码：

权值为整数：

1. #include <iostream>#include <limits.h>using namespace std;// 界说哈夫曼树节点结构typedef struct {    int weight;    int parent, lch, rch;} HTNode;typedef HTNode* HuffmanTree;// 选择两个双亲域为0且权值最小的结点void Select(const HTNode* HT, int i, int& s1, int& s2) {    s1 = s2 = -1;    int min1 = INT_MAX, min2 = INT_MAX;    for (int j = 1; j <= i; ++j) {        if (HT[j].parent == 0 && HT[j].weight < min1) {            min2 = min1;            s2 = s1;            min1 = HT[j].weight;            s1 = j;        }        else if (HT[j].parent == 0 && HT[j].weight < min2) {            min2 = HT[j].weight;            s2 = j;        }    }}void CreatHuffmanTree(HuffmanTree& HT, int n) { //构造哈夫曼树--哈夫曼算法
2.     if (n <= 1) return;
4.     int m = 2 * n - 1; // 数组共2n-1个元素
5.     HT = new HTNode[m + 1]; // 动态分配内存，0号单元未用，HT[m]表示根结点
7.     // 初始化2n-1个元素的lch、rch、parent为0
8.     for (int i = 1; i <= m; ++i) {
9.         HT[i].lch = HT[i].rch = HT[i].parent = 0;
10.     }
12.     // 输入前n个元素的weight值
13.     cout << "请输入" << n << "个字符的频率：" << endl;
14.     for (int i = 1; i <= n; ++i) {
15.         cin >> HT[i].weight;
16.     }
18.     // 构建哈夫曼树
19.     for (int i = n + 1; i <= m; i++) {
20.         int s1, s2;
21.         Select(HT, i - 1, s1, s2);
23.         HT[s1].parent = i;
24.         HT[s2].parent = i;
26.         HT[i].lch = s1;
27.         HT[i].rch = s2;
28.         HT[i].weight = HT[s1].weight + HT[s2].weight;
29.     }
30. }
31. int main() {    int n;    cout << "请输入叶子节点的数目：";    cin >> n;    HuffmanTree HT;    CreatHuffmanTree(HT, n);    // 打印哈夫曼树（示例）    cout << "哈夫曼树构造完成，打印结果如下：" << endl;    for (int i = 1; i < 2 * n; ++i) {        cout << "Node " << i << ": Weight=" << HT[i].weight            << ", Parent=" << HT[i].parent            << ", Left Child=" << HT[i].lch            << ", Right Child=" << HT[i].rch << endl;    }    delete[] HT; // 开释动态分配的内存    return 0;}

复制代码

权值为浮点数

1. #include <iostream>
2. #include <limits.h> // 如果不再使用 INT_MAX，可以不需要这个头文件
4. using namespace std;
6. // 定义哈夫曼树节点结构，将 weight 改为 double 类型
7. typedef struct {
8.     double weight;  // 权值改为 double 类型
9.     int parent, lch, rch;
10. } HTNode;
12. typedef HTNode* HuffmanTree;
14. // 选择两个双亲域为0且权值最小的结点
15. void Select(const HTNode* HT, int i, int& s1, int& s2) {
16.     s1 = s2 = -1;
17.     double min1 = DBL_MAX, min2 = DBL_MAX; // 使用 DBL_MAX 作为最大值初始化
19.     for (int j = 1; j <= i; ++j) {
20.         if (HT[j].parent == 0 && HT[j].weight < min1) {
21.             min2 = min1;
22.             s2 = s1;
23.             min1 = HT[j].weight;
24.             s1 = j;
25.         }
26.         else if (HT[j].parent == 0 && HT[j].weight < min2) {
27.             min2 = HT[j].weight;
28.             s2 = j;
29.         }
30.     }
31. }
33. void CreatHuffmanTree(HuffmanTree& HT, int n) { //构造哈夫曼树--哈夫曼算法
34.     if (n <= 1) return;
36.     int m = 2 * n - 1; // 数组共2n-1个元素
37.     HT = new HTNode[m + 1]; // 动态分配内存，0号单元未用，HT[m]表示根结点
39.     // 初始化2n-1个元素的lch、rch、parent为0
40.     for (int i = 1; i <= m; ++i) {
41.         HT[i].lch = HT[i].rch = HT[i].parent = 0;
42.         HT[i].weight = 0.0; // 初始化 weight 为 0.0
43.     }
45.     // 输入前n个元素的weight值
46.     cout << "请输入" << n << "个字符的小数频率：" << endl;
47.     for (int i = 1; i <= n; ++i) {
48.         cin >> HT[i].weight;
49.     }
51.     // 构建哈夫曼树
52.     for (int i = n + 1; i <= m; i++) {
53.         int s1, s2;
54.         Select(HT, i - 1, s1, s2);
56.         HT[s1].parent = i;
57.         HT[s2].parent = i;
59.         HT[i].lch = s1;
60.         HT[i].rch = s2;
61.         HT[i].weight = HT[s1].weight + HT[s2].weight;
62.     }
63. }
65. int main() {
66.     int n;
67.     cout << "请输入叶子节点的数量：";
68.     cin >> n;
70.     HuffmanTree HT;
71.     CreatHuffmanTree(HT, n);
73.     // 打印哈夫曼树（示例）
74.     cout << "哈夫曼树构造完成，打印结果如下：" << endl;
75.     for (int i = 1; i <= 2 * n - 1; ++i) { // 注意这里应该是 2*n-1 而不是 2*n
76.         cout << "Node " << i << ": Weight=" << HT[i].weight
77.             << ", Parent=" << HT[i].parent
78.             << ", Left Child=" << HT[i].lch
79.             << ", Right Child=" << HT[i].rch << endl;
80.     }
82.     delete[] HT; // 释放动态分配的内存
83.     return 0;
84. }

复制代码

（4）运行结果：

3）哈夫曼编码

在远程通讯中，要将待传字符转换成由二进制的字符串：

若将编码设计为长度不等的二进制编码，即让待传字符串中出现次数较多的字符采用尽可能短的编码，则转换的二进制字符串便可能减少。

问题1 ：什么样的前缀码能使得电文总长最短？

——哈夫曼编码
方法:
1、统计字符集中每个字符在电文中出现的均匀概率（概率越大要求编码越短）。
2、利用哈夫曼树的特点：权越大的叶子离根越近；将每个字符的概率值作为权值，构造哈夫曼树。 则概率越大的结点，路径越短。
3、在哈夫曼树的每个分支上标上0或1：

• 结点的左分支标0，右分支桥 1。
  
• 把从根到每个吐子的路径上的标号连接起来，作为该叶子代表的字符的编码。
  

问题2 ：为什么哈夫曼编码可以或许包管是前缀编码?

因为没有一片树叶是另一片树叶的祖先，所以每个叶结点的编码就不可能是其它叶结点编码的前缀。
问题 3 ：为什么哈夫曼编码可以或许包管字符编码总长最短?

因为哈夫曼树的带权路径长度最短，故字符编码的总长最短。

• 性质1 哈夫曼编码是前缀码
  
• 性质2 哈夫曼编码是最优前缀码
  

算法实现：

1. // 从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
2. void CreatHuffmanCode(const HuffmanTree& HT, HuffmanCode& HC, int n) {
3.     HC = new char*[n + 1]; // 分配n个字符编码的头指针数组
4.     char* cd = new char[n]; // 分配临时存放编码的动态数组空间
5.     cd[n - 1] = '\0'; // 编码结束符
7.     for (int i = 1; i <= n; ++i) {
8.         int start = n - 1;
9.         int c = i;
10.         int f = HT[i].parent;
12.         // 从叶子结点开始向上回溯，直到根结点
13.         while (f != 0) {
14.             --start;
15.             if (HT[f].lch == c)
16.                 cd[start] = '0'; // 结点c是f的左孩子，则生成代码0
17.             else
18.                 cd[start] = '1'; // 结点c是f的右孩子，则生成代码1
20.             c = f;
21.             f = HT[f].parent;
22.         }
24.         // 计算编码长度并分配适当的空间
25.         int codeLength = n - start;
26.         HC[i] = new char[codeLength];
27.         strncpy(HC[i], &cd[start], codeLength);
28.         HC[i][codeLength - 1] = '\0'; // 确保字符串以空字符终止
29.     }
31.     delete[] cd; // 释放临时空间
32. }

复制代码

strncpy(HC, &cd[start], codeLength);语句在C++中确实可以用于复制字符数组，但它有一些潜在的问题和局限性。特别是当你使用strncpy时，假如目标缓冲区没有充足的空间来包罗源字符串加上制止空字符（\0），它不会自动添加制止空字符，这可能会导致后续利用出现问题。
此外，在现代C++中，更推荐使用std::string来处理字符串，因为它们更安全、更方便，并且可以克制手动管理内存的复杂性和风险。

1. // 从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
2. void CreatHuffmanCode(const HuffmanTree& HT, HuffmanCode& HC, int n) {
3.     HC.resize(n + 1); // 分配n个字符编码的空间
5.     for (int i = 1; i <= n; ++i) {
6.         string code = "";
7.         int c = i;
8.         int f = HT[i].parent;
10.         // 从叶子结点开始向上回溯，直到根结点
11.         while (f != 0) {
12.             if (HT[f].lch == c)
13.                 code = '0' + code; // 结点c是f的左孩子，则生成代码0
14.             else
15.                 code = '1' + code; // 结点c是f的右孩子，则生成代码1
17.             c = f;
18.             f = HT[f].parent;
19.         }
21.         HC[i] = code;
22.     }
23. }

复制代码

总代码实现：

1. #include <iostream>
2. #include <cstring> // 用于 strcpy 和 strlen
3. #include <limits>  // 用于 std::numeric_limits
5. using namespace std;
7. // 定义哈夫曼树节点结构
8. typedef struct HTNode {
9.     double weight; // 权重改为 double 类型
10.     int parent, lch, rch;
11. } HTNode;
13. typedef HTNode* HuffmanTree;
15. // 定义哈夫曼编码结构
16. typedef char** HuffmanCode;
18. // 选择两个双亲域为0且权值最小的结点
19. void Select(const HTNode* HT, int i, int& s1, int& s2) {
20.     s1 = s2 = -1;
21.     double min1 = numeric_limits<double>::max(), min2 = numeric_limits<double>::max();
23.     for (int j = 1; j <= i; ++j) {
24.         if (HT[j].parent == 0 && HT[j].weight < min1) {
25.             min2 = min1;
26.             s2 = s1;
27.             min1 = HT[j].weight;
28.             s1 = j;
29.         } else if (HT[j].parent == 0 && HT[j].weight < min2) {
30.             min2 = HT[j].weight;
31.             s2 = j;
32.         }
33.     }
34. }
36. // 构造哈夫曼树--哈夫曼算法
37. void CreatHuffmanTree(HuffmanTree &HT, int n) {
38.     if (n <= 1) return;
40.     int m = 2 * n - 1; // 数组共2n-1个元素
41.     HT = new HTNode[m + 1]; // 动态分配内存，0号单元未用，HT[m]表示根结点
43.     // 初始化2n-1个元素的lch、rch、parent为0
44.     for (int i = 1; i <= m; ++i) {
45.         HT[i].lch = HT[i].rch = HT[i].parent = 0;
46.         HT[i].weight = 0.0; // 初始化权重为 0.0
47.     }
49.     // 输入前n个元素的weight值
50.     cout << "请输入" << n << "个字符的频率（浮点数）：" << endl;
51.     for (int i = 1; i <= n; ++i) {
52.         cin >> HT[i].weight;
53.     }
55.     // 构建哈夫曼树
56.     for (int i = n + 1; i <= m; i++) {
57.         int s1, s2;
58.         Select(HT, i - 1, s1, s2);
60.         HT[s1].parent = i;
61.         HT[s2].parent = i;
63.         HT[i].lch = s1;
64.         HT[i].rch = s2;
65.         HT[i].weight = HT[s1].weight + HT[s2].weight;
66.     }
67. }
69. // 从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
70. void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n) {
71.     HC = new char*[n + 1]; // 分配n个字符编码的头指针数组
72.     char* cd = new char[n]; // 分配临时存放编码的动态数组空间
73.     cd[n - 1] = '\0'; // 编码结束符
75.     for (int i = 1; i <= n; ++i) {
76.         int start = n - 1;
77.         int c = i;
78.         int f = HT[i].parent;
80.         // 从叶子结点开始向上回溯，直到根结点
81.         while (f != 0) {
82.             --start;
83.             if (HT[f].lch == c)
84.                 cd[start] = '0'; // 结点c是f的左孩子，则生成代码0
85.             else
86.                 cd[start] = '1'; // 结点c是f的右孩子，则生成代码1
88.             c = f;
89.             f = HT[f].parent;
90.         }
92.         // 计算编码长度并分配适当的空间
93.         int codeLength = n - start;
94.         HC[i] = new char[codeLength];
95.         strncpy(HC[i], &cd[start], codeLength);
96.         HC[i][codeLength - 1] = '\0'; // 确保字符串以空字符终止
97.     }
99.     delete[] cd; // 释放临时空间
100. }
102. // 测试函数
103. int main() {
104.     int n;
105.     cout << "请输入叶子节点的数量：";
106.     cin >> n;
108.     HuffmanTree HT;
109.     CreatHuffmanTree(HT, n);
111.     HuffmanCode HC;
112.     CreatHuffmanCode(HT, HC, n);
114.     // 打印哈夫曼编码
115.     cout << "哈夫曼编码如下：" << endl;
116.     for (int i = 1; i <= n; ++i) {
117.         cout << "Character " << i << ": " << HC[i] << endl;
118.     }
120.     // 清理资源
121.     for (int i = 1; i <= n; ++i) {
122.         delete[] HC[i];
123.     }
124.     delete[] HC;
125.     delete[] HT;
127.     return 0;
128. }

复制代码

改进后的代码：

1. #include <iostream>
2. #include <vector>
3. #include <string>
4. #include <limits>
6. using namespace std;
8. // 定义哈夫曼树节点结构
9. typedef struct HTNode {
10.     double weight; // 权重改为 double 类型
11.     int parent, lch, rch;
12. } HTNode;
14. typedef HTNode* HuffmanTree;
16. // 选择两个双亲域为0且权值最小的结点
17. void Select(const vector<HTNode>& HT, int i, int& s1, int& s2) {
18.     s1 = s2 = -1;
19.     double min1 = numeric_limits<double>::max(), min2 = numeric_limits<double>::max();
21.     for (int j = 1; j <= i; ++j) {
22.         if (HT[j].parent == 0 && HT[j].weight < min1) {
23.             min2 = min1;
24.             s2 = s1;
25.             min1 = HT[j].weight;
26.             s1 = j;
27.         } else if (HT[j].parent == 0 && HT[j].weight < min2) {
28.             min2 = HT[j].weight;
29.             s2 = j;
30.         }
31.     }
32. }
34. // 构造哈夫曼树--哈夫曼算法
35. void CreatHuffmanTree(vector<HTNode>& HT, int n) {
36.     if (n <= 1) return;
38.     int m = 2 * n - 1; // 数组共2n-1个元素
40.     // 初始化2n-1个元素的lch、rch、parent为0，权重为0.0
41.     HT.resize(m + 1);
42.     for (int i = 1; i <= m; ++i) {
43.         HT[i] = {0.0, 0, 0, 0};
44.     }
46.     // 输入前n个元素的weight值
47.     cout << "请输入" << n << "个字符的频率（浮点数）：" << endl;
48.     for (int i = 1; i <= n; ++i) {
49.         cin >> HT[i].weight;
50.     }
52.     // 构建哈夫曼树
53.     for (int i = n + 1; i <= m; i++) {
54.         int s1, s2;
55.         Select(HT, i - 1, s1, s2);
57.         HT[s1].parent = i;
58.         HT[s2].parent = i;
60.         HT[i].lch = s1;
61.         HT[i].rch = s2;
62.         HT[i].weight = HT[s1].weight + HT[s2].weight;
63.     }
64. }
66. // 从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
67. void CreatHuffmanCode(const vector<HTNode>& HT, vector<string>& HC, int n) {
68.     HC.resize(n + 1); // 分配n个字符编码的空间
70.     for (int i = 1; i <= n; ++i) {
71.         string code = "";
72.         int c = i;
73.         int f = HT[i].parent;
75.         // 从叶子结点开始向上回溯，直到根结点
76.         while (f != 0) {
77.             if (HT[f].lch == c)
78.                 code = '0' + code; // 结点c是f的左孩子，则生成代码0
79.             else
80.                 code = '1' + code; // 结点c是f的右孩子，则生成代码1
82.             c = f;
83.             f = HT[f].parent;
84.         }
86.         HC[i] = code;
87.     }
88. }
90. // 测试函数
91. int main() {
92.     int n;
93.     cout << "请输入叶子节点的数量：";
94.     cin >> n;
96.     vector<HTNode> HT;
97.     CreatHuffmanTree(HT, n);
99.     vector<string> HC;
100.     CreatHuffmanCode(HT, HC, n);
102.     // 打印哈夫曼编码
103.     cout << "哈夫曼编码如下：" << endl;
104.     for (int i = 1; i <= n; ++i) {
105.         cout << "Character " << i << ": " << HC[i] << endl;
106.     }
108.     return 0;
109. }

复制代码

改进后：

1. #include <iostream>
2. #include <cstring> // 用于 strcpy 和 strlen
3. #include <limits>  // 用于 std::numeric_limits
5. using namespace std;
7. // 定义哈夫曼树节点结构
8. typedef struct HTNode {
9.     double weight; // 权重改为 double 类型
10.     int parent, lch, rch;
11. } HTNode;
13. typedef HTNode* HuffmanTree;
15. // 定义哈夫曼编码结构
16. typedef char** HuffmanCode;
18. // 选择两个双亲域为0且权值最小的结点
19. void Select(const HTNode* HT, int i, int& s1, int& s2) {
20.     s1 = s2 = -1;
21.     double min1 = numeric_limits<double>::max(), min2 = numeric_limits<double>::max();
23.     for (int j = 1; j <= i; ++j) {
24.         if (HT[j].parent == 0 && HT[j].weight < min1) {
25.             min2 = min1;
26.             s2 = s1;
27.             min1 = HT[j].weight;
28.             s1 = j;
29.         } else if (HT[j].parent == 0 && HT[j].weight < min2) {
30.             min2 = HT[j].weight;
31.             s2 = j;
32.         }
33.     }
34. }
36. // 构造哈夫曼树--哈夫曼算法
37. void CreatHuffmanTree(HuffmanTree &HT, int n) {
38.     if (n <= 1) return;
40.     int m = 2 * n - 1; // 数组共2n-1个元素
41.     HT = new HTNode[m + 1]; // 动态分配内存，0号单元未用，HT[m]表示根结点
43.     // 初始化2n-1个元素的lch、rch、parent为0
44.     for (int i = 1; i <= m; ++i) {
45.         HT[i].lch = HT[i].rch = HT[i].parent = 0;
46.         HT[i].weight = 0.0; // 初始化权重为 0.0
47.     }
49.     // 输入前n个元素的weight值
50.     cout << "请输入" << n << "个字符的频率）：" << endl;
51.     for (int i = 1; i <= n; ++i) {
52.         cin >> HT[i].weight;
53.     }
55.     // 构建哈夫曼树
56.     for (int i = n + 1; i <= m; i++) {
57.         int s1, s2;
58.         Select(HT, i - 1, s1, s2);
60.         HT[s1].parent = i;
61.         HT[s2].parent = i;
63.         HT[i].lch = s1;
64.         HT[i].rch = s2;
65.         HT[i].weight = HT[s1].weight + HT[s2].weight;
66.     }
67. }
69. // 从叶子到根逆向求每个字符的哈夫曼编码，存储在编码表HC中
70. void CreatHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n) {
71.     HC = new char*[n + 1]; // 分配n个字符编码的头指针数组
73.     for (int i = 1; i <= n; ++i) {
74.         string code = ""; // 使用string来构建编码
75.         int c = i;
76.         int f = HT[i].parent;
78.         // 从叶子结点开始向上回溯，直到根结点
79.         while (f != 0) {
80.             if (HT[f].lch == c)
81.                 code = '0' + code; // 结点c是f的左孩子，则生成代码0
82.             else
83.                 code = '1' + code; // 结点c是f的右孩子，则生成代码1
85.             c = f;
86.             f = HT[f].parent;
87.         }
89.         // 将string转换为C风格字符串并分配适当的空间
90.         HC[i] = new char[code.length() + 1];
91.         strcpy(HC[i], code.c_str());
92.     }
93. }
95. // 测试函数
96. int main() {
97.     int n;
98.     cout << "请输入叶子节点的数量：";
99.     cin >> n;
101.     if (n <= 0) {
102.         cerr << "叶子节点数量必须大于0." << endl;
103.         return 1;
104.     }
106.     HuffmanTree HT;
107.     CreatHuffmanTree(HT, n);
109.     HuffmanCode HC;
110.     CreatHuffmanCode(HT, HC, n);
112.     // 打印哈夫曼编码
113.     cout << "哈夫曼编码如下：" << endl;
114.     for (int i = 1; i <= n; ++i) {
115.         cout << "Character " << i << ": " << HC[i] << endl;
116.     }
118.     // 清理资源
119.     for (int i = 1; i <= n; ++i) {
120.         delete[] HC[i];
121.     }
122.     delete[] HC;
123.     delete[] HT;
125.     return 0;
126. }

复制代码

运行结果：

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。