二叉树的课程设计

⑴ C++二叉树的课程设计

《数据结构》实验三——二叉树排序算法
*试编写算法，对一棵二叉树根结点不变，将左、右子树进行交换，树中每个结点的左、右子树进行交换。*/
Exchange(pBiNode BiTree)
{
pBiNode p;
if(BiTree)
{
p = BiTree->lChild;
BiTree->lChild = BiTree->rChild;
BiTree->rChild = p;
Exchange(BiTree->lChild);
Exchange(BiTree->rChild);
}
}
/*这个算法要求同学必须掌握*/
《数据结构》实验三——动态查找
*
1.试按表(10,8,9,12,20,5,6,15,19,25)中元素的排列次序，将所有元素插入一棵初始为空的二叉排序树中，使之仍是一棵二叉排序树，请设计算法
2.在已构建的二叉排序树中插入元素40，使之依然为二叉排序树
*/

#include <malloc.h>
typedef struct node
{
int data;
struct node * lChild,*rChild;
}node,*BTNode;
BTNode Create(BTNode BiTree)
{
int n;
BTNode p,q;
scanf("%d",&n);
for(;n != 0;)
{
p = (BTNode)malloc(sizeof(struct node));
p->data = n;
p->lChild = NULL;
p->rChild = NULL;
if(!BiTree)
BiTree = p;
else
{ q = BiTree;
while(q->data != n)
{
if(q->data > n)
if(q->lChild != NULL)
q = q->lChild;
else
q->lChild = p;
else if(q->rChild != NULL)
q = q->rChild;
else
q->rChild = p;
}
}
scanf("%d",&n);
}
return BiTree;
}
InOrderTraverse(BTNode BiTree)
{
if(BiTree)
{
InOrderTraverse(BiTree->lChild);
printf("%4d",BiTree->data);
InOrderTraverse(BiTree->rChild);
}
}
Insert(BTNode BiTree,int n)
{
BTNode p,q = BiTree;
while(q->data != n)
{
if(q->data > n)
if(q->lChild != NULL)
q = q->lChild;
else
{
p = (BTNode)malloc(sizeof(struct node));
p->data = n;
p->lChild = p->rChild = NULL;
q->lChild = p;
}
else if(q->rChild != NULL)
q = q->rChild;
else
{
p = (BTNode)malloc(sizeof(struct node));
p->data = n;
p->lChild = p->rChild = NULL;
q->rChild = p;
}
}

}
main()
{
BTNode BTRoot;
BTRoot = NULL;
BTRoot = Create(BTRoot);
printf("\n Sorted numbers are:\n");
InOrderTraverse(BTRoot);
Insert(BTRoot,40);
printf("\nAfter instert numbers are:\n");
InOrderTraverse(BTRoot);
printf("\n");
}
*将序列（13,15,22,8,34,19,21）插入到一个初始时是空的哈希表中，哈希函数采用hash(x)=1+(x MOD 7)。使用线性探测法解决冲突*/

#define N 8
struct number
{
int data;
int flag; /*冲突与否标志*/
}hx[N] = {0};
Create_hxTable(struct number a[])
{
int i,j,n;
for(i = 1;i < 8;i++)
{
scanf("%d",&n);
j= 1 + n % 7;
while(a[j].flag)
j = (j + 1) % N;
a[j].data = n;
a[j].flag = 1;
}
}
main()
{
int i;
Create_hxTable(hx);
for(i = 0;i < N;i++)
{
if(hx[i].flag)
printf("%3d",hx[i].data);
else
printf(" * ");
}
printf("\n");
}
Joseph算法实现
#include <malloc.h>
typedef struct s
{
int no,password;
struct s *next;
}*node;
node create_cycle(int n)
{
node head,end,p;
int i;
head = NULL;
end = NULL;
printf("Please input %d passwords(password > 0)\n",n);
for(i = 1;i <= n;i++)
{
p = (node)malloc(sizeof(struct s));
scanf("%d",&p->password);
p->no = i;
if(!head)
{
head = p;
end = p;
}
else
{
end->next = p;
end = p;
}
}
end->next = head;
head = end;
return head;
}
void out_link(node head,int n,int m)
{
int i,j,k = m;
node p = head,q;
for(i = 1;i < n;i++)
{
for(j = 1;j < k;j++)
p = p->next;
q = p->next;
k = q->password;
p->next = q->next;
printf("%3d",q->no);
free(q);
}
printf("%3d",p->no);
free(p);
}
void main()
{
node head;
int n,m;
printf("Please input numbers of people and init_password\n");
scanf("%d%d",&n,&m);
head = create_cycle(n);
printf("Out link sequence is:\n");
out_link(head,n,m);
printf("\n");
}
串操作：判断子串
int find(char *c1,char *c2)
{
int flag = -1,i,j;
for(i = 0;*(c1 + i);i++)
{
j = 0;
if(*(c1 + i) == *(c2 + j))
{
flag = i;
for(;*(c1 + i) && *(c2 + j) && *(c1 + i) == *(c2 + j);i++,j++) ;
/*空循环，继续判断是否匹配*/
if(*(c2 + j) == '\0') /*找到匹配的串*/
break;
else
flag = -1;
}

}
return flag;
}
void main()
{
char c1[30],c2[30];
int f;
scanf("%s%s",c1,c2);
f = find(c1,c2);
if(f == -1)
printf("No\n");
else
printf("Yes! Position is %d\n",f + 1);
}
/*找二叉树的叶节点及统计叶节点个数*/

int ShowLeaves(pBiNode BiTree)
{
static int i = 0;
if(BiTree)
{
ShowLeaves(BiTree->lChild);
ShowLeaves(BiTree->rChild);
if((BiTree->lChild==NULL)&&(BiTree->rChild==NULL))
{
printf("%c",BiTree->data);
i++;
}
}
return i;
}
/*求二叉树的深度*/
int Depth(pBiNode BiTree)
{
int dep1,dep2;
if(BiTree==NULL)return 0;
else
{
dep1=Depth(BiTree->lChild);
dep2=Depth(BiTree->rChild);
return dep1>dep2? dep1+1: dep2+1;
}
}
二叉树的创建和遍历(递归)
#include <malloc.h>
typedef struct BiNode
{
char data;
struct BiNode *lChild,*rChild;
}BiNode,*pTree;
CreateTree(pTree *BTRoot)
{
char ch;
scanf("%c",&ch);
if(ch == '#')
(*BTRoot) = NULL;
else
{
(*BTRoot) = (pTree)malloc(sizeof(BiNode));
(*BTRoot)->data = ch;
CreateTree(&((*BTRoot)->lChild));
CreateTree(&((*BTRoot)->rChild));
}
}
PreOrderTraverse(pTree pRoot)
{
if(pRoot)
{
printf("%c ",pRoot->data);
PreOrderTraverse(pRoot->lChild);
PreOrderTraverse(pRoot->rChild);
}

}
InOrderTraverse(pTree pRoot)
{
if(pRoot)
{
InOrderTraverse(pRoot->lChild);
printf("%c ",pRoot->data);
InOrderTraverse(pRoot->rChild);
}

}
PostOrderTraverse(pTree pRoot)
{
if(pRoot)
{

PostOrderTraverse(pRoot->lChild);
PostOrderTraverse(pRoot->rChild);
printf("%c ",pRoot->data);
}

}
main()
{
pTree root = NULL;
CreateTree(&root);
printf("\n\nPreOrder is :\n");
PreOrderTraverse(root);
printf("\n\nInOrder is :\n");
InOrderTraverse(root);
printf("\n\nPostOrder is :\n");
PostOrderTraverse(root);
printf("\n");
}
循环链表的建立及两循环链表的链接

#include <malloc.h>
typedef struct s
{
int num;
struct s *next;
}*ls;
ls creat()
{
ls head,p,end;
int i;
static int n = 501;
head = (ls)malloc(sizeof(struct s));
head->next = NULL;
end = head;

for(i = 1;i <= 10;i++)
{ p = (ls)malloc(sizeof(struct s));
p->num = n++;
end->next = p;
end = p;
}
p->next = head;
return head;
}
ls link_two(ls h1,ls h2)
{
ls end1,end2,p;
for(p = h1->next;p->next != h1;p = p->next)

end1 = p;
for(p = h2->next;p->next != h2;p = p->next)

end2 = p;
end1->next = h2->next;
end2->next = h1;
free(h2);
return h1;
}

main()
{
ls head1,head2,head,p;
head1 = creat();
head2 = creat();
head = link_two(head1,head2);
for(p = head->next;p != head;p = p->next)
printf("%5d",p->num);
}
与课堂上讲的稍修改了下，把n改为了静态变量static int n = 501;
creat()函数不带参数

单链表的建立、节点查找、插入、删除等操作实现
#include <malloc.h>
typedef struct s
{
int num;
struct s *next;
}*ls;
ls creat()
{
ls head,p,end;
int i,n = 501;
head = (ls)malloc(sizeof(struct s));
head->next = NULL;
end = head;

for(i = 1;i <= 10;i++)
{ p = (ls)malloc(sizeof(struct s));
p->num = n++;
end->next = p;
end = p;
}
p->next = NULL;
return head;
}

ls find_front(ls head,ls e)
{
ls p;
p = head->next;
for(;p->next && p->next->num != e->num;p = p->next)

if(p->next->num == e->num)

return p;

else return NULL;
}
void insert_front(ls head,ls e,ls f)
{
ls p;
p = find_front(head,e);
f->next = p->next;
p->next = f;
}

main()
{
ls head,p,e,f;
head = creat();
for(p = head->next;p;p = p->next)
printf("%5d",p->num);
printf("\n");
e = (ls)malloc(sizeof(struct s));
f = (ls)malloc(sizeof(struct s));
scanf("%d%d",&e->num,&f->num);
e->next = NULL;
f->next = NULL;
/*p = find_front(head,e);*/
insert_front(head,e,f);
printf("Inerted!\n");
for(p = head->next;p;p = p->next)
printf("%5d",p->num);

}

节点删除
void delete(ls head,ls e)
{
ls p,q;
p = find_front(head,e);
q = p->next;
p->next = p->next->next;
free(q);
}
堆栈操作（检验符号匹配实例）
#include <malloc.h>
#include <stdio.h>
typedef struct stack
{
char c;
struct stack *next;
}*node;

node push(node top,node new) /*入栈*/
{
if(top == NULL)
top = new;
else
{
new->next = top;
top = new;
}
return top;
}
node pop(node top) /*出栈*/
{
node p;
if(!top)
{
printf("NULL stack\n");
return NULL;
}

else
{
p = top;
top = top->next;
free(p);
return top;
}

}
char top_data(node top) /*取栈顶数据*/
{
char ch = 0;
if(!top)
return 0;
else
ch = top->c;
return ch;
}
void main()
{
char ch;
node top = NULL,p;
for(;(ch = getchar()) != '\n';) /*输入表达式*/
{
if(ch == '(' ||ch == '[' ||ch == '{')
{
p = (node)malloc(sizeof(struct stack));
p->c = ch;
p->next = NULL;
top =push(top,p);
}
else if(ch == ')')
{
if(top_data(top) != '(')
{
printf("No\n");
exit();
}
else
top = pop(top);
}
else if(ch == ']')
{
if(top_data(top) != '[')
{
printf("No\n");
exit();
}
else
top = pop(top);
}
else if(ch == '}')
{
if(top_data(top) != '{')
{
printf("No\n");
exit();
}
else
top = pop(top);
}
}
if(top)
printf("No\n");
else
printf("Yes\n");

}

⑵ 【数据结构】课程设计:二叉树的设计与遍历

#include<iostream.h>
#include<stdio.h>
#include<stdlib.h>
#define MAX 100
//定义二叉树链表
struct Bitree
{
char c;
struct Bitree *lchild,*rchild;
};
//定义队列
struct Quene
{
struct Bitree *p;//指向数的节点的指针
struct Quene *next;
};
//定义哈夫曼树的结构
struct Huffman
{
int weight;//权值
int tag;
int parent,lchild,rchild;
char ch;
};

struct Bitree *creatBt()
{
struct Bitree *btree;
char ch;
cin>>ch;
// "访问"操作为生成根结点
if(ch!='#')
{
btree=(struct Bitree * )malloc(sizeof(struct Bitree )) ;
btree->c=ch;
btree->lchild=creatBt(); // 递归建(遍历)左子树
btree->rchild=creatBt(); // 递归建(遍历)右子树
}
if(ch=='#')
{
btree=NULL;
}
return btree;
}
//先序遍历递归
void preOrder1(struct Bitree *btree)
{
struct Bitree *p;
p=btree;
if(p!=NULL)
{
cout<<p->c<<" ";
preOrder1(p->lchild);
preOrder1(p->rchild);
}
}
//中序遍历递归
void inOrder1(struct Bitree *btree)
{
struct Bitree *p;
p=btree;

if(p->lchild!=NULL)
inOrder1(p->lchild);
cout<<p->c<<" ";
if(p->rchild!=NULL)
inOrder1(p->rchild);
}
//后序遍历递归
void postOrder1(struct Bitree *btree)
{
struct Bitree *p;
p=btree;

if(p->lchild!=NULL)
postOrder1(p->lchild);
if(p->rchild!=NULL)
postOrder1(p->rchild);
cout<<p->c<<" ";

}
//非递归先序遍历
void preOrder2(struct Bitree *btree)
{
struct Bitree *p, *node[MAX];
int top=0;
p=btree;
do
{
while(p!=NULL)
{
cout<<p->c<<" ";
node[top]=p;
top++;
p=p->lchild;
}
if(top>0)
{
top--;
p=node[top];
p=p->rchild;
}
}
while(top>0||p!=NULL);
}
//非递归中序遍历
void inOrder2(struct Bitree *btree)
{
struct Bitree *p, *node[MAX];
int top=0;
p=btree;
do// while(top>0||p!=NULL)
{
while(p!=NULL)
{
node[top]=p;
top++;
p=p->lchild;
}
if(top>0)
{
top--;
p=node[top];
cout<<p->c<<" ";
p=p->rchild;
}
} while(top>0||p!=NULL);
}
//非递归后序遍历
void postOrder2(struct Bitree *btree)
{
struct Bitree *p, *node[MAX];
int top=0;
p=btree;
while(top>0||p!=NULL)
{
while(p!=NULL)
{
node[top]=p;
top++;
p=p->lchild;
}
if(top>0)
{
top--;
p=node[top];
if(p->rchild==NULL)
cout<<p->c<<" ";
p=p->rchild;
}
}
p=btree;
cout<<p->c<<" ";
}
//二叉树的高度
int btHeigh(struct Bitree *btree)
{
struct Bitree *p;
p=btree;
int hl=0, h2=0, max=0;
if(p!=NULL)
{
hl=btHeigh(p->lchild); //求左子树的深度
h2=btHeigh(p->rchild); //求右子树的深度
max=hl>h2?hl: h2;
return(max+1);// 返回树的深度
}
else
return 0;
}
//求二叉树的叶子个数
int numLeave(struct Bitree *btree)
{
struct Bitree *p;
p=btree;
int static n=0;//静态变量计数
if(p!=NULL)
{
if(p->lchild==NULL&&p->rchild==NULL)
n++; //若root所指结点为叶子, 则累加
numLeave(p->lchild);
numLeave(p->rchild);
return n;
}
else
return 0;
}
//借助队列实现二叉树的层次遍历。
void btQuene(struct Bitree *btree)
{
struct Quene *head,*rear,*temp;
head=(struct Quene*)malloc(sizeof(struct Quene));//给队列头指针分配器空间
head->p=btree;
head->next=NULL;
rear=head;
while(head!=NULL)
{
if(head->p->lchild!=NULL)
{
temp=(struct Quene *)malloc(sizeof(struct Quene));//中间变量暂时保存数的结点
temp->p=head->p->lchild;
temp->next=NULL;
rear->next=temp;//将新结点连接在前一个结点的后面
rear=temp;
}
if(head->p->rchild!=NULL)
{
temp=(struct Quene *)malloc(sizeof(struct Quene));
temp->p=head->p->rchild;
temp->next=NULL;
rear->next=temp;
rear=temp;
}
temp=head;
cout<<head->p->c;
head=head->next;
free(temp);
}
}
//建立哈夫曼树
void creatHfm()
{
struct Huffman *HF;
int num;
int i,j,x1,x2,m1,m2;
cout<<"输入字符个数；";
cin>>num;
if(num<=1)
{
cout<<"不能建立哈夫曼树！"<<endl;
return ;
}
HF=new struct Huffman[2*num-1];
char c;
//构造叶子结点数为num,权值为weight的哈夫曼树HF[]
for(i=0;i<num;i++)
{
cout<<"请输入第"<<i+1<<"个字符值:";
cin>>c;
HF[i].ch=c;
cout<<"请输入该字符的权值:";
cin>>HF[i].weight;
HF[i].parent=-1;
HF[i].lchild=-1;
HF[i].rchild=-1;
HF[i].tag=0;
}
//构造非叶子结点
for(i=0;i<num-1;i++)//合并n-1次
{
m1=m2=32767;//m1是最小值单元，m2为次小值
x1=x2=0;//x1，x2为下标号
for(j=0;j<num+1;j++)//找最小权值和次小权值
{
if(HF[i].weight<m1&&HF[j].tag==0)
{
m2=m1;
x2=x1;
m1=HF[j].weight;
x1=j;
}
else if(HF[j].weight<m2&&HF[j].tag==0)
{
m2=HF[j].weight;
x2=j;
}
}
//将两棵子树合并成一棵新树
HF[x1].parent=num+i;//x1,x2对应的子树分别作为n+i的左右子树
HF[x2].parent=num+i;
HF[x1].tag=1;
HF[x2].tag=1;
HF[num+i].weight=HF[x1].weight+HF[x2].weight;//新书跟的权值为左右树根的权值之和
HF[num+i].lchild=x1;//n+i的做孩子是x1
HF[num+i].rchild=x2;
}
cout<<"哈夫曼树创建成功!"<<endl;
}

//删除值为x的结点，并释放相应的空间
void btFree(struct Bitree *btree,char x)
{
struct Bitree *p;
p=btree;
if(p!=NULL)
{
if(p->c==x)
{
free(p);
cout<<"释放成功！"<<endl;
}
else
{
btFree(p->lchild,x);
btFree(p->rchild,x);
}

}
else
cout<<"空间释放失败！"<<endl;
}
void main()
{
int key;
int depth;
int numLea;
struct Bitree *btree;
cout<<"输入数的节点，'#'表示空节点:"<<endl;
btree=creatBt();
cout<<"二叉树创建成功!"<<endl;
cout<<endl;

cout<<"***********************************"<<endl;
cout<<" 选择菜单 "<<endl;
cout<<"1、递归先序遍历二叉树 "<<endl;
cout<<"2、递归中序遍历二叉树 "<<endl;
cout<<"3、递归后序遍历二叉树 "<<endl;
cout<<"4、非递归先序遍历二叉树 "<<endl;
cout<<"5、非递归中序遍历二叉树 "<<endl;
cout<<"6、非递归后序遍历二叉树 "<<endl;
cout<<"7、求二叉树的高度 "<<endl;
cout<<"8、求二叉树的叶子结点个数 "<<endl;
cout<<"9、队列实现二叉树层次遍历"<<endl;
cout<<"10、建立哈夫曼树 "<<endl;
cout<<"11、释放空间 "<<endl;
cout<<"***********************************"<<endl;
for(;key!=0;)
{
cout<<"输入选项，(0表示结束操作):";
cin>>key;
switch(key)
{

case 1:
cout<<"递归先序遍历结果是:";
preOrder1(btree);
cout<<endl;
break;
case 2:
cout<<"递归中序遍历结果是:";
inOrder1(btree);
cout<<endl;
break;
case 3:
cout<<"递归后序遍历结果是:";
postOrder1(btree);
cout<<endl;
break;
case 4:
cout<<"非递归先序遍历结果是:";
preOrder2(btree);
cout<<endl;
break;
case 5:
cout<<"非递归中序遍历结果是:";
inOrder2(btree);
cout<<endl;
break;
case 6:
cout<<"非递归后序遍历结果是:";
postOrder2(btree);
cout<<endl;
break;
case 7:
depth=btHeigh(btree);
cout<<"二叉树的高度为";
cout<<depth<<endl;
break;
case 8:
numLea=numLeave(btree);
cout<<"二叉树的叶子结点数为";
cout<<numLea<<endl;
break;
case 9:
cout<<"层次遍历的结果为:";
btQuene(btree);
cout<<endl;
break;
case 10:
creatHfm();
break;
case 11:
char c;
cout<<"输入要释放的结点:";
cin>>c;
btFree(btree,c);
break;
default:
printf("\n输入选项错误！\n ");
}
}
}

⑶ 写一份 数据结构课程设计报告。两个部分为：二叉树的遍历和查找（折半查找）的实现

二叉树的遍历

#include<iostream>
#include<cstring>
#definemaxLength32
usingnamespacestd;
typedefstructbinaryNode
{
chardata;
structbinaryNode*lchild,*rchild;
}binaryNode;
voidcreateByPreAndIn(charpreArray[],charinArray[],binaryNode*&parent,intpreStart,intpreEnd,intinStart,intinEnd);
voidcreateByLastAndIn(charlastArray[],charinArray[],binaryNode*&parent,intlastEnd,intlastStart,intinStart,intinEnd);
voidpreOrderVisit(binaryNode*root);
voidinOrderVisit(binaryNode*root);
voidlastOrderVisit(binaryNode*root);
voidrugged(binaryNode*root,int);
voidbrackets(binaryNode*root);
voidlevel(binaryNode*root);
voiddisplay(binaryNode*root);
intmain(void)
{
charpreArray[maxLength],inArray[maxLength],lastArray[maxLength];
binaryNode*root;
cout<<"构造二叉树，输入构造方式。(1代表前中序，其它数字代表后中序):";
intway;
cin>>way;
if(way==1)
{
cout<<"输入前序遍历序列:";
cin>>preArray;
cout<<"输入中序遍历序列:";
cin>>inArray;

createByPreAndIn(preArray,inArray,root,0,strlen(preArray)-1,0,strlen(inArray)-1);
}
elseif(way==2)
{
cout<<"输入后序遍历序列:";
cin>>lastArray;
cout<<"输入中序遍历序列:";
cin>>inArray;
createByLastAndIn(lastArray,inArray,root,0,strlen(lastArray)-1,0,strlen(inArray)-1);
}//initialization
cout<<"构造完成,下列是该二叉树的表示方式"<<endl;
display(root);
cout<<"按enter键继续...";
cin.get();cin.get();

return0;
}
voidcreateByPreAndIn(charpreArray[],charinArray[],binaryNode*&parent,intpreStart,intpreEnd,intinStart,intinEnd)
{
if(preStart<=preEnd)
{
parent=newbinaryNode;
parent->data=preArray[preStart],parent->lchild=parent->rchild=NULL;
intmiddle=inStart;
while(inArray[middle]!=preArray[preStart]&&middle<=inEnd)
middle++;
createByPreAndIn(preArray,inArray,parent->lchild,preStart+1,preStart+middle-inStart,inStart,middle-1);
createByPreAndIn(preArray,inArray,parent->rchild,preStart+middle-inStart+1,preEnd,middle+1,inEnd);
}
}
voidcreateByLastAndIn(charlastArray[],charinArray[],binaryNode*&parent,intlastStart,intlastEnd,intinStart,intinEnd)
{
if(lastStart<=lastEnd)
{
parent=newbinaryNode;
parent->data=lastArray[lastEnd],parent->lchild=parent->rchild=NULL;
intmiddle=inStart;
while(inArray[middle]!=lastArray[lastEnd]&&middle<=inEnd)
middle++;
createByLastAndIn(lastArray,inArray,parent->lchild,lastEnd-inEnd+inStart,lastEnd-inEnd+middle-1,inStart,middle-1);
createByLastAndIn(lastArray,inArray,parent->rchild,lastEnd-inEnd+middle,lastEnd-1,middle+1,inEnd);
}
}
voidpreOrderVisit(binaryNode*root)
{
if(root)
{
std::cout<<root->data;
preOrderVisit(root->lchild);
preOrderVisit(root->rchild);
}
}
voidinOrderVisit(binaryNode*root)
{
if(root)
{
inOrderVisit(root->lchild);
std::cout<<root->data;
inOrderVisit(root->rchild);
}
}
voidlastOrderVisit(binaryNode*root)
{
if(root)
{
lastOrderVisit(root->lchild);
lastOrderVisit(root->rchild);
cout<<root->data;
}
}
voidrugged(binaryNode*root,intindent)
{
if(root)
{
for(intj=0;j<indent;j++)
std::cout<<"-";
indent++;
std::cout<<root->data;
std::cout<<std::endl;
rugged(root->lchild,indent+1);
rugged(root->rchild,indent+1);
}
}
voidlevel(binaryNode*root)
{
intfront=-1,rear=0;
binaryNode*buff[maxLength],*visit;
buff[rear]=root;
while(front!=rear)
{
front=(front+1)%maxLength;
visit=buff[front];
if(visit->lchild)
{
rear=(rear+1)%maxLength;
buff[rear]=visit->lchild;
}
if(visit->rchild)
{
rear=(rear+1)%maxLength;
buff[rear]=visit->rchild;
}
cout<<visit->data;
}
}
voidbrackets(binaryNode*root)
{
if(root)
{
std::cout<<root->data;
if(root->lchild||root->rchild)
std::cout<<'(';
brackets(root->lchild);
if(root->lchild&&root->rchild)
std::cout<<',';
brackets(root->rchild);
if(root->lchild||root->rchild)
std::cout<<')';
}
}
voiddisplay(binaryNode*root)
{
cout<<"前序遍历:";
preOrderVisit(root);
cout<<endl;
cout<<"中序遍历:";
inOrderVisit(root);
cout<<endl;
cout<<"后序遍历:";
lastOrderVisit(root);
cout<<endl;
cout<<"层次遍历:"<<endl;
level(root);
cout<<endl;
cout<<"凹入表示法:"<<endl;
rugged(root,0);
cout<<endl;
cout<<"括号表示法:"<<endl;
brackets(root);
cout<<endl;
}

⑷ C语言课程设计，二叉树，源程序已给出，求三种便利程序和注释以及流程图！

#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>

struct tree //定义结构体tree
{
char info;
struct tree *left,*right; //定义左树结点指针和右树结点指针
};
//声明函数
struct tree *create_btree(struct tree *root,struct tree *r,char info);
struct tree *search_btree(struct tree *root,char key);
void print_btree(struct tree *r,int l);
void pretra(struct tree *head);
void midtra(struct tree *head);
void afttra(struct tree *head);

main ()
{
char s[100],c,key=' ' ;
struct tree *root=0 ;
do
{
printf("Enter a letter:");
gets(s);
//下面这个条件是我添加的，如果没有这个条件最后会多一个info为NULL也就是0的值，因为是先gets(s)->赋值，最后才判断*s是否为空
if(*s==0)
break;
if (!root)
root=create_btree(root,root,*s);
else
create_btree(root,root,*s);
}while(*s) ;

//printf("%d",root->left);

print_btree(root,0);
printf("前序遍历:\n");
pretra(root);
printf("\n");
printf("中序遍历:\n");
midtra(root);
printf("\n");
printf("后序遍历:\n");
afttra(root);
printf("\n");
key='1';
while (key)
{
printf("Enter a key to find:");
scanf("%s",&c);
root=search_btree(root,c);
printf("press to continue\n");
}
} /* Btree.C 结束 */
//创建二叉树,实际上创建的是一个有序二叉树
struct tree *create_btree(struct tree *root,struct tree *r,char info)
{
if (r ==0 ) //也就是r==NULL
{
//r=new(struct tree);// same as function: malloc(sizeof())
r=(struct tree *)malloc(sizeof(struct tree)); //我这用前面那句老是编译不过
if ( r == 0) //如果内存申请失败，就报错然后退出
{
printf("Out of memory\n");
return 0;
}
r->left=0; //初始化这个新结点
r->right=0;
r->info=info; //将输入的字符赋值给这个结点
if (root) //如果root不为空
{
if(info<root->info) //如果info小于root的info，则新结点为root的左结点
root -> left=r;
else //否则为右结点
root -> right=r;
}
else
{
r->right=0; //如果root为空，那么新结点的左右结点都设置为空
r->left=0;
}
return r; //返回新结点的指针的地址
} /* if = = 0 接下页 */
if (info < r->info) //如果输入的info小于r的info
create_btree(r,r->left,info); //递归调用，目的是插入到合适的位置，小则跟左子结点比较，没有就加为左子结点
if(info>=r->info)
create_btree(r,r->right,info); //同理，没有右子节点就加为右子结点
} /* create_btree(root,r,info) */

//查询功能
struct tree *search_btree(struct tree *root,char key)
{
if (!root) //如果跟结点为空，输出该二叉树是一个空二叉树,并返回NULL
{
printf("Emptu btree\n");
return root;
}
while(root->info!=key) //如果当前结点不是要查找的结点
{
if(key<root->info) //如果要查找的结点小于当前结点，当前结点指向当前结点的左结点
root=root->left;
else
root=root->right; //如果key大于当前结点，则当前结点指向当前结点的右结点
if(root==0) //如果root为空，打印查找失败
{
printf("Search Failure\n");
break ;
}
} /* while(root->info!=key) */
if (root !=0) //如果root不为空，也就是上面找到了root->info==key的值
printf("Successful search\n key=%c\n",root->info); //那么返回找到的值
return root ; //分会该值的指针，如果没找到是NULL,找到的话就是找到结点的指针
} /* *search_btree(root,key) */

//二叉树的输出
void print_btree(struct tree *r,int l)
{
int i;
if (r == 0)
return ; //如果r指针为空，该次调用返回
print_btree(r->left,l+1); //调用传入结点的左子结点
for(i=0;i<l;i++) //打印l*2个空格
printf(" ");
printf("%c\n",r->info); //打印出该结点的info值
print_btree(r->right,l+1); //调用传入结点的又子结点
}

void pretra(struct tree *head) //前序遍历
{
if(NULL==head)
{
printf("这是一个空的二叉树!\n");
return;
}
else
{
printf("%c",head->info);
if(head->left!=NULL)
pretra(head->left);
if(head->right!=NULL)
pretra(head->right);
}
}

void midtra(struct tree *head) //中序遍历
{
if(NULL==head)
{
printf("这是一个空的二叉树!\n");
return;
}
else
{
if(head->left!=NULL)
midtra(head->left);
printf("%c",head->info);
if(head->right!=NULL)
midtra(head->right);
}
}

void afttra(struct tree *head) //后序遍历
{
if(NULL==head)
{
printf("这是一个空的二叉树!\n");
return;
}
else
{
if(head->left!=NULL)
afttra(head->left);
if(head->right!=NULL)
afttra(head->right);
printf("%c",head->info);
}
}

⑸ 线索二叉树课程设计

//二叉树的二叉链表存储的基本操作(22个)
Status InitBiTree(BiTree &T)
{ // 操作结果: 构造空二叉树T
T=NULL;
return OK;
}

void DestroyBiTree(BiTree &T)
{ // 初始条件: 二叉树T存在。操作结果: 销毁二叉树T
if(T) // 非空树
{
if(T->lchild) // 有左孩子
DestroyBiTree(T->lchild); // 销毁左孩子子树
if(T->rchild) // 有右孩子
DestroyBiTree(T->rchild); // 销毁右孩子子树
free(T); // 释放根结点
T=NULL; // 空指针赋0
}
}

void CreateBiTree(BiTree &T)
{ // 算法6.4:按先序次序输入二叉树中结点的值（可为字符型或整型，在主程中
// 定义），构造二叉链表表示的二叉树T。变量Nil表示空（子）树。有改动
TElemType ch;
#ifdef CHAR
scanf("%c",&ch);
#endif
#ifdef INT
scanf("%d",&ch);
#endif
if(ch==Nil) // 空
T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode));
if(!T)
exit(OVERFLOW);
T->data=ch; // 生成根结点
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree(T->rchild); // 构造右子树
}
}

Status BiTreeEmpty(BiTree T)
{ // 初始条件: 二叉树T存在
// 操作结果: 若T为空二叉树,则返回TRUE,否则FALSE
if(T)
return FALSE;
else
return TRUE;
}

#define ClearBiTree DestroyBiTree

int BiTreeDepth(BiTree T)
{ // 初始条件: 二叉树T存在。操作结果: 返回T的深度
int i,j;
if(!T)
return 0;
if(T->lchild)
i=BiTreeDepth(T->lchild);
else
i=0;
if(T->rchild)
j=BiTreeDepth(T->rchild);
else
j=0;
return i>j?i+1:j+1;
}

TElemType Root(BiTree T)
{ // 初始条件: 二叉树T存在。操作结果: 返回T的根
if(BiTreeEmpty(T))
return Nil;
else
return T->data;
}

TElemType Value(BiTree p)
{ // 初始条件: 二叉树T存在，p指向T中某个结点
// 操作结果: 返回p所指结点的值
return p->data;
}

void Assign(BiTree p,TElemType value)
{ // 给p所指结点赋值为value
p->data=value;
}

typedef BiTree QElemType; // 设队列元素为二叉树的指针类型
#include"c3-2.h"
#include"bo3-2.cpp"
TElemType Parent(BiTree T,TElemType e)
{ // 初始条件: 二叉树T存在,e是T中某个结点
// 操作结果: 若e是T的非根结点,则返回它的双亲,否则返回＂空＂
LinkQueue q;
QElemType a;
if(T) // 非空树
{
InitQueue(q); // 初始化队列
EnQueue(q,T); // 树根入队
while(!QueueEmpty(q)) // 队不空
{
DeQueue(q,a); // 出队,队列元素赋给a
if(a->lchild&&a->lchild->data==e||a->rchild&&a->rchild->data==e) // 找到e(是其左或右孩子)
return a->data; // 返回e的双亲的值
else // 没找到e,则入队其左右孩子指针(如果非空)
{
if(a->lchild)
EnQueue(q,a->lchild);
if(a->rchild)
EnQueue(q,a->rchild);
}
}
}
return Nil; // 树空或没找到e
}

BiTree Point(BiTree T,TElemType s)
{ // 返回二叉树T中指向元素值为s的结点的指针。另加
LinkQueue q;
QElemType a;
if(T) // 非空树
{
InitQueue(q); // 初始化队列
EnQueue(q,T); // 根结点入队
while(!QueueEmpty(q)) // 队不空
{
DeQueue(q,a); // 出队,队列元素赋给a
if(a->data==s)
return a;
if(a->lchild) // 有左孩子
EnQueue(q,a->lchild); // 入队左孩子
if(a->rchild) // 有右孩子
EnQueue(q,a->rchild); // 入队右孩子
}
}
return NULL;
}

TElemType LeftChild(BiTree T,TElemType e)
{ // 初始条件: 二叉树T存在,e是T中某个结点
// 操作结果: 返回e的左孩子。若e无左孩子,则返回＂空＂
BiTree a;
if(T) // 非空树
{
a=Point(T,e); // a是结点e的指针
if(a&&a->lchild) // T中存在结点e且e存在左孩子
return a->lchild->data; // 返回e的左孩子的值
}
return Nil; // 其余情况返回空
}

TElemType RightChild(BiTree T,TElemType e)
{ // 初始条件: 二叉树T存在,e是T中某个结点
// 操作结果: 返回e的右孩子。若e无右孩子,则返回＂空＂
BiTree a;
if(T) // 非空树
{
a=Point(T,e); // a是结点e的指针
if(a&&a->rchild) // T中存在结点e且e存在右孩子
return a->rchild->data; // 返回e的右孩子的值
}
return Nil; // 其余情况返回空
}

TElemType LeftSibling(BiTree T,TElemType e)
{ // 初始条件: 二叉树T存在,e是T中某个结点
// 操作结果: 返回e的左兄弟。若e是T的左孩子或无左兄弟,则返回＂空＂
TElemType a;
BiTree p;
if(T) // 非空树
{
a=Parent(T,e); // a为e的双亲
p=Point(T,a); // p为指向结点a的指针
if(p->lchild&&p->rchild&&p->rchild->data==e) // p存在左右孩子且右孩子是e
return p->lchild->data; // 返回p的左孩子(e的左兄弟)
}
return Nil; // 树空或没找到e的左兄弟
}

TElemType RightSibling(BiTree T,TElemType e)
{ // 初始条件: 二叉树T存在,e是T中某个结点
// 操作结果: 返回e的右兄弟。若e是T的右孩子或无右兄弟,则返回＂空＂
TElemType a;
BiTree p;
if(T) // 非空树
{
a=Parent(T,e); // a为e的双亲
p=Point(T,a); // p为指向结点a的指针
if(p->lchild&&p->rchild&&p->lchild->data==e) // p存在左右孩子且左孩子是e
return p->rchild->data; // 返回p的右孩子(e的右兄弟)
}
return Nil; // 树空或没找到e的右兄弟
}

Status InsertChild(BiTree p,int LR,BiTree c) // 形参T无用
{ // 初始条件: 二叉树T存在,p指向T中某个结点,LR为0或1,非空二叉树c与T
// 不相交且右子树为空
// 操作结果: 根据LR为0或1,插入c为T中p所指结点的左或右子树。p所指结点的
// 原有左或右子树则成为c的右子树
if(p) // p不空
{
if(LR==0)
{
c->rchild=p->lchild;
p->lchild=c;
}
else // LR==1
{
c->rchild=p->rchild;
p->rchild=c;
}
return OK;
}
return ERROR; // p空
}

Status DeleteChild(BiTree p,int LR) // 形参T无用
{ // 初始条件: 二叉树T存在,p指向T中某个结点,LR为0或1
// 操作结果: 根据LR为0或1,删除T中p所指结点的左或右子树
if(p) // p不空
{
if(LR==0) // 删除左子树
ClearBiTree(p->lchild);
else // 删除右子树
ClearBiTree(p->rchild);
return OK;
}
return ERROR; // p空
}

void PreOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ // 初始条件: 二叉树T存在,Visit是对结点操作的应用函数。算法6.1，有改动
// 操作结果: 先序递归遍历T,对每个结点调用函数Visit一次且仅一次
if(T) // T不空
{
Visit(T->data); // 先访问根结点
PreOrderTraverse(T->lchild,Visit); // 再先序遍历左子树
PreOrderTraverse(T->rchild,Visit); // 最后先序遍历右子树
}
}

void InOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ // 初始条件: 二叉树T存在,Visit是对结点操作的应用函数
// 操作结果: 中序递归遍历T,对每个结点调用函数Visit一次且仅一次
if(T)
{
InOrderTraverse(T->lchild,Visit); // 先中序遍历左子树
Visit(T->data); // 再访问根结点
InOrderTraverse(T->rchild,Visit); // 最后中序遍历右子树
}
}

typedef BiTree SElemType; // 设栈元素为二叉树的指针类型
#include"c3-1.h"
#include"bo3-1.cpp"
Status InOrderTraverse1(BiTree T,Status(*Visit)(TElemType))
{ // 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。算法6.3
// 中序遍历二叉树T的非递归算法(利用栈)，对每个数据元素调用函数Visit
SqStack S;
InitStack(S);
while(T||!StackEmpty(S))
{
if(T)
{ // 根指针进栈,遍历左子树
Push(S,T);
T=T->lchild;
}
else
{ // 根指针退栈,访问根结点,遍历右子树
Pop(S,T);
if(!Visit(T->data))
return ERROR;
T=T->rchild;
}
}
printf("\n");
return OK;
}

Status InOrderTraverse2(BiTree T,Status(*Visit)(TElemType))
{ // 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。算法6.2
// 中序遍历二叉树T的非递归算法(利用栈)，对每个数据元素调用函数Visit
SqStack S;
BiTree p;
InitStack(S);
Push(S,T); // 根指针进栈
while(!StackEmpty(S))
{
while(GetTop(S,p)&&p)
Push(S,p->lchild); // 向左走到尽头
Pop(S,p); // 空指针退栈
if(!StackEmpty(S))
{ // 访问结点,向右一步
Pop(S,p);
if(!Visit(p->data))
return ERROR;
Push(S,p->rchild);
}
}
printf("\n");
return OK;
}

void PostOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ // 初始条件: 二叉树T存在,Visit是对结点操作的应用函数
// 操作结果: 后序递归遍历T,对每个结点调用函数Visit一次且仅一次
if(T) // T不空
{
PostOrderTraverse(T->lchild,Visit); // 先后序遍历左子树
PostOrderTraverse(T->rchild,Visit); // 再后序遍历右子树
Visit(T->data); // 最后访问根结点
}
}

void LevelOrderTraverse(BiTree T,Status(*Visit)(TElemType))
{ // 初始条件：二叉树T存在,Visit是对结点操作的应用函数
// 操作结果：层序递归遍历T(利用队列),对每个结点调用函数Visit一次且仅一次
LinkQueue q;
QElemType a;
if(T)
{
InitQueue(q);
EnQueue(q,T);
while(!QueueEmpty(q))
{
DeQueue(q,a);
Visit(a->data);
if(a->lchild!=NULL)
EnQueue(q,a->lchild);
if(a->rchild!=NULL)
EnQueue(q,a->rchild);
}
printf("\n");
}
}

⑹ 二叉树排序算法实现（数据结构课程设计）

#include <malloc.h>
#include<stdio.h>
#define NUM 7 //宏定义
int i; //变量类型定义
typedef struct Node{
int data ; //数据域
struct Node *next; //指针域
}Node,*LNode; //用结构体构造结点及相应的指针

typedef struct Tree{
int data ;
struct Tree *left ;
struct Tree *right ;
}Tree,*LTree ; //用结构体构造树及相应的指针

CreateList( LNode Head ) //创建单链表
{
for(int i=1 ; i <=NUM ; i++) //创建循环，依次输入NUM个数据
{
LNode temp ; //中间结点
temp = (LNode) malloc( sizeof( Node ) ); //动态存储分配

temp-> next = NULL; //中间结点初始化
scanf("%2d",&temp-> data); //输入赋值到结点temp数据域
temp-> next = Head-> next ;
Head-> next = temp ; //将temp结点插入链表

}
return 1 ;//返回1
}

InsertSqTree( LTree &root , LNode temp ) //二叉树排序原则的设定
{
if(!root) //root为NULL时执行
{
root = (LTree)malloc(sizeof(Tree)); //动态存储分配

root-> left =NULL;
root-> right=NULL; //初始化
root-> data = temp-> data ; //赋值插入
return 1 ; //函数正常执行，返回1
}
else
{
if(root-> data>= temp-> data)
return InsertSqTree( root-> left , temp ) ; //比较插入左子树
else if(root-> data <temp-> data)
return InsertSqTree( root-> right , temp ); //比较插入右子树
}
return 1 ; //如果满足，就不做处理，返回1
}

void BianLiTree(LTree root) //采用中序遍历，实现将所有数字按从左向右递增的顺序排序
{
if(root) //root不为空执行
{BianLiTree(root-> left); //左递归处理至叶子结点，当root-> left为NULL时不执行
printf("%4d ",root-> data); //输出
BianLiTree(root-> right); //处理右结点
}
}

int main()
{
LNode Head = NULL;
LTree root = NULL ; //初始化
Head = (LNode) malloc(sizeof(Node)); //动态存储分配

Head-> next = NULL ; //初始化
printf("please input numbers:\n");//输入提示语句
if(!CreateList( Head )) //建单链表成功返回1不执行下一语句
return 0; //结束函数，返回0
LNode temp = Head-> next ; //将头指针的指针域赋值予中间结点
while( temp ) //temp为NULL时停止执行
{
if(!InsertSqTree( root ,temp )) //排序正常执行，返回1不执行下一语句
return 0 ; //结束函数，返回0
Head-> next = temp-> next ; //将中间指针的指针域赋值予头结点指针域
free(temp); //释放空间
temp = Head-> next ; //将头指针的指针域赋值予中间结点，以上三句实现了temp指针后移
}
printf("the result is:\n");//输出提示语句
BianLiTree(root); //采用中序遍历，输出并观察树结点
return 1; //函数正常结，返回1
}

⑺ 课程设计题二：二叉树的基本操作 一、 设计目的 1．掌握二叉树的概念和性质 2. 掌握任意二叉树存储结构。

自己写啊。。这个东西很简单的。上大学总要会点东西吧。。。

⑻ 数据结构课程设计 求二叉树上结点的路径

#include <stdio.h>
#include<malloc.h>
#define MAXSIZE 20
#define exit 0
typedef struct btnode
{
char cdata;
struct btnode *lchild,*rchild;
}BTNode;
BTNode *Create_BiTree()/*二叉树的建立*/
{
/*用辅助数组建立二叉树*/
int i,j;
char ch;
BTNode *s,*t,*p[MAXSIZE];
printf("\t=========数据结构=======RANBO========\n");
printf("\t=========二叉树基本操作==============\n");
printf("输入顶点编号及信息，输入0和#结束:i,ch\n");
scanf("%d,%c",&i,&ch);
while (i!=0 &&ch!='#')/*建立二叉树的存储结构*/
{
s=(BTNode *)malloc(sizeof(BTNode));
s->cdata=ch;
s->lchild=s->rchild=NULL;
p[i]=s;
if (i==1) t=s;/*判断输入结点是根结点、左孩子还是右孩子*/
else
{
j=i/2;
if (i%2==0) p[j]->lchild=s;
else p[j]->rchild=s;
}
printf("输入顶点编号及信息，输入0和#结束:i,ch\n");
scanf("%d,%c",&i,&ch);
}
return t;
}/* Create_BiTree1*/
void Preorder(BTNode *bt)
{
/*前序递归遍历*/
if (bt)
{
printf("%c",bt->cdata);
Preorder(bt->lchild);
Preorder(bt->rchild);
}
}/* Preorder*/
void Inorder(BTNode *bt)
{
/*中序递归遍历*/
if (bt)
{
Inorder(bt->lchild);
printf("%c",bt->cdata);
Inorder(bt->rchild);
}
}/* Inorder*/
void Postorder(BTNode *bt)
{
/*后序递归遍历*/
if (bt)
{
Postorder(bt->lchild);
Postorder(bt->rchild);
printf("%c",bt->cdata);
}
}/* Postorder*/
void LevelOrder(BTNode *bt) /*层次遍历二叉树bt*/
{
BTNode* queue[MAXSIZE];
int front,rear;
if (bt==NULL) return;
front=0; /*非循环队列*/
rear=0;
queue[rear++]=bt;
while (front!=rear)
{
printf("%c",queue[front]->cdata); /*访问队首结点的数据域*/
if (queue[front]->lchild!=NULL) /*将队首结点的左孩子指针入队列*/
{
queue[rear]=queue[front]->lchild;
rear++;
}
if (queue[front]->rchild!=NULL) /*将队首结点的右孩子指针入队列*/
{
queue[rear]=queue[front]->rchild;
rear++;
}
front++;
} /* while */
}/* LevelOrder*/
int main()
{
int i,j=1;
BTNode *t;
t=Create_BiTree();
while (j)
{
printf("\n"); /*功能菜单*/
printf("请选择操作:\n");
printf("1: 二叉树的前序遍历\n");
printf("2: 二叉树的中序遍历\n");
printf("3: 二叉树的后序遍历\n");
printf("4: 二叉树的层次遍历\n");
printf("0: 退出程序\n");
scanf("%d",&j);
switch (j)
{
case 0:
printf(" 程序退出!\n ");
exit(0);
case 1:
printf("前序遍历结果:\n");
Preorder(t);
break;
case 2:
printf("中序遍历结果:\n");
Inorder(t);
break;
case 3:
printf("后序遍历结果:\n");
Postorder(t);
break;
case 4:
printf("按层遍历结果:\n");
LevelOrder(t);
break;
default :
printf("\n输入无效，请重新选择操作!\n" );
break;
}
}
}

⑼ 排序二叉树的遍历课程设计（跪求参考）

我们刚做完的实验。希望帮到您：
#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
int right=0;
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

void CreateBiTree(BiTree *T)
{
TElemType ch;
scanf("%c",&ch);
if(ch==' ')
*T=NULL;
else
{
*T=(BiTree)malloc(sizeof(BiTNode));
if(!*T) exit(-1);
(*T)->data=ch;
CreateBiTree(&(*T)->lchild);
CreateBiTree(&(*T)->rchild);
}

}

void PreOrderTraverse(BiTree T)
{
if(T)
{
printf("%c",T->data);
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
if(T->rchild) right++;
}

}

void InOrderTraverse(BiTree T)
{
if(T)
{
InOrderTraverse(T->lchild);
printf("%c",T->data);
InOrderTraverse(T->rchild);
}

}

void PostOrderTraverse(BiTree T)
{

if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
printf("%c",T->data);
}
}

void DestroyBiTree(BiTree *T)
{
if(*T)
{
if((*T)->lchild)
DestroyBiTree(&((*T)->lchild));
if((*T)->rchild)
DestroyBiTree(&((*T)->rchild));
free(*T);
*T=NULL;
}
}

int main()
{
BiTree T;

printf("请输入建立二叉树的字符序列(包括空格):\n");
CreateBiTree(&T);

printf("\n先序递归遍历二叉树:\n");
PreOrderTraverse(T);

printf("\n中序递归遍历二叉树:\n");
InOrderTraverse(T);

printf("\n后序递归遍历二叉树:\n");
PostOrderTraverse(T);

DestroyBiTree(&T);
printf(":\n");
printf("\n二叉树T的右子树的结点的个数:%d",right);
printf("\n");
return 0;
}

⑽ 《数据结构》的课程设计，题目是请设计一个算法，把二叉树的叶子结点按从左到右的顺序连成。

下面是函数
//定义二叉树链式结构
typedef struct BitNode
{
char data; //数据域
struct BitNode *lchild,*rchild;//左右指针域
}BitNode,*BiTree;

//叶子节点从左到右依次存入链表中
//bt-二叉树,head-表头,pre-前趋节点
void LeafLink(BiTree bt,BiTree &head,BiTree &pre)
{
if(bt!=NULL)
{
LeafLink(bt->lchild,head,pre);

if(bt->lchild==NULL&&bt->rchild==NULL)//叶子节点
{
BiTree s;

s=(BiTree)malloc(sizeof(BitNode));
if(s==NULL)
{
printf("建立单链表申请内存出错\n");
exit(-1);
}
memcpy(s,bt,sizeof(BitNode));//内存拷贝,不破坏原二叉树信息
if(pre==NULL)//第一个叶子节点
{
head=s;
pre=s;
}
else
{
pre->rchild=s;
pre=s;
}
}

LeafLink(bt->rchild,head,pre);

pre->rchild=NULL;//最后节点后续为空

}
}