二叉树复制的算法

A. 编写复制一棵二叉树的递归算法，我的算法正确吗

#include
using namespace std;

typedef struct TNode//二叉树结构
{
char nodeValue;//结点的值
TNode* left;//左子树
TNode* right;//右子树
}*BiTree;
void CreateBiTree(BiTree &T)//中序遍历方式创建二叉树 ,输入#代表该结点为空
{
char nodeValue;
cin>> nodeValue;
if(nodeValue!='#')//结点非空
{
T=new TNode;
T->nodeValue=nodeValue;
CreateBiTree(T->left);
CreateBiTree(T->right);
}
else T=NULL;

}
int CountLeaf(BiTree T)
{
static int LeafNum=0;//叶子初始数目为0，使用静态变量
if(T)//树非空
{
if(T->left==NULL&&T->right==NULL)//为叶子结点
LeafNum++;//叶子数目加1
else//不为叶子结点
{
CountLeaf(T->left);//递归统计左子树叶子数目
CountLeaf(T->right);//递归统计右子树叶子数目
}
}
return LeafNum;
}
//用来测试的main函数，
int main()
{
BiTree T;
int leafNum;
cout<<"请输入中序遍历的二叉树序列(#号代表该结点为空)：如(ABC##DE#G##F###)"<<endl;
CreateBiTree(T);
leafNum=CountLeaf(T);
cout<<"该二叉树中叶子结点数为："<<leafNum<<endl;
return 0;
}

B. 编写一个复制一棵二叉树的递归算法……

void CopyTree(BiTree S,BiTree &T){
if (!s) T=NULL;
else{
CopyTree(S->lchild,lptr);//复制左扒纳培子树到lptr
CopyTree(S->rchild,rptr);//茄虚复制右子树到rptr
T=(BiTree)malloc(sizeof（BiNode));
T->data=S->data;
T->lchild=lptr;T->春唯rchild=rptr;
}//else
}//CopyTree
hiahia,同学，拿分来吧~

C. 二叉树以二叉链表存储，试定义二叉链表的结构，并编写复制一棵二叉树的算法。

用递归实现：
void PrintBiTree(BiTree T){
cout<<endl;
LayerTraverse(T,printelem);
cout<<endl;
}
void CopyBiTree(BiTree T,BiTree &M){
if (!T) M=T;
else{
M=new BiTNode;
M->data=T->data;
CopyBiTree (T->lchild,M->lchild);
CopyBiTree(T->rchild,M->rchild);
}
}

D. 计算机二级二叉树算法

1、二叉树的概念

二叉树是一种特殊的树形结构，每个结点最多只有两棵子树，且有左右之分不能互换，因此，二叉树有五种不同的形态。

2、二叉树的性质

性质1 在二叉树的第k层上，最多有2^(k-1)(k≥1）个结点。

性质2 深度为m的二叉树最多有2^m-1个结点。

性质3 在任意一棵二叉树中，度为0的结点（叶子结点）总是比度为2的结点多一个。

性质4 具有n个结点的二叉树，其深度不小于[log2n]+1,其中[log2n]表示为log2n的整数部分。

E. 请利用栈的基本操作写出复制二叉树的非递归算法

//非递归方法
pbinary_tree_node _binary_tree(pbinary_tree_node bt)
{//先序遍历输出一颗树的全部结点值1,2,3
stack<pbinary_tree_node> stack_left,stack_right;
pbinary_tree_node newbt;
if (bt!=NULL)
{
//new root
newbt=new binary_tree_node;
newbt->data=bt->data;
//travel bt and travel newbt at the same time
stack_left.push(bt);
stack_right.push(newbt);
while (!stack_left.empty())
{
pbinary_tree_node pleft=stack_left.top();
pbinary_tree_node pright=stack_right.top();
stack_left.pop();
stack_right.pop();
if (pleft->rchild!=0)
{
stack_left.push(pleft->rchild);
pright->rchild=new binary_tree_node;
pright->rchild->data=pleft->rchild->data;
stack_right.push(pright->rchild);
}
if (pleft->lchild!=0)
{
stack_left.push(pleft->lchild);
pright->lchild=new binary_tree_node;
pright->lchild->data=pleft->lchild->data;
stack_right.push(pright->lchild);
}
}
}
return newbt;
}

//递归方法
void _binary_tree(pbinary_tree_node bt,pbinary_tree_node &newbt)
{
if(bt!=NULL)
{
newbt=(pbinary_tree_node )malloc(sizeof(binary_tree_node));
newbt->data=bt->data;
_binary_tree(bt->lchild,newbt->lchild);
_binary_tree(bt->rchild,newbt->rchild);
}
else
newbt=NULL;
}
这个应该没问题了，

F. 二叉树各种计算公式总结有哪些

二叉树各种计算公式总结有n个节点的二叉树一共有2n除以n乘以 n+1这种，n层二叉树的第n层最多为2乘n减1个。二叉树节点计算公式 N 等于n0加n1加n2，度为0的叶子节点比度为2的节点数多一个。N等于1乘n1加2乘n2加1。具有n个节点的完全二叉树的深度为log2n加 1。

二叉树的含义

二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个最多只能有两棵子树，且有左右之分。

二叉树是n个有限元素的集合，该集合或者为空，或者由一个称为根的元素及两个不相交的，被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。

G. 复制二叉树的非递归算法.算法思想和算法实现.

voidMain()
{
	BNodenode=newBNode(){
		value="1",
		lNode=newBNode(){
			value="1-1"
		},
		rNode=newBNode(){
			value="1-2",
			lNode=newBNode(){
				value="1-2-1",
				rNode=newBNode(){
					value="1-2-1-2"
				}
			},
			rNode=newBNode(){
				value="1-2-2"
			}
		}
	};
	
	BNodeclone=Clone(node);
}

BNodeClone(BNodesource){
	Stack<BNode>stack=newStack<BNode>();
	stack.Push(source);
	
	BNodedest=newBNode();
	Stack<BNode>stackDest=newStack<BNode>();
	stackDest.Push(dest);
	while(stack.Count>0){
		//复制节点的值
		BNodes=stack.Peek();
		BNoded=stackDest.Peek();
		d.value=s.value;

		if(s.lNode!=null){//寻找左子树作为下一个结点
			stack.Push(s.lNode);
			d.lNode=newBNode();
			stackDest.Push(d.lNode);
		}elseif(s.rNode!=null){//没有就找右子树
			stack.Push(s.rNode);
			d.rNode=newBNode();
			stackDest.Push(d.rNode);
		}else{//全没有跳转到父结点的右子树
			while(true){
				stack.Pop();
				stackDest.Pop();
				if(stack.Count<=0)break;
				
				BNodep=stack.Peek();
				if(p.rNode==s){//已经使用过右结点向上继续回溯
					s=p;
				}
				elseif(p.rNode!=null){
					stack.Push(p.rNode);
					d=stackDest.Peek();
					d.rNode=newBNode();
					stackDest.Push(d.rNode);
					break;
				}
				elses=p;
			}
		}
	}
	returndest;
}

//
classBNode{
	publicobjectvalue;
	publicBNodelNode;
	publicBNoderNode;
}

算法思想的话就是构建两个栈用于回溯父结点...

其实递归算法隐藏了栈而已... 手动把这个栈构建出来就算成功了...

以上是一段C#代码示例 java代码应该复制粘贴就能用 C或者C++的话把BNode写成指针就可以使用...