數據結構哈夫曼樹中每次尋找的最小結點和次小結點穩定在二到四個結點中產生

原理:

      給定n個權值作為n個葉子結點，構建一棵二叉樹，若帶權值路徑長度達到最小，稱這樣的二叉樹為哈夫曼樹。
Huffman樹是一種特殊的二叉樹，其葉結點的編碼是一種前綴碼，同時，通過統計字符的頻度，能夠達到編碼電文的最小化。
假設有n個權值，則構造出的哈夫曼樹有n個葉子結點。n個權值分別設為w1、w2、···、wn，則哈夫曼樹的構造規則為：
（1） 將w1、w2、···、wn看成有n棵樹的森林（每棵樹僅有一個結點）；
（2） 在森林中選出兩個根結點的權值最小的樹合並，作為一棵新樹的左、右子樹，且新樹的根結點權值為其左、右子樹根結點權值之和；
（3） 將新樹加入森林中；
（4） 重復（2）、（3）步，直到森林中的樹都被比較過為止，該樹即為所求得的哈夫曼樹。

 

實現步驟:

1.建立哈夫曼樹前先根據權值對結點進行從小到大的排序1...n;

2.哈夫曼樹的總結點數為2*n-1,新節點下標從n+1到2*n-1新節點從小到大產生;

3.最小結點和次小結點在舊結點未加入樹里的最小兩個結點和新結點未被加入到樹里的最小的兩個結點總共四個結點中產生;設置舊結點未加入樹里的最小結點的下標為kfirst,新節點未被加入到樹里的最小結點的下標為ksum:

      (1)當產生第一個新結點即下標為n+1的結點時,最小結點和次小結點的下標分別是1和2;

      (2)當產生第二個新結點即下標為n+2的結點時,最小結點和次小結點的下標在3,4和n+1中產生;

      (3)當產生新結點的下標大於n+2時,最小結點和次小結點的下標在kfirst,kfirst+1和ksum,ksum+1中產生;

 

畫圖顯示藍色表示新節點,紅色表示舊結點:

 

總流程圖,紅色表示舊結點:

C語言源代碼:

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
typedef struct{
    unsigned int weight;//權值
    unsigned int parent, lchild,rchild;//父結點,左孩子,右孩子
}HTNode,*HuffmanTree;
typedef char ** HuffmanCode;
//舊結點根據權值由小到大排序
int sort(HuffmanTree t,int n)
{ 
    int i,j,k;
    for(i=1;i<n;i++){    
        for(j=1;j<=n-i;j++)        
            if(t[j].weight>t[j+1].weight)        
            {        
                k=t[j].weight;        
                t[j].weight=t[j+1].weight;        
                t[j+1].weight=k;        
            }
    }
    return 1;
}
//找出未被加入樹里的最小結點和次小結點下標
int Select(HuffmanTree HT,int n,int *s1,int *s2,int i,int &kfirst,int &ksum)
{    
    if(i==n+1)
    {
        *s1=1;
        *s2=2;
        kfirst=3;
        ksum=n+1;
    }
    else{
        int b[4]={0,0,0,0}; 
        int index[4];
        int ii,j;
        //把舊結點中未加入樹中的最小和次小值加到b數組中
        for(j=0, ii=kfirst;ii<kfirst+2&&ii<=n&&j<4;ii++,j++){        
            b[j]=HT[ii].weight;
            index[j]=ii;
        }
        //把新結點中未加入樹中的最小和次小值加到b數組中
        for(j=j, ii=ksum;ii<ksum+2&&ii<=i-1&&j<4;ii++,j++){
            b[j]=HT[ii].weight;
            index[j]=ii;
        }
        //把最小值和次小值得下標分別放到index[0]和index[1]中
        for(int aa=0;aa<2;aa++){
            if(aa==0){
                for(int k=1;k<4&&b[k]>0;k++){
                    if(b[0]>b[k]){
                        int temp=b[0];
                        int subtemp=index[0];
                        b[0]=b[k];
                        index[0]=index[k];
                        b[k]=temp;
                        index[k]=subtemp;
                    }
                }
            }
            else{
                for(int k=2;k<4&&b[k]>0;k++){
                    if(b[1]>b[k]){
                        int temp=b[1];
                        int subtemp=index[1];
                        b[1]=b[k];
                        index[1]=index[k];
                        b[k]=temp;
                        index[k]=subtemp;
                    }
                }
            }
        }    
        *s1=index[0];
        *s2=index[1];
        //找出舊結點中未加入到樹中的最小結點對應的下標kfirst和新結點中未加入到樹中的最小結點對應的下標ksum
        if(index[1]==kfirst+1&&kfirst+2<=n){
            kfirst=kfirst+2;    
        }else if(index[1]==ksum+1&&ksum+2<=2*n-1){
            ksum=ksum+2;
        }
        else{
            kfirst=kfirst+1;
            ksum=ksum+1;
        }
    }
    return 1;
}

void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n,int &kfirst,int &ksum)
{
    int i,m,s1,s2,start;
    char *cd;
    unsigned int c,f;
    if(n<=1) exit(1);
    m=2*n-1;      
    for(i=n+1;i<=m;i++)
    {
        HT[i].parent=0;
    }
    //產生新節點
    for(i=n+1;i<=m;i++)
    {
        Select(HT,n,&s1,&s2, i,kfirst,ksum);
        HT[s1].parent=i;HT[s2].parent=i;
        HT[i].lchild=s1;HT[i].rchild=s2;
        HT[i].weight=HT[s1].weight+HT[s2].weight;      
    }
    HC=(HuffmanCode )malloc((n+1)*sizeof(char* ));
    cd=(char *)malloc(n*sizeof(char ));
    cd[n-1]='\0';
    for(i=1;i<=n;i++)
    {
        HC[i]=(char*)malloc((n-start)*sizeof(char));
        start=n-1;
        for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)
        {
            if(HT[f].lchild==c) 
            {
                cd[--start]='0';            
            }
            else
            {
                cd[--start]='1';
            }                        
            
            strcpy(HC[i],&cd[start]);
        }
    }
    free(cd);
}
void main()
{
    HuffmanTree HT;
    HuffmanCode HC;
    int *w,n,j,K;
    int i,m,s1,s2;//i為結點的下標,m為總結點數,s1為最小結點下標,s2為次小結點的下標
    int kfirst=0,ksum=0;//舊結點未加入樹里的最小結點的下標kfirst,新節點未被加入到樹里的最小結點的下標ksum:
    HuffmanTree p;
    char *cd;    
    printf("結點的個數為：\n");
    scanf("%d",&n);
    w=(int *)malloc(n*sizeof(int));
    for(i=1;i<=n;i++)
    {
        printf("第%d個結點的權值為：",i);
        scanf("%d",w+i-1);
    }        
    if(n<=1) exit(1);
    m=2*n-1;//總結點數
    HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
    for(i=1;i<=n;i++,w++)
    {
        HT[i].weight=*w;
        HT[i].parent=0;
        HT[i].lchild=0;
        HT[i].rchild=0;
    }
    sort(HT, n);
    HuffmanCoding(HT,HC,w, n,kfirst,ksum);     
      for(i=1;i<=n;i++)
      {
          printf("權值為%d結點的哈夫曼編碼：",HT[i].weight);
          puts(HC[i]);
      }
      for(i=1;i<=n;i++)
          free(HC[i]); 
      free(HC); 
      free(HT);
}

 

 

 

運行結果:

Java源代碼:

 

import java.util.Scanner;

//結點類
class HTNode {
    int weight;
    int parent, lchild, rchild;
}

public class HuffmanDemo {
    static int[] s = new int[3];
    static int kfirst = 1;//舊結點未加入樹里的最小結點的下標kfirst
    static int ksum;//新節點未被加入到樹里的最小結點的下標ksum:

    public static void main(String[] args) {
        HuffmanDemo hf = new HuffmanDemo();

        int n;
        System.out.println("結點的個數為：");
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        ksum = n + 1;//新結點從n+1開始,由小到大產生
        HTNode[] HT = new HTNode[2 * n];//總結點數為2*n-1,從下標1開始
        for (int i = 0; i <= 2 * n - 1; i++) {
            HT[i] = new HTNode();
        }
        hf.input(n, HT);
        StringBuilder[] HC = new StringBuilder[n + 1];
        hf.sort(HT, n);
        StringBuilder[] hcret;
        hcret = hf.HuffmanCoding(HT, HC, n);
        for (int i = 1; i <= n; i++) {
            System.out.print("權值為" + HT[i].weight + "結點的哈夫曼編碼：");
            System.out.println(hcret[i].reverse());
        }
    }

    // 輸入結點權值
    void input(int n, HTNode[] HT) {
        Scanner sc = new Scanner(System.in);
        int[] w = new int[20];
        int i;
        for (i = 1; i <= n; i++) {
            System.out.println("第" + i + "個結點的權值為：");
            w[i] = sc.nextInt();
        }
        if (n <= 1)
            System.exit(1);
        for (i = 1; i <= n; i++) {
            HT[i].weight = w[i];
            HT[i].parent = 0;
            HT[i].lchild = 0;
            HT[i].rchild = 0;
        }
    }

    // 結點根據權值由小到大排序
    int sort(HTNode[] t, int n) {
        int i, j, k;
        for (i = 1; i < n; i++)
            for (j = 1; j <= n - i; j++)
                if (t[j].weight > t[j + 1].weight) {
                    k = t[j].weight;
                    t[j].weight = t[j + 1].weight;
                    t[j + 1].weight = k;
                }
        return 1;
    }

    // 找出未被加入樹里的最小結點和次小結點下標
    public int[] Select(HTNode[] HT, int n, int[] s, int i) {
        if (i == n + 1) {
            s[1] = 1;
            s[2] = 2;
            kfirst = 3;
            ksum = n + 1;
        } else {
            int b[] = { 0, 0, 0, 0 };
            int index[] = new int[4];
            int ii, j;
            // 把舊結點中未加入樹中的最小和次小值加到b數組中
            for (j = 0, ii = kfirst; ii < kfirst + 2 && ii <= n && j < 4; ii++, j++) {
                b[j] = HT[ii].weight;
                index[j] = ii;
            }
            // 把新結點中未加入樹中的最小和次小值加到b數組中
            for (ii = ksum, j = j; ii < ksum + 2 && ii <= i - 1 && j < 4; ii++, j++) {
                b[j] = HT[ii].weight;
                index[j] = ii;
            }
            // 把最小值和次小值得下標分別放到index[0]和index[1]中
            for (int aa = 0; aa < 2; aa++) {
                if (aa == 0) {
                    for (int k = 1; k < 4 && b[k] > 0; k++) {
                        if (b[0] > b[k]) {
                            int temp = b[0];
                            int subtemp = index[0];
                            b[0] = b[k];
                            index[0] = index[k];
                            b[k] = temp;
                            index[k] = subtemp;
                        }
                    }
                } else {
                    for (int k = 2; k < 4 && b[k] > 0; k++) {
                        if (b[1] > b[k]) {
                            int temp = b[1];
                            int subtemp = index[1];
                            b[1] = b[k];
                            index[1] = index[k];
                            b[k] = temp;
                            index[k] = subtemp;
                        }
                    }
                }
            }
            s[1] = index[0];
            s[2] = index[1];
            // 找出舊結點中未加入到樹中的最小結點對應的下標kfirst和新結點中未加入到樹中的最小結點對應的下標ksum
            if (index[1] == kfirst + 1 && kfirst + 2 <= n) {
                kfirst = kfirst + 2;
            } else if (index[1] == ksum + 1 && ksum + 2 <= 2 * n - 1) {
                ksum = ksum + 2;
            } else {
                kfirst = kfirst + 1;
                ksum = ksum + 1;
            }
        }
        return s;
    }

    // 編碼
    StringBuilder[] HuffmanCoding(HTNode[] HT, StringBuilder[] HC, int n) {

        int i, m, start;
        char[] cd = new char[100];
        int c, f;
        if (n <= 1)
            System.exit(1);
        m = 2 * n - 1;
        for (i = n + 1; i <= m; i++) {
            HT[i].parent = 0;
        }
        for (i = n + 1; i <= m; i++) {
            int[] ss = new int[3];
            int[] sa = new int[3];
            sa = Select(HT, n, ss, i);
            HT[sa[1]].parent = i;
            HT[sa[2]].parent = i;
            HT[i].lchild = sa[1];
            HT[i].rchild = sa[2];
            HT[i].weight = HT[sa[1]].weight + HT[sa[2]].weight;
        }
        cd[n - 1] = '\0';
        for (i = 1; i <= n; i++) {
            HC[i] = new StringBuilder();
            start = n - 1;
            for (c = i, f = HT[i].parent; f != 0; c = f, f = HT[f].parent) {
                if (HT[f].lchild == c) {
                    cd[--start] = '0';
                } else {
                    cd[--start] = '1';
                }
                HC[i].append((char) cd[start]);
            }
        }
        return HC;
    }
}

 

 

運行結果: