很难吗？树结构哦。看你数据结构学的怎么样呗。呵呵，我先想到的数据结构是双亲孩子表示法，当然查找关系的时候就要进行一些条件设置，比如祖孙的关系数大于父子的关系数2，兄弟拥有相同的双亲，堂兄弟的双亲是兄弟，回溯到相同的祖先结点则有共同的祖先咯。

#include<stdioh>

#include<stdlibh>

typedef struct node NODE, PNODE;

struct node {

int data;

PNODE next;

};

PNODE newnode()

{

PNODE p = (PNODE)malloc(sizeof(NODE));

p->data = 0;

p->next = NULL;

return p;

}

void append(PNODE &p, int &val)

{

while(p->next)p = p->next;

p->data = val;

p->next = newnode();

p = p->next;

}

void display(PNODE a, PNODE b)

{

while(a->next && b->next){

printf("%d %d\n", a->data, b->data);

a = a->next;

b = b->next;

}

}

void freed(PNODE p)

{

PNODE t;

while(p) {

t = p->next;

free(p);

p = t;

}

}

void main()

{

int n, m;

PNODE q1, q2, qq1, qq2;

qq1 = q1 = newnode();

qq2 = q2 = newnode();

n = m = 0;

scanf("%d", &n);

while(n--) {

scanf("%d", &m);

if(m % 2) {

append(qq1, m);

} else {

append(qq2, m);

}

}

display(q1, q2);

freed(q1);

freed(q2);

}

1假设线性表的长度为n，则最坏情况下:

冒泡排序: 需要经过n/2遍的从前往后扫描和n/2遍从后往前扫描，需要比较的次数为n(n-1)/2。总的时间复杂度为O(n的平方)。

快速排序: 比较次数也是n(n-1)/2。总的时间复杂度为O(n的平方)。

直接插入排序: 所需要比较的次数为n(n-1)/2。总的时间复杂度为O(n的平方)。

希尔排序所需要比较的次数为O(n的15次方)。(时间复杂度小于以上三种)

堆排序: 最坏情况下，其时间复杂度为O(nlogn)。(小于O(n的平方))。

2根据数据结构中各元素之间前后关系的复杂程度，一般数据结构分为两大类: 线性结构和非线性结构。

如果一个非空的数据结构满足下列两个条件，①有且只有一个根结点 ②每个结点最多有一个前件，也最多有一个后件。则称该数据结构为线性结构，又称线性表。

3算法时间复杂度与空间复杂度没有关系。

4所谓算法的时间复杂度，是指执行算法所需要的计算工作量。

为了能够比较客观的反映出一个算法的效率，在度量一个算法的工作量时，不仅应该与所用的计算机程序设计语言，以及程序编制者无关，而且还应该与算法实现过程中的许多细节无关。

5同一问题可用不同算法解决，而一个算法的质量优劣将影响到算法乃至程序的效率。

算法分析的目的在于选择合适算法和改进算法。

6堆排序在平均情况下的时间复杂度与最坏情况下的时间复杂度都是O(nlogn)。

7二叉链表: 以二叉链表作为树的存储结构。链表中结点的两个链域分别指向该结点的第一个孩子结点和第一个孩子下的一个兄弟结点。

  循环链表是链式存储结构，循环队列是线性存储结构。( ×循环链表是循环队列的链式存储结构)

  双向链表也叫双链表，是链表的一种，它的每个数据结点都有两个指针，分别指向直接后继和直接前驱，所以从双链表中的任意一个结点开始都可以很方便地访问它的前驱结点和后继结点。

8数据的逻辑结构由两个要素: 一是数据元素的集合，通常记为D。二是D上的关系，它反映了D中各元素之间的前后件关系，通常记为R。

即一个数据结构可以表示成B=(D,R)，其中B表示数据结构，为了反映D中各元素之间的前后件关系，一般用二元组来表示。例如，假如a与b是D中的两个数据，则二元组表示a是b的前件，b是a的后件。

  线性结构用图形表示更加直观。例如: R=｛(5,1)，(7,9)，(1,7)，(9,3)｝，结构为: 5→1→7→9→3

9快速排序法是一种互换类的排序方法，但由于比冒泡排序的速度快，因此称为快速排序。

其基本思想是从线性表中选择一个元素设为t，将线性表后面小于t的元素移到前面，而前面大于t的元素移到后面，结果就将线性表分成了两部分，t插入到分界线的位置处，这个过程称为线性表的分割。

  简单插入排序法，是指将无序序列中的各元素依次插入到已经有序的线性表中。

  冒泡排序法是一种最简单的交换类排序方法，它是通过相邻数据元素的交换，逐步将线性表变为有序。

  后两种元素的移动过程中不会产生新的逆序。

10程序可作为算法的一种描述。

11为了降低算法的空间复杂度，要求算法尽量采用原地工作，所谓的原地工作是指执行算法时所使用的额外空间固定。

  一个算法的空间复杂度一般是指执行这个算法所需要的内存空间，一个算法所占用的存储空间包括程序所占的空间，输入的初始数据所占的空间以及算法执行过程中所需要的额外空间。

12能从任意一个结点开始没有重复的扫描到所有结点的数据结构是循环链表。

13循环队列是队列的一种存储结构

14算法的设计要求包括效率与低存储量，即要考虑算法的时间复杂度与空间复杂度。

  算法的复杂度包括时间复杂度和空间复杂度。

  时间复杂度: 是指执行算法所需要的计算工作量。

  空间复杂度: 一般是指执行这个算法所需要的内存空间。

15栈是一种特殊的线性表。链式结构把每一个存储结点分为数据域与指针域，带链的栈可以通过指针域的变化改变原有的栈的组织数据原则; 而顺序栈的栈底指针不变，栈顶指针改变。

16堆排序在最坏的情况下需要比较nlogn次。

  快速排序，在最坏情况下需要比较n(n-1)/2次。

  顺序查找，在最坏情况下需要比较n次。

  最坏情况下，二分查找需要log2n(小于n-1)

  在长度为n的顺序表中寻找最大项/最小项时，比较次数最少为1，最多为n-1。

17如果一个非空的数据结构满足下列两个条件，①有且只有一个根节点 ②每一个结点最多有一个前件，也最多有一个后件，则称该数据结构为线性结构。如果一个数据结构不是线性结构，则称为非线性结构。

18带链栈空的条件是 top=bottom=NULL

19满二叉树也是完全二叉树，完全二叉树不一定是满二叉树。对于满二叉树和完全二叉树来说，可以按照程序进行顺序存储，不仅节省了空间，又能方便地确定每一个结点的父结点等于左右子结点的位置，但顺序存储结构对于一般的二叉树不适用。

20带链栈队头指针与队尾指针相同，且不为空时，队列元素个数为1; 若为空时，队列元素个数为0。

带链栈的栈底指针是随栈的操作而动态变化的。

21二叉树的链式存储结构，也称为二叉链表。在二叉树中，由于每一个元素可以有两个后件，因此用于存储二叉树的存储结点的指针域有两个，所以二叉链表属于非线性结构。

22线性表由一组元素数据元素构成，各元素的数据类型必须相同，矩阵是一个比较复杂的线性表，线性表除了插入和删除运算之外，还可以查找，排序，分解，合并等。数组是长度固定的线性表。

23冒泡排序中，在互换两个相邻元素时，只能消除一个逆序; 快速排序及希尔排序中，一次交换可以消除多个逆序。

24二分法检索的效率比较高，设线性表有n个元素，则最多的比较次数为log2n，最少检索次数为1。

25循环链表的结构具有以下两个特点。一，在循环链表中，增加了一个表头结点，其数据域为任意或者根据需要来设置指针域指向线性表的第一个元素的结点。循环链表的头指针指向表头结点。二、循环链表中最后一个节点的指针域不是空，而是指向表头结点，即在循环链表中所有的结点指针构成一个环状链。

26二叉树的存储结构是非线性结构，而完全二叉树是特殊形态的二叉树。采用顺序存储的完全二叉树属于非线性结构。

27时间复杂度和计算机运行速度以及存储空间无关。

算法的空间复杂度和存储结构无关。

数据处理效率与数据的存储结构有关。

28线性表，向量，栈，队列都属于线性结构的顺序存储。

29循环队列是队列的存储结构。

  循环链表是另一种形式的念式存储结构。

  (✘循环链表是循环队列的链式存储结构。✘)

30完全二叉树的总结点为奇数时，叶子结点是总结点加一再除以二。

31在实际处理中，可以用一位数组来存储堆序列中的元素，也可以用完全二叉树来直观的表示堆的结构。在用完全二叉树表示堆时，树中所有非叶子结点值均不小于其左，右子树的根结点值，因为堆顶元素必须为序列的n个元素的最大项，因此其中序并不是有序序列。

  多重链表指表中每个结点由两个或两个以上的指针域的链表。如果一个非空的数据结构满足下列两个条件，①有且只有一个根结点，②每个结点最多有一个前件，也最多有一个后件，则称该数据结构为线性结构，所以多重链表不一定是非线性结构。

  在计算机中二叉树通常采用链式存储结构，对于满二叉树和完全二叉树来说，可以按层次进行顺序存储。

  排序二叉树的中序遍历序列是有序序列。

32对于一个固定的规模，算法所执行的基本运算次数还可能与特定的输入有关。

33在线性表中寻找最大项时，平均情况下和最坏情况下比较次数都是n-1。

34在长度为n的顺序表中查找一 个元素， 假没需要查找的元素有一半的机会在表中，并且如果元素在表中，则出现在表中每个位置上的可能性是相

同的。则在平均情况下需要比较的次数大约为_

A3n/4    Bn    Cn/2  Dn/4

本题的考查知识点是顺序表的存储结构。

因为需要查找的元素有一半机会在表中，所以二分之一的情况下平均比较次数为n/2，另二分之一的情况下平均比较次数为n。总的平均比较次数为(n/2+n) /2-3n/4。

故本题答案为A。

35设数据结构B=(D, R)，其中

D={a,b,c,d，e，f}

R={(a，b)，(b，c)，(c，d)，(d，e)，(e，f)，(f,a)}该数据结构为

A线性结构    B循环队列

C循环链表    D非线性结构

本题的考查知识点是数据结构。

如果一个非控的数据结构满足下列两个条件: 1) 有且只有一个根节点; 2) 每一一个结点最多有一一个前件，也最多有一一个后件。则称该数据结构为线性结构。如果一个数据结构不是线性结构，则称之为非线性结构。

数据结构B=(D, R)中， 每一个结点均有一个前件，不符合“有且只有一个根节点”的条件，所以为非线性结构。故本题答案选D。

36某带链的队列初始状态为front=rear=NULL。经过一系列正常的入队与退队操作后，front=rear=10。 该队列中的元素个数为_

A1    B0    C1或0    D不确定

本题的考查知识点是带链队列。

在初始状态为front=rear=NULL的带链队列入队时，如果插入的结点既是队首结点又是队尾结点，则rear和front同时指向这个结点;否则在循环队列的队尾加入一一个新元素，rear指向新增结点的数据域，rear+1, front不变。 退队时，在循环队列的排头位置退出一个元素并赋给指定的变量，front指向第二个结点的数据域，front+1, rear不变。当front=rear=10时， front和rear同时指向这个唯一 元素，所以该队列中的元素个数为1。

故本题答案为A。

37若二叉树没有叶子结点，则为空二叉树。

38某带链栈的初始状态为top=bottom=NULL, 经过一系列正 常的入栈与退栈操作后，top=10, bottom=20。 该栈中的元素个数为_____。

A不确定    B 10    C1    D0

本题考查的知识点是栈。

带链的栈是具有栈属性的链表，线性链表的存储单元是不连续的，为把存储空间中一-些离散的空闲存 储结点利用起来，把所有空闲的结点组织成一个带链的栈，称为可利用栈。

线性链表执行删除操作运算时， 被删除的结点可以”回收到可利用栈，对应于可利用栈的入栈运算;线性链表执行插入运算时，需要一个新的结点，可以在可利用栈中取栈顶结点，对应于可利用栈的退栈运算。

可利用栈的入栈运算和退栈运算只需要改动top指针即可。因为是不连续的存储空间，所以top指针将不会有规律地连续变化，因此无法据此判断栈中的元素个数。

所以本题答案为A。

数据结构，data

strucure

是具有特定关系的数据元素的集合。它包含两方面的信息：D+S

D

即数据元素的集合，也就是数据对象；S

数据元素间的关系，而这种关系指的是数据元素之间本身的关系

也叫做逻辑结构！而这种逻辑结构需要通过一种高级语言

比如c语言才能使得将这种逻辑结构在计算机中表现出来

也就是通过高级语言存储结构。

1。。。。。。。。。。。

#include <stdioh>

#include <stdlibh>

#define STACK_MAX_SIZE 30

#define QUEUE_MAX_SIZE 30

#ifndef elemType

typedef char elemType;

#endif

//

/ 以下是关于二叉树操作的11个简单算法 /

//

struct BTreeNode{

elemType data;

struct BTreeNode left;

struct BTreeNode right;

};

/ 1初始化二叉树 /

void initBTree(struct BTreeNode bt)

{

bt = NULL;

return;

}

/ 2建立二叉树(根据a所指向的二叉树广义表字符串建立) /

void createBTree(struct BTreeNode bt, char a)

{

struct BTreeNode p;

struct BTreeNode s[STACK_MAX_SIZE];/ 定义s数组为存储根结点指针的栈使用 /

int top = -1; / 定义top作为s栈的栈顶指针，初值为-1,表示空栈 /

int k; / 用k作为处理结点的左子树和右子树，k = 1处理左子树，k = 2处理右子树 /

int i = 0; / 用i扫描数组a中存储的二叉树广义表字符串，初值为0 /

bt = NULL; / 把树根指针置为空，即从空树开始建立二叉树 /

/ 每循环一次处理一个字符，直到扫描到字符串结束符\0为止 /

while(a[i] != '\0'){

switch(a[i]){

case ' ':

break; / 对空格不作任何处理 /

case '(':

if(top == STACK_MAX_SIZE - 1){

printf("栈空间太小！\n");

exit(1);

}

top++;

s[top] = p;

k = 1;

break;

case ')':

if(top == -1){

printf("二叉树广义表字符串错误!\n");

exit(1);

}

top--;

break;

case ',':

k = 2;

break;

default:

p = malloc(sizeof(struct BTreeNode));

p->data = a[i];

p->left = p->right = NULL;

if(bt == NULL){

bt = p;

}else{

if( k == 1){

s[top]->left = p;

}else{

s[top]->right = p;

}

}

}

i++; / 为扫描下一个字符修改i值 /

}

return;

}

/ 3检查二叉树是否为空，为空则返回1,否则返回0 /

int emptyBTree(struct BTreeNode bt)

{

if(bt == NULL){

return 1;

}else{

return 0;

}

}

/ 4求二叉树深度 /

int BTreeDepth(struct BTreeNode bt)

{

if(bt == NULL){

return 0; / 对于空树，返回0结束递归 /

}else{

int dep1 = BTreeDepth(bt->left); / 计算左子树的深度 /

int dep2 = BTreeDepth(bt->right); / 计算右子树的深度 /

if(dep1 > dep2){

return dep1 + 1;

}else{

return dep2 + 1;

}

}

}

/ 5从二叉树中查找值为x的结点，若存在则返回元素存储位置，否则返回空值 /

elemType findBTree(struct BTreeNode bt, elemType x)

{

if(bt == NULL){

return NULL;

}else{

if(bt->data == x){

return &(bt->data);

}else{ / 分别向左右子树递归查找 /

elemType p;

if(p = findBTree(bt->left, x)){

return p;

}

if(p = findBTree(bt->right, x)){

return p;

}

return NULL;

}

}

}

/ 6输出二叉树(前序遍历) /

void printBTree(struct BTreeNode bt)

{

/ 树为空时结束递归，否则执行如下操作 /

if(bt != NULL){

printf("%c", bt->data); / 输出根结点的值 /

if(bt->left != NULL || bt->right != NULL){

printf("(");

printBTree(bt->left);

if(bt->right != NULL){

printf(",");

}

printBTree(bt->right);

printf(")");

}

}

return;

}

/ 7清除二叉树，使之变为一棵空树 /

void clearBTree(struct BTreeNode bt)

{

if(bt != NULL){

clearBTree(&((bt)->left));

clearBTree(&((bt)->right));

free(bt);

bt = NULL;

}

return;

}

/ 8前序遍历 /

void preOrder(struct BTreeNode bt)

{

if(bt != NULL){

printf("%c ", bt->data); / 访问根结点 /

preOrder(bt->left); / 前序遍历左子树 /

preOrder(bt->right); / 前序遍历右子树 /

}

return;

}

/ 9前序遍历 /

void inOrder(struct BTreeNode bt)

{

if(bt != NULL){

inOrder(bt->left); / 中序遍历左子树 /

printf("%c ", bt->data); / 访问根结点 /

inOrder(bt->right); / 中序遍历右子树 /

}

return;

}

/ 10后序遍历 /

void postOrder(struct BTreeNode bt)

{

if(bt != NULL){

postOrder(bt->left); / 后序遍历左子树 /

postOrder(bt->right); / 后序遍历右子树 /

printf("%c ", bt->data); / 访问根结点 /

}

return;

}

/ 11按层遍历 /

void levelOrder(struct BTreeNode bt)

{

struct BTreeNode p;

struct BTreeNode q[QUEUE_MAX_SIZE];

int front = 0, rear = 0;

/ 将树根指针进队 /

if(bt != NULL){

rear = (rear + 1) % QUEUE_MAX_SIZE;

q[rear] = bt;

}

while(front != rear){ / 队列非空 /

front = (front + 1) % QUEUE_MAX_SIZE; / 使队首指针指向队首元素 /

p = q[front];

printf("%c ", p->data);

/ 若结点存在左孩子，则左孩子结点指针进队 /

if(p->left != NULL){

rear = (rear + 1) % QUEUE_MAX_SIZE;

q[rear] = p->left;

}

/ 若结点存在右孩子，则右孩子结点指针进队 /

if(p->right != NULL){

rear = (rear + 1) % QUEUE_MAX_SIZE;

q[rear] = p->right;

}

}

return;

}

//

/

int main(int argc, char argv[])

{

struct BTreeNode bt; / 指向二叉树根结点的指针 /

char b; / 用于存入二叉树广义表的字符串 /

elemType x, px;

initBTree(&bt);

printf("输入二叉树广义表的字符串：\n");

/ scanf("%s", b); /

b = "a(b(c), d(e(f, g), h(, i)))";

createBTree(&bt, b);

if(bt != NULL)

printf(" %c ", bt->data);

printf("以广义表的形式输出：\n");

printBTree(bt); / 以广义表的形式输出二叉树 /

printf("\n");

printf("前序："); / 前序遍历 /

preOrder(bt);

printf("\n");

printf("中序："); / 中序遍历 /

inOrder(bt);

printf("\n");

printf("后序："); / 后序遍历 /

postOrder(bt);

printf("\n");

printf("按层："); / 按层遍历 /

levelOrder(bt);

printf("\n");

/ 从二叉树中查找一个元素结点 /

printf("输入一个待查找的字符：\n");

scanf(" %c", &x); / 格式串中的空格跳过空白字符 /

px = findBTree(bt, x);

if(px){

printf("查找成功：%c\n", px);

}else{

printf("查找失败！\n");

}

printf("二叉树的深度为：");

printf("%d\n", BTreeDepth(bt));

clearBTree(&bt);

return 0;

}

2。。。。。。。

#include<stdioh>

#include<stdlibh>

#include<stringh>

#include<conioh>a

#include<graphicsh>

#define MAXVALUE 200 /权值的最大值/

#define MAXBIT 30 /最大的编码位数/

#define MAXNODE 30 /初始的最大的结点数/

struct haffnode

{char data;

int weight;

int flag;

int parent; /双亲结点的下标/

int leftchild; /左孩子下标/

int rightchild; /右孩子下标/

};

struct haffcode

{int bit[MAXNODE];

int start; /编码的起始下标/

char data;

int weight; /字符权值/

};

/函数说明/

//

void pprintf(struct haffcode haffcode[],int n);

/输出函数/

void haffmantree(int weight[],int n,struct haffnode hafftree[],char

data[]);

/建立哈夫曼树/

void haffmancode(struct haffnode hafftree[],int n,struct haffcode

haffcode[]);

/求哈夫曼编码/

void test(struct haffcode haffcode[],int n);

/测试函数/

void end();

/结束界面函数/

//

void haffmantree(int weight[],int n,struct haffnode hafftree[],char

data[])

/建立叶结点个数为n，权值数组为weight[]的哈夫曼树/

{int i,j,m1,m2,x1,x2;

/哈夫曼树hafftree[]初始化，n个叶结点共有2n-1个结点/

for(i=0;i<2n-1;i++)

{if(i<n) {hafftree[i]data=data[i];

hafftree[i]weight=weight[i]; /叶结点/

}

else {hafftree[i]weight=0; /非叶结点/

hafftree[i]data='\0';

}

hafftree[i]parent=0;

/初始化没有双亲结点/

hafftree[i]flag=0;

hafftree[i]leftchild=-1;

hafftree[i]rightchild=-1;

}

for(i=0;i<n-1;i++)

/构造哈夫曼树n-1个非叶结点/

{m1=m2=MAXVALUE;

x1=x2=0;

for(j=0;j<n+i;j++)

{if(hafftree[j]weight<m1&&hafftree[j]flag==0)

{m2=m1;

x2=x1;

m1=hafftree[j]weight;

x1=j;

}

else if(hafftree[j]weight<m2&&hafftree[j]flag==0)

{m2=hafftree[j]weight;

x2=j;

}

}

hafftree[x1]parent=n+i;

hafftree[x2]parent=n+i;

hafftree[x1]flag=1;

hafftree[x2]flag=1;

hafftree[n+i]weight=hafftree[x1]weight+hafftree[x2]weight;

hafftree[n+i]leftchild=x1;

hafftree[n+i]rightchild=x2;

}

}

void haffmancode(struct haffnode hafftree[],int n,struct haffcode

haffcode[])

{/由n个结点的哈夫曼树hafftree[]构成的哈夫曼编码haffcode[]/

int i,j,child,parent;

struct haffcode newcode;

struct haffcode cd;

cd=&newcode;

for(i=0;i<n;i++)

/求n个结点的哈夫曼编码/

{cd->start=MAXBIT-1;

/不等长编码的最后一位是n-1/

cd->weight=hafftree[i]weight;

cd->data=hafftree[i]data; /取得编码对应值的字符/

child=i;

parent=hafftree[child]parent;

while(parent!=0)

{if(hafftree[parent]leftchild==child)

cd->bit[cd->start]=0;

/左孩子编码为0/

else

cd->bit[cd->start]=1; /右孩子编码为1/

cd->start--;

child=parent;

parent=hafftree[child]parent;

}

for(j=cd->start+1;j<MAXBIT;j++)

/保存每个叶结点的编码和等长编码的起始位/

haffcode[i]bit[j]=cd->bit[j];

haffcode[i]data=cd->data;

haffcode[i]start=cd->start;

haffcode[i]weight=cd->weight;

}

}

void pprintf(struct haffcode myhaffcode[],int n)

{int i,j,count=0;

clrscr();

for(i=0;i<n;i++)

{textcolor(YELLOW);

cprintf("字符=%c",myhaffcode[i]data);

printf(" ");

textcolor(YELLOW);

cprintf("weight=%3d",myhaffcode[i]weight);

printf(" ");

textcolor(YELLOW);

cprintf("haffcode=");

for(j=myhaffcode[i]start+1;j<MAXBIT;j++)

cprintf("%d",myhaffcode[i]bit[j]);

printf("\n");

count++;

if(count==21)

getch();

}

}

void test(struct haffcode haffcode[],int n)

{int i,j,k,s;

char sstring[MAXNODE];

struct haffcode newhaffcode[MAXNODE];

j=0;

clrscr();

textcolor(YELLOW);

cprintf("请输入哈夫曼编码测试数据，在此建议为'this

programme is my favorite'");

printf("\n");

cprintf("注意小写,空格由大写字母T代替，并且字符数小于27\n");

scanf("%s",sstring);

if(strlen(sstring)>=MAXNODE)

{printf("you input the data number >=MAXNODE");

exit(1);

}

for(i=0;i<strlen(sstring);i++)

{

for(j=0;j<MAXBIT;j++)

if(sstring[i]==haffcode[j]data)

{

k=j;

break;

}

if(k<0||k>MAXNODE-1)

{printf("在系统中找不到与第个%d字符相匹配的编码\n",i+1);

continue;

}

newhaffcode[i]start=haffcode[k]start;

newhaffcode[i]weight=haffcode[k]weight;

newhaffcode[i]data=haffcode[k]data;

for(s=haffcode[k]start+1;s<MAXBIT;s++)

newhaffcode[i]bit[s]=haffcode[k]bit[s];

}

pprintf(newhaffcode,strlen(sstring));

}

void end()

{int driver,mode;

driver=VGA;

mode=VGAHI;

initgraph(&driver,&mode," ");

setlinestyle(0,0,2);

setfillstyle(1,9);

bar(120,60,520,80);

setfillstyle(1,9);

bar(90,100,550,350);

moveto(121,65);

settextstyle(5,0,6);

setcolor(7);

outtext("This programme is designed by Dou Zheren");

settextstyle(3,0,3);

setcolor(7);

moveto(150,200);

outtext("thank you use this programme");

moveto(100,300);

settextstyle(3,0,2);

setcolor(7);

outtext("please press anykey to end this programme");

}

void main()

{

int i,j,n=27;

int driver=VGA,mode=VGAHI;

char ch;

int weight[27]={186,64,13,22,32,103,21,15,47,

57,1,5,32,20,57,63,15,1,48,

51,80,23,8,18,1,16,1};

char data[28]={'T','a','b','c','d','e','f','g','h',

'i','j','k','l','m','n','o','p','q',

'r','s','t','u','v','w','x','y','z'};

struct haffnode newhaffnode[2MAXNODE-1];

struct haffcode newcode[MAXNODE];

struct haffnode myhafftree=newhaffnode;

struct haffcode myhaffcode=newcode;

if(n>MAXNODE)

{printf("you input the haffnode > MAXNODE,so you input the data is

wrong");

printf("\n");

exit(1);

}

clrscr();

textcolor(YELLOW);

cprintf("WELCOME!这是一个求哈夫曼编码的问题");

printf("\n");

cprintf("即对所有的字母进行编码后，在根据用户的需要，对用户的要求进行编码。");

printf("\n");

cprintf("注意：本程序只支持小写字母，空格用大写字母T代替!

");

printf("\n");

getch();

textcolor(YELLOW);

cprintf("ReadyEnter,if you want to begin!\n");

printf("\n");

getch();

cprintf("Now，开始演示哈夫曼编码");

getch();

haffmantree(weight,n,myhafftree,data);

haffmancode(myhafftree,n,myhaffcode);

pprintf(myhaffcode,n);

clrscr();

printf("若执行自定义编译，请输入y继续。否则程序将结束");

if((ch=getch())=='y'||ch=='Y')

test(myhaffcode,n);

getch();

clrscr();

end();

getch();

exit(1);

}