求一个C＋＋的二叉书生成算法

[MikeWEE]

求一个C＋＋的二叉书生成算法。找了好多地方，看了好多书，都没有讲这个，请高人指点！！

[kgn28]

什么二叉树？平衡二叉树？？？
这是一个平衡二叉树的标准程序：
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
#define Boolean int
#define TRUE 1
#define FALSE 0

typedef struct treespe{
char key[30];
float treesum;
}treespe;

#define ElemType treespe
#define EQ(a,b) (!strcmp(a,b))
#define LT(a,b) (strcmp(a,b)<0)
#define Status int
typedef struct BSTNode{
ElemType data;
int bf;
struct BSTNode *lchild,*rchild;
}BSTNode,*BSTree;
int N,flag;
#define LH 1
#define EH 0
#define RH -1

void R_Rotate(BSTree &p);
void L_Rotate(BSTree &p);
void LeftBalance(BSTree &T);
void RightBalance(BSTree &T);
Status InsertAVL(BSTree &T,ElemType e,Boolean &taller);
int print(BSTree T);
void freetree(BSTree T);
int main()
{
int i=0;
ElemType e;
Boolean taller;
BSTree T=NULL;

scanf("%d\n",&N);
while(N!=0){
for(i=0;i<N;i++){
gets(e.key);
e.treesum=0;
InsertAVL(T,e,taller);

}
print(T);
T=NULL;
// freetree(T);
scanf("%d\n",&N);
}
return 0;
}


void R_Rotate(BSTree &p)
{
BSTree lc;
lc=p->lchild;
p->lchild=lc->rchild;
lc->rchild=p;
p=lc;
}
void L_Rotate(BSTree &p)
{
BSTree rc;
rc=p->rchild;
p->rchild=rc->lchild;
rc->lchild=p;
p=rc;
}


void LeftBalance(BSTree &T)
{
BSTree lc,rd;
lc=T->lchild;
switch(lc->bf){
case LH:
T->bf=lc->bf=EH;
R_Rotate(T);
break;
case RH:
rd=lc->rchild;
switch(rd->bf){
case LH:
T->bf=RH;
lc->bf=EH;
break;
case EH:
T->bf=lc->bf=EH;
break;
case RH:
T->bf=EH;
lc->bf=LH;
break;
}
rd->bf=EH;
L_Rotate(T->lchild);
R_Rotate(T);
}
}
void RightBalance(BSTree &T)
{
BSTree rc,ld;
rc=T->rchild;
switch(rc->bf){
case RH:
T->bf=rc->bf=EH;
L_Rotate(T);
break;
case LH:
ld=rc->lchild;
switch(ld->bf){
case LH:
T->bf=EH;
rc->bf=RH;
break;
case EH:
T->bf=rc->bf=EH;
break;
case RH:
T->bf=LH;
rc->bf=EH;
break;
}
ld->bf=EH;
R_Rotate(T->rchild);
L_Rotate(T);
}
}

Status InsertAVL(BSTree &T,ElemType e,Boolean &taller)
{
if(!T){
e.treesum++;
T=(BSTree)malloc(sizeof(BSTNode));
T->data=e;
T->lchild=T->rchild=NULL;
T->bf=EH;
taller=TRUE;
}else {
if(EQ(T->data.key,e.key)){
T->data.treesum++;
taller=FALSE;
return 0;
}
if(LT(e.key,T->data.key)){
if(!(InsertAVL(T->lchild,e,taller)))return 0;
if(taller){
switch(T->bf){
case LH:
LeftBalance(T);
taller=FALSE;
break;
case EH:
T->bf=LH;
taller=TRUE;
break;
case RH:
T->bf=EH;
taller=FALSE;
break;
}
}
}else {
if(!InsertAVL(T->rchild,e,taller))return 0;
if(taller){
switch(T->bf){
case LH:
T->bf=EH;
taller=FALSE;
break;
case EH:
T->bf=RH;
taller=TRUE;
break;
case RH:
RightBalance(T);
taller=FALSE;
break;
}
}
}
}
return 1;
}
int print(BSTree T)
{
if(T!=NULL){
if(T->data.treesum>=N/2){
printf("Case %d:\n%s\n",++flag,T->data.key);
return 0;
}
print(T->lchild);
print(T->rchild);
}
return 0;
}
void freetree(BSTree T)
{
if(T->lchild)freetree(T->lchild);
if(T->rchild)freetree(T->rchild);
free(T);
}

[manrenmanren]

二叉树就是最普通的吧
应该不是特指平衡二叉树

[可爱的小莱]

//bitree.h
//定义二叉树的节点
typedef struct node{
BiTree *lchild, *rchild;
struct node * next;
}Node ,*BiTree;

class BiTree{
publc:
BiTree * CreateBiTree( BiTree * T)

private:

};
*********************************************

//BiTree.cpp

void CreateBiTree( BiTree * T)
{