设计一个算法，给一个字符串进行二进制编码，使得编码后的字符串长度最短

#include<map>
#include<iostream>
#include<string>
using namespace std;
struct BTreeNode
{
int weight;
char value;
struct BTreeNode* left;
struct BTreeNode* right;
};

struct BTreeNode* CreateHuffman(int weight[],char value[], int n)
{
int i, j;
struct BTreeNode **b, *q;
b = (BTreeNode **) malloc(n*sizeof(struct BTreeNode));
for (i = 0; i < n; i++) //初始化b指针数组，使每个指针元素指向a数组中对应的元素结点
{
b[i] = (BTreeNode *) malloc(sizeof(struct BTreeNode));
b[i]->weight= weight[i];
b[i]->value=value[i];
b[i]->left = b[i]->right = NULL;
}
for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树
{
//k1表示森林中具有最小权值的树根结点的下标，k2为次最小的下标
int k1 = -1, k2;
for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树，k2指向第二棵
{
if (b[j] != NULL && k1 == -1)
{
k1 = j;
continue;
}
if (b[j] != NULL)
{
k2 = j;
break;
}
}
for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小
{
if (b[j] != NULL)
{
if (b[j]->weight < b[k1]->weight)
{
k2 = k1;
k1 = j;
}
else if (b[j]->weight < b[k2]->weight)
k2 = j;
}
}
//由最小权值树和次最小权值树建立一棵新树，q指向树根结点
q = (BTreeNode *) malloc(sizeof(struct BTreeNode));
q->weight = b[k1]->weight + b[k2]->weight;
q->value='\0';
q->left = b[k1];
q->right = b[k2];

b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置
b[k2] = NULL;//k2位置为空
}
free(b); //删除动态建立的数组b
return q; //返回整个哈夫曼树的树根指针
};
int HuffManCoding(struct BTreeNode* FBT, int len)//len初始值为0
{

if (FBT != NULL)//访问到叶子结点时输出其保存在数组a中的0和1序列编码
{
if (FBT->left == NULL && FBT->right == NULL)
{
return FBT->weight*len;
}
else//访问到非叶子结点时分别向左右子树递归调用，并把分支上的0、1编码保存到数组a
{   //的对应元素中，向下深入一层时len值增1

return HuffManCoding(FBT->left, len + 1)+  HuffManCoding(FBT->right, len + 1);
}
}
}
int getMinCode(string s)
{
map<char,int> m;
map<char,int>::iterator it;;
int len=s.length();
//统计每个字符的频率
for(int i=0;i<len;i++)
{
it=m.find(s[i]);//返回的是一个指针
if(it==m.end())//没找到
{
m.insert(pair<char,int> (s[i],1));
}else
{
m[s[i]]=m.find(s[i])->second+1;
}
}
//构建哈夫曼树
int size=m.size();
int* weight=(int *)malloc(size*sizeof(int));
char* value=(char *)malloc(size*sizeof(char));
int j=0;
for ( it = m.begin( ) ; it != m.end() ; it++ )
{
weight[j]=it->second;
value[j]=it->first;
j++;
}
BTreeNode* root= CreateHuffman(weight,value, size);
//深度优先遍历
return HuffManCoding(root,0);

}
int main()
{
string s;
cin>>s;
cout<<getMinCode(s);
return 0;
}