判断两棵树是否相等

请实现两棵树是否相等的比较，相等返回1，否则返回其他值，并说明算法复杂度。 数据结构为： typedef struct_TreeNode{ char c; TreeNode *leftchild; TreeNode *rightchild; }TreeNode; 函数接口为：int CompTree(TreeNode* tree1,TreeNode* tree2); 注：A、B两棵树相等当且仅当Root->c==RootB-->c,而且A和B的左右子树相等或者左右互换相等。

 

如果是单纯比较树则这个问题比较简单，这个地方有一个左右互换相等，需要特别处理一下：

如下图，就是相同的树，左右互换相等。

仔细分析一下，如果用递归算法，可以很简单的得到一个解：

对于2个孩子的节点，A与B是否相等等同于

compare(A.left, B.left) && compare(A.right, B.right) || compare(A.left, B.right) && compare(A.right, B.left)

而对于一个孩子的节点和叶子节点需要特殊处理，用JAVA实现之就是：

 

public class TreeNode { char c; TreeNode left; TreeNode right; public static boolean compare(TreeNode treea, TreeNode treeb){ if(treea==null && treeb==null){ return true; }else{ if(treea==null && treeb!=null || treea!=null && treeb==null){ return false; }else{ if(treea.c==treeb.c){ return compare(treea.left, treeb.left) && compare(treea.right, treeb.right) || compare(treea.left, treeb.right) && compare(treea.right, treeb.left); }else{ return false; } } } } }

 

如果说递归不好，想用其他方法，自然想到深度遍历的栈，简单来讲，可以用2个栈来实现，A栈放A树，B栈放B树，有点特殊的就是：

1.如果节点有1个孩子，则可能要进行左右交换，如上图中的b节点。

2.如果节点有2个孩子，也可能要进行左右交换，如上图中的b和c节点。

交换的结果就是入栈时候放入不同元素。

 

用Java实现就是：

 

import java.util.Stack; public class TreeNode { char c; TreeNode left; TreeNode right; public static boolean compare2(TreeNode treea, TreeNode treeb){ Stack<TreeNode> _stacka = new Stack<TreeNode>(); Stack<TreeNode> _stackb = new Stack<TreeNode>(); _stacka.push(treea); _stackb.push(treeb); while(!_stacka.isEmpty() && !_stackb.isEmpty()){ TreeNode _a = _stacka.pop(); TreeNode _b = _stackb.pop(); if(_a.c!=_b.c || _a.numberOfchildren()!=_b.numberOfchildren()){ return false; } if(_a.numberOfchildren()==1){ _stacka.push(_a.left!=null?_a.left:_a.right); _stackb.push(_b.left!=null?_b.left:_b.right); } if(_a.numberOfchildren()==2){ if(_a.left.c==_b.left.c){ _stacka.push(_a.left); _stacka.push(_a.right); _stackb.push(_b.left); _stackb.push(_b.right); }else{ _stacka.push(_a.left); _stacka.push(_a.right); _stackb.push(_b.right); _stackb.push(_b.left); } } } return true; } }

 

这里用到了2个栈，其实可以看到，AB两个栈要么同时出，要么同时进，可以简化为一个栈。

 

import java.util.Stack; public class TreeNode { char c; TreeNode left; TreeNode right; public static boolean compare3(TreeNode treea, TreeNode treeb){ Stack _stack = new Stack(); TreeNode[] pair = new TreeNode[2]; pair[0] = treea; pair[1] = treeb; _stack.push(pair); while(!_stack.isEmpty()){ TreeNode[] tmp = (TreeNode[]) _stack.pop(); TreeNode _a = tmp[0]; TreeNode _b = tmp[1]; if(_a.c!=_b.c || _a.numberOfchildren()!=_b.numberOfchildren()){ return false; } if(_a.numberOfchildren()==1){ tmp = new TreeNode[2]; tmp[0] = _a.left!=null?_a.left:_a.right; tmp[1] = _b.left!=null?_b.left:_b.right; _stack.push(tmp); } if(_a.numberOfchildren()==2){ if(_a.left.c==_b.left.c){ tmp = new TreeNode[2]; tmp[0] = _a.left; tmp[1] = _b.left; _stack.push(tmp); tmp = new TreeNode[2]; tmp[0] = _a.right; tmp[1] = _b.right; _stack.push(tmp); }else{ tmp = new TreeNode[2]; tmp[0] = _a.left; tmp[1] = _b.right; _stack.push(tmp); tmp = new TreeNode[2]; tmp[0] = _a.right; tmp[1] = _b.left; _stack.push(tmp); } } } return true; } public int numberOfchildren(){ return ((left!=null)?1:0) + ((right!=null)?1:0); } }

 

3种算法的时间复杂度是O(N)，因为树元素都只访问一次。