为什么会创造二叉树

『壹』 二叉树的创建

如输入ABCD#
是不能建立一个完整的二叉树的，
代码中以字符'#'判断是否是空结点，有N个结点就会有N+1个空结点。
从代码中可以看出是先序历遍（根-左-右），进行输入的。
如果想得到二叉树:
A
/ \
B C
/ \
D E

就要输入:ABD##E##C##

就是:
A
/ \
B C
/ \ / \
D E # #
/ \ / \
# # # #

『贰』 二叉树创建问题!

程序逻辑上有错误。
else{}里面的代码，生成根节点后，再调用create_btree();创建左子树，调用create_btree()时再创建左子树的根节点，然后再调用。就这样一直循环下去。
输入“#”的时候返回NULL，怎样判断这个NULL？如果生成的左子树有节点右子树没有节点，怎样判断并返回上层节点？
你用笔按照你的程序写一下生成二叉树的过程就知道了。

『叁』 怎么理解递归创建二叉树

递归=传递+回归，即任务的下放和结果的回收。
这个需要自己慢慢体会，其实所有递归算法实质上都是一样的，理解了就万变不离其宗了。
create（node *root）
{
root=new node；
写上关于root的信息//初始化root节点
if(root满足自定义的条件)//自定义一个递归的条件，即传递和回归的界限，这是必须的。
{
create(root->lchild);//建左子树
create(root->rchild);//建右子树
}
}
总体上来看，建一颗树，每一次调用creat（）都是只创建一个节点，把剩下的任务下放给create（root->lchild)和create(root->rchild) ，而这两个也会重复第一个create（root）的做法，实质体现的是任务的不断下放，当达到最后的回归的界限的，结果又将不断回收，对应的是函数的不断返回，实质是退栈的过程。这个过程其实经历了一个不断进栈和不断出栈的过程，对应的是任务的不断下放和不断提交，最后栈空，即告全部任务完成！

pTree createTree(pTree T)
{
char ch;
ch = getchar();
if (ch == '#')//这是递归结束条件
{
T = NULL;
}
else
{
T = (pTree)malloc(sizeof(TreeNode));
T->data = ch;
T->left = createTree(T->left);//注意，这里采用的是先建左子树
T->right = createTree(T->right);//再建右子树，所以建树时须按照相应的遍历次序，即先序遍历
}
return T;//这里不能缺，新建的树，必须让它的父亲能指向它，如T->left = createTree(T->left);
}
}

『肆』 二叉树怎么建立

二叉树建立方法：

『伍』 数据结构-二叉树的创建

如果要在内存中建立一个如下左图这样的树，wield能让每个结点确认是否有左右孩子，我们对它进行扩展，变成如下右图的样子，也就是将二叉树中的每个结点的空指针引出一个虚结点，其值为一个特定值，比如”#”，称之为扩展二叉树。扩展二叉树就可以做到一个遍历序列确定一棵二叉树了。如前序遍历序列为AB#D##C##。

//创建树方法二
intCreateTree2(BiTree*t)
{
charch;
scanf("%c",&ch);

if(ch=='#')
{
(*t)=NULL;
}
else
{
(*t)=(BiTree)malloc(sizeof(BitNode));
if((*t)==NULL)
{
fprintf(stderr,"malloc()errorinCreateTree2. ");
returnERROR;
}

(*t)->data=ch;
CreateTree2(&((*t)->lchild));
CreateTree2(&((*t)->rchild));
}
returnOK;
}

其实建立二叉树，也是利用了递归的原理。只不过在原来应该打印结点的地方，改成生成结点、给结点赋值的操作而已。因此，完全可以用中序或后序遍历的方式实现二叉树的建立，只不过代码里生成结点和构造左右子树的代码顺序交互一下即可。

『陆』 如何构建一颗二叉树

//二叉树结点类型为字符型的情况
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define null 0
#define MaxSize 1024
typedef struct tree
{ /*声明树的结构*/
struct tree *left; /*存放左子树的指针*/
struct tree *right; /*存放右子树的指针*/
char data; /*存放节点的内容*/
} treenode, * b_tree; /*声明二叉树的链表*/

b_tree Q[MaxSize];

/*建立二叉树，按完全二叉树的层次遍历序列输入*/
b_tree createbtree()
{
char ch;
int front,rear;
b_tree root,s;
root=NULL;
front=1;rear=0;
ch=getchar();
getchar();
while(ch!='?')
{
s=NULL;
if(ch!='.')
{
s=(b_tree)malloc(sizeof(treenode));
s->data=ch;
s->left=NULL;
s->right=NULL;
}
rear++;
Q[rear]=s;
if(rear==1)
root=s;
else
{
if(s&&Q[front])
if(rear%2==0)
Q[front]->left=s;
else
Q[front]->right=s;
if(rear%2==1)
front++;
}
ch=getchar();
getchar();
}
return root;
}

/*先序遍历打印二叉排序树*/
void preorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
printf("%3c",p->data);
preorder_btree(p->left);
preorder_btree(p->right);
}
}

/* 中序遍历打印二叉排序树*/
void inorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null){
inorder_btree(p->left );
printf("%3c",p->data );
inorder_btree(p->right );
}
}

/*后序遍历打印二叉排序树*/
void postorder_btree(b_tree root)
{
b_tree p=root;
if(p!=null)
{
postorder_btree(p->left );
postorder_btree(p->right );
printf("%3c",p->data );
}
}

/*求树的高度*/
int treedepth(b_tree bt)
{
int hl,hr,max;
if(bt!=null)
{
hl=treedepth(bt->left);
hr=treedepth(bt->right);
max=(hl>hr)?hl:hr;
return (max+1);
}
else
return 0;
}

int count=0;
/*求叶子结点总数*/
int leafcount(b_tree bt)
{
if(bt!=null)
{
leafcount(bt->left);
leafcount(bt->right);
if(bt->left==null&&bt->right==null)
count++;
}
return count;
}

void paintleaf(b_tree bt)
{
if(bt!=null)
{
if(bt->left==null&&bt->right==null)
printf("%3c",bt->data);
paintleaf(bt->left);
paintleaf(bt->right);
}
}

typedef b_tree ElemType ;

int main()
{
char nodelist[MaxSize];
int len,flag;
char cmd;
b_tree root;
do
{
printf(" 输入c......选择创建一棵二叉排序树\n");
printf(" 输入a......将结束本程序\n\n");
flag=0;
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='c'&&cmd!='a');
if(cmd=='c')
{
printf("请输入那你所要创建的二叉树的结点的值,以'？'结束）：\n");
getchar();
root=createbtree();
do
{
flag=0;
printf("\n\n 请选择你要对这棵二叉树所做的操作:\n\n");
printf(" x......先序遍历\n");
printf(" z......中序遍历\n");
printf(" h......后序遍历\n");
printf(" b......层次遍历\n");
printf(" d......求二叉树的深度\n");
printf(" y......求叶子总数并输出各叶子结点\n");
printf(" q......结束操作\n\n");
do
{
if(flag!=0)
printf("选择操作错误！请重新选择！\n");
fflush(stdin);
scanf("%c",&cmd);
flag++;
}while(cmd!='x'&&cmd!='z'&&cmd!='h'&&cmd!='b'&&cmd!='d'&&cmd!='y'&&cmd!='j'&&cmd!='q');
switch(cmd)
{
case 'x':
printf("\n先序遍历开始:\n");
preorder_btree(root);
printf("\n先序遍历结束\n\n");
break;
case 'z':
printf("\n中序遍历开始:\n");
inorder_btree(root);
printf("\n中序遍历结束\n\n");
break;
case 'h':
printf("\n后序遍历开始:\n");
postorder_btree(root);
printf("\n后序遍历结束\n\n");
break;

case 'd':
printf("\n这棵二叉树的高度：\n%d\n\n",treedepth(root));
break;
case 'y':
printf("\n这棵二叉树的叶子结点为：\n");
paintleaf(root);
printf("\n");
count=0;
count=leafcount(root);
printf("\n这棵二叉树的叶子总数为:\n%d\n\n",count);
count=0;
break;
}
}while(cmd!='q'&&cmd!='Q');
}
}while(cmd!='a'&&cmd!='A');
printf("****谢谢使用！欢迎指正！****\n\n");
return 0;
}

『柒』 中序建立二叉树

中序创建二叉树是不科学的，因为在创建完左子树后，若此时根节点的设置值非法，此时左子树的创建将无意义，而且需要释放左子树空间，工作会比较复杂。
typedef struct Node {
int data;
struct Node *left;
struct Node *right;
}TreeNode;

TreeNode * CreateTree()
{
int data;
TreeNode *root;
root = (TreeNode *) malloc (sizeof(TreeNode));
root->left = CreateTree(); //创建左子树

scanf("%d", &data);
if (data != '#')
{
root->data = data;
} else {
//若要保证不发生内存泄露此处需要通过
//后序遍历左子树释放全部结点空间
free(root);
return NULL;
}
root->right = CreateTree(); //创建右子树
return root;
}

『捌』 二叉树的创建，求救

试一下这个

#include "iostream.h"
#include "stdlib.h"
#include "stdio.h"

typedef char ElemType;//定义二叉树结点值的类型为字符型
const int MaxLength=10;//结点个数不超过10个

typedef struct BTNode{
ElemType data;
struct BTNode *lchild,*rchild;
}BTNode,* BiTree;

void CreateBiTree(BiTree &T){//按先序次序输入，构造二叉链表表示的二叉树T，空格表示空树
// if(T) return;
char ch;
ch=getchar(); //不能用cin来输入，在cin中不能识别空格。
if(ch==' ') T=NULL;
else{
if(!(T=(BTNode *)malloc(sizeof(BTNode)))) cout<<"malloc fail!";
T->data=ch;
CreateBiTree(T->lchild);
CreateBiTree(T->rchild);
}
}

void PreOrderTraverse(BiTree T){//先序遍历
if(T){
cout<<T->data<<' ';
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
}
void InOrderTraverse(BiTree T){//中序遍历
if(T){
InOrderTraverse(T->lchild);
cout<<T->data<<' ';
InOrderTraverse(T->rchild);
}
}
void PostOrderTraverse(BiTree T){//后序遍历
if(T){
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data<<' ';
}
}
void LevelOrderTraverse(BiTree T){//层序遍历

BiTree Q[MaxLength];
int front=0,rear=0;
BiTree 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 NRPreOrder(BiTree bt)
{ BiTree stack[MaxLength],p;
int top;
if (bt!=NULL){
top=0;p=bt;
while(p!=NULL||top>0)
{ while(p!=NULL)
{
cout<<p->data;
stack[top]=p;
top++;
p=p->lchild;
}
if (top>0)
{ top--; p=stack[top]; p=p->rchild; }
}
}
}
//非递归的中序遍历算法
void NRInOrder(BiTree bt)
{ BiTree stack[MaxLength],p;
int top;
if (bt!=NULL){
top=0;p=bt;
while(p!=NULL||top>0)
{ while(p!=NULL)
{

stack[top]=p;
top++;
p=p->lchild;
}
if (top>0)
{ top--; p=stack[top];cout<<p->data; p=p->rchild; }
}
}
}
//非递归的后序遍历算法
/*bt是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。
需要判断根结点的左右子树是否均遍历过。
可采用标记法，结点入栈时，配一个标志tag一同入栈
(1：遍历左子树前的现场保护，2：遍历右子树前的现场保护)。
首先将bt和tag(为1)入栈，遍历左子树；
返回后，修改栈顶tag为2，遍历右子树；最后访问根结点。*/

typedef struct
{
BiTree ptr;
int tag;
}stacknode;

void NRPostOrder(BiTree bt)
{
stacknode s[MaxLength],x;
BiTree p=bt;
int top;
if(bt!=NULL){
top=0;p=bt;
do
{
while (p!=NULL) //遍历左子树
{
s[top].ptr = p;
s[top].tag = 1; //标记为左子树
top++;
p=p->lchild;
}

while (top>0 && s[top-1].tag==2)
{
x = s[--top];
p = x.ptr;
cout<<p->data; //tag为R，表示右子树访问完毕，故访问根结点
}

if (top>0)
{
s[top-1].tag =2; //遍历右子树
p=s[top-1].ptr->rchild;
}
}while (top>0);}
}//PostOrderUnrec

int BTDepth(BiTree T){//求二叉树的深度
if(!T) return 0;
else{
int h1=BTDepth(T->lchild);
int h2=BTDepth(T->rchild);
if(h1>h2) return h1+1;
else return h2+1;
}
}

int Leaf(BiTree T){//求二叉树的叶子数
if(!T) return 0;
else if(!T->lchild&&!T->rchild) return 1;
else return(Leaf(T->lchild)+Leaf(T->rchild));
}

int NodeCount(BiTree T){//求二叉树的结点总数
if(!T) return 0;
else return NodeCount(T->lchild)+NodeCount(T->rchild)+1;
}

void main(){
BiTree T;
T=NULL;
int select;
//cout<<"请按先序次序输入各结点的值，以空格表示空树(输入时可连续输入):"<<endl;
// CreateBiTree(T);
while(1){
cout<<"\n\n请选择要执行的操作:\n";
cout<<"1.创建二叉树\n";
cout<<"2.二叉树的递归遍历算法（前、中、后）\n";
cout<<"3.二叉树的层次遍历算法\n";
cout<<"4.求二叉树的深度\n";
cout<<"5.求二叉树的叶子结点\n";
cout<<"6.求二叉树的结点总数\n";
cout<<"7.二叉树的非递归遍历算法（前、中、后）\n"; //此项可选做
cout<<"0.退出\n";
cin>>select;
switch(select){
case 0:return;
case 1:
cout<<"请按先序次序输入各结点的值，以空格表示空树(输入时可连续输入):"<<endl;
CreateBiTree(T);
break;
case 2:
if(!T) cout<<"未建立树，请先建树！";
else{
cout<<"\n先序遍历:\n";
PreOrderTraverse(T);
cout<<"\n中序遍历:\n";
InOrderTraverse(T);
cout<<"\n后序遍历:\n";
PostOrderTraverse(T);
}
break;
case 3:
cout<<"\n层序遍历:\n";
LevelOrderTraverse(T);
break;
case 4:
cout<<"二叉树的深度为:\n";
cout<<BTDepth(T);
break;
case 5:
cout<<"\n叶子节点数:\n";
cout<<Leaf(T);
break;
case 6:
cout<<"总节点数:\n";
cout<<NodeCount(T);
break;
case 7:
if(!T) cout<<"未建立树，请先建树！";
else{
cout<<"\n先序遍历:\n";
NRPreOrder(T);
cout<<"\n中序遍历:\n";
NRInOrder(T);
cout<<"\n后序遍历:\n";
NRPostOrder(T);
}
break;
default:
cout<<"请确认选择项:\n";
}//end switch
}//end while

}
先输入1
然后输入回车
再输入123
再输入一个空格
再输入4
再输入三个空格
再输入56
再输入三个空格
再输入输入回车
一定要照这循序输这输不要乱敲回车和其他键

你试一下这个吧里面还有说明

『玖』 创建二叉树，完全看不懂

void CreatBiTree(BiTree &T)
{
//前序法创建二叉树
//前序遍历首先访问根结点然后遍历左子树，最后遍历右子树

char ch;
if((ch=getchar())=='\n') // 遍历结束判断
//为啥getchar（）没有参数传进去啊？怎么取得当前节点的内容啊
T=NULL;
else
{
T=(BiTNode*)malloc(sizeof(BiTNode)); //分配空间作为根节点
if(!T) //没有分配成功就退出
exit(1);
T->data=ch; //把当前节点作为根节点
CreatBiTree(T->lchild);//递归遍历左子树
CreatBiTree(T->rchild);///递归遍历右子树
}
}
要是这都看不懂，我也没有办法了。

『拾』 如何构建二叉树

先序递归创建二叉树，并对其进行 先序、中序、后序遍历

1.建立二叉树
2.为了直观的输出树，那么可以选择广度遍历。查查书应该有。
3.深度的话我这刚好有两个函数
#include <stdlib.h>
typedef struct{
char data;
}TElemType;
typedef struct BiTNode{
TElemType data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode, *BiTree;
void CreateBiTree(BiTree &T)
{
char ch;
TElemType elem;
printf("请输入树节点, 空树以#代替:");
scanf("\n%c", &ch);
elem.data = ch;
if(ch == '#')
{
T = NULL;
}
else
{
T = (BiTNode * )malloc(sizeof(BiTNode));
if(!T) exit(-1);
T->data = elem; //生成根
CreateBiTree(T->lchild);//构造左子树
CreateBiTree(T->rchild);// 构造右子树
}
}
void main()
{
BiTree T;
CreateBiTree(T);
}