判断两个二叉树是否相同

判断两个二叉树是否相同

递归解法：

public boolean isSameTreeRec(TreeNode p, TreeNode q) {
if((p==null)&(q!=null)||((p!=null)&(q==null))){
return false;
}
if (p == null && q == null) {
return true;
} else {
if (p.val == q.val) {
if (isSameTreeRec(p.left, q.left)
& isSameTreeRec(p.right, q.right)) {
return true;
} else {
return false;
}

} else {
return false;
}
}
}

第一次写了一个是这样的，自己觉得也可以，提交时不能AC，想了下根本是自己算法立足点不对，分享下：

对于一棵二叉树，有前序序列或后序序列与中序序列能否就此确定此二叉树？

答案是否定的，当二叉树中节点值全部相等时，二叉树的形态不能被确定

如果二叉树中的前序遍历与中序遍历序列里存在值不相等的节点，那么可以通过前序序列与中序序列确定这棵二叉树

如果存在值不相等的节点，那么判断两个二叉树是否相等可以这样：分别前序，中序遍历两个二叉树，并保存值结果集，然后再分别循环比较两个树的前序遍历结果集

与中序遍历结果集，一样，则两棵树一样。

public boolean isSameTree(TreeNode p, TreeNode q) {
boolean ret = true;
if (p == null && q == null) {
return ret;
}
LinkedList<Integer> pPreOrderList = (LinkedList<Integer>) PreOrderListRec(p);
LinkedList<Integer> pInOrderList = (LinkedList<Integer>) InOrderListRec(p);
LinkedList<Integer> qPreOrderList = (LinkedList<Integer>) PreOrderListRec(q);
LinkedList<Integer> qInOrderList = (LinkedList<Integer>) InOrderListRec(q);
ret = isSameList(pInOrderList, qInOrderList)
& isSameList(pPreOrderList, qPreOrderList);
return ret;
}

public List<Integer> PreOrderListRec(TreeNode root) {
List<Integer> ret = new LinkedList<Integer>();
PreOrderList(root, ret);
return ret;
}

public void PreOrderList(TreeNode root, List<Integer> ret) {
if (root == null) {
return;
} else {
PreOrderList(root.left, ret);
ret.add(root.val);
PreOrderList(root.right, ret);
}
}

@SuppressWarnings("null")
public List<Integer> InOrderListRec(TreeNode root) {
List<Integer> ret = new LinkedList<Integer>();
InOrderList(root, ret);
return ret;
}

public void InOrderList(TreeNode root, List<Integer> ret) {
if (root == null) {
return;
} else {
ret.add(root.val);
InOrderList(root.left, ret);
InOrderList(root.right, ret);
}
}

public boolean isSameList(List<Integer> list1, List<Integer> list2) {
boolean ret = true;
if (list1.size() != list2.size()) {
return false;
} else {
for (int i = 0; i < list1.size(); i++) {
if (list1.get(i) != list2.get(i)) {
return false;
}
}
}
return ret;
}

算法二真不是一个可行（不能AC）的结，但算法二中这些函数之前已经实现，调用方便，可是考虑不够缜密出现了漏解情况。

由此想到，如果一个算法不是深入其内部结构去实现它，而是通过其他一些算法堆积，那么就要注意一些边界问题了。以后很多都是这样的，对于大问题并不是想着基础编码去实现，更多的是调用已经写好的方法（比如本地方法），就要仔细考虑问题的边界是怎样的，该怎样解决