涉及到c語言樹的程序

Ⅰ c語言 樹的生成和遍歷

#include //頭文件
#include
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}
BiTNode,*BiTree;//定義結點類型
BiTree CreateBiTree()//創建樹
{
char p;BiTree T;
scanf("%c",&p);
if(p==' ')
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));//為結點開辟空間
T->data=p;
T->lchild=CreateBiTree();
T->rchild=CreateBiTree();
}
return (T);
}
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()//主函數
{
BiTree Ta;
Ta=CreateBiTree();
printf("先序遍歷:");
printf("\n");
PreOrder(Ta);
printf("\n");
printf("中序遍歷:");
printf("\n");
InOrder(Ta);
printf("\n");
printf("後序遍歷:");
printf("\n");
PostOrder(Ta);
}
給你個簡單的例子：
AB***
其中*代表空格
復雜點的例子
ABC**DE*f**g***
其中*代表空格

Ⅱ 用C語言實現樹的建立和三種遍歷

#include <stdio.h>//頭文件
#include <stdlib.h>
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}
BiTNode,*BiTree;//定義結點類型
BiTree CreateBiTree()//創建樹
{
char p;BiTree T;
scanf("%c",&p);
if(p==' ')
T=NULL;
else
{
T=(BiTNode *)malloc(sizeof(BiTNode));//為結點開辟空間
T->data=p;
T->lchild=CreateBiTree();
T->rchild=CreateBiTree();
}
return (T);
}
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()//主函數
{
BiTree Ta;
Ta=CreateBiTree();
printf("先序遍歷:");
printf("\n");
PreOrder(Ta);
printf("\n");
printf("中序遍歷:");
printf("\n");
InOrder(Ta);
printf("\n");
printf("後序遍歷:");
printf("\n");
PostOrder(Ta);
}
給你個簡單的例子：
AB***
其中*代表空格
復雜點的例子
ABC**DE*f**g***
其中*代表空格

Ⅲ 二叉樹的C語言程序求教

typedef char DataType;//給char起個別名 DataType

//定義二叉樹的數據結構
typedef struct node{
DataType data;//二叉樹存儲的數據
struct node *lchild, *rchild;//二叉樹的左、右子樹的指針
}BinTNode;

typedef BinTNode *BinTree ; //自定義一個數據類型（二叉樹的指針類型）
#include <stdio.h>
#include <malloc.h>

//以前序遍歷構建二叉樹
void CreatBinTree(BinTree *T)
{
char ch;//定義臨時變數ch，用來接受數據
if ((ch=getchar())==' ')
*T=NULL;//如果輸入為空，則停止構建二叉樹
else{*T=(BinTNode *)malloc(sizeof(BinTNode));//為二叉樹分配內存空間
(*T)->data=ch;//把輸入的數據存入二叉樹
CreatBinTree(&(*T)->lchild);//構建左子樹（遞歸）
CreatBinTree(&(*T)->rchild);//構建左子樹（遞歸）
}
}

//求二叉樹的結點數
int Node(BinTree T)
{ int static nodes=0;//定義一個變數存儲二叉樹的結點數
if(T)//如果二叉樹不為空（是結點），執行此語句
{
Node(T->lchild);//看左子樹是不是個結點（遞歸）
nodes++;//結點數加1
Node(T->rchild);//看右子樹是不是個結點（遞歸）
}
return nodes;//返回結點數
}

//求二叉樹的葉子數
int Leaf(BinTree T)
{ int static leaves=0;//定義一個變數存儲二叉樹的葉子數
if(T)//如果二叉樹不為空，執行此語句
{
Leaf(T->lchild);//看左子樹是不是葉子（遞歸）
if(!(T->lchild||T->rchild))//如果二叉樹T的左、右結點都為空，則執行此語句（即是葉子）
leaves++;//葉子數加1
Leaf(T->rchild);//看右子樹是不是葉子（遞歸）
}
return leaves;//返回葉子數
}

#include <stdio.h>
void main()
{ BinTree root;
CreatBinTree(&root);//構建二叉樹
int nodes=Node(root);//求此二叉樹的結點數
int leaves=Leaf(root);//求此二叉樹的葉子數
printf("\nnodes=%d leaves=%d",nodes,leaves);
}

上面是我的理解，好久沒有寫過代碼了，如有錯誤，請指出。

Ⅳ 求C語言版二叉樹代碼

*創建二叉樹：先序創建；
遍歷二叉樹：先，中，後；
二叉樹屬性：深度，結點數，葉子結點數；
*/
#include<stdio.h>
#include<malloc.h>
typedef char DataType;
typedef struct Node
{
DataType data;
struct Node *Lchild;
struct Node *Rchild;
}BNode,*BiTree;
BiTree CreateTree()
{
char ch;
BiTree T;
scanf("%c",&ch); //讀入一個字元
if(ch==' ') T=NULL;
else{T=(BiTree)malloc(sizeof(BNode)); //生成一個新結點
T->data=ch;
T->Lchild=CreateTree(); //生成左子樹
T->Rchild=CreateTree(); //生成右子樹
}
return T;
}

void visit(char c)
{

printf("%c",c);
}
void PreOrder(BiTree root)
{if(root!=NULL)
{
visit(root->data);
PreOrder(root->Lchild);
PreOrder(root->Rchild);
}
}
void InOrder(BiTree root)
{if(root!=NULL)
{
InOrder(root->Lchild);
visit(root->data);
InOrder(root->Rchild);
}
}
void PostOrder(BiTree root)
{if(root!=NULL)
{
PostOrder(root->Lchild);
PostOrder(root->Rchild);
visit(root->data);
}
}
int PostTreeDepth(BiTree bt)
{
int h1,h2,max;
if(bt!=NULL)
{
h1=PostTreeDepth(bt->Lchild);
h2=PostTreeDepth(bt->Rchild);
max=h1>h2?h1:h2;
return(max+1);
}
else return(0);
}
int TreeCount(BiTree root)
{
int Count;
if(root==NULL) return(0);
else
Count=TreeCount(root->Lchild)+TreeCount(root->Rchild)+1;
return(Count);
}
int leaf(BiTree root)
{
int LeafCount;
if(root==NULL)
return 0;
else if((root->Lchild==NULL)&&(root->Rchild==NULL))
return 1;
LeafCount=leaf(root->Lchild)+leaf(root->Rchild);
return(LeafCount);
}

void main()
{
BiTree T;
char j;
int flag=1;
//---------------------程序解說-----------------------
printf("本程序實現二叉樹的操作。\n");
printf("可以進行建立二叉樹;遞歸先序、中序、後序遍歷;二叉樹屬性：深度，結點數，葉子結點數\n");
//----------------------------------------------------
printf("\n");
printf("請建立二叉樹。\n");
T=CreateTree();
getchar();
while(flag)
{
printf("\n");
printf("請選擇: \n");
printf("1.遞歸先序遍歷\n");
printf("2.遞歸中序遍歷\n");
printf("3.遞歸後序遍歷\n");
printf("4.二叉樹深度\n");
printf("5.二叉樹結點數\n");
printf("6.二叉樹葉子結點數\n");
printf("0.退出程序\n");
scanf(" %c",&j);
switch(j)
{
case '1':if(T)
{ printf("遞歸先序遍歷二叉樹:");
PreOrder(T);
printf("\n");
}
else
printf("二叉樹為空!\n");
break;
case '2':if(T)
{
printf("遞歸中序遍歷二叉樹:");
InOrder(T);
printf("\n");
}
else
printf("二叉樹為空!\n");
break;
case '3':if(T)
{ printf("遞歸後序遍歷二叉樹:");
PostOrder(T);
printf("\n");
}
else
printf("二叉樹為空!\n");
break;
case '4':if(T)
{
printf("二叉樹深度:");
printf("%d",PostTreeDepth(T));
printf("\n");
}
else
printf("二叉樹為空!\n");
break;
case '5':if(T)
{
printf("二叉樹結點數:");
printf("%d",TreeCount(T));
printf("\n");
}
else printf("二叉樹為空!\n");
break;
case '6':if(T)
{
printf("二叉樹葉子結點數:");
printf("%d",leaf(T));
printf("\n");
}
else printf("二叉樹為空!\n");
break;
default:flag=0;printf("程序運行結束，按任意鍵退出!\n");
}

}
}
希望對你有幫助，如需cpp可以發給你哦

Ⅳ 用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 maxsize 100
typedef struct btnode
{
int data ; //結點數據類型
struct btnode *lchild, *rchild; //定義左、右孩子為指針型
} bitree;
bitree *creat(bitree *t) //創建二叉樹
{
bitree *s,*p,*q;
int x;
scanf("%d",&x);
while(x!=0)
{
s= ( bitree *)malloc(sizeof(bitree));
s->data=x;
s->lchild=s->rchild=NULL;
if(t==NULL)
t=s;
else
{
p=t;
while(p)
{
q=p;
if(s->data<p->data)
p=p->lchild;
else
p=p->rchild;
}
if(s->data<q->data)
q->lchild=s;
else
q->rchild=s;
}
scanf("%d",&x);
}
return(t);
}
bitree *insert(bitree *t) //插入結點
{
bitree *s,*p,*q;
int x;
scanf("%d",&x);
while(x!=0)
{
s= ( bitree *)malloc(sizeof(bitree));
s->data=x;
s->lchild=s->rchild=NULL;
if(t==NULL)
t=s;
else
{
p=t;
while(p)
{
q=p;
if(s->data<p->data)
p=p->lchild;
else
p=p->rchild;
}
if(s->data<q->data)
q->lchild=s;
else
q->rchild=s;
}
scanf("%d",&x);
}
return(t);
}
void search(bitree *t,int k) //查找數據
{
int flag=0;
while(t!=NULL)
{
if(t->data==k)
{
printf("已查到要找的數!\n");
flag=1;
break;
}
else
if(t->data<k)
t=t->rchild;
else
t=t->lchild;
}
if(flag!=1)
printf("沒有找到要查找的數據!\n");
}
bitree *dele(bitree *t,int k) //刪除數據
{
int flag;
bitree *p,*q,*s=NULL,*f;
f=t;
while(t!=NULL) //查找數據
{
if(t->data==k)
{
printf("已找到所查找的數!\n");
break;
}
else
if(t->data<k)
{
p=t;
t=t->rchild;
flag=0;
}
else
{
p=t;
t=t->lchild;
flag=1;
}
}
if(t->lchild==NULL&&t->rchild==NULL) //刪除葉子結點
{
free(t);
if(flag==0)
p->rchild=NULL;
else
p->lchild=NULL;
}
else
{
if(t->lchild==NULL&&t->rchild!=NULL) //刪除只有右子樹的結點
{
if(flag==0)
p->rchild=t->rchild;
else
p->lchild=t->rchild;
free(t);
}
else
{
if(t->lchild!=NULL&&t->rchild==NULL) //刪除只有左子樹的結點
{
if(flag==0)
p->rchild=t->lchild;
else
p->lchild=t->lchild;
free(t);
}
else //刪除左右子樹都有的結點
{
p=t;
t=t->lchild;
q=t;
while(t->rchild)
{
q=t;
t=t->rchild;
}
if(t==q)
{
p->data=t->data;
p->lchild=t->lchild;
free(t);
}
else
{
p->data=t->data;
q->rchild=t->lchild;
free(t);
}
}
}
}
return(f);
}
void output(bitree * t) //實現二叉樹的遍歷
{
bitree *q[maxsize],*p;
int f,r;
q[0]=t;
f=r=0;
while (f<=r)
{
p=q[f];
f++;
printf("%d ",p->data);
if(p ->lchild!=NULL)
{
r++;
q[r]=p->lchild;
}
if (p->rchild!=NULL)
{
r++;
q[r]=p->rchild;
}
}
}
void main()
{

bitree *q=NULL,*r;
int m,n,x=1;
while(x==1)
{
system("cls");
printf(" ********************************\n");
printf(" 創建請按1\n");
printf(" 插入請按2\n");
printf(" 查找請按3\n");
printf(" 刪除請按4\n");
printf(" 顯示請按5\n");
printf(" 退出請按0\n");
printf(" ********************************\n");
scanf("%d",&m);
switch(m)
{
case 1:printf("請輸入數據並以'0'結束\n");
r=creat(q);system("pause");break;
case 2:printf("請輸入數據並以'0'結束\n");
r=insert(r);break;
case 3:printf("請輸入要查找的數:");
scanf("%d",&n);
search(r,n);
system("pause");
break;
case 4:printf("請輸入要刪除的數:");
scanf("%d",&n);
r=dele(r,n);
printf("已刪除輸入數據!\n");
system("pause");
break;
case 5:output(r);system("pause");printf("\n");
break;
case 0:x=0;break;
}

}
}

Ⅶ 用c語言如何編寫一個關於事故樹的程序

#include <stdio.h>
#include <stdlib.h>
#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 = new 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;#include <stdio.h>
#include <stdlib.h>
#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 = new 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;
}

Ⅷ 有關二叉樹的簡單C語言程序。

先序輸入 如 abc##d##e## (#表示空)
輸出 cbdae

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#include "cstdlib"
#include "malloc.h"
typedef int Status;
typedef char TElemType;
#include <stdio.h>
#include <iostream>
using namespace std;

typedef struct BiTNode { // 結點結構
TElemType data;
struct BiTNode *lchild, *rchild; // 左右孩子指針
} BiTNode, *BiTree;

Status CreateBiTree(BiTree &T){//構造二叉樹
TElemType ch;
scanf("%c",&ch);
if(ch=='#') T=NULL;
else{
if(!(T=(BiTree)malloc(sizeof(BiTNode)))) exit(OVERFLOW);
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
return OK;
}//CreateBiTree

Status Visit(char Data)
{
printf("%c",Data);
return OK;
}

Status InOrderTraval(BiTree pTree)
{
if(pTree)
{
if(InOrderTraval(pTree->lchild))
{
if(Visit(pTree->data))
{
if(InOrderTraval(pTree->rchild))
{
return OK;
}
}
return ERROR;
}
return ERROR;
}
else
{
return OK;
}
}

Status v(char a)
{
printf("%c",a);
return OK;
}
void main()
{
BiTree A,b;
printf("先序輸入，空用 ＃ 表示：\n");
CreateBiTree(A);
b=A;
printf("中序輸出：\n");
InOrderTraval(b);
}

Ⅸ C語言二叉樹的建立完整程序謝謝！！！

完整程序自己寫吧，我提供個思路：
二叉樹的節點包含三個指針：左指針，右指針，字元串鏈表的頭指針；
構造一個通過兩個字元串的頭指針比較字元竄大小的函數；（先比較串長，再從頭對位開始比較）；
構造一個插入函數（遞歸）
最後查找函數（遞歸）返回查找元素距根的距離；