二叉树编程实例

① 二叉树问题编程

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

typedef struct BiTNode{
char data;
struct BiTNode *Lchild,*Rchild;
}BiTNode,*BiTree;
//创建二拍绝数叉树
void CreateBiTree(BiTree &T)
{
char ch;
scanf("%c",&ch);
if(ch==' ')T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));
T->data=ch;
CreateBiTree(T->Lchild);
CreateBiTree(T->Rchild);
}
}
//求二叉树的高度
int BiTreeHeight(BiTree &T)
{
int l=0,r=0;
if(T->Lchild)
l=BiTreeHeight(T->Lchild)+1;
if(T->Rchild)
r=BiTreeHeight(T->Rchild)+1;
if(T->Lchild==NULL && T->Rchild==NULL)
l=1;
if(l>=r)
return l;
else return r;
}
//求二叉树的结点个数
int All_BiTNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else i=All_BiTNode(T->Lchild)+All_BiTNode(T->Rchild)+1;
return i;
}
//求二叉树出度为0的结点个数
int Out0_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else if(T->Lchild==NULL && T->Rchild==NULL)
i++;
else i=Out0_BitNode(T->Lchild)+Out0_BitNode(T->Rchild);
return i;
}
//求二叉树出度为1的结点个数
int Out1_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else
{
i=Out1_BitNode(T->Lchild)+Out1_BitNode(T->Rchild);
if(T->Lchild==NULL && T->Rchild ||T->Lchild && T->Rchild==NULL)
i++;
}

return i;
}
/宏清/求二叉树出度为2的结点个数
int Out2_BitNode(BiTree &T)
{
int i=0;
if(T==NULL)
return 0;
else
{
i=Out2_BitNode(T->Lchild)+Out2_BitNode(T->Rchild);
if(T->Lchild && T->Rchild)
i++;
}
return i;
}
//复制二叉树袭首
BiTree Copy_BiTree(BiTree &T)
{
BiTree _T;
if(T)
{
_T=(BiTNode *)malloc(sizeof(BiTNode));
_T->data=T->data;
_T->Lchild=Copy_BiTree(T->Lchild);
_T->Rchild=Copy_BiTree(T->Rchild);
}
else return NULL;
return _T;
}
//交换二叉树的左右子树
BiTree Exchange_Left_Right(BiTree &T)
{
BiTree p;
if(T==NULL)
return T;
else
{
p=Exchange_Left_Right(T->Lchild);
T->Lchild=Exchange_Left_Right(T->Rchild);
T->Rchild=p;
}
return T;
}
//判断两棵树相似
int BiTree_Resemble(BiTree &T1,BiTree &T2)
{
int l,r;
if(T1==NULL && T2==NULL)
return 1;
else if(T1==NULL && T2 || T1 && T2==NULL)
return 0;
l=BiTree_Resemble(T1->Lchild,T2->Lchild);
r=BiTree_Resemble(T1->Rchild,T2->Rchild);
if(l==1 && r==1)
return 1;
else
return 0;
}

void main()
{
char clear;
int i=0;
BiTree T,T2,_T;
CreateBiTree(T);
scanf("%c",&clear);
CreateBiTree(T2);
scanf("%c",&clear);
/* printf("二叉树的高度为：%d\n",BiTreeHeight(T));
printf("总结点个数为：%d\n",All_BiTNode(T));
printf("度数为0的结点个数为：%d\n",Out0_BitNode(T));
printf("度数为1的结点个数为：%d\n",Out1_BitNode(T));
printf("度数为2的结点个数为：%d\n",Out2_BitNode(T));
_T=Copy_BiTree(T);
*/
i=BiTree_Resemble(T,T2);
if(i==1)
printf("相似\n");
else printf("不相似\n");
}

② 用C语言编程实现二叉树的基本操作，并完成下述函数功能： (1) CreateBiTree( )：根据先序遍历序列生成一棵

下面有一个建树的例子。
class TreeNode{
public:
TreeNode *left;
TreeNode *right;
int value;
TreeNode(int v): value(v)
{
left = NULL;
right = NULL;
}
~TreeNode() {
if (left != NULL) delete left;
if (right != NULL) delete right;
}
};

void addToTree(TreeNode *curr, TreeNode *p) {
if(p->value <= curr->value) {
if(curr->left == NULL) {
curr->left = p;
return;
}
else addToTree(curr->left, p);
} else {
if(curr->right == NULL) {
curr->right = p;
return;
}
else addToTree(curr->right, p);
}
}
void printTree(TreeNode *p) {
if(p==NULL) return;
printTree(p->left);
printf("%d ", p->value);
printTree(p->right);
}
TreeNode * createBiTree(int[] a, int len)
{
TreeNode *root = new TreeNode(a[0]);
for(int i=1; i<5; i++) {
TreeNode *p = new TreeNode(a[i]);
addToTree(root, p);
}
return root;
}

void main() {
int a[] = {3, 4, 1, 2, 5};
CreateBiTeee(a, 5);
printTree(root);
delete root;
}

③ 用c语言实现二叉树的程序，可以输入输出和遍历

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

const int MaxLength=10;//结点个数不超过10个

typedef struct tree
{
char data;
struct tree *lchild,*rchild;
}tree;
//先序递归 建立二叉树
void Createbitree(tree* &T)
{
char ch;
ch=getchar();
if(ch=='#')
T=NULL;
else
{
T=(tree*)malloc(sizeof(tree));
T->data =ch;
Createbitree(T->lchild );
Createbitree(T->rchild );
}
}
//先序递归遍历
void PreOrderTraverse(tree* T)
{
if(T)
{
cout<<T->data;
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
//中序递归遍历
void InOrderTraverse(tree* T)
{
if(T)
{
InOrderTraverse(T->lchild);
cout<<T->data;
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(tree* T)
{
if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data;
}
}
//层序遍历
void LevelOrderTraverse(tree* T)
{
tree* Q[MaxLength];
int front=0,rear=0;
tree* p;
if(T)//根结点入队
{
Q[rear]=T;
rear=(rear+1)%MaxLength;
}
while(front!=rear)
{
p=Q[front]; //队头元素出队
front=(front+1)%MaxLength;
cout<<p->data;
if(p->lchild)//左孩子不为空，入队
{
Q[rear]=p->lchild;
rear=(rear+1)%MaxLength;
}
if(p->rchild)//右孩子不为空，入队
{
Q[rear]=p->rchild;
rear=(rear+1)%MaxLength;
}
}
}
//主函数
void main()
{
cout<<"请按先序次序输入二叉树的数据:"<<endl;
tree* T;
Createbitree(T);
cout<<"二叉树的先序序列为:"<<endl;
PreOrderTraverse(T);
cout<<endl<<"二叉树的中序序列为:"<<endl;
InOrderTraverse(T);
cout<<endl<<"二叉树的后序序列为:"<<endl;
PostOrderTraverse(T);
cout<<endl<<"二叉树的层序序列为:"<<endl;
LevelOrderTraverse(T);
cout<<endl;
}
比如 1
2 3
4 5 6 7
按先序输入是124##5##36##7##

④ C语言编程题建立二叉树

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

#define ERROR 0
#define OK 1
#define OVERFLOW -2
#define FLASE 0
#define TURE 1

typedef int Status;
typedef char TElemType;

typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;

//构造一个二叉树
Status CreateBiTree(BiTree &T){
TElemType str[]="ABC$$D$EF$$G$$$";

static int i=0;

TElemType ch;
ch=str[i++];

if(ch=='$')
T=NULL;
else{
//创建树结点雀汪
T=(BiTNode*)malloc(sizeof(BiTNode));
if(!T) exit(OVERFLOW);
T->data=ch;

//创建左子树
CreateBiTree(T->顷戚仔lchild);

//创建右子树
CreateBiTree(T->rchild);
}

return OK;
}

//输出元素data
Status PrntTElem(TElemType data){
putchar(data);

return OK;
}

//先序遍历二叉树
Status PreOrderTraverse(BiTree T,Status(*visit)(TElemType e)){
if(T){
if((*visit)(T->data))
if(PreOrderTraverse(T->lchild,visit))
if(PreOrderTraverse(T->rchild,visit))
return OK;
return ERROR;
}
else return OK;
}

/仔世/中序遍历二叉树
Status InOrderTraverse(BiTree T,掸袱侧惶乇耗岔同唱括Status(*visit)(TElemType e)){
if(T){
if(InOrderTraverse(T->lchild,visit))
if(visit(T->data))
if(InOrderTraverse(T->rchild,visit))
return OK;
return ERROR;
}
else return OK;
}

//后序遍历二叉树
Status PostOrderTraverse(BiTree T,Status(*visit)(TElemType e)){
if(T){
if(PostOrderTraverse(T->lchild,visit))
if(PostOrderTraverse(T->rchild,visit))
if(visit(T->data))
return OK;
return ERROR;
}
else return OK;
}

/ /求二叉树深度
int BiTreeDepth(BiTree T){
int ldep=0,rdep=0;
if(T==NULL)
return 0;
ldep=BiTreeDepth(T->lchild);
rdep=BiTreeDepth(T->rchild);
if(ldep>=rdep)
return ldep+1;
else
return rdep+1;
}
//求叶子数
int BiTreeLeaves(BiTree T){
if(!T)
return 0;
else if(!T->lchild&&!T->rchild)
return 1;
else
return BiTreeLeaves(T->lchild)+BiTreeLeaves(T->rchild);
}

//销毁
int DestroyBiTree(BiTree &T){
if(T){
if(DestroyBiTree(T->lchild))
if(DestroyBiTree(T->rchild))
T=NULL;
}
return OK;
}

void main()
{
BiTree T;

CreateBiTree(T);

printf("先序结果为:");
PreOrderTraverse(T,PrntTElem);

printf("\n中序结果为:");
InOrderTraverse(T,PrntTElem);

printf("\n后序结果为:");
PostOrderTraverse(T,PrntTElem);

printf("\n二叉树的深度为: %d\n",BiTreeDepth(T));

printf("叶子数为: %d\n",BiTreeLeaves(T));

DestroyBiTree(T);

printf("先序结果为:");
PreOrderTraverse(T,PrntTElem);

printf("\n中序结果为:");
InOrderTraverse(T,PrntTElem);

printf("\n后序结果为:");
PostOrderTraverse(T,PrntTElem);

printf("\n");
}

⑤ 数据结构二叉树的程序，用c语言怎么实现

您好，想哪链手要实现一个二叉树，需要用到结构体来存储每个节点的信息，并使用指针来存储每个节点的左右子节点的地址。具体的实现方法唤物可以参考下面的代码示例：

#include <stdio.h>

#include <stdlib.h>

struct TreeNode {

int val;

struct TreeNode *left;

struct TreeNode *right;

};

struct TreeNode* createNode(int val) {

struct TreeNode* node = (struct TreeNode*) malloc(sizeof(struct TreeNode));

node->val = val;

node->left = NULL;

node->right = NULL;

return node;

}

void insertNode(struct TreeNode* root, int val) {

if (root == NULL) {

return;

}

if (val < root->李嫌val) {

if (root->left == NULL) {

root->left = createNode(val);

} else {

insertNode(root->left, val);

}

} else {

if (root->right == NULL) {

root->right = createNode(val);

} else {

insertNode(root->right, val);

}

}

}

void printTree(struct TreeNode* root) {

if (root == NULL) {

return;

}

printf("%d ", root->val);

printTree(root->left);

printTree(root->right);

}

int main() {

struct TreeNode* root = createNode(5);

insertNode(root, 3);

insertNode(root, 2);

insertNode(root, 4);

insertNode(root, 7);

insertNode(root, 6);

insertNode(root, 8);

printTree(root);

return 0;

}

在这段代码中，我们定义了一个结构体 TreeNode 来表示二叉树的每个节点，结构体中包含了一个节点的数值 val，以及指向左子节点和右子节点的指针 left 和 right。

⑥ 编写一个程序，实现二叉树的先序遍历，中序遍历，后序遍历的各种递归和非递归算法，以及层次遍历的算法

文件 main.cpp 代码如下：

#include<malloc.h> // malloc()等
#include<stdio.h> // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等
#include<stdlib.h> // atoi()，exit()
#include<math.h> // 数学函数头文件，包括floor()，ceil()，abs()等

#define ClearBiTree DestroyBiTree // 清空二叉树和销毁二叉树的操作一样

typedef struct BiTNode
{
int data; // 结点的值
BiTNode *lchild,*rchild; // 左右孩子指针
}BiTNode,*BiTree;

int Nil=0; // 设咐凯整型以0为空
void visit(int e)
{ printf("%d ",e); // 以整型格式输出
}
void InitBiTree(BiTree &T)
{ // 操作结果：构造空二叉树T
T=NULL;
}

void CreateBiTree(BiTree &T)
{ // 算法6.4：按先序次序输入二叉树中结点的值(可为字符型或整型，在主程中定义)，
// 构造二叉链表表示的二叉树T。变量Nil表示空(子)树。修改
int number;
scanf("%d",&number); // 输入结点的值
if(number==Nil) // 结点镇简中的值为空
T=NULL;
else // 结点的值不为空
{ T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点
if(!T)
exit(OVERFLOW);
T->data=number; // 将值赋给T所指结点
CreateBiTree(T->lchild); // 递归构造左子树
CreateBiTree(T->rchild); // 递归构造右子树
}
}

void DestroyBiTree(BiTree &T)
{ // 初始条件：二叉树T存在。操作结果：销毁二叉树T
if(T) // 非空树
{ DestroyBiTree(T->lchild); // 递归销毁左子树，如无左子树，则不执行任何操作
DestroyBiTree(T->rchild); // 递归销毁右子树，如无御山右子树，则不执行任何操作
free(T); // 释放根结点
T=NULL; // 空指针赋0
}
}

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

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

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

void main()
{
BiTree T;
InitBiTree(T); // 初始化二叉树T
printf("按先序次序输入二叉树中结点的值,输入0表示节点为空，输入范例：1 2 0 0 3 0 0\n");
CreateBiTree(T); // 建立二叉树T
printf("先序递归遍历二叉树：\n");
PreOrderTraverse(T,visit); // 先序递归遍历二叉树T
printf("\n中序递归遍历二叉树：\n");
InOrderTraverse(T,visit); // 中序递归遍历二叉树T
printf("\n后序递归遍历二叉树：\n");
PostOrderTraverse(T,visit); // 后序递归遍历二叉树T
}
这样可以么？

⑦ 用C++写一个二叉树的程序

#include <stdio.h>
#include <stdlib.h>
typedef struct {
char data;
int weight;
} bitree_data_t;

typedef struct bitree
{
bitree_data_t data;
struct bitree *lchild, *rchild;
}bitree_t;

typedef bitree_t * data_t;
typedef struct linknode {
data_t data;
struct linknode *next;
}linknode_t, linkstack_t, linklist_t;

//创建一个链表
//1. 在内存总开辟头结点的空间malloc
//2. 将头结点的next域置空NULL
//3. 返回创建并设置好的链表的首地址
linklist_t *create_linklist()
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->next = NULL;

return node;
}

//判断当前链表是否为空
int empty_linklist(linklist_t *ll)
{
return ll->next == NULL;
}
//求链表中当前有效元素的个数
int length_linklist(linklist_t *ll)
{
int length = 0;
while(ll->next != NULL)
{
ll = ll->next;
length++;
}

return length;
}
//获得下标为index位置的元素，成功返回0，失败返回-1
//1. 判断index是否合法(部分判断)
//2. 在保证ll->next 不为空的清空下，将ll的首地址向后移动index次
//3. 判断ll->next 是否等于空，如果等于空，则返回-1，如果不为空，执行4.
//4. 当移动了index次之后，当前ll->next 的位置的节点就保存了我要获得的
//数据
//5. *data = ll->next->data;
//6. 返回0
int get_linklist(linklist_t *ll, int index, data_t *data)
{
int i;
if(index < 0)
return -1;

for(i = 0; ll->next != NULL && i < index; i++)
{
ll = ll->next;
}

if(ll->next == NULL)
return -1;

*data = ll->next->data;
return 0;
}
//使用头插法插入一个元素
//1. 创建一个节点node
//2. 将要插入的数据保存到node
//3. 执行插入操作
//4. 返回0
int insert_linklist(linklist_t *ll, data_t *data)
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->data = *data;

node->next = ll->next;
ll->next = node;
return 0;
}
//删除链表中的一个节点:删除头结点的后一个位置(头删法)
//首先可以判断当前链表是否为空，如果为空返回-1
//如果不为空则删除头结点的下一个位置的节点
//最后返回0
int delete_linklist(linklist_t *ll)
{
linknode_t *node;
if(empty_linklist(ll))
return -1;
node = ll->早锋猛next;
ll->next = node->next;
free(node);

return 0;
}
//清空链表
//循环删除链表的一个节点，然后判断删除函数的返回值是否为0
/陆桥/如果为0，继续删除，如果为-1则停止循环
int clear_linklist(linklist_t *ll)
{
while(delete_linklist(ll) == 0);
return 0;
}
/基做/销毁链表
//1. 调用清空操作清空链表
//2. 删除头结点
//3. 返回0
int detory_linklist(linklist_t *ll)
{
clear_linklist(ll);
free(ll);
return 0;
}

void preorder(bitree_t *root)
{
if(root == NULL)
return ;
printf("[%c,%d]", root->data.data, root->data.weight);
preorder(root->lchild);
preorder(root->rchild);

return;
}

int insert_order_linklist(linklist_t *ll, data_t *data)
{
linknode_t *node = (linknode_t *)malloc(sizeof(linknode_t));
node->data = *data;
while(ll->next != NULL && ll->next->data->data.weight < node->data->data.weight)
{
ll = ll->next;
}

node->next = ll->next;
ll->next = node;

return 0;
}

bitree_t *huffman_bitree(linklist_t *ll)
{
bitree_t *node1, *node2, *root;
while(ll->next != NULL && ll->next->next != NULL)
{
get_linklist(ll, 0, &node1);
delete_linklist(ll);
get_linklist(ll, 0, &node2);
delete_linklist(ll);

root = (bitree_t *)malloc(sizeof(bitree_t));
root->data.data = '#';
root->data.weight = node1->data.weight + node2->data.weight;
root->lchild = node1;
root->rchild = node2;
insert_order_linklist(ll, &root);
}
get_linklist(ll, 0, &root);
delete_linklist(ll);

return root;
}

int main(void)
{
bitree_data_t data;
bitree_t *leaf;
linklist_t *ll;
ll = create_linklist();

while(scanf("[%c,%d]", &data.data, &data.weight) == 2)
{
getchar();

leaf = (bitree_t *)malloc(sizeof(bitree_t));
leaf->lchild = leaf->rchild = NULL;
leaf->data = data;
insert_order_linklist(ll, &leaf);
}
leaf = huffman_bitree(ll);
preorder(leaf);
putchar(10);
return 0;
}

⑧ 二叉树c语言实现

#include<iostream.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct node {
char data;
struct node *lchild,*rchild;//
}BiTNode,*BiTree;
void CreatBiTree(BiTree &T)
{
char ch;
ch=getchar();
if (ch == ' ')
T = 0;
else {
T=(BiTNode*)malloc(sizeof(BiTNode));
T->data=ch;//生成根节点
CreatBiTree(T->lchild);//构造左子树
CreatBiTree(T->rchild);//构造右子树
}
}
void preorder(BiTree T)//前序遍历
{
if (T!=NULL){
printf ("%c",T->data);
preorder(T->lchild);
preorder(T->rchild);
}
}
void inorder(BiTree T)//中序遍历
{
if (T!=NULL){
inorder(T->lchild);
printf ("%c",T->data);
inorder(T->rchild);
}
}
void postorder(BiTree T)//后序遍历
{
if (T!=NULL){
postorder(T->lchild);
postorder(T->rchild);
printf ("%c",T->data);
}
}
void main ()
{
cout<<"请输入要创建的二叉树包括空格:"<<endl ;
BiTree T;
CreatBiTree(T);//创建二叉树
cout<<"前序遍历的结果为:"<<endl;
preorder(T);
cout<<endl;
cout<<"中序遍历的结果为:"<<endl;
inorder(T);
cout<<endl;
cout<<"后序遍历的结果为:"<<endl;
postorder(T);
}

⑨ 用C语言编程 ：建立三层二叉树，先根遍历输出，在线求高手

A
(B C)
(D E) (F G)

以这课树为例

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

typedef char Elem;

typedef struct Node
{
Elem data;
struct Node *pLchild;
struct Node *pRchild;
}BTreeNode, *BTree;

BTree CreateBTree(BTree T, Elem *str)//创建二叉树旅塌
{
static int i = 0;

if ('0' == str[i])
{
T = NULL;
}
else
{
T = (BTree) malloc (sizeof(BTreeNode));
T->data = str[i++];

T->pLchild = CreateBTree(T->pLchild, str);
i++;
T->pRchild = CreateBTree(T->pRchild, str);
}

return T;
}

void PostTraverseBTree(BTree T)//后序
{
if (NULL != T)
{
PostTraverseBTree(T->pLchild);
PostTraverseBTree(T->pRchild);
printf("%c ", T->data);
}
}

void InTraverseBTree(BTree T)//中序
{
if (NULL != T)
{
InTraverseBTree(T->pLchild);
printf("%c ", T->data);
InTraverseBTree(T->pRchild);
}
}

void PreTraverseBTree(BTree T)//拆返圆先序
{
if (NULL != T)
{
printf("%c ", T->data);
PreTraverseBTree(T->pLchild);
PreTraverseBTree(T->pRchild);
}
}

int main(void)
{
BTree T = NULL;

Elem str[] = "ABD00E00CF00G00";

T = CreateBTree(T, str);
printf("\n\n");

printf("先世嫌序遍历:\n");
PreTraverseBTree(T);
printf("\n\n");

printf("中序遍历:\n");
InTraverseBTree(T);
printf("\n\n");

printf("后序遍历:\n");
PostTraverseBTree(T);
printf("\n\n");
}

⑩ 用C语言编写程序，创建一个二叉树的二叉链表结构，然后输出从根结点到所有叶子结点的路径。

#include
#include
#include
typedef
struct
node
{
char
data;
struct
node
*lchild;
struct
node
*rchild;
}tnode;
tnode
*createtree()
{
tnode
*t;
char
ch;
ch=getchar();
if(ch=='0')
t=null;
else
{
t=(tnode
*)malloc(sizeof(tnode));
t->data=ch;
t->lchild=createtree();
t->rchild=createtree();
}
return
t;
}
void
listtree(tnode
*t)
{
if
(t!=null)
{
printf("%c",t->data);
if(t->lchild!=null||t->rchild!=null)
{
printf("(");
listtree(t->lchild);
if(t->rchild!=null)
printf(",");
listtree(t->rchild);
printf(")");
}
}
}
void
inorder(tnode
*t)
{
if(t!=null)
{
inorder(t->lchild);
printf("%c\t",t->data);
inorder(t->rchild);
}
}
void
leve(tnode
*t)
{
tnode
*quee[100];
int
front,rear;
front=-1;
rear=0;
quee[rear]=t;
while(front!=rear)
{
front++;
printf("%c\t",quee[front]->data);
if(quee[front]->lchild!=null)
{
rear++;
quee[rear]=quee[front]->lchild;
}
if(quee[front]->rchild!=null)
{
rear++;
quee[rear]=quee[front]->rchild;
}
}
}
main()
{
tnode
*t=null;
printf("请输入二叉树元素：");
t=createtree();
printf("广义表的输出：");
listtree(t);
printf("喊败\n");
printf("二叉树的中序遍历：");
inorder(t);
printf("\n");
printf("二叉树的层滚渗滚次遍历：");
leve(t);
printf("\n");
system("pause"大余);
}
/*
输入：ab00cd00e00f000
输出：a(b,c((d,e))
中序遍历：
b
a
d
c
e
层次遍历：a
b
c
d
e
*/