剑指offer 刷题 十五 搜索与回溯（34 36 54）

剑指 Offer 34. 二叉树中和为某一值的路径
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

尝试写，没写出来的DFS：

def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        def dfs(root, li):
            li.append(root.val)
            if sum(li) == target: return li
            if not root.left and not root.right: return li
            if root.left: dfs(root.left, li)
            if root.right: dfs(root.right, li)

        li = []
        return dfs(root, li)

下面是大佬的思路和代码：



大佬代码DFS：

class Solution:
    def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
        res, path = [], []
        def recur(root, tar):
            if not root: return
            path.append(root.val)
            tar -= root.val
            if tar == 0 and not root.left and not root.right:
                res.append(list(path))
            recur(root.left, tar)
            recur(root.right, tar)
            path.pop()

        recur(root, tar)
        return res

根据大佬代码，自己写了一遍：

def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        res, path = [], []
        
        def dfs(root, tar):
            if not root: return 
            path.append(root.val)
            if sum(path) == target and not root.left and not root.right:
                res.append(list(path))
            dfs(root.left, tar)
            dfs(root.right, tar)
            path.pop()
        
        dfs(root, target)
        return res

DFS和BFS每种题型都需要刷20道，才能找到一点感觉。光看老师理论部分绝绝对对的不行。还要及时复盘，不然忘的很快。

剑指 Offer 36. 二叉搜索树与双向链表
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。




打印中序遍历

def dfs(root):
    if not root: return
    dfs(root.left)  # 左
    print(root.val) # 根
    dfs(root.right) # 右

class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        def dfs(cur):
            if not cur: return
            dfs(cur.left) # 递归左子树
            if self.pre: # 修改节点引用
                self.pre.right, cur.left = cur, self.pre
            else: # 记录头节点
                self.head = cur
            self.pre = cur # 保存 cur
            dfs(cur.right) # 递归右子树
        
        if not root: return
        self.pre = None
        dfs(root)
        self.head.left, self.pre.right = self.pre, self.head
        return self.head

对照大佬思路和代码写的，说实话，第一次写绝对写不了，即便看了答案也写不出来。DFS的思想需要多刷才能找到感觉。其实就是递归，我递归就是很理解不来。。。

def treeToDoublyList(self, root: 'Node') -> 'Node':
        def dfs(cur):
            if not cur: return
            dfs(cur.left)
            if self.pre:
                self.pre.right, cur.left = cur, self.pre
            else:
                self.head = cur
            self.pre = cur
            dfs(cur.right)

        if not root: return 
        self.pre = None
        dfs(root)        
        self.pre.right = self.head
        self.head.left = self.pre
        return self.head

剑指 Offer 54. 二叉搜索树的第k大节点

给定一棵二叉搜索树，请找出其中第 k 大的节点的值。

BFS:

def kthLargest(self, root: TreeNode, k: int) -> int:
        queue = collections.deque()
        queue.append(root)
        li = []
        while queue:
            node = queue.popleft()
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
            li.append(node.val)
        li.sort()
        return li[-k]

下面是大佬的思路和代码，注意这里的代码假设的测试例题是排序的。

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        def dfs(root):
            if not root: return
            dfs(root.right)
            if self.k == 0: return
            self.k -= 1
            if self.k == 0: self.res = root.val
            dfs(root.left)

        self.k = k
        dfs(root)
        return self.res