//2、根據(jù)數(shù)組 a 中 n 個(gè)權(quán)值建立一棵哈夫曼樹，返回樹根指針 
  struct BTreeNode* CreateHuffman(ElemType a[], int n) 
  { 
    int i, j; 
    struct BTreeNode **b, *q; 
    b = malloc(n*sizeof(struct BTreeNode)); 
    for (i = 0; i < n; i++) //初始化b指針數(shù)組，使每個(gè)指針元素指向a數(shù)組中對(duì)應(yīng)的元素結(jié)點(diǎn) 
    { 
      b[i] = malloc(sizeof(struct BTreeNode)); 
      b[i]->data = a[i]; 
      b[i]->left = b[i]->right = NULL; 
    } 
    for (i = 1; i < n; i++)//進(jìn)行 n-1 次循環(huán)建立哈夫曼樹 
    { 
      //k1表示森林中具有最小權(quán)值的樹根結(jié)點(diǎn)的下標(biāo)，k2為次最小的下標(biāo) 
      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++)//從當(dāng)前森林中求出最小權(quán)值樹和次最小 
      { 
        if (b[j] != NULL) 
        { 
          if (b[j]->data < b[k1]->data) 
          { 
            k2 = k1; 
            k1 = j; 
          } 
          else if (b[j]->data < b[k2]->data) 
            k2 = j; 
        } 
      } 
      //由最小權(quán)值樹和次最小權(quán)值樹建立一棵新樹，q指向樹根結(jié)點(diǎn) 
      q = malloc(sizeof(struct BTreeNode)); 
      q->data = b[k1]->data + b[k2]->data; 
      q->left = b[k1]; 
      q->right = b[k2]; 
   
      b[k1] = q;//將指向新樹的指針賦給b指針數(shù)組中k1位置 
      b[k2] = NULL;//k2位置為空 
    } 
    free(b); //刪除動(dòng)態(tài)建立的數(shù)組b 
    return q; //返回整個(gè)哈夫曼樹的樹根指針 
  } 

 #include<stdio.h> 
 #include<stdlib.h> 
 typedef int ElemType; 
 struct BTreeNode 
 { 
  ElemType data; 
  struct BTreeNode* left; 
  struct BTreeNode* right; 
 }; 
  
 //1、輸出二叉樹，可在前序遍歷的基礎(chǔ)上修改。采用廣義表格式，元素類型為int 
 void PrintBTree_int(struct BTreeNode* BT) 
 { 
  if (BT != NULL) 
  { 
   printf("%d", BT->data); //輸出根結(jié)點(diǎn)的值 
   if (BT->left != NULL || BT->right != NULL) 
   { 
    printf("("); 
    PrintBTree_int(BT->left); //輸出左子樹 
    if (BT->right != NULL) 
     printf(","); 
    PrintBTree_int(BT->right); //輸出右子樹 
    printf(")"); 
   } 
  } 
 } 
  
 //2、根據(jù)數(shù)組 a 中 n 個(gè)權(quán)值建立一棵哈夫曼樹，返回樹根指針 
 struct BTreeNode* CreateHuffman(ElemType a[], int n) 
 { 
  int i, j; 
  struct BTreeNode **b, *q; 
  b = malloc(n*sizeof(struct BTreeNode)); 
  for (i = 0; i < n; i++) //初始化b指針數(shù)組，使每個(gè)指針元素指向a數(shù)組中對(duì)應(yīng)的元素結(jié)點(diǎn) 
  { 
   b[i] = malloc(sizeof(struct BTreeNode)); 
   b[i]->data = a[i]; 
   b[i]->left = b[i]->right = NULL; 
  } 
  for (i = 1; i < n; i++)//進(jìn)行 n-1 次循環(huán)建立哈夫曼樹 
  { 
   //k1表示森林中具有最小權(quán)值的樹根結(jié)點(diǎn)的下標(biāo)，k2為次最小的下標(biāo) 
   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++)//從當(dāng)前森林中求出最小權(quán)值樹和次最小 
   { 
    if (b[j] != NULL) 
    { 
     if (b[j]->data < b[k1]->data) 
     { 
      k2 = k1; 
      k1 = j; 
     } 
     else if (b[j]->data < b[k2]->data) 
      k2 = j; 
    } 
   } 
   //由最小權(quán)值樹和次最小權(quán)值樹建立一棵新樹，q指向樹根結(jié)點(diǎn) 
   q = malloc(sizeof(struct BTreeNode)); 
   q->data = b[k1]->data + b[k2]->data; 
   q->left = b[k1]; 
   q->right = b[k2]; 
  
   b[k1] = q;//將指向新樹的指針賦給b指針數(shù)組中k1位置 
   b[k2] = NULL;//k2位置為空 
  } 
  free(b); //刪除動(dòng)態(tài)建立的數(shù)組b 
  return q; //返回整個(gè)哈夫曼樹的樹根指針 
 } 
  
 //3、求哈夫曼樹的帶權(quán)路徑長(zhǎng)度 
 ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始為0 
 { 
  if (FBT == NULL) //空樹返回0 
   return 0; 
  else 
  { 
   if (FBT->left == NULL && FBT->right == NULL)//訪問到葉子結(jié)點(diǎn) 
    return FBT->data * len; 
   else //訪問到非葉子結(jié)點(diǎn)，進(jìn)行遞歸調(diào)用，返回左右子樹的帶權(quán)路徑長(zhǎng)度之和，len遞增 
    return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1); 
  } 
 } 
  
 //4、哈夫曼編碼（可以根據(jù)哈夫曼樹帶權(quán)路徑長(zhǎng)度的算法基礎(chǔ)上進(jìn)行修改） 
 void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值為0 
 { 
  static int a[10];//定義靜態(tài)數(shù)組a，保存每個(gè)葉子的編碼，數(shù)組長(zhǎng)度至少是樹深度減一 
  if (FBT != NULL)//訪問到葉子結(jié)點(diǎn)時(shí)輸出其保存在數(shù)組a中的0和1序列編碼 
  { 
   if (FBT->left == NULL && FBT->right == NULL) 
   { 
    int i; 
    printf("結(jié)點(diǎn)權(quán)值為%d的編碼：", FBT->data); 
    for (i = 0; i < len; i++) 
     printf("%d", a[i]); 
    printf("\n"); 
   } 
   else//訪問到非葉子結(jié)點(diǎn)時(shí)分別向左右子樹遞歸調(diào)用，并把分支上的0、1編碼保存到數(shù)組a 
   { //的對(duì)應(yīng)元素中，向下深入一層時(shí)len值增1 
    a[len] = 0; 
    HuffManCoding(FBT->left, len + 1); 
    a[len] = 1; 
    HuffManCoding(FBT->right, len + 1); 
   } 
  } 
 } 
  
 //主函數(shù) 
 void main() 
 { 
  int n, i; 
  ElemType* a; 
  struct BTreeNode* fbt; 
  printf("從鍵盤輸入待構(gòu)造的哈夫曼樹中帶權(quán)葉子結(jié)點(diǎn)數(shù)n："); 
  while(1) 
  { 
   scanf("%d", &n); 
   if (n > 1) 
    break; 
   else 
    printf("重輸n值："); 
  } 
  a = malloc(n*sizeof(ElemType)); 
  printf("從鍵盤輸入%d個(gè)整數(shù)作為權(quán)值：", n); 
  for (i = 0; i < n; i++) 
   scanf(" %d", &a[i]); 
  fbt = CreateHuffman(a, n); 
  printf("廣義表形式的哈夫曼樹："); 
  PrintBTree_int(fbt); 
  printf("\n"); 
  printf("哈夫曼樹的帶權(quán)路徑長(zhǎng)度："); 
  printf("%d\n", WeightPathLength(fbt, 0)); 
  printf("樹中每個(gè)葉子結(jié)點(diǎn)的哈夫曼編碼：\n"); 
  HuffManCoding(fbt, 0); 
 } 

 #include <stdio.h> 
 #include <stdlib.h> 
 #define max 1001 
  
 struct htree 
 { 
  int weight; 
  struct htree *lchild; 
  struct htree *rchild; 
  struct htree *next; 
 }; 
  
 void addNode(struct htree *, struct htree *); 
 struct htree* createHfmtree(int *, int); 
 int getWpl(struct htree *, int); 
  
 int main() 
 { 
  int w[max]; 
  int i, n, wpl; 
  struct htree *ht; 
  
  while(scanf("%d", &n) != EOF) 
  { 
   for(i = 0; i < n; i ++) 
   { 
    scanf("%d", &w[i]); 
   } 
    
   ht = createHfmtree(w, n); 
   wpl = getWpl(ht, 0); 
   printf("%d\n", wpl); 
  } 
  return 0; 
 } 
  
 struct htree* createHfmtree(int *w, int n) 
 { 
  int i; 
  struct htree *head, *pl, *pr, *proot; 
  head = (struct htree *)malloc(sizeof(struct htree)); 
  head->next = NULL; 
  
  for(i = 0; i < n; i ++) 
  { 
   struct htree *pnode = malloc(sizeof(struct htree)); 
   pnode->weight = *(w + i); 
   pnode->lchild = pnode->rchild = pnode->next = NULL; 
   addNode(head, pnode); 
  } 
  
  while(head->next) 
  { 
   if(head->next->next == NULL) 
    break; 
   pl = head->next; 
   pr = pl->next; 
   head->next = pr->next; 
   proot = (struct htree *)malloc(sizeof(struct htree)); 
   proot->weight = pl->weight + pr->weight; 
   proot->lchild = pl; 
   proot->rchild = pr; 
   addNode(head, proot); 
  } 
  return head->next; 
 } 
  
 void addNode(struct htree *head, struct htree *pnode) 
 { 
  struct htree *t = head; 
  
  while(t->next && t->next->weight < pnode->weight) 
   t = t->next; 
  pnode->next = t->next; 
  t->next = pnode; 
 } 
  
 int getWpl(struct htree *ht, int level) 
 { 
  if(ht == NULL) 
   return 0; 
  if(!ht->lchild && !ht->rchild) 
  { 
   return ht->weight * level; 
  } 
  
  return getWpl(ht->lchild, level + 1) + getWpl(ht->rchild, level + 1); 
 }