LeetCode-深度优先搜索-esay

记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步

---

100. Same Tree 相同的树

解题思路：
递归实现，判断是否为相同的树可以分成三个小问题：该node的值是否相同；左子树是否相同；右子树是否相同

def isSameTree(p, q):
    """
    :type p: TreeNode
    :type q: TreeNode
    :rtype: bool
    """
    if p==None and q == None:
        return True
    elif p==None or q == None:
        return False
    
    return (q.val == p.val) and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

---

101. Symmetric Tree 对称二叉树

解题思路：
可以使用中序遍历 即左根右， 若中序遍历产生的list是对称的 那么为对称二叉树

def isSymmetric(root):
    """
    :type root: TreeNode
    :rtype: bool
    """
    def getvalue(node):
        ret =[]
        if node==None:
            return ret
        
        if node.left != None:
            ret.extend(getvalue(node.left))
        
        ret.append(node.val)
        
        if node.right!= None:
            ret.extend(getvalue(node.right))
        
        return ret
    
    if root.left!=None and root.right!=None and root.left.val != root.right.val:
        return False
    v = getvalue(root)
    ret = True
    
    while len(v)>1:
        if v[0]==v[-1]:
            v.pop(0)
            v.pop(-1)
        else:
            ret = False
            break
    if ret and len(v)>1:
        ret = False
    return ret

---

104. Maximum Depth of Binary Tree 二叉树的最大深度

解题思路1：
遍历二叉树 用一个list存储node 每一次取出list中首个node （先进先出的队列）
记录每一个node的深度

def maxDepth(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    ret = 0
    if root == None:
        return ret
    l =[]
    l.append((root,1))
    ret += 1
    while len(l)>0:
        node,level = l.pop(0)
        if node.left!=None or node.right!=None:
            ret = max(ret,level+1)
        if node.left!=None:
            l.append((node.left,level+1))
        if node.right!=None:
            l.append((node.right,level+1))
    return ret

解题思路2：
递归实现 最大深度为1+max(左子树最大深度，右子树最大深度)

def maxDepth2(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    if root is None:
        return 0
    
    l = maxDepth2(root.left)
    r = maxDepth2(root.right)
    return 1+max(l,r)

---

108. Convert Sorted Array to Binary Search Tree 将有序数组转换为二叉搜索树

解题思路：
为达到高度平衡二叉树 左右子树包含的节点数尽量接近相等
取中间的值作为根节点的值 递归生成左右子树

def sortedArrayToBST(nums):
    """
    :type nums: List[int]
    :rtype: TreeNode
    """
    if len(nums)==0:
        return None
    pos = len(nums)//2
    node = TreeNode(nums[pos])
    if pos:
        node.left = sortedArrayToBST(nums[:pos])
        node.right = sortedArrayToBST(nums[pos+1:])
        return node
    else:
        return node

---

110. Balanced Binary Tree 平衡二叉树

解题思路：
判断是否为平衡二叉树 分成四种情况
1.若左右子树为空 则是
2.若左右子树都非空 则判断左右子树深度差 同时左右子树都要为平衡二叉树（递归实现）
3.若左子树非空 右子树为空 则左子树不能再有子树
4.若右子树非空 左子树为空 则右子树不能再有子树

def isBalanced( root):
    """
    :type root: TreeNode
    :rtype: bool
    """
    if root==None:
        return True
    
    def depth(node):
        l =[]
        if node==None:
            return 0
        l.append((node,1))
        ret =1
        while len(l)>0:
            n,level = l.pop(0)
            if n.left!=None:
                l.append((n.left,level+1))
                ret = max(ret,level+1)
            if n.right!=None:
                l.append((n.right,level+1))
                ret = max(ret,level+1)
        return ret
            
    
    if root.left!=None and root.right!=None:
        ret = isBalanced(root.left) and isBalanced(root.right)
        if ret:
            ret = abs(depth(root.left)-depth(root.right))<2
        return ret
    if root.left==None and root.right==None:
            return True
    
    if root.left == None:
        node = root.right
        if node.left!=None or node.right!=None:
            return False
    
    if root.right == None:
        node = root.left
        if node.left!=None or node.right!=None:
            return False
    return True

---

111. Minimum Depth of Binary Tree 二叉树的最小深度

解题思路：
list存储node 遍历二叉树
当首次遇到node为叶节点时 退出

def minDepth(root):
    """
    :type root: TreeNode
    :rtype: int
    """
    if root==None:
        return 0
    ret = 1
    l = []
    l.append((root,1))
    while len(l)>0:
        v,d = l.pop(0)
        if v.left==None and v.right==None:
            ret = d
            break
        if v.left!=None:
            l.append((v.left,d+1))
        if v.right!=None:
            l.append((v.right,d+1))
    return ret

---

112. Path Sum 路径总和

解题思路：
递归实现 遍历每一种情况

def hasPathSum(root, sum):
    """
    :type root: TreeNode
    :type sum: int
    :rtype: bool
    """
    if root == None:
        return False
   
    def path(root,num):
        if root == None:
            if num == 0:
                return True
            else:
                return False
        
        if root.left==None and root.right==None:
            if root.val == num:
                return True
            else:
                return False
        ret1 = False
        ret2 = False
        if root.left!=None:
            ret1 = path(root.left,num-root.val)
        
        if root.right!=None:
            ret2 = path(root.right,num-root.val)
            
        if ret1 or ret2:
            return True
        else:
            return False
     
    return path(root,sum)

---

257. Binary Tree Paths 二叉树的所有路径

解题思路：
递归实现 传递到本节点时已有路径 若为叶节点则完成一条路径

def binaryTreePaths(root):
    """
    :type root: TreeNode
    :rtype: List[str]
    """
    ret =[]
    if root==None:
        return ret
    
    def path(s,root):
        s += str(root.val)
        if root.left==None and root.right== None:
            ret.append(s)
        s += "->"
        if root.left!=None:
            path(s,root.left)
        if root.right!=None:
            path(s,root.right)
            
    path("",root)

---

559. Maximum Depth of N-ary Tree N叉树的最大深度

解题思路：
遍历每一个节点 记录深度

def maxDepth(root):
    """
    :type root: Node
    :rtype: int
    """
    if not root:
        return 0
    l=[]
    ret = 1
    l.append((root,1))
    while len(l)>0:
        v,d = l.pop(0)
        n = len(v.children)
        for i in range(n):
            l.append((v.children[i],d+1))
            ret = max(ret,d+1)
            
    return ret

---

690. Employee Importance 员工的重要性

解题思路：
将涉及到的员工都放入到list中
将list中的员工重要性相加

def getImportance(employees, id):
    """
    :type employees: Employee
    :type id: int
    :rtype: int
    """
    if len(employees)==0:
        return 0
    dic = {}
    for v in employees:
        dic[v.id] = v
    ret = 0
    l =[]
    l.append(id)
    while len(l)>0:
        n = l.pop(0)
        e = dic.get(n)
        ret += e.importance
        l.extend(e.subordinates)
    return ret

---

695. Max Area of Island 岛屿的最大面积

解题思路：
每一个1点 上下左右寻找是否还包含1 到过的点设为0

def maxAreaOfIsland(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    def island(area,i,j):
        if grid[i][j]==0:
            return 0
        grid[i][j]=0
        area = 1
        if i-1>=0:
            area += island(area,i-1,j)
        if i+1<n:
            area += island(area,i+1,j)
        if j-1>=0:
            area += island(area,i,j-1)
        if j+1<m:
            area += island(area,i,j+1)
        return area
    n = len(grid)
    if n==0:
        return 0
    m = len(grid[0])
    
    ret =0
    for i in range(n):
        for j in range(m):
            if grid[i][j]==1:
                ret= max(ret,island(0,i,j))
    return ret

---