LeetCode刷题之旅（中等 -5）：101. 对称二叉树

2019年9月20日

小白我接触到这里题目时，一开始是有点懵逼的，虽然说有点基础，但是门槛就在那，所以还是花了点时间去消化递归与树的结合，直到自己最后恍然大悟，原来如此。。。

目录

题目：

解决方法1：递归遍历左右字数的对称节点

性能结果：

官方解决思路：

复杂度分析

解决方法2：

性能结果：

复杂度分析：

其他：

---

题目：

 

解决方法1：递归遍历左右字数的对称节点

package leetCode.tree;

/**
 * 对称二叉树
 * @author moubin.mo
 * @date: 2019/9/18 21:40
 */

public class SymmetricTreeSolution {

	public static void main(String[] args){
		TreeNode aTree = getATree();
		System.out.println("result = " + isSymmetric(aTree));
	}

	public static boolean isSymmetric(TreeNode root){

		if (root == null){
			return true;
		}

		if(root.left == null && root.right == null){
			return true;
		}

		if (root.left != null && root.right != null){
			return isSymmetric(root.left, root.right) && isSymmetric(root.right, root.left);
		}

		return false;
	}

	public static boolean isSymmetric(TreeNode node1, TreeNode node2){
		if (node1 == null && node2 == null){
			return true;
		}

		if (node1 == null || node2 == null){
			return false;
		}

		if (node1.val == node2.val){
			return isSymmetric(node1.left, node2.right) && isSymmetric(node1.right, node2.left);
		}

		return false;
	}

	/**
	 * 创建一棵树
	 */
	public static TreeNode getATree(){
		TreeNode headNode = new TreeNode(1);

		// 第一场节点
		TreeNode leftNode = new TreeNode(2);
		TreeNode rightNode = new TreeNode(2);

		// 第二层节点
		TreeNode leftChild1Node = new TreeNode(3);
		TreeNode leftChild2Node = new TreeNode(4);
		TreeNode rightChild1Node = new TreeNode(3);
		TreeNode rightChild2Node = new TreeNode(4);

//		leftNode.left = leftChild1Node;
//		leftNode.right = leftChild2Node;
//		rightNode.left = rightChild2Node;
//		rightNode.right = rightChild1Node;

		headNode.setLeft(leftNode);
		headNode.setRight(rightNode);
		return headNode;
	}

}

性能结果：

官方解决思路：

方法：递归
如果一个树的左子树与右子树镜像对称，那么这个树是对称的。

因此，该问题可以转化为：两个树在什么情况下互为镜像？

如果同时满足下面的条件，两个树互为镜像：

• 它们的两个根结点具有相同的值。
• 每个树的右子树都与另一个树的左子树镜像对称。

就像人站在镜子前审视自己那样。镜中的反射与现实中的人具有相同的头部，但反射的右臂对应于人的左臂，反之亦然。

复杂度分析

• 时间复杂度：O(n)O(n)，因为我们遍历整个输入树一次，所以总的运行时间为 O(n)O(n)，其中 nn 是树中结点的总数。
• 空间复杂度：递归调用的次数受树的高度限制。在最糟糕情况下，树是线性的，其高度为 O(n)O(n)。因此，在最糟糕的情况下，由栈上的递归调用造成的空间复杂度为 O(n)O(n)。

官方解决方法2：

/**
 * 对称二叉树
 * @author moubin.mo
 * @date: 2019/9/18 21:40
 */

public class SymmetricTreeSolution {

	public static void main(String[] args){
		TreeNode aTree = getATree();
		System.out.println("result = " + isSymmetricVIteration(aTree));
	}

	/**
	 * 迭代-队列
	 */
	public static boolean isSymmetricVIteration(TreeNode root){
		Queue<TreeNode> queue = new LinkedList<>();
		queue.add(root);
		queue.add(root);
		while (!queue.isEmpty()){
			TreeNode t1 = queue.poll();
			TreeNode t2 = queue.poll();
			if (t1 == null && t2 == null){
				continue;
			}
			if (t1 == null || t2 == null){
				return false;
			}
			if (t1.val != t2.val){
				return false;
			}
			queue.add(t1.left);
			queue.add(t2.right);
			queue.add(t1.right);
			queue.add(t2.left);
		}
		return true;
	}

	/**
	 * 创建一棵树
	 */
	public static TreeNode getATree(){
		TreeNode headNode = new TreeNode(1);

		// 第一场节点
		TreeNode leftNode = new TreeNode(2);
		TreeNode rightNode = new TreeNode(3);

		// 第二层节点
		TreeNode leftChild1Node = new TreeNode(3);
		TreeNode leftChild2Node = new TreeNode(4);
		TreeNode rightChild1Node = new TreeNode(3);
		TreeNode rightChild2Node = new TreeNode(4);

//		leftNode.left = leftChild1Node;
//		leftNode.right = leftChild2Node;
//		rightNode.left = rightChild2Node;
//		rightNode.right = rightChild1Node;

		headNode.setLeft(leftNode);
		headNode.setRight(rightNode);
		return headNode;
	}
}

除了递归的方法外，我们也可以利用队列进行迭代。队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像。最初，队列中包含的是 root 以及 root。该算法的工作原理类似于 BFS，但存在一些关键差异。每次提取两个结点并比较它们的值。然后，将两个结点的左右子结点按相反的顺序插入队列中。当队列为空时，或者我们检测到树不对称（即从队列中取出两个不相等的连续结点）时，该算法结束。（BFS，其英文全称是Breadth First Search。 BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中。一般的实验里，其邻居节点尚未被检验过的节点会被放置在一个被称为 open 的容器中（例如队列或是链表），而被检验过的节点则被放置在被称为 closed 的容器中。（open-closed表））

 

性能结果：

复杂度分析：

• 时间复杂度：O(n)，因为我们遍历整个输入树一次，所以总的运行时间为 O(n)，其中 n 是树中结点的总数。
• 空间复杂度：搜索队列需要额外的空间。在最糟糕情况下，我们不得不向队列中插入 O(n) 个结点。因此，空间复杂度为 O(n)。

 

其他：

Queue<TreeNode> queue = new LinkedList<>();

Deque接口继承了Queue接口,而Queue接口继承了Collection接口,
LinkedList实现了Deque接口;
关系很明显了吧：(顶级接口)Collection-->Queue-->Deque-->LinkedList(实现类)