创建二叉树并实现相关操作（急！！！）（多谢了！！！！！）

[suosuiduiqishenghuo]

请写出一下程序，可以实现：
1、创建二叉树（顺序表、先序和中序字串）；
2、遍历操作输出（层次、先序、中序、后序序列）；
3、求出（1）叶子个数（2）本二叉树的深度。
初学者，望各位高手支招教导，谢谢了！

[sduxiaoxiang]

网上代码一堆
Google之

[wind_breez]

template <class T>
class BinaryTreeNode {
friend void Vi s i t ( B i n a r y TreeNode<T> *);
friend void InOrder(BinaryTreeNode<T> *);
friend void PreOrder(BinaryTreeNode<T> *);
friend void PostOrder(BinaryTreeNode<T> *);
friend void LevelOrder(BinaryTreeNode<T> *);
friend void main(void);
p u b l i c :
B i n a r y TreeNode() {LeftChild = RightChild = 0;
B i n a r y TreeNode(const T& e)
{data = e;
LeftChild = RightChild = 0;}
B i n a r y TreeNode(const T& e, BinaryTreeNode
B i n a r y TreeNode *r)
{data = e;
LeftChild = l;
RightChild = r;}
p r i v a t e :
T data;
B i n a r y TreeNode<T> *LeftChild, //左子树
*RightChild; // 右子树
} ;


template<class T>
class BinaryTree {
public :
B i n a r y Tree( ) {root = 0; };
~ B i n a r y Tree( ) { };
bool IsEmpty( ) const
{reurn ((root) ? false : true);}
bool Root(T& x) const;
void MakeTree(const T& element，B i n a r y Tree<T>& left，B i n a r y Tree<T>& right);
void BreakTree(T& element，B i n a r y Tree<T>& left ，B i n a r y Tree<T>& right);
void PreOrder(void(*Visit) (BinaryTreeNode<T> *u))
{ P r e O r d e r ( Vi s i t，r o o t ) ; }
void Inorder(void (*Visit) (BinaryTreeNode<T> *u))
{ I n o r d e r ( Vi s i t，r o o t ) ; }
void PostOrder(void(*Visit ) (BinaryTreeNode<T> *u));
{Postorder (Visit, root); }
void LevelOrder(void(*Visit) (BinaryTreeNode<T> *u));
p r i v a t e :
B i n a r y TreeNode<T> *root; // 根节点指针
void PreOrder(void (*Visit) (BinaryTreeNode<T> *u)，B i n a r y TreeNode<T> *t);
void InOrder(void(*Visit) (BinaryTreeNode<T> *u)，B i n a r y TreeNode<T> *t);
void PostOrder(void(*Visit) (BinaryTreeNode<T> *u)，B i n a r y TreeNode<T> *t);
};


template <class T>
void PreOrder(BinaryTreeNode<T> *t)
{// 对* t进行前序遍历
if (t) {
Vi s i t ( t ) ; // 访问根节点
P r e O r d e r ( t - > L e f t C h i l d ) ; // 前序遍历左子树
P r e O r d e r ( t - > R i g h t C h i l d ) ; // 前序遍历右子树
}
}

template <class T>
void InOrder(BinaryTreeNode<T> *t)
{// 对* t进行中序遍历
if (t) {
I n O r d e r ( t - > L e f t C h i l d ) ; // 中序遍历左子树
Vi s i t ( t ) ; // 访问根节点
I n O r d e r ( t - > R i g h t C h i l d ) ; // 中序遍历右子树
}
}


template <class T>
void PostOrder(BinaryTreeNode<T> *t)
{// 对* t进行后序遍历
if (t) {
P o s t O r d e r ( t - > L e f t C h i l d ) ; // 后序遍历左子树
P o s t O r d e r ( t - > R i g h t C h i l d ) ; // 后序遍历右子树
Vi s i t ( t ) ; // 访问根节点
}
}

template<class T>
bool BinaryTree<T>::Root(T& x) const
{// 取根节点的d a t a域，放入x
// 如果没有根节点，则返回f a l s e
if (root) {x = root->data;
return true;}
else return false; // 没有根节点
}
template<class T>
void BinaryTr e e < T > : : M a k e Tree(const T& element, BinaryTree<T>& left, BinaryTree<T>& right)
{// 将left, right和element 合并成一棵新树
// left, right和t h i s必须是不同的树
// 创建新树
root = new BinaryTr e e N o d e < T >
(element, left.root, right.root);
// 阻止访问l e f t和r i g h t
left.root = right.root = 0;
}
template<class T>
void BinaryTr e e < T > : : B r e a k Tree(T& element, BinaryTree<T>& left, BinaryTree<T>& right)
{// left, right和t h i s必须是不同的树
// 检查树是否为空
if (!root) throw BadInput(); // 空树
// 分解树
element = root->data;
left.root = root->LeftChild;
right.root = root->RightChild;
delete root;
root = 0;
}

template<class T>
void BinaryTr e e < T > : : P r e O r d e r ( v o i d ( * Vi s i t ) ( B i n a r y TreeNode<T> *u), BinaryTreeNode<T> *t)
{// 前序遍历
if (t) {Vi s i t ( t ) ;
P r e O r d e r ( Visit, t->LeftChild);
P r e O r d e r ( Visit, t->RightChild);
}
}
template <class T>
void BinaryTr e e < i n t > : : I n O r d e r ( v o i d ( * Vi s i t ) ( B i n a r y TreeNode<T> *u), BinaryTreeNode<T> *t)
{// 中序遍历
if (t) {InOrder(Visit, t->LeftChild);
Vi s i t ( t ) ;
I n O r d e r ( Visit, t->RightChild);
}
}
template <class T>
void BinaryTr e e < T > : : P o s t O r d e r ( v o i d ( * Vi s i t ) ( B i n a r y TreeNode<T> *u), BinaryTreeNode<T> *t)
{// 后序遍历
if (t) {PostOrder(Visit, t->LeftChild);
P o s t O r d e r ( Visit, t->RightChild);
Vi s i t ( t ) ;
}
}




以上代码来自于数据结构与算法。

[selooloo]

#include<stdio.h>
#include<stdlib.h>
/********************************************************************/
/*二叉树相关操作*/
typedef struct tree *treelink; /*二叉树结点结构*/
typedef struct tree        
{
int data; /*data为结点值*/
treelink left; /*left为指向左儿子的指针*/
treelink right;/*right为指向右儿子的指针*/
}treenode;

treelink Newtreenode()    /*创建新结点并返回结点指针*/
{
treelink p;
if((p=(treelink)malloc(sizeof(treenode)))==0)
printf("Exhaused memory.");
else return p;
}

typedef struct binarytree *BinaryTree; /*指针实现的二叉树结构类型*/
typedef struct binarytree
{
treelink root; /*指向二叉树根结点的指针*/
}BTree;

void createtreenode(treelink p,int n) /*嵌套方式将一个数插入树中*/
{
if(n>p->data) /*如果此数大于结点值，则向结点的右儿子方向插入*/
{
   if(p->right==0) /*如果结点右儿子为空，则创建此结点的右儿子*/
   {
    treelink q=Newtreenode();
    q->data=n; q->right=0; q->left=0;
    p->right=q;
   }
   else createtreenode(p->right,n);/*如果右儿子不空，则继续判断与此右儿子的关系*/
}
else /*如果此数小于结点值，则向结点的左儿子方向插入*/
{
   if(p->left==0) /*如果结点左儿子为空，则创建此结点的左儿子*/
   {
    treelink q=Newtreenode();
    q->data=n; q->right=0; q->left=0;
    p->left=q;
   }
   else createtreenode(p->left,n);/*如果左儿子不空，则继续判断与此左儿子的关系*/
}
} 

treelink createTree(int a[], int size) /*根据数组创建树,size为a[]数组大小*/
{
int i=1;
treelink root;
root=Newtreenode();
root->data=a[0]; root->right=0; root->left=0;/*将a[0]作为树根结点值*/
while(i<size) /*把a[1]至a[size-1]插入树中*/
{
   createtreenode(root,a[i]);
   i++;
}
return root;/*返回指向树根的指针*/
}

void outTree(treelink root)   /*嵌套方式前序遍历树输出结点值*/
{
if(root!=0)
{
   printf("%d\n",root->data);
     outTree(root->left);
     outTree(root->right);
} 
}
int Leaves=0;//叶子数量 
void coutLeaf(treelink root)//计算叶子节点 
{
if(root!=0)
{
   if(root->left==0 && root->right==0)
   Leaves++;
     coutLeaf(root->left);
     coutLeaf(root->right);
} 
}
/************************************************************/
/*主函数*/
int main()
{
int a[9]={5,6,4,8,2,3,7,1,9}; /*结点值数组*/
    treelink root;
    root=Newtreenode();
    root=createTree(a,9);          /*根据数组创建一个树得到树根*/
    printf("前序遍历树结点值输出:\n");
    outTree(root);                 /*前序遍历树输出结点值*/
    coutLeaf(root);
    printf("leaves:%d\n",Leaves);
    getchar();
    return 0;
}

[mmilmf]

学数据结构的话书上这部分代码都有的，程序还是自己写的好。
确实写不出，就把树的结构弄懂在写。
我有几个例子，网上例子更多的。

[再见悟空D]

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
typedef struct BiTNode
{ char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*Bitree;
int createbitree(Bitree *T)//定义一个指向二叉树结点的指针的指针
//用扩展先序遍历序列创建二叉树，如果是#当前树根置为空，否则申请一个新节点
{char ch;
ch=getchar();
if(ch=='#')*T=NULL;
else{
*T=(Bitree )malloc(sizeof(BiTNode));
if(!T)return -1;
(*T)->data=ch;
createbitree(&((*T)->lchild));
createbitree(&((*T)->rchild));
}return 1;
}
visit(char c)//访问节点
{
printf("%c ",c);
return 1;
}
int PreOrderTraverse(Bitree root)//先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针
{if(root!=NULL)
{ visit(root->data);//访问根节点
PreOrderTraverse(root->lchild);//先序遍历二叉树的左子树
PreOrderTraverse(root->rchild);//先序遍历二叉树的右子树
}return 1;
}
int InOrderTraverse(Bitree root)//中序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针
{
if(root!=NULL){
InOrderTraverse(root->lchild);
visit(root->data);
InOrderTraverse(root->rchild);
}return 1;
}
int PostOrderTraverse(Bitree root)//后序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针
{
if(root!=NULL)
{
PostOrderTraverse(root->lchild);
PostOrderTraverse(root->rchild);
visit(root->data);
}return 1;
}
void PreOrder(Bitree root)//输出叶子结点的元素
{ if(root!=NULL)
{if(root->lchild==NULL&&root->rchild==NULL)
visit(root->data);
PreOrder(root->lchild);//输出左子树的叶子结点的元素
PreOrder(root->rchild);//输出右子树的叶子结点的元素
}
}
int sumleaf(Bitree T)//求树的叶子结点数
{
int sum=0;
if(T==NULL)sum=0;//空树
else if((
T->lchild==NULL&&T->rchild==NULL))//没有左右孩子的节点
sum=1;
else sum=sumleaf(T->lchild)+sumleaf(T->rchild);
return sum;//返回叶子结点数
}
int Depth(Bitree T)//求树的深度
{
int dep=0,depl,depr;
if(!T) dep=0;
else{
depl=Depth(T->lchild); //求左子树的深度
depr=Depth(T->rchild); //求右子树的深度
dep=1+(depl>depr?depl:depr);
}
return dep;
}

void main()
{ Bitree T;int sum,dep;
T=NULL;
printf("请输入二叉树中的元素(以扩展先序遍历序列输入,其中.代表空子树):\n");
printf("比如二叉树：ABC##DE#G##F###\n二叉树为：");
createbitree(&T);
printf("先序遍历序列为:");
PreOrderTraverse(T);
printf("\n中序遍历序列为:");
InOrderTraverse(T);
printf("\n后序遍历序列为:");
PostOrderTraverse(T);
printf("\n此二叉树的叶子节点个数是:");
sum=sumleaf(T);
printf("%d",sum);
printf("\n叶子结点是：");
PreOrder(T);
printf("\n此二叉树的深度为:");
dep=Depth(T);
printf("%d",dep);
getch();
}

[suosuiduiqishenghuo]

多谢各位，我是菜鸟中的菜鸟，所以很多还看不懂，还请各位高手多多批评指教，树的结构我是弄懂了，当然也许还没有达到那种量变到质变的境界，所以还得继续努力，现在正在恶补C语言，有没有初级c语言的练习方面的书，各位高手给我介绍几本。总感觉学了没动手写，总觉得什么都没学会，什么都没掌握。呵呵，再次在这里感觉各位！

[ljsdaya]

学习