update day7/31

Author: Obsession-kai

LeetCode/剑指offer/day7_搜索与回溯算法(简单)2/二叉树的镜像.go

@@ -0,0 +1,92 @@
+// 题目链接：https://leetcode.cn/problems/er-cha-shu-de-jing-xiang-lcof/?envType=study-plan&id=lcof
+// day7/31
+// 第 7 天主题为：搜索与回溯算法（简单），与前一天主题相同
+// 包含三道题目：
+// 剑指offer26.树的子结构
+// 剑指offer27.二叉树的镜像
+// 剑指offer28.对称的二叉树
+
+
+package main
+
+
+// Definition for a binary tree node.
+type TreeNode struct {
+    Val int
+    Left *TreeNode
+    Right *TreeNode
+}
+
+// 解题思路：观察例子可以发现，镜像 就是 每个节点的左右子树进行翻转。所以，两步完成本题：
+//1. 遍历二叉树保存所有节点（前中后序遍历都可以），用节点的指针类型切片保存；
+//2. 遍历切片，交换其左右子节点 node.Left,node.Right = node.Right,node.Left
+func mirrorTree(root *TreeNode) *TreeNode {
+	nodes := []*TreeNode{}
+	var preorder func(root *TreeNode)
+	preorder = func(root *TreeNode){
+		if root == nil{
+			return
+		}
+		nodes = append(nodes,root)
+		if root.Left != nil{
+			preorder(root.Left)
+		}
+		if root.Right != nil{
+			preorder(root.Right)
+		}
+	}
+	preorder(root)
+	for _,node := range nodes{
+		node.Left,node.Right = node.Right,node.Left
+	}
+	return root
+}
+
+// 上面这种解法的时间空间复杂度均为 O(n)
+// 我们也可以在遍历的过程中交换节点的左右子节点，省去 nodes 切片占用的内存空间，但这本质上并不会降低时间和空间复杂度，
+// 因为我们在对二叉树进行遍历的过程中，调用了系统栈，系统需要使用 O(n) 大小的栈空间。
+// 前序遍历的过程中交换左右子节点
+// 为避免函数命名冲突，次函数名添加后缀 “_2”
+func mirrorTree_2(root *TreeNode) *TreeNode {
+	var preorder func(root *TreeNode)
+	preorder = func(root *TreeNode){
+		if root == nil{
+			return
+		}
+		root.Left,root.Right = root.Right,root.Left
+		if root.Left != nil{
+			preorder(root.Left)
+		}
+		if root.Right != nil{
+			preorder(root.Right)
+		}
+	}
+	preorder(root)
+	return root
+}
+
+
+// 另外，在LeetCode题解区我还看到了有人用层序遍历的方式解题，本质上和上面两种思路是一样的，就是选择了另一种遍历二叉树的方式，
+// 交换左右子节点的核心操作无任何变化，代码开头的判断 root 节点是否为空不可省略，因为 q 初始化默认加入root节点，若该节点为空，后续代码会出错。
+// 为避免函数命名冲突，次函数名添加后缀 “_3”
+func mirrorTree_3(root *TreeNode) *TreeNode {
+	if root == nil{
+		return root
+	}
+	q := []*TreeNode{root}
+	for len(q) != 0{
+		node := q[0]
+		node.Left,node.Right = node.Right,node.Left
+		if node.Left != nil{
+			q = append(q,node.Left)
+		}
+		if node.Right != nil{
+			q = append(q,node.Right)
+		}
+		q = q[1:]
+	}
+	return root
+}
+
+
+// 二叉树的定义就是递归的，所以做二叉树的题目一定要有递归的想法，有思路后开始着手写代码，不要在脑海中模拟太多层的递归，否则很容易绕进去。

LeetCode/剑指offer/day7_搜索与回溯算法(简单)2/对称的二叉树.go

@@ -0,0 +1,36 @@
+// 题目链接：https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/?envType=study-plan&id=lcof
+
+package main
+
+
+// 解题思路：如果二叉树只有一个根节点，那其必然是对称的，本题主要是判断节点的左右子树是否对称。
+//
+// 判断左右子树是否对称，若两子树根节点均为空，说明对称，若某子树为空而另一颗子树不为空，说明不对称，两子树根节点值不相等的话也必定不对称吗，否则，对称，之后递归地判断
+//- 左子树的左子树 与 右子树的右子树 是否对称
+//- 左子树的右子树 与 右子树的左子树 是否对称
+// 两者均对称时，说明该左右子树对称；否则，不对称。
+
+func isSymmetric(root *TreeNode) bool {
+	// 根节点为空，对称
+	if root == nil{
+		return true
+	}
+	var sym func(x,y *TreeNode) bool
+	// 递归判断左右子树是否对称
+	sym = func(x,y *TreeNode) bool {
+		// 两者均为空说明对称
+		if x == nil && y == nil{
+			return true
+		//	其中某一子树为空，而另一子树不为空，不对称
+		} else if x == nil || y == nil{
+			return false
+		}
+		// 两者根节点值不相等时也不对称
+		if x.Val != y.Val{
+			return false
+		}
+		// 递归判断x的左右子树 与 y 的右左子树是否对称
+		return sym(x.Left,y.Right) && sym(x.Right,y.Left)
+	}
+	return sym(root.Left,root.Right)
+}

LeetCode/剑指offer/day7_搜索与回溯算法(简单)2/树的子结构.go

@@ -0,0 +1,60 @@
+// 题目链接：https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/
+
+package main
+
+
+// 此题解参考自：https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/solution/mian-shi-ti-26-shu-de-zi-jie-gou-xian-xu-bian-li-p/
+// 若树 B 是 A 的子结构，则 A 子结构的根节点可能是 A 中任意一个节点，我们判断 B 是否为 A 的子结构，就需要遍历 A 的所有节点，
+// 然后判断是否有某节点 以 该节点为 根节点的子树包含（有点绕，其实就是，若 A 与 B 根节点相同， B 是否为 A 的子结构，
+// 但当 B 为空的时候，B 必为 A 的子结构）。
+// 名词规定：树 A 的根节点记作 节点 A，树 B 的根节点称为 节点 B 。
+// recur(A, B)函数，用于判断树 A 中以 A为根节点的子结构是否包含树 B
+//终止条件：
+//- 当节点 B 为空：说明树 B 已匹配完成（越过叶子节点），因此返回 true ；
+//- 当节点 A 为空：说明已经越过树 A 叶子节点（而 B 节点非空），即匹配失败，返回 false ；
+//- 当节点 A 和 B 的值不同：说明匹配失败，返回 false ；
+//返回值：
+//- 判断 A 和 B 的左子节点是否相等，即 recur(A.left, B.left) ；
+//- 判断 A 和 B 的右子节点是否相等，即 recur(A.right, B.right) ；
+//两者取逻辑与后返回。
+// 特例处理：当 树 A 为空 或 树 B 为空时，直接返回 false（对应题目中的约定：空树不是任意一个树的子结构） 。
+// 之后我们对 A 作遍历（前中后序都可以），对其中每个节点与 B 进行 recur 判断，若存在 true 结果，返回最终的 true；若全为 false，说明 B 不是 A 的子结构，返回 false。
+func isSubStructure(A *TreeNode, B *TreeNode) bool {
+	if A == nil || B == nil{
+		return false
+	}
+	nodes := []*TreeNode{}
+	// 对树的遍历，这里我采用前序遍历
+	// 使用 中序遍历、后序遍历 or 层序遍历都是可以的
+	var perorder func(root *TreeNode)
+	perorder = func(root *TreeNode){
+		if root == nil{
+			return
+		}
+		nodes = append(nodes,root)
+		if root.Left != nil{
+			perorder(root.Left)
+		}
+		if root.Right != nil{
+			perorder(root.Right)
+		}
+	}
+	perorder(A)
+	// 判断B是否为以为根节点的子树的在子结构
+	var sub func(A,B *TreeNode) bool
+	sub = func(A,B *TreeNode) bool{
+		if B == nil{
+			return true
+		}
+		if A == nil || A.Val != B.Val {
+			return false
+		}
+		return sub(A.Left,B.Left) && sub(A.Right,B.Right)
+	}
+	for _,node := range nodes{
+		if sub(node,B){
+			return true
+		}
+	}
+	return false
+}