❶ C语言二叉树递归算法怎么做
#include<stdio.h>
#include<string.h>
structtreenode{
intvalue;
treenode*left;
treenode*right;
};
typedeftreenode*BiTree;
voidvisit(treenode*node)
{
printf("%2d",node->value);
}
//结点总数
intnode(BiTreeT)
{
if(!T){
return0;
}
returnnode(T->left)+node(T->right)+1;
}
//前序
voidpreOrder(BiTreeT)
{
if(T){
visit(T);
preOrder(T->left);
preOrder(T->right);
吵盯}
}
//中序
voidinOrder(BiTreeT)
{
if(T){
inOrder(T->left);
液枝visit(T);
inOrder(T->right);
升埋和}
}
//后序
voidpostOrder(BiTreeT)
{
if(T){
postOrder(T->left);
postOrder(T->right);
visit(T);
}
}
//叶子节点数
intleafnode(BiTreeT)
{
if(T){
if(!T->left&&!T->right)
return1;
else
leafnode(T->left)+leafnode(T->right);
}else{
return0;
}
}
intheight(BiTreeT)
{
if(T){
intlh=height(T->left);
intrh=height(T->right);
return(lh>rh?lh:rh)+1;
}else{
return0;
}
}
intmain()
{
return0;
}
❷ C语言二叉树遍历代码
1.t = malloc(sizeof(tree));
2.t->rchild =createTree();
3.void qianxu(tree *t)
4.zhongxu(t->lchild );//再读左子树
printf("%c",t->data);//先读根结点
zhongxu(t->rchild );//再读右子树
5.houxu(t->lchild );//再读左子树
houxu(t->rchild );//再读右子树
printf("%c",t->data);//先读根结点
6.return 0;
7.n=count(t->lchild)+count(t->rchild)+1;
8.t1->data=t->data;
9.return t1;
10.return m+1;
PS:注意有些专语句属结尾是没有分号的
❸ 求c语言数据结构二叉树的建树，前序遍历，输出树的代码，能用采纳。
#include
#include
#define MAXSIZE 100 //二叉树中最多的结点数
typedef char TElemType;
typedef struct BiTNode
{
TElemType data;
BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
//定义函数指针
typedef void(* Visit)(BiTree);
//二叉树的初始化
void Init_BiTree(BiTree *T)
{
*T = NULL;
}
//判断二叉树是否为空,返回1
int IsEmpty_BiTree(BiTree *T)
{
return *T == NULL;
}
//创建二叉树
void Create_BiTree(BiTree *T)
{
char ch;
ch = getchar();
//当输入的是"#"时，认为该子树为空
if(ch == '#')
*T = NULL;
//创建树结点
else{
*T = (BiTree)malloc(sizeof(BiTNode));
(*T)->data = ch; //生成树结点
//生成左子树
Create_BiTree(&(*T)->lchild);
//生成右子树
Create_BiTree(&(*T)->rchild);
}
}
//输出结点的值
void Print_BiTreeNode(BiTree T)
{
printf("%c\t",T->data);
}
//先序遍历二叉树
void PreOrder_BiTree(BiTree T,Visit visit)
{
if(!IsEmpty_BiTree(&T))
{
visit(T);
PreOrder_BiTree(T->lchild,visit);
PreOrder_BiTree(T->rchild,visit);
}
}
int main(){
BiTree T;
//将二叉树初始为一个空的二叉树
Init_BiTree(&T);
//创建二叉树
Create_BiTree(&T);
//先序遍历
printf("\n先序遍历结果：");
PreOrder_BiTree(T,Print_BiTreeNode);
return 0;
}
❹ 二叉树的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语言版）建立二叉树的代码~~急~~谢谢了
BT.H文件
#include
<stdio.h>
#include
<malloc.h>
#include
<conio.h>
#define
TRUE
1
#define
FALSE
0
#define
ERROR
0
#define
OK
1
#define
Stack_Size
50
#define
NUM
50
#define
MAXSIZE
50
//队列的最大长度
//定义二叉树
typedef
char
DataType;
typedef
struct
Node
{
DataType
data;
struct
Node
*LChild;
struct
Node
*RChild;
}BiTNode,
*BiTree;
//定义stack
typedef
BiTree
StackElementType;
typedef
struct
{
StackElementType
elem[Stack_Size];
int
top;
}SeqStack;
//定义队列
typedef
BiTree
QueueElementType;
typedef
struct
{
QueueElementType
element[MAXSIZE];
int
front;
int
rear;
}SeqQueue;
//队列的抽象
void
InitQueue(SeqQueue
*Q)
{
Q->front=Q->rear=0;
}
int
EnterQueue(SeqQueue
*Q,
QueueElementType
x)
{
if((Q->rear+1)%MAXSIZE==Q->front)
return(FALSE);
Q->element[Q->rear]=x;
Q->rear=(Q->rear+1)%MAXSIZE;
return(TRUE);
}
❻ 求代码——二叉树——要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 = (BTreeNode *)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;
}
❼ 用c语言写二叉树，源代码。
//定义结构体
typedef struct btnode
{
char data;
struct btnode *lchild,*rchild;
}*bitreptr;
//建立二叉树
void create_btr(bitreptr t)
{
getchar();
if(x=='#')
t=NULL;
else
{
p=new node;
p->data=x;
t=p;
create_btr(t->lchild);
create_btr(t->rchild);
}
}
//中序遍历二叉树
void inorder(bitreptr p)
{
if(p)
{
inorder(p->lchild);//访问左子树
printf("%c",p->data);//访问根节点
inorder(p->rchild);//访问右子树
}
}
其他的细节你内自己去完善，我就写到这里容了