判断两个数组形成的树是否相同

package test.com.li;

public class TreeConsist<E extends Comparable<? super E>> {
	public static void main(String[] args) {
		int[] a = { 3, 1, 4, 2 };
//		Integer[] b = { 3, 1, 4, 2 };
		Integer[] b = {  3, 4, 2, 1 };
		TreeConsist<Integer> treeConsist = new TreeConsist<Integer>();
		// 建立树
		TreeNode<Integer> node = null;
		for (int i = 0; i < a.length; i++) {
			node = treeConsist.insert(node, a[i]);
		}
		System.out.println(treeConsist.judge(node, b));
		;

	}

	private static class TreeNode<E extends Comparable<? super E>> {
		public E data;

		public TreeNode<E> parentNode;
		public TreeNode<E> lfNode;
		public TreeNode<E> rgNode;
		boolean flg;

		public TreeNode(E data) {
			this.data = data;
		}
	}

	public TreeNode<E> insert(TreeNode<E> node, E data) {
		if (node == null)
			return new TreeNode<E>(data);
		else if (node.data.compareTo(data) > 0) {
			node.lfNode = insert(node.lfNode, data);
			node.lfNode.parentNode = node;
		} else if (node.data.compareTo(data) < 0) {
			node.rgNode = insert(node.rgNode, data);
			node.rgNode.parentNode = node;

		} else
			;
		return node;
	}

	public boolean judge(TreeNode<E> node, E[] a) {
		for (int i = 0; i < a.length; i++) {
			TreeNode<E> node1 = findNode(node, a[i]);
			if (node1 == null)
				return false;
			else if (node1.parentNode != null && !node1.parentNode.flg)
				return false;
		}
		return true;
	}

	public TreeNode<E> findNode(TreeNode<E> node, E a) {
		if (node == null)
			return null;
		if (node.data.compareTo(a) > 0)
			return findNode(node.lfNode, a);
		if (node.data.compareTo(a) < 0)
			return findNode(node.rgNode, a);
		else {
			node.flg = true;
			return node;
		}

	}

}