剑指offer-二叉树
1. 平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
解：
要么是一颗空树，要么左右子树都是平衡二叉树且左右子树深度之差不超过1
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def IsBalanced_Solution(self, pRoot): 8 # write code here 9 if not pRoot: 10 return True 11 res = abs(self.getDepth(pRoot.left) - self.getDepth(pRoot.right)) 12 if res <= 1 and self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right): 13 return True 14 return False 15 16 def getDepth(self, root): 17 if not root: 18 return 0 19 if not (root.left or root.right): 20 return 1 21 return max(self.getDepth(root.left), self.getDepth(root.right)) + 1
2. 二叉树的深度
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。
解：
层次遍历，bfs 实现
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def TreeDepth(self, pRoot): 8 # write code here 9 if not pRoot: 10 return 0 11 depth = 0 12 queue = [pRoot] 13 while queue: 14 tmp = [] 15 for i in range(len(queue)): 16 node = queue.pop(0) 17 tmp.append(node.val) 18 if node.left: 19 queue.append(node.left) 20 if node.right: 21 queue.append(node.right) 22 if tmp: 23 depth += 1 24 return depth
dfs 实现，只需要记录深度即可，不用记录节点
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def TreeDepth(self, pRoot): 8 # write code here 9 if not pRoot: 10 return 0 11 self.depth = 0 12 def helper(node, level): 13 if not(node.left or node.right): 14 self.depth = max(self.depth, level) 15 return 16 if node.left: 17 helper(node.left, level+1) 18 if node.right: 19 helper(node.right, level+1) 20 21 helper(pRoot, 1) 22 return self.depth
3. 二叉树的下一个节点
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
解：
几种可能的情况考虑一下即可
1 # class TreeLinkNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 # self.next = None 7 class Solution: 8 def GetNext(self, pNode): 9 # write code here 10 if not pNode: 11 return 12 13 # 如果当前节点有右子树，中序遍历的下一个节点是其右子树的最左节点 14 if pNode.right: 15 pRight = pNode.right 16 while pRight.left: 17 pRight = pRight.left 18 return pRight 19 20 # 如果当前节点没有右子树，但是当前节点是其父节点的左子节点，下一个节点是其父节点 21 if pNode.next and pNode.next.left == pNode: 22 return pNode.next 23 24 # 如果当前节点没有右子树，但是是其父节点的右子节点，则一直向上遍历，找到是其父节点的左子结点的pNode 25 # 当前节点的下一个节点就是pNode的父节点 26 if pNode.next and pNode.next.right == pNode: 27 while pNode.next and pNode != pNode.next.left: 28 pNode = pNode.next 29 return pNode.next 30 return
4. 对称的二叉树
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。
解：
递归实现，判断给定两个节点为根的子树是否镜像，首先根节点的值要相等，其次A的左子树和B的右子树、A的右子树和B的左子树要递归的进行判断
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def isSymmetrical(self, pRoot): 8 # write code here 9 if not pRoot: 10 return True 11 return self.compare(pRoot.left, pRoot.right) 12 13 def compare(self, p1, p2): 14 if p1 == None : 15 return p2 == None 16 if p2 == None: 17 return False 18 if p1.val != p2.val: 19 return False 20 return self.compare(p1.left, p2.right) and self.compare(p1.right, p2.left)
dfs，用栈实现，成对取出成对插入，镜像：左左配右右，左右配右左
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def isSymmetrical(self, pRoot): 8 # write code here 9 if not pRoot: 10 return True 11 stack = [pRoot.left, pRoot.right] 12 13 while stack: 14 right = stack.pop() # 成对取出 15 left = stack.pop() 16 if left == None and right == None: 17 continue 18 if left == None or right == None: 19 return False 20 if left.val != right.val: 21 return False 22 23 # 成对插入 24 stack.append(left.left) 25 stack.append(right.right) 26 stack.append(left.right) 27 stack.append(right.left) 28 29 return True
bfs，队列实现
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def isSymmetrical(self, pRoot): 8 # write code here 9 if not pRoot: 10 return True 11 queue = [pRoot.left, pRoot.right] 12 13 while queue: 14 left = queue.pop(0) # 成对取出 15 right = queue.pop(0) 16 if left == None and right == None: 17 continue 18 if left == None or right == None: 19 return False 20 if left.val != right.val: 21 return False 22 23 # 成对插入 24 queue.append(left.left) 25 queue.append(right.right) 26 queue.append(left.right) 27 queue.append(right.left) 28 29 return True
5. 把二叉树打印成多行
从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。
解：
层次遍历，bfs
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 # 返回二维列表[[1,2],[4,5]] 8 def Print(self, pRoot): 9 # write code here 10 if not pRoot: 11 return [] 12 res = [] 13 queue = [pRoot] 14 while queue: 15 tmp = [] 16 for i in range(len(queue)): 17 node = queue.pop(0) 18 tmp.append(node.val) 19 if node.left: 20 queue.append(node.left) 21 if node.right: 22 queue.append(node.right) 23 if tmp: 24 res.append(tmp) 25 return res
dfs
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 # 返回二维列表[[1,2],[4,5]] 8 def Print(self, pRoot): 9 # write code here 10 if not pRoot: 11 return [] 12 self.res = [] 13 14 def helper(node, level): 15 if not node: 16 return 17 if level == len(self.res): 18 self.res.append([]) 19 self.res[level].append(node.val) 20 if node.left: 21 helper(node.left, level + 1) 22 if node.right: 23 helper(node.right, level + 1) 24 25 helper(pRoot, 0) 26 return self.res
6. 按之字形顺序打印二叉树
请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
解：
还是层次遍历，用一个 flag 控制每一层是正序还是逆序
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def Print(self, pRoot): 8 # write code here 9 if not pRoot: 10 return [] 11 leftToRight = True 12 queue = [pRoot] 13 res = [] 14 while queue: 15 tmp = [] 16 for i in range(len(queue)): 17 node = queue.pop(0) 18 tmp.append(node.val) 19 if node.left: 20 queue.append(node.left) 21 if node.right: 22 queue.append(node.right) 23 if tmp: 24 if leftToRight: 25 res.append(tmp) 26 else: 27 res.append(tmp[::-1]) 28 leftToRight = not leftToRight 29 return res
7. 序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
解：
这题的序列化就直接前序遍历实现即可，注意按要求用字符 # 和 ！表示空节点和结束符。
主要问题在反序列化上，还是按照根左右的顺序递归，用 flag 来控制递归过程中，反序列化的节点值在数组中的索引，flag从0开始，每次都+1，遇到‘#’说明是空节点，不需要构造node
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 def __init__(self): 8 self.flag = -1 9 def Serialize(self, root): 10 # write code here 11 if not root: 12 return '#!' 13 return str(root.val)+'!'+self.Serialize(root.left)+self.Serialize(root.right) 14 15 def Deserialize(self, s): 16 # write code here 17 self.flag += 1 18 vals = s.split('!') 19 if self.flag >= len(vals): 20 return None 21 root = None 22 if vals[self.flag] != '#': 23 root = TreeNode(int(vals[self.flag])) 24 root.left = self.Deserialize(s) 25 root.right = self.Deserialize(s) 26 return root
8. 二叉搜索树的第k个节点
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
解：
中序遍历即有序
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 # 返回对应节点TreeNode 8 def KthNode(self, pRoot, k): 9 # write code here 10 if not pRoot: 11 return None 12 self.res = [] 13 self.midOrdTrav(pRoot) 14 return self.res[k-1] if 0<k<=len(self.res) else None 15 16 def midOrdTrav(self, root): 17 if not root: 18 return 19 self.midOrdTrav(root.left) 20 self.res.append(root) 21 self.midOrdTrav(root.right)
中序遍历的时候维护一个计数器，到 k 个数了就返回
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 # 返回对应节点TreeNode 8 def KthNode(self, pRoot, k): 9 # write code here 10 if not pRoot: 11 return None 12 13 count = 0 14 stack = [] 15 p = pRoot 16 while p or stack: 17 while p: 18 stack.append(p) 19 p = p.left 20 if stack: 21 p = stack.pop() 22 count += 1 23 if count == k: 24 return p 25 p = p.right 26 return None
9.数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
解：
维护两个堆，大顶堆用来存较小的数，从大到小排列；小顶堆用来存较大的数，从小到大排列。
保证小顶堆中的元素都大于等于大顶堆中的元素（始终保证较大数的那一半多一个或者一样多，中位数始终在这一边），所以 insert 的时候先 push 进小顶堆（存较大的数），再把小顶堆中的最小值 pop 出来 push 到大顶堆（存较小的数）中。
每次都检查，如果小顶堆的元素个数小于大顶堆的元素个数（较大的数比较小的数少了），就把大顶堆中的最大值 pop 出来 push 小顶堆。
取中位数的时候，如果当前两个堆一样多，显然是取小顶堆和大顶堆根结点的平均值；如果当前小顶堆元素个数多一个，显然是取小顶堆的根节点
1 import heapq 2 class Solution: 3 def __init__(self): 4 self.small = [] # 小的数，大顶堆 5 self.large = [] # 大的数，小顶堆 6 7 def Insert(self, num): 8 # write code here 9 heapq.heappush(self.small, -heapq.heappushpop(self.large, num)) 10 if len(self.large) < len(self.small): 11 heapq.heappush(self.large, -heapq.heappop(self.small)) 12 13 def GetMedian(self, default=None): 14 # write code here 15 if len(self.large) > len(self.small): 16 return float(self.large[0]) 17 return (self.large[0] - self.small[0])/2.
10. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解：
其实就是一个递归的过程，每次找一下根节点在哪，进而定位好左右子树的切片，构建好了根节点之后再分别去构建左右子树
1 # class TreeNode: 2 # def __init__(self, x): 3 # self.val = x 4 # self.left = None 5 # self.right = None 6 class Solution: 7 # 返回构造的TreeNode根节点 8 def reConstructBinaryTree(self, pre, tin): 9 # write code here 10 if not pre or not tin: 11 return None 12 root = TreeNode(pre[0]) 13 index = self.Search(tin, root.val) # tin.index(root.val) 14 root.left = self.reConstructBinaryTree(pre[1:index+1], tin[:index]) 15 root.right = self.reConstructBinaryTree(pre[index+1:], tin[index+1:]) 16 return root 17 18 def Search(self, nums, target): 19 if not nums: 20 return -1 21 n = len(nums) 22 for i in range(n): 23 if nums[i] == target: 24 return i 25 return -1
----想成为合格的算法工程师----
