帮我看看这个程序吧！

[fulimei1002]

输入一棵二叉树的前序序列和中序序列为
：A B C D E F G
B C A E D F G
最后按照前序序列输出。运行一半出不了结果，不知道错误在哪儿，请大家帮我看看吧~~~~~~~~·
程序如下：
//treenode.h
#include <iostream>
using namespace std;

class treenode
{
friend void visittree(treenode *root);
friend void creattree(char pre[], char in[], int n,treenode *root);
friend void constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend, treenode *root);
private:
treenode *left;
treenode *right;
char data;
};

void visittree(treenode *root)
{
if(root)
{
cout << root->data;
visittree(root->left);
visittree(root->right);
}
}

void creattree(char pre[], char in[], int n,treenode *root)
{
if(n < 0)
root = NULL;
else
constructtree(pre, in, 1, n, 1, n, root);
}

void constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend, treenode *root)
{
root = new treenode;
root->data = pre[pstart];
int mid = istart;
while (in[mid] != pre[pstart])
mid++;

if(mid == istart)
root->left = NULL;
else if(mid == iend)
root->right = NULL;
else
{
constructtree(pre, in, pstart+1,pstart+mid-istart,istart, mid-1,root->left);
constructtree(pre, in, pstart+mid-istart+1,pend,mid+1, iend,root->left);
}
}
//>>>>>>>>>>>>>>//
#include "treenode.h"
#define N 7

int main()
{
treenode *A;
char pre[N], in[N];

cout << "enter the array of pre :";
for(int i=1; i <= N; ++i)
cin >> pre[i];

cout << "enter the array of in :";
for(int j=1; j <= N; ++j)
cin >> in[j];

creattree(pre, in, N, A);
visittree(A);
return 0;
}

[sailing0123]

[Quote=引用楼主 fulimei1002 的帖子:]
输入一棵二叉树的前序序列和中序序列为
：A B C D E F G
B C A E D F G
最后按照前序序列输出。运行一半出不了结果，不知道错误在哪儿，请大家帮我看看吧~~~~~~~~·
程序如下：
[/Quote]

这题目写错了吧？

[wudeshou82666]

查一查你递归函数的结束条件！！！！

[wudeshou82666]

楼主，你把你要的结果再给说清楚点，以及你的输入。。。那样就很容易看了

[s79947171]

完全无注释，我晕死

[jia_xiaoxin]

你程序中指针的传递有问题
我修改了一下

#include <iostream> 
using namespace std; 

class treenode 
{ 
	friend void visittree(treenode *root); 
	friend treenode *  creattree(char pre[], char in[], int n); 
    friend treenode *  constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend); 
private: 
	treenode *left; 
	treenode *right; 
	char data; 
}; 

void visittree(treenode *root) 
{ 
	if(root) 
	{ 
		cout << root->data; 
		visittree(root->left); 
		visittree(root->right); 
	} 
} 

treenode * creattree(char pre[], char in[], int n) 
{ 
	return constructtree(pre, in, 0, n, 0, n); 
} 

treenode * constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend) 
{ 
	treenode *root = new treenode; 
	root->data = pre[pstart]; 
	int mid = istart; 
	while (in[mid] != pre[pstart]) 
		mid++; 
	
	if(mid == istart) 
		root->left = NULL; 
	else
		root->left = constructtree(pre, in, pstart+1,pstart+mid-istart,istart, mid-1); 
	
	if(mid == iend) 
		root->right = NULL; 
	else	
		root->right = constructtree(pre, in, pstart+mid-istart+1,pend,mid+1, iend); 
	
	return root;
} 
//>>>>>>>>>>>>>>// 
//#include "treenode.h" 
#define N 8

int main() 
{ 
	treenode  * A; 
	char pre[N] = "ABCDEFG";
	char in[N] = "BCAEDFG";
	
	/*
	cout << "enter the array of pre :"; 
	for(int i=1; i <= N; ++i) 
		cin >> pre[i]; 
	
	cout << "enter the array of in :"; 
	for(int j=1; j <= N; ++j) 
		cin >> in[j]; 
	*/

	A = creattree(pre, in, N-1); 
	visittree(A); 
	return 0; 
} 

[neurobot]

#include <iostream>
#include <string>
using namespace std;

//二叉树链存储结构类型定义
typedef char ElemType;
const int MaxSize = 1000;
const int MaxWidth = 60;
struct BTNode
{
	ElemType data;
	BTNode *lchild, *rchild;
};
//求二叉树高度运算
//递归模型
//f(bt)=Max{f(bt->lchild), f(bt->rchild)}+1; f(NULL) = 0
int BTHeight(BTNode *bt);

//求二叉树结点个数运算
//递归模型 
//f(bt) = f(bt->lchild)+f(bt->rchild)+1;f(NULL) = 0
int NodeCount(BTNode *bt);

//求二叉树叶子结点个数运算
//递归模型
//f(bt) = f(bt->lchild)+f(bt->rchild)
//f(bt) = 0,bt=NULL; f(bt) = 1, bt为叶子结点
int LeafCount(BTNode *&bt);

//二叉树的先根遍历
//若二叉树非空
//1，访问根结点 2，先根遍历左子树 3，先根遍历右子树
void PreOrder(BTNode *bt);

//中根遍历
//若二叉树非空
//1，中根遍历左子树 2，访问根结点 3，中根遍历右子树
void InOrder(BTNode *bt);

//后根遍历
//若二叉树非空
//1，后根遍历左子树 2，后根遍历右子树 3，访问根结点
void PostOrder(BTNode *bt);

//由先根序列和中根序列构造二元树
void PreInOrder(BTNode *&bt, char *pre, char *in);

//由中根序列和后根序列构造二元树
void PostInOrder(BTNode *&bt, char *in, char *post);

//-----------------------------------------------------------------------------
//主函数
int main()
{
	BTNode *bt;
	char ch[MaxSize];
	char pre[100];
	char in[100];
	char *a, *b;
	int n;

	cout << "请输入先根序列和中根序列：" << endl;
	cin >> pre >> in;
	a = pre;
	b = in;
	PreInOrder(bt, a, b);


	cout << "\n叶子结点的个数\n";
	cout << LeafCount(bt);
	cout << "\n二叉树高度\n";
	cout << BTHeight(bt);
	cout << "\n二叉树结点个数\n";
	cout << NodeCount(bt) << "\n";
	cout << "先根遍历:";
	PreOrder(bt);
	cout << "\n中根遍历:";
	InOrder(bt);
	cout << "\n后根遍历:";
	PostOrder(bt);
	cout << endl;



	return 0;
}

//求二叉树高度运算
//递归模型
//f(bt)=Max{f(bt->lchild), f(bt->rchild)}+1; f(NULL) = 0
int BTHeight(BTNode *bt)
{
	int lchilddep, rchilddep;
	if(bt == NULL)
		return 0;//空树的高度为0
	lchilddep = BTHeight(bt->lchild);//求左子树的高度为lchilddep
	rchilddep = BTHeight(bt->rchild);//求右子树的高度为rchilddep
	return (lchilddep>rchilddep)?(lchilddep+1):(rchilddep+1);
}

//求二叉树结点个数运算
//递归模型 
//f(bt) = f(bt->lchild)+f(bt->rchild)+1;f(NULL) = 0
int NodeCount(BTNode *bt)
{
	int num1, num2;
	if(bt == NULL)
		return 0;
	num1 = NodeCount(bt->lchild);
	num2 = NodeCount(bt->rchild);

	return (num1+num2+1);
}
//求二叉树叶子结点个数运算
//递归模型
//f(bt) = f(bt->lchild)+f(bt->rchild)
//f(bt) = 0,bt=NULL; f(bt) = 1, bt为叶子结点
int LeafCount(BTNode *&bt)
{
	int num1, num2;
	if(bt == NULL)
		return 0;
	if(bt->lchild == NULL && bt->rchild == NULL)
		return 1;
	num1 = LeafCount(bt->lchild);
	num2 = LeafCount(bt->rchild);
	return (num1+num2);
}

//二叉树的先根遍历
//若二叉树非空
//1，访问根结点 2，先根遍历左子树 3，先根遍历右子树
void PreOrder(BTNode *bt)
{
	if(bt != NULL){
		cout << bt->data;
		PreOrder(bt->lchild);
		PreOrder(bt->rchild);
	}
}
//中根遍历
//若二叉树非空
//1，中根遍历左子树 2，访问根结点 3，中根遍历右子树
void InOrder(BTNode *bt)
{
	if(bt != NULL){
		InOrder(bt->lchild);
		cout << bt->data;
		InOrder(bt->rchild);
	}
}
//后根遍历
//若二叉树非空
//1，后根遍历左子树 2，后根遍历右子树 3，访问根结点
void PostOrder(BTNode *bt)
{
	if(bt != NULL){
		PostOrder(bt->lchild);
		PostOrder(bt->rchild);
		cout << bt->data;
	}
}
//由先根序列和中根序列构造二元树
void PreInOrder(BTNode *&bt, char *pre, char *in)
{
	char *rsub, *rsub0;

	if(in[0] == '\0')
		bt = NULL;
	else
	{
		bt = new BTNode;
		bt->data = pre[0];
		rsub = strchr(in, pre[0]);
		rsub0 = pre+(rsub-in);
		*rsub = '\0';

		pre++;
		rsub++;
		rsub0++;

		PreInOrder(bt->lchild, pre, in);
		PreInOrder(bt->rchild, rsub0, rsub);
	}
}

程序执行结果如下：


请输入先根序列和中根序列：
abcdefg
cbdafeg

叶子结点的个数
4
二叉树高度
3
二叉树结点个数
7
先根遍历:abcdefg
中根遍历:cbdafeg
后根遍历:cdbfgea
请按任意键继续. . .

[fulimei1002]

其实我还是不明白的程序错在哪儿╭(╯^╰)╮

[fulimei1002]

请大家说清楚点我的指针怎么传递错误了，新手啊 看不错问题 呵呵

[fulimei1002]

请大家说清楚点我的指针怎么传递错误了，新手啊 看不出问题 呵呵

[jia_xiaoxin]

你定义了一个空指针 treenode * A;
将空指针A作为实参传递给函数，而函数的形参treenode * root会指向空指针A指向的数据
所以root也为空
在函数内部
root = new treenode;
只是将形参指向了新建的结点，而原来的实参A指向的还为空
所以A指针毫无意义

[chenxiong115]

你应该使用
指向指针的指针
或者指针的引用。
像这样：

void creattree(char pre[], char in[], int n,treenode **proot) 调用方法：creattree(pre, in, N, &A);
void constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend, treenode **proot)

void creattree(char pre[], char in[], int n,treenode *&proot) 调用方法：creattree(pre, in, N, A);
void constructtree(char pre[], char in[], int pstart,int pend, int istart, int iend, treenode *&proot)

还有一点就是算法上的：
你想下：
前序为：ABCD
中序为：ABCD
你的算法能建立起该二叉树吗？