1.树的储存方式
  1. //****************双亲表示法************************
  2. #define Max_TREE_SIZE 100
  3. typedef int TElemType;
  4. typedef struct PTNode //结点结构
  5. {
  6. 	TElemType data;
  7. 	int parent;
  8. }PTNode;
  10. typedef struct
  11. {
  12. 	PTNode nodes[Max_TREE_SIZE];//结点数组
  13. 	int r,n;
  14. }Ptree;
  16. //****************孩子表示法************************
  17. typedef struct CTNode //孩子结点
  18. {
  19. 	int child;
  20. 	struct CTNode *next;
  21. }*ChildPtr;
  23. typedef struct //表头结构
  24. {
  25. 	TElemType data;
  26. 	ChildPtr firstChild;
  27. }CTBox;
  29. typedef struct
  30. {
  31. 	CTBox nodes[Max_TREE_SIZE]; //结点数组
  32. 	int r,n;
  33. }CTree;
  35. //****************双亲孩子表示法************************
  37. typedef struct CTNode
  38. {
  39. 	int child;
  40. 	struct CTNode *next;
  41. }*ChildPtr;
  43. typedef struct
  44. {
  45. 	TElemType data;
  46. 	int parent;
  47. 	ChildPtr firstChild;
  48. }CTBox;
  50. typedef struct
  51. {
  52. 	CTBox nodes[Max_TREE_SIZE];
  53. 	int r,n;
  54. }CTree;
59
 
1
  1. //****************双亲表示法************************
2
  1. #define Max_TREE_SIZE 100
3
  1. typedef int TElemType;
4
  1. typedef struct PTNode //结点结构
5
  1. {
6
  1.     TElemType data;
7
  1.     int parent;
8
  1. }PTNode;
9
  1.  
10
  1. typedef struct
11
  1. {
12
  1.     PTNode nodes[Max_TREE_SIZE];//结点数组
13
  1.     int r,n;
14
  1. }Ptree;
15
  1.  
16
  1.  
17
  1. //****************孩子表示法************************
18
  1. typedef struct CTNode //孩子结点
19
  1. {
20
  1.     int child;
21
  1.     struct CTNode *next;
22
  1. }*ChildPtr;
23
  1.  
24
  1. typedef struct //表头结构
25
  1. {
26
  1.     TElemType data;
27
  1.     ChildPtr firstChild;
28
  1. }CTBox;
29
  1.  
30
  1.  
31
  1. typedef struct
32
  1. {
33
  1.     CTBox nodes[Max_TREE_SIZE]; //结点数组
34
  1.     int r,n;
35
  1. }CTree;
36
  1.  
37
  1.  
38
  1.  
39
  1. //****************双亲孩子表示法************************
40
  1.  
41
  1. typedef struct CTNode
42
  1. {
43
  1.     int child;
44
  1.     struct CTNode *next;
45
  1. }*ChildPtr;
46
  1.  
47
  1. typedef struct
48
  1. {
49
  1.     TElemType data;
50
  1.     int parent;
51
  1.     ChildPtr firstChild;
52
  1. }CTBox;
53
  1.  
54
  1. typedef struct
55
  1. {
56
  1.     CTBox nodes[Max_TREE_SIZE];
57
  1.     int r,n;
58
  1. }CTree;
59
  1.  

2.根据扩展前序列确定一个二叉树（通过外界持续输入字符串或者是以字符串的形式输入）
  1. //**************************BiTree.h*******************************
  2. #ifndef BITREE_H
  3. #define BITREE_H
  5. #include <stdio.h>
  6. #include <stdlib.h>
  8. typedef int datatype;
  10. typedef struct Tree
  11. {
  12. 	datatype data;
  13. 	struct Tree *left;
  14. 	struct Tree *right;
  15. }Node,*BiTree;
  17. //以输入扩展前序递归的方式创建二叉树
  18. void CreateBiTree(BiTree *T);
  20. //后序遍历
  21. void NextOrderTravel(BiTree T);
  23. #endif //BITREE_H
  25. //**************************BiTree.c*******************************
  27. #include "BiTree.h"
  29. //以输入扩展前序递归的方式创建二叉树
  30. void CreateBiTree(BiTree *T)
  31. {
  32. 	char ch;
  33. 	scanf("%c",&ch);
  35. 	if('#' == ch)
  36. 	{
  37. 		*T = NULL;
  38. 	}
  39. 	else
  40. 	{
  41. 		*T = (BiTree)malloc(sizeof(Node));
  42. 		(*T)->data = ch;
  43. 		CreateBiTree(&(*T)->left);
  44. 		CreateBiTree(&(*T)->right);
  45. 	}
  46. }
  48. void NextOrderTravel(BiTree T)
  49. {
  50. 	if(NULL == T)return;
  52. 	NextOrderTravel(T->left);
  53. 	NextOrderTravel(T->right);
  55. 	printf("%c ",T->data);
  56. }
  58. //**************************BiTreeTest.c*******************************
  59. #include <stdio.h>
  60. #include "BiTree.h"
  62. char *str;
  64. void CreateBiTreeStr(BiTree *T)
  65. {
  67. 	char ch = *str++;
  69. 	if('#' == ch)
  70. 	{
  71. 		*T = NULL;
  72. 	}
  73. 	else
  74. 	{
  75. 		*T = (BiTree)malloc(sizeof(Node));
  76. 		(*T)->data = ch;
  77. 		CreateBiTreeStr(&(*T)->left);
  78. 		CreateBiTreeStr(&(*T)->right);
  79. 	}
  80. }
  82. //将这个序列以字符串的形式输入函数生成二叉树
  83. void Create(BiTree *T,char *str1)
  84. {
  85. 	str = str1;
  86. 	CreateBiTreeStr(T);
  87. }
  89. int main()
  90. {
  91. 	BiTree T = NULL;
  92. 	CreateBiTree(&T);
  93. 	NextOrderTravel(T);
  95. 	printf("\n-------\n");
  97. 	char *str1 = "AB#D##C##";
  98. 	Create(&T,str1);
  100. 	NextOrderTravel(T);
  101. }
x
 
1
  1. //**************************BiTree.h*******************************
2
  1. #ifndef BITREE_H
3
  1. #define BITREE_H
4
  1.  
5
  1. #include <stdio.h>
6
  1. #include <stdlib.h>
7
  1.  
8
  1. typedef int datatype;
9
  1.  
10
  1. typedef struct Tree
11
  1. {
12
  1.     datatype data;
13
  1.     struct Tree *left;
14
  1.     struct Tree *right;
15
  1. }Node,*BiTree;
16
  1.  
17
  1.  
18
  1. //以输入扩展前序递归的方式创建二叉树
19
  1. void CreateBiTree(BiTree *T);
20
  1.  
21
  1. //后序遍历
22
  1. void NextOrderTravel(BiTree T);
23
  1.  
24
  1.  
25
  1.  
26
  1. #endif //BITREE_H
27
  1.  
28
  1.  
29
  1. //**************************BiTree.c*******************************
30
  1.  
31
  1. #include "BiTree.h"
32
  1.  
33
  1. //以输入扩展前序递归的方式创建二叉树
34
  1. void CreateBiTree(BiTree *T)
35
  1. {
36
  1.     char ch;
37
  1.     scanf("%c",&ch);
38
  1.  
39
  1.     if('#' == ch)
40
  1.     {
41
  1.         *T = NULL;
42
  1.     }
43
  1.     else
44
  1.     {
45
  1.         *T = (BiTree)malloc(sizeof(Node));
46
  1.         (*T)->data = ch;
47
  1.         CreateBiTree(&(*T)->left);
48
  1.         CreateBiTree(&(*T)->right);
49
  1.     }
50
  1. }
51
  1.  
52
  1. void NextOrderTravel(BiTree T)
53
  1. {
54
  1.     if(NULL == T)return;
55
  1.  
56
  1.     NextOrderTravel(T->left);
57
  1.     NextOrderTravel(T->right);
58
  1.  
59
  1.     printf("%c ",T->data);
60
  1. }
61
  1.  
62
  1.  
63
  1. //**************************BiTreeTest.c*******************************
64
  1. #include <stdio.h>
65
  1. #include "BiTree.h"
66
  1.  
67
  1. char *str;
68
  1.  
69
  1. void CreateBiTreeStr(BiTree *T)
70
  1. {
71
  1.  
72
  1.     char ch = *str++;
73
  1.  
74
  1.     if('#' == ch)
75
  1.     {
76
  1.         *T = NULL;
77
  1.     }
78
  1.     else
79
  1.     {
80
  1.         *T = (BiTree)malloc(sizeof(Node));
81
  1.         (*T)->data = ch;
82
  1.         CreateBiTreeStr(&(*T)->left);
83
  1.         CreateBiTreeStr(&(*T)->right);
84
  1.     }
85
  1. }
86
  1.  
87
  1. //将这个序列以字符串的形式输入函数生成二叉树
88
  1. void Create(BiTree *T,char *str1)
89
  1. {
90
  1.     str = str1;
91
  1.     CreateBiTreeStr(T);
92
  1. }
93
  1.  
94
  1. int main()
95
  1. {
96
  1.     BiTree T = NULL;
97
  1.     CreateBiTree(&T);
98
  1.     NextOrderTravel(T);
99
  1.  
100
  1.     printf("\n-------\n");
101
  1.  
102
  1.  
103
  1.     char *str1 = "AB#D##C##";
104
  1.     Create(&T,str1);
105
  1.  
106
  1.     NextOrderTravel(T);
107
  1. }

3.线索二叉树的建立，线索化，遍历
  1. #include <stdio.h>
  2. #include <stdlib.h>  
  4. typedef char ElemType;  
  6. // 线索存储标志位
  7. // Link(0)：表示指向左右孩子的指针
  8. // Thread(1)：表示指向前驱后继的线索
  9. typedef enum {Link, Thread} PointerTag;  
  11. typedef struct BiThrNode
  12. {
  13.     char data;
  14.     struct BiThrNode *lchild, *rchild;
  15.     PointerTag ltag;
  16.     PointerTag rtag;
  17. } BiThrNode, *BiThrTree;  
  19. // 全局变量，始终指向刚刚访问过的结点
  20. BiThrTree pre;  
  22. // 创建一棵二叉树，约定用户遵照前序遍历的方式输入数据
  23. void CreateBiThrTree( BiThrTree *T )
  24. {
  25.     char c;  
  27.     scanf("%c", &c);
  28.     if( '#' == c )
  29.     {
  30.         *T = NULL;
  31.     }
  32.     else
  33.     {
  34.         *T = (BiThrNode *)malloc(sizeof(BiThrNode));
  35.         (*T)->data = c;
  36.         (*T)->ltag = Link;
  37.         (*T)->rtag = Link;  
  39.         CreateBiThrTree(&(*T)->lchild);
  40.         CreateBiThrTree(&(*T)->rchild);
  41.     }
  42. }  
  44. // 中序遍历线索化
  45. void InThreading(BiThrTree T)
  46. {
  47.     if( T )
  48.     {
  49.         InThreading( T->lchild );        // 递归左孩子线索化  
  51.         if( !T->lchild ) // 如果该结点没有左孩子，设置ltag为Thread，并把lchild指向刚刚访问的结点。
  52.         {
  53.             T->ltag = Thread;
  54.             T->lchild = pre;
  55.         }  
  57.         if( !pre->rchild )
  58.         {
  59.             pre->rtag = Thread;
  60.             pre->rchild = T;
  61.         }  
  63.         pre = T;  
  65.         InThreading( T->rchild );        // 递归右孩子线索化
  66.     }
  67. }  
  69. void InOrderThreading( BiThrTree *p, BiThrTree T )
  70. {
  71.     *p = (BiThrTree)malloc(sizeof(BiThrNode));
  72.     (*p)->ltag = Link;
  73.     (*p)->rtag = Thread;
  74.     (*p)->rchild = *p;
  75.     if( !T )
  76.     {
  77.         (*p)->lchild = *p;
  78.     }
  79.     else
  80.     {
  81.         (*p)->lchild = T;
  82.         pre = *p;
  83.         InThreading(T);
  84.         pre->rchild = *p;
  85.         pre->rtag = Thread;
  86.         (*p)->rchild = pre;
  87.     }
  88. }  
  90. void visit( char c )
  91. {
  92.     printf("%c", c);
  93. }  
  95. // 中序遍历二叉树，非递归
  96. void InOrderTraverse( BiThrTree T )
  97. {
  98.     BiThrTree p;
  99.     p = T->lchild;  
  101.     while( p != T )
  102.     {
  103.         while( p->ltag == Link )
  104.         {
  105.             p = p->lchild;
  106.         }
  107.         visit(p->data);  
  109.         while( p->rtag == Thread && p->rchild != T )
  110.         {
  111.             p = p->rchild;
  112.             visit(p->data);
  113.         }  
  115.         p = p->rchild;
  116.     }
  117. }  
  119. int main()
  120. {
  121.     BiThrTree P, T = NULL;  
  123.     CreateBiThrTree( &T );  
  125.     InOrderThreading( &P, T );  
  127.     printf("中序遍历输出结果为: ");  
  129.     InOrderTraverse( P );  
  131.     printf("\n");  
  133.     return 0;
  134. }
1
134
 
1
  1. #include <stdio.h>  
2
  1. #include <stdlib.h>  
3
  1.   
4
  1. typedef char ElemType;  
5
  1.   
6
  1. // 线索存储标志位  
7
  1. // Link(0)：表示指向左右孩子的指针  
8
  1. // Thread(1)：表示指向前驱后继的线索  
9
  1. typedef enum {Link, Thread} PointerTag;  
10
  1.   
11
  1. typedef struct BiThrNode  
12
  1. {  
13
  1.     char data;  
14
  1.     struct BiThrNode *lchild, *rchild;  
15
  1.     PointerTag ltag;  
16
  1.     PointerTag rtag;  
17
  1. } BiThrNode, *BiThrTree;  
18
  1.   
19
  1. // 全局变量，始终指向刚刚访问过的结点  
20
  1. BiThrTree pre;  
21
  1.   
22
  1. // 创建一棵二叉树，约定用户遵照前序遍历的方式输入数据  
23
  1. void CreateBiThrTree( BiThrTree *T )  
24
  1. {  
25
  1.     char c;  
26
  1.   
27
  1.     scanf("%c", &c);  
28
  1.     if( '#' == c )  
29
  1.     {  
30
  1.         *T = NULL;  
31
  1.     }  
32
  1.     else  
33
  1.     {  
34
  1.         *T = (BiThrNode *)malloc(sizeof(BiThrNode));  
35
  1.         (*T)->data = c;  
36
  1.         (*T)->ltag = Link;  
37
  1.         (*T)->rtag = Link;  
38
  1.   
39
  1.         CreateBiThrTree(&(*T)->lchild);  
40
  1.         CreateBiThrTree(&(*T)->rchild);  
41
  1.     }  
42
  1. }  
43
  1.   
44
  1. // 中序遍历线索化  
45
  1. void InThreading(BiThrTree T)  
46
  1. {  
47
  1.     if( T )  
48
  1.     {  
49
  1.         InThreading( T->lchild );        // 递归左孩子线索化  
50
  1.   
51
  1.         if( !T->lchild ) // 如果该结点没有左孩子，设置ltag为Thread，并把lchild指向刚刚访问的结点。  
52
  1.         {  
53
  1.             T->ltag = Thread;  
54
  1.             T->lchild = pre;  
55
  1.         }  
56
  1.   
57
  1.         if( !pre->rchild )  
58
  1.         {  
59
  1.             pre->rtag = Thread;  
60
  1.             pre->rchild = T;  
61
  1.         }  
62
  1.   
63
  1.         pre = T;  
64
  1.   
65
  1.         InThreading( T->rchild );        // 递归右孩子线索化  
66
  1.     }  
67
  1. }  
68
  1.   
69
  1. void InOrderThreading( BiThrTree *p, BiThrTree T )  
70
  1. {  
71
  1.     *p = (BiThrTree)malloc(sizeof(BiThrNode));  
72
  1.     (*p)->ltag = Link;  
73
  1.     (*p)->rtag = Thread;  
74
  1.     (*p)->rchild = *p;  
75
  1.     if( !T )  
76
  1.     {  
77
  1.         (*p)->lchild = *p;  
78
  1.     }  
79
  1.     else  
80
  1.     {  
81
  1.         (*p)->lchild = T;  
82
  1.         pre = *p;  
83
  1.         InThreading(T);  
84
  1.         pre->rchild = *p;  
85
  1.         pre->rtag = Thread;  
86
  1.         (*p)->rchild = pre;  
87
  1.     }  
88
  1. }  
89
  1.   
90
  1. void visit( char c )  
91
  1. {  
92
  1.     printf("%c", c);  
93
  1. }  
94
  1.   
95
  1. // 中序遍历二叉树，非递归  
96
  1. void InOrderTraverse( BiThrTree T )  
97
  1. {  
98
  1.     BiThrTree p;  
99
  1.     p = T->lchild;  
100
  1.   
101
  1.     while( p != T )  
102
  1.     {  
103
  1.         while( p->ltag == Link )  
104
  1.         {  
105
  1.             p = p->lchild;  
106
  1.         }  
107
  1.         visit(p->data);  
108
  1.   
109
  1.         while( p->rtag == Thread && p->rchild != T )  
110
  1.         {  
111
  1.             p = p->rchild;  
112
  1.             visit(p->data);  
113
  1.         }  
114
  1.           
115
  1.         p = p->rchild;  
116
  1.     }  
117
  1. }  
118
  1.   
119
  1. int main()  
120
  1. {  
121
  1.     BiThrTree P, T = NULL;  
122
  1.   
123
  1.     CreateBiThrTree( &T );  
124
  1.   
125
  1.     InOrderThreading( &P, T );  
126
  1.   
127
  1.     printf("中序遍历输出结果为: ");  
128
  1.   
129
  1.     InOrderTraverse( P );  
130
  1.   
131
  1.     printf("\n");  
132
  1.   
133
  1.     return 0;  
134
  1. }  

3.赫夫曼树的建立
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. typedef int ElemType;
  4. struct BTreeNode
  5. {
  6.     ElemType data;
  7.     struct BTreeNode* left;
  8.     struct BTreeNode* right;
  9. };  
  11. //1、输出二叉树，可在前序遍历的基础上修改。采用广义表格式，元素类型为int
  12. void PrintBTree_int(struct BTreeNode* BT)
  13. {
  14.     if (BT != NULL)
  15.     {
  16.         printf("%d", BT->data); //输出根结点的值
  17.         if (BT->left != NULL || BT->right != NULL)
  18.         {
  19.             printf("(");
  20.             PrintBTree_int(BT->left); //输出左子树
  21.             if (BT->right != NULL)
  22.                 printf(",");
  23.             PrintBTree_int(BT->right); //输出右子树
  24.             printf(")");
  25.         }
  26.     }
  27. }  
  29. //2、根据数组 a 中 n 个权值建立一棵哈夫曼树，返回树根指针
  30. struct BTreeNode* CreateHuffman(ElemType a[], int n)
  31. {
  32.     int i, j;
  33.     struct BTreeNode **b, *q;
  34.     b = malloc(n*sizeof(struct BTreeNode));
  35.     for (i = 0; i < n; i++) //初始化b指针数组，使每个指针元素指向a数组中对应的元素结点
  36.     {
  37.         b[i] = malloc(sizeof(struct BTreeNode));
  38.         b[i]->data = a[i];
  39.         b[i]->left = b[i]->right = NULL;
  40.     }
  41.     for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树
  42.     {
  43.         //k1表示森林中具有最小权值的树根结点的下标，k2为次最小的下标
  44.         int k1 = -1, k2;
  45.         for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树，k2指向第二棵
  46.         {
  47.             if (b[j] != NULL && k1 == -1)
  48.             {
  49.                 k1 = j;
  50.                 continue;
  51.             }
  52.             if (b[j] != NULL)
  53.             {
  54.                 k2 = j;
  55.                 break;
  56.             }
  57.         }
  58.         for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小
  59.         {
  60.             if (b[j] != NULL)
  61.             {
  62.                 if (b[j]->data < b[k1]->data)
  63.                 {
  64.                     k2 = k1;
  65.                     k1 = j;
  66.                 }
  67.                 else if (b[j]->data < b[k2]->data)
  68.                     k2 = j;
  69.             }
  70.         }
  71.         //由最小权值树和次最小权值树建立一棵新树，q指向树根结点
  72.         q = malloc(sizeof(struct BTreeNode));
  73.         q->data = b[k1]->data + b[k2]->data;
  74.         q->left = b[k1];
  75.         q->right = b[k2];  
  77.         b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置
  78.         b[k2] = NULL;//k2位置为空
  79.     }
  80.     free(b); //删除动态建立的数组b
  81.     return q; //返回整个哈夫曼树的树根指针
  82. }  
  84. //3、求哈夫曼树的带权路径长度
  85. ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始为0
  86. {
  87.     if (FBT == NULL) //空树返回0
  88.         return 0;
  89.     else
  90.     {
  91.         if (FBT->left == NULL && FBT->right == NULL)//访问到叶子结点
  92.             return FBT->data * len;
  93.         else //访问到非叶子结点，进行递归调用，返回左右子树的带权路径长度之和，len递增
  94.             return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);
  95.     }
  96. }  
  98. //4、哈夫曼编码（可以根据哈夫曼树带权路径长度的算法基础上进行修改）
  99. void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值为0
  100. {
  101.     static int a[10];//定义静态数组a，保存每个叶子的编码，数组长度至少是树深度减一
  102.     if (FBT != NULL)//访问到叶子结点时输出其保存在数组a中的0和1序列编码
  103.     {
  104.         if (FBT->left == NULL && FBT->right == NULL)
  105.         {
  106.             int i;
  107.             printf("结点权值为%d的编码：", FBT->data);
  108.             for (i = 0; i < len; i++)
  109.                 printf("%d", a[i]);
  110.             printf("\n");
  111.         }
  112.         else//访问到非叶子结点时分别向左右子树递归调用，并把分支上的0、1编码保存到数组a
  113.         {   //的对应元素中，向下深入一层时len值增1
  114.             a[len] = 0;
  115.             HuffManCoding(FBT->left, len + 1);
  116.             a[len] = 1;
  117.             HuffManCoding(FBT->right, len + 1);
  118.         }
  119.     }
  120. }  
  122. //主函数
  123. void main()
  124. {
  125.     int n, i;
  126.     ElemType* a;
  127.     struct BTreeNode* fbt;
  128.     printf("从键盘输入待构造的哈夫曼树中带权叶子结点数n：");
  129.     while(1)
  130.     {
  131.         scanf("%d", &n);
  132.         if (n > 1)
  133.             break;
  134.         else
  135.             printf("重输n值：");
  136.     }
  137.     a = malloc(n*sizeof(ElemType));
  138.     printf("从键盘输入%d个整数作为权值：", n);
  139.     for (i = 0; i < n; i++)
  140.         scanf(" %d", &a[i]);
  141.     fbt = CreateHuffman(a, n);
  142.     printf("广义表形式的哈夫曼树：");
  143.     PrintBTree_int(fbt);
  144.     printf("\n");
  145.     printf("哈夫曼树的带权路径长度：");
  146.     printf("%d\n", WeightPathLength(fbt, 0));
  147.     printf("树中每个叶子结点的哈夫曼编码：\n");
  148.     HuffManCoding(fbt, 0);
  149. }
1
149
 
1
  1. #include<stdio.h>  
2
  1. #include<stdlib.h>  
3
  1. typedef int ElemType;  
4
  1. struct BTreeNode  
5
  1. {  
6
  1.     ElemType data;  
7
  1.     struct BTreeNode* left;  
8
  1.     struct BTreeNode* right;  
9
  1. };  
10
  1.   
11
  1. //1、输出二叉树，可在前序遍历的基础上修改。采用广义表格式，元素类型为int  
12
  1. void PrintBTree_int(struct BTreeNode* BT)  
13
  1. {  
14
  1.     if (BT != NULL)  
15
  1.     {  
16
  1.         printf("%d", BT->data); //输出根结点的值  
17
  1.         if (BT->left != NULL || BT->right != NULL)  
18
  1.         {  
19
  1.             printf("(");  
20
  1.             PrintBTree_int(BT->left); //输出左子树  
21
  1.             if (BT->right != NULL)  
22
  1.                 printf(",");  
23
  1.             PrintBTree_int(BT->right); //输出右子树  
24
  1.             printf(")");  
25
  1.         }  
26
  1.     }  
27
  1. }  
28
  1.   
29
  1. //2、根据数组 a 中 n 个权值建立一棵哈夫曼树，返回树根指针  
30
  1. struct BTreeNode* CreateHuffman(ElemType a[], int n)  
31
  1. {  
32
  1.     int i, j;  
33
  1.     struct BTreeNode **b, *q;  
34
  1.     b = malloc(n*sizeof(struct BTreeNode));  
35
  1.     for (i = 0; i < n; i++) //初始化b指针数组，使每个指针元素指向a数组中对应的元素结点  
36
  1.     {  
37
  1.         b[i] = malloc(sizeof(struct BTreeNode));  
38
  1.         b[i]->data = a[i];  
39
  1.         b[i]->left = b[i]->right = NULL;  
40
  1.     }  
41
  1.     for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树  
42
  1.     {  
43
  1.         //k1表示森林中具有最小权值的树根结点的下标，k2为次最小的下标  
44
  1.         int k1 = -1, k2;  
45
  1.         for (j = 0; j < n; j++)//让k1初始指向森林中第一棵树，k2指向第二棵  
46
  1.         {  
47
  1.             if (b[j] != NULL && k1 == -1)  
48
  1.             {  
49
  1.                 k1 = j;  
50
  1.                 continue;  
51
  1.             }  
52
  1.             if (b[j] != NULL)  
53
  1.             {  
54
  1.                 k2 = j;  
55
  1.                 break;  
56
  1.             }  
57
  1.         }  
58
  1.         for (j = k2; j < n; j++)//从当前森林中求出最小权值树和次最小  
59
  1.         {  
60
  1.             if (b[j] != NULL)  
61
  1.             {  
62
  1.                 if (b[j]->data < b[k1]->data)  
63
  1.                 {  
64
  1.                     k2 = k1;  
65
  1.                     k1 = j;  
66
  1.                 }  
67
  1.                 else if (b[j]->data < b[k2]->data)  
68
  1.                     k2 = j;  
69
  1.             }  
70
  1.         }  
71
  1.         //由最小权值树和次最小权值树建立一棵新树，q指向树根结点  
72
  1.         q = malloc(sizeof(struct BTreeNode));  
73
  1.         q->data = b[k1]->data + b[k2]->data;  
74
  1.         q->left = b[k1];  
75
  1.         q->right = b[k2];  
76
  1.   
77
  1.         b[k1] = q;//将指向新树的指针赋给b指针数组中k1位置  
78
  1.         b[k2] = NULL;//k2位置为空  
79
  1.     }  
80
  1.     free(b); //删除动态建立的数组b  
81
  1.     return q; //返回整个哈夫曼树的树根指针  
82
  1. }  
83
  1.   
84
  1. //3、求哈夫曼树的带权路径长度  
85
  1. ElemType WeightPathLength(struct BTreeNode* FBT, int len)//len初始为0  
86
  1. {  
87
  1.     if (FBT == NULL) //空树返回0  
88
  1.         return 0;  
89
  1.     else  
90
  1.     {  
91
  1.         if (FBT->left == NULL && FBT->right == NULL)//访问到叶子结点  
92
  1.             return FBT->data * len;  
93
  1.         else //访问到非叶子结点，进行递归调用，返回左右子树的带权路径长度之和，len递增  
94
  1.             return WeightPathLength(FBT->left,len+1)+WeightPathLength(FBT->right,len+1);  
95
  1.     }  
96
  1. }  
97
  1.   
98
  1. //4、哈夫曼编码（可以根据哈夫曼树带权路径长度的算法基础上进行修改）  
99
  1. void HuffManCoding(struct BTreeNode* FBT, int len)//len初始值为0  
100
  1. {  
101
  1.     static int a[10];//定义静态数组a，保存每个叶子的编码，数组长度至少是树深度减一  
102
  1.     if (FBT != NULL)//访问到叶子结点时输出其保存在数组a中的0和1序列编码  
103
  1.     {  
104
  1.         if (FBT->left == NULL && FBT->right == NULL)  
105
  1.         {  
106
  1.             int i;  
107
  1.             printf("结点权值为%d的编码：", FBT->data);  
108
  1.             for (i = 0; i < len; i++)  
109
  1.                 printf("%d", a[i]);  
110
  1.             printf("\n");  
111
  1.         }  
112
  1.         else//访问到非叶子结点时分别向左右子树递归调用，并把分支上的0、1编码保存到数组a  
113
  1.         {   //的对应元素中，向下深入一层时len值增1  
114
  1.             a[len] = 0;  
115
  1.             HuffManCoding(FBT->left, len + 1);  
116
  1.             a[len] = 1;  
117
  1.             HuffManCoding(FBT->right, len + 1);  
118
  1.         }  
119
  1.     }  
120
  1. }  
121
  1.   
122
  1. //主函数  
123
  1. void main()  
124
  1. {  
125
  1.     int n, i;  
126
  1.     ElemType* a;  
127
  1.     struct BTreeNode* fbt;  
128
  1.     printf("从键盘输入待构造的哈夫曼树中带权叶子结点数n：");  
129
  1.     while(1)  
130
  1.     {  
131
  1.         scanf("%d", &n);  
132
  1.         if (n > 1)  
133
  1.             break;  
134
  1.         else  
135
  1.             printf("重输n值：");  
136
  1.     }  
137
  1.     a = malloc(n*sizeof(ElemType));  
138
  1.     printf("从键盘输入%d个整数作为权值：", n);  
139
  1.     for (i = 0; i < n; i++)  
140
  1.         scanf(" %d", &a[i]);  
141
  1.     fbt = CreateHuffman(a, n);  
142
  1.     printf("广义表形式的哈夫曼树：");  
143
  1.     PrintBTree_int(fbt);  
144
  1.     printf("\n");  
145
  1.     printf("哈夫曼树的带权路径长度：");  
146
  1.     printf("%d\n", WeightPathLength(fbt, 0));  
147
  1.     printf("树中每个叶子结点的哈夫曼编码：\n");  
148
  1.     HuffManCoding(fbt, 0);  
149
  1. }  

附件列表

Chapter 6(树)的更多相关文章

  1. Chapter 3 树与二叉树

    Chapter 3 树与二叉树 1-   二叉树 主要性质: 1   叶子结点数 = 度为2的结点数 + 1   2   二叉树第i层上最多有 (i≥1)个结点 3   深度为k的二叉树最多有 个结点 ...

  2. Render树、RenderObject与RenderLayer

    Chapter: 呈现树的构建 1. 呈现树与CSS盒子模型千丝万缕的关系 2. 呈现树与DOM树的关系 3. 浏览器构建呈现树的流程 4. Firefox的规则树和样式上下文树 5. 规则树是如何解 ...

  3. 《Linux内核设计与实现》Chapter 3 读书笔记

    <Linux内核设计与实现>Chapter 3 读书笔记 进程管理是所有操作系统的心脏所在. 一.进程 1.进程就是处于执行期的程序以及它所包含的资源的总称. 2.线程是在进程中活动的对象 ...

  4. Chapter 13. Miscellaneous PerlTk Methods PerlTk 方法杂项:

    Chapter 13. Miscellaneous PerlTk Methods PerlTk 方法杂项: 到目前为止,这本书的大部分章节 集中在特定的几个部件, 这个章节覆盖了方法和子程序 可以被任 ...

  5. 《算法导论》 — Chapter 7 高速排序

    序 高速排序(QuickSort)也是一种排序算法,对包括n个数组的输入数组.最坏情况执行时间为O(n^2). 尽管这个最坏情况执行时间比較差.可是高速排序一般是用于排序的最佳有用选择.这是由于其平均 ...

  6. Java编程思想总结笔记The first chapter

    总觉得书中太啰嗦,看完总结后方便日后回忆,本想偷懒网上找别人的总结,无奈找不到好的,只好自食其力,尽量总结得最好. 第一章  对象导论 看到对象导论觉得这本书 目录: 1.1 抽象过程1.2 每个对象 ...

  7. 机器学习(Machine Learning)&深度学习(Deep Learning)资料(Chapter 2)

    ##机器学习(Machine Learning)&深度学习(Deep Learning)资料(Chapter 2)---#####注:机器学习资料[篇目一](https://github.co ...

  8. Formal Grammars of English -10 chapter（Speech and Language Processing）

    determiner  限定词 DET propernoun 专有名词 NP (or noun phrase) mass noun 不可数名词 Det Nouns 限定词名词 relative pro ...

  9. 梦殇 chapter three

    chapter three 悲伤有N个层面.对于生命是孤独的底色,对于时间是流动的伤感,对于浪漫是起伏的变奏,对于善和怜悯是终生的慨叹…… 出去和舍友买完东西,刚回到宿舍,舍友就说,刚才有人给你打电话 ...

随机推荐

  1. js中 null, undefined, 0，空字符串，false，不全等比较

    null == undefined // true null == ''  // false null == 0 // false null == false // false undefined = ...

  2. python的多路复用实现聊天群

    在我的<python高级编程和异步io编程>中我讲解了socket编程,这里贴一段用socket实现聊天室的功能的源码,因为最近工作比较忙,后期我会将这里的代码细节分析出来,目前先把代码贴 ...

  3. Notes of Daily Scrum Meeting（11.3）

    Notes of Daily Scrum Meeting(11.3) 2014年11月3日  星期一  20:00—20:30 团队成员 今日团队任务 当日工作分配额 完成情况 陈少杰 阅读理解代码中 ...

  4. Daily Scrumming 2015.10.21（Day 2）

    今明两天任务表 Member Today’s Task Tomorrow’s Task 江昊 配置ruby与rails环境 配置mysql与数据库用户管理 配置apache2环境 学习rails Ac ...

  5. 2018软工实践—Alpha冲刺(10)

    队名 火箭少男100 组长博客 林燊大哥 作业博客 Alpha 冲鸭鸭鸭鸭鸭鸭鸭鸭鸭鸭! 成员冲刺阶段情况 林燊(组长) 过去两天完成了哪些任务 协调各成员之间的工作 测试整体软件 展示GitHub当 ...

  6. 23_IO_第23天（字节流、字符流）_讲义

    今日内容介绍 1.字节流 2.字符流 01输入和输出 * A:输入和输出 * a: 参照物 * 到底是输入还是输出,都是以Java程序为参照 * b: Output * 把内存中的数据存储到持久化设备 ...

  7. SQL Server 无法连接到本地服务器

    未找到或无法访问服务器.请验证实例名称是否正确并且 SQL Server 已配置为允许远程连接:     解决办法: 在服务中启动SQL Server (MSSQLSERVER)这个服务.

  8. 2D变换

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  9. ORACLE:一列的多行数据拼成字符串

    查询表中的一个字段,返回了多行,就把这么多行的数据都拼成一个字符串. 例:   id  name        1   aa        2   bb        3   cc 要的结果是&quo ...

  10. 【Web Shell】- 技术剖析中国菜刀 - Part II

    在第一部分,简单描述了中国菜刀的基本功能.本文我将剖析中国菜刀的平台多功能性.传输机制.交互模式和检测.我希望通过我的讲解,您能够根据您的环境检测出并清除它. 平台 那么中国菜刀可以在哪些平台上运行? ...