6.2 数据结构---树（路径）

posted @ 2019-10-15 09:35 nxf_rabbit75 阅读(2463) 评论(0) 编辑收藏举报

分类: 数据结构

undefined

一、路径

1.二叉树的所有路径 leetcode 257

思路：深度遍历

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
  
class Solution:
    def __init__(self):
            self.paths = []
              
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        def dfs(root,path):  
            if not root.left and not root.right:#叶子节点
                path += str(root.val)
                self.paths.append(path)
                return
              
            path += str(root.val)+'->'
            if root.left:
                dfs(root.left,path)
            if root.right:
                dfs(root.right,path)
              
        if root == None:
            return []
        elif not root.left and not root.right:
            return [str(root.val)]
        else:
            dfs(root,'')
            return self.paths
          
        

2.求根到叶子节点数字之和 leetcode 129

思路：深度遍历，递归保存每一条路径

这里用int(s)就可以将以0开头的字符串'00123...'转成数字，或者将很多0组成的‘000...’转成0

‘001’--> int('001')=1

'000'-->int('000')=0

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
  
class Solution:
    def __init__(self):
            self.paths = []
              
    def sumNumbers(self, root: TreeNode) -> int:
        def dfs(root,path):
            if not root.left and not root.right:#叶子
                path += str(root.val)
                self.paths.append(path)
                return
            path += str(root.val)
            if root.left:
                dfs(root.left,path)
            if root.right:     
                dfs(root.right,path)
          
        if not root:
            return 0
        if not root.left and not root.right:
            return root.val
        path = ''
        dfs(root,path)
        res = 0
        # print(self.paths)
        for i_path in self.paths:
            if len(i_path) * '0' == i_path:#全0
                continue
            elif i_path.startswith('0'):#以0开头
                while len(i_path) > 0:
                    if i_path.startswith('0'):
                        i_path = i_path[1:]
                    else:
                        print(i_path)
                        res += eval(i_path)
                        break
            else:#正常
                print(eval(i_path))
                res += eval(i_path)

二、路径总和

1.路径总和 leetcode112

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
 
说明: 叶子节点是指没有子节点的节点。
 
示例:
给定如下二叉树，以及目标和 sum = 22，
 
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1
返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

思路： 用栈将递归转成迭代的形式。深度优先搜索在除了最坏情况下都比广度优先搜索更快。最坏情况是指满足目标和的 root->leaf 路径是最后被考虑的，这种情况下深度优先搜索和广度优先搜索代价是相通的。利用深度优先策略访问每个节点，同时更新剩余的目标和。所以我们从包含根节点的栈开始模拟，剩余目标和为 sum - root.val。然后开始迭代：弹出当前元素，如果当前剩余目标和为 0 并且在叶子节点上返回 True；如果剩余和不为零并且还处在非叶子节点上，将当前节点的所有孩子以及对应的剩余和压入栈中。

时间复杂度：和递归方法相同是O(N)。空间复杂度：当树不平衡的最坏情况下是O(N) 。在最好情况（树是平衡的）下是 O(log N)。

# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
 
class Solution:
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if not root:
            return False
 
        de = [(root, sum - root.val), ]
        while de:
            node, curr_sum = de.pop()
            if not node.left and not node.right and curr_sum == 0:
                return True
            if node.right:
                de.append((node.right, curr_sum - node.right.val))
            if node.left:
                de.append((node.left, curr_sum - node.left.val))
        return False

2.路径总和| leetcode113

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。
 
说明: 叶子节点是指没有子节点的节点。
 
示例:
给定如下二叉树，以及目标和 sum = 22，
 
              5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1
返回:
 
[
   [5,4,11,2],
   [5,8,4,5]
]

思路：

从根节点深度遍历二叉树，先序遍历时，将该节点值存储值path栈中，使用path_value累加节点值；
当遍历至叶节点时，检查path_value值是否为sum，若为sum，则将path push进入result中；
在后续遍历时，将该节点值从path栈中弹出，path_value减去节点值。

代码1：用栈

class Solution:
    def pathSum2(self, root, target, ):
        self.result = []
        path = []
        def helper(root, target, path):
            if root == None:
                return
            path.append(root.val)
            if (root.left == None) and (root.right == None) and (sum(path) == target):
                tmp = path[:]
                self.result.append(tmp)
            helper(root.left, target, path)
            helper(root.right, target, path)
            path.pop()
 
        helper(root, target, path)
        return self.result

代码2：

class Solution (object):
    def pathSum(self,root,sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: List[List[int]]
        """
        res = []
        if not root: return []
 
        def helper(root, sum, tmp):
            if not root:
                return
            if not root.left and not root.right and sum - root.val == 0:
                tmp += [root.val]
                res.append (tmp)
                return
            helper (root.left, sum - root.val, tmp + [root.val])
            helper (root.right, sum - root.val, tmp + [root.val])
 
        helper (root, sum, [])
        return res

3.路径总和|| leetcode437

给定一个二叉树，它的每个结点都存放着一个整数值。
 
找出路径和等于给定数值的路径总数。
 
路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
 
二叉树不超过1000个节点，且节点数值范围是 [-1000000,1000000] 的整数。
 
示例：
 
root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8
 
      10
     /  \
    5   -3
   / \    \
  3   2   11
 / \   \
3  -2   1
 
返回 3。和等于 8 的路径有:
 
1.  5 -> 3
2.  5 -> 2 -> 1
3.  -3 -> 11

三、最大路径和

1.最大路径和 leetcode124

题目：给定一棵二叉树，求各个路径的最大和，路径可以以任意节点作为起点和终点。

思路：后序遍历，每次递归的时候只返回左子树/右子树+root.data，最大值是全局记录的，所以不需要返回

最大路径和：根据当前节点的角色，路径和可分为两种情况：
一：以当前节点为根节点
1.只有当前节点
2.当前节点+左子树🌲
3.当前节点+右子树🌲
4.当前节点+左右子树
这四种情况的最大值即为以当前节点为根的最大路径和
此最大值要和已经保存的最大值比较，得到整个树的最大路径值

二：当前节点作为父节点的一个子节点
和父节点连接的话则需取【单端的最大值】
1.只有当前节点
2.当前节点+左子树🌲
3.当前节点+右子树🌲
这三种情况的最大值

class TreeNode:
    def __init__(self,data):
        self.data = data
        self.left = None
        self.right = None
 
class IntRef:
    def __init__(self):
        self.val = None
 
class Solution:
    def findMaxPathRecursive(self,root,maxs):
        if root == None:
            return 0
        leftmax = self.findMaxPathRecursive(root.left,maxs)
        rightmax = self.findMaxPathRecursive(root.right,maxs)
        tmp = max(max(leftmax+root.data,rightmax+root.data),leftmax+rightmax+root.data)
        if tmp > maxs.val:
            maxs.val = tmp
            print(maxs)
        submax = leftmax if leftmax > rightmax else rightmax
        return root.data + submax
 
    def findMaxPath(self,root):
        maxs = IntRef()
        maxs.val = -2 **31
        self.findMaxPathRecursive(root,maxs)
        return maxs.val
 
if __name__ == '__main__':
    root = TreeNode(2)
    left = TreeNode(3)
    right = TreeNode(5)
    root.lef= left
    root.right = right
    S = Solution()
    maxs = S.findMaxPath(root)
    print(maxs)

四、最长同值路径

1.最长同值路径 leetcode687

给定一个二叉树，找到最长的路径，这个路径中的每个节点具有相同值。这条路径可以经过也可以不经过根节点。
注意：两个节点之间的路径长度由它们之间的边数表示。
 
示例1:
输入:
              5
             / \
            4   5
           / \   \
          1   1   5
输出:2
 
示例 2:
输入:
              1
             / \
            4   5
           / \   \
          4   4   5
输出:2
注意: 给定的二叉树不超过10000个结点.树的高度不超过1000。　

思路：先解释一下题目，就是让我们找到一个路径，这个路径上面的值都相同，而且可以不经过根节点，例如，例2中的4-4-4这样的。可以使用递归来做，首先，求出以每个节点为根节点的最长路径，然后从底向上，判断与父亲节点的值是否相同，如果相同，就把当前结点最长的一个分支路径加上1返回给父节点。其中，可以把最长路径保存到一个全局变量中。

class Solution (object):
    def longestUnivaluePath(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        maxL = 0
        def getMaxL(node,val):
            nonlocal maxL #用来在函数或其他作用域中使用外层(非全局)变量。
            if node == None:
                return 0
            leftMaxL = getMaxL(node.left,node.val)
            rightMaxL = getMaxL(node.right,node.val)
            maxL = max(maxL, leftMaxL + rightMaxL)
            print('node=%s,maxL=%s'%(node.val,maxL))
            if node.val == val:
                return max(leftMaxL,rightMaxL) + 1
            else:
                return 0
        if root != None:
            getMaxL(root,root.val)
        return maxL
 
 
    def longestUnivaluePath1(self,root):
        res = 0
        def dns(node):
            nonlocal res
            if node == None:
                return 0
            lmax = dns(node.left)
            rmax = dns(node.right)
            if node.left and node.left.val == node.val:
                lmax = lmax + 1
            else:
                lmax = 0
 
            if node.right and node.right.val == node.val:
                rmax = rmax + 1
            else:
                rmax = 0
            res = max(res,lmax+rmax) #最大值是当前的最大值或者左右孩子路径的和。
            return max(lmax,rmax) #返回值是左右路径中的最大值，因为它还需要和父节点继续构建路径。
 
        dns(root)
        return res
 
root = TreeNode(1)
Node1 = TreeNode(4)
Node2 = TreeNode(5)
Node3 = TreeNode(5)
Node4 = TreeNode(4)
Node5 = TreeNode(5)
Node6 = TreeNode(5)
 
root.left = Node1
root.right = Node2
Node1.left = Node3
Node1.right = Node4
Node2.right = Node5
Node3.left = Node5
Node5.left = Node6
 
S = Solution()
res = S.longestUnivaluePath1(root)
print(res)

五、公共祖先

1.找出排序二叉树上任意两个节点的公共父节点

思考：

两个节点的公共祖先一定在从根节点，至这两个节点的路径上；
由于求公共祖先中的最近公共祖先，那么即同时出现在这两条路径上的离根节点最远的节点（或离两个最近）；
最终算法即：求p节点路径，q节点路径，两路径上最后一个相同的节点。

思路：先序遍历

从根节点遍历（搜索）至该节点，找到该节点后就结束搜索；
将遍历过程中遇到的节点按照顺序存储起来，这些节点即路径节点。
求出较短路径的长度n；
同时遍历p节点的路径和q节点的路径，遍历n个节点，最后一个发现的相同节点，即最近公共祖先。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
 
#获取二叉树从根节点root到node结点的路径
def getPathFromRoot(root,node,s):
    '''
    :param root:
    :param node: 二叉树中的某个节点
    :param s: 用来存储路径的栈
    :return: node在root的子树上
    '''
    if root == None:
        return False
    if root == node:
        s.append(root)
        return root
    if getPathFromRoot(root.left,node,s):
        s.append(root)
        return True
    elif getPathFromRoot(root.right,node,s):
        s.append(root)
        return True
    return False
 
#查找二叉树中两个节点最近的公共父节点
def FindParentNode(root,node1,node2):
    s1 = []
    path1 = getPathFromRoot(root,node1,s1)
    s2 = []
    path2 = getPathFromRoot(root,node2,s2)
    for ss1 in s1:
        print(ss1.val,end=',')
    print()
    for ss2 in s2:
        print(ss2.val,end=',')
    #找s1,s2第一个相等的节点，就是最近的公共父节点
    for i in s1:
        for j in s2:
            if i == j:
                return i.val
 
L1 = TreeNode(6)
L2 = TreeNode(3)
L3 = TreeNode(-7)
L4 = TreeNode(-1)
L5 = TreeNode(9)
 
L1.left = L2
L1.right = L3
L2.left = L4
L2.right = L5
 
res = FindParentNode(L1,L3,L4)
print('公共节点',res)

posted @ 2019-10-15 09:35 nxf_rabbit75 阅读(2463) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· 按钮权限的设计及实现

2025年3月

日

一

二

三

四

五

六