leetcode.100-200

• 102 二叉树的层序遍历
  这道需要一层一层的遍历二叉树，我的思路在解决每层时需要一个队列来存放本层的node个数，每次开始循环前先看队列里有几个node，作为弹出node的个数。
  py语法上犯了个错，list1 is [], 用来判断数值list1==[]并且id也要相同，is用来判断是一个对象，这个bug是在IDE调试才想到的。

class Solution:
    def levelOrder(self, root):
        if not root: return []
        rt = []
        stack = [root]
        while stack:
            n = len(stack)
            level_rt = []  # 每层node.val放入
            for i in range(n):  # 要直到本层循环需要弹出几个node
                cur = stack.pop(0)
                if cur.val: level_rt.append(cur.val)
                if cur.left is not None:
                    stack.append(cur.left)
                if cur.right is not None:
                    # 节点不None入队
                    stack.append(cur.right)
            rt.append(level_rt)
        return rt

• 108 将有序数组转换为二叉搜索树

给定有序数组: [-10,-3,0,5,9],一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

思路是找到数组中间的点，使树整体平衡，用递归思想解决：
先提起来中间的点，
然后中间点左边数组去建左树，
然后中间点右边数组去建右树，
每次递归时都是生层了新的数组，List[]生成新对象。

class Solution:
    def sortedArrayToBST(self, nums):
        if not nums : return None
        mid = len(nums)//2
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right= self.sortedArrayToBST(nums[mid+1:])
        return root

• 111 二叉树的最小深度
  ❀记第一次提交通过。递归首先要考虑出栈条件，其次从最深层思考如何构建递归：要返回什么，要比较什么。
  这题的思路：找到有效路径的最小深度，最小深度一定是局部最小构成全局最小，每次递归入栈就是寻找左右树哪颗树深度浅。

class Solution:
    def minDepth(self, root): #TreeNode) -> int:
        if root == None: return 0
        def inner_search(cur, deep):
            if not cur: return deep
            # 向左树搜索，如果左边是空，那么要赋值+无穷，令左边搜索结果无效
            # 如果返回此时深度deep那么next_deep会取错误的深度,如：
            #    1
            #   /  \
            #  2   null
            #  这颗树的深度是2 ，不是1
            left_deep = inner_search(cur.left, deep+1) if cur.left else float("inf")
            right_deep = inner_search(cur.right, deep+1) if cur.right else float("inf")
            # 寻找浅的路径
            next_deep = min(left_deep, right_deep)
            # 如果是+无穷，该节点是叶子，替换此时深度
            return next_deep if next_deep!=float("inf") else deep

        return inner_search(root, 1)

• 112 路径总和
  递归, 第二遍通过,写前考虑好,路径是根节点到叶子,所以叶子条件是什么,没有左右子节点

class Solution:
    def hasPathSum(self, root, sum):
        if root is None: return False
        self.rt = False
        def search(cur, tmp):
            # 递归的出口是叶子
            if not (cur.left or cur.right):
                # 根到叶子的和判断
                if tmp == sum: self.rt = True
                return
            # 有左节点时候,搜索
            if cur.left:
                search(cur.left, tmp+cur.left.val)
            # 有右节点时候,搜索
            if cur.right:
                search(cur.right, tmp+cur.right.val)
        search(root, root.val)

        return self.rt

• 124 二叉树中的最大路径和
• 
  
  图片来自，也可以参考思想：树的题一般用递归实现，最大路径可能是二叉树从左到右的任意路径的和，所以是由多个局部最大组成全局最大路径， 也可能不路过根节点，局部路径最大。递归实现时候需要用一个缓存保存每次可能出现的路径和。

class Solution:
    def maxPathSum(self, root):# TreeNode) -> int:
        ans = float("-inf")
        def helper(node):
            if not node: return 0
            left = max(0, helper(node.left))
            right = max(0, helper(node.right))
            nonlocal ans
             # 记录可能出现的某个最大路径
            ans = max(ans, node.val+left+right)
             # 返回左树路径或右树中的大值
            return max(left, right) + node.val
        helper(root)
        return ans

• 147 对链表进行插入排序

# 从前到后比较Node的值,
# 不满足从小到大就从链表中摘除
# 摘除点从前到后插入原来链表
class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution(object):
    def insertionSortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None: return None
        # 增加一个新节点主要为了比较方便,
        # 顺便了处理了单节点的情况
        new_head = ListNode(float("-inf"))
        new_head.next = head
        p1 = new_head
        p2 = new_head.next
        while p2 != None:
            if p1.val < p2.val:
                p1 = p2
                p2 = p2.next
            else:
                # 不满足从小到大
                tmp_node = p2
                p2 = p2.next # 摘除p2
                p1.next = p2
                point = new_head
                # 寻找插入的点
                while tmp_node.val > point.next.val:
                    point = point.next
                # 插入
                tmp_node.next = point.next
                point.next = tmp_node
        return new_head.next

• 162 寻找峰值
  这道题思路很简单，就是二分法查找合适的峰值数数

class Solution:
    def findPeakElement(self, nums):
        self.ls = nums
        if len(self.ls) == 1:  return 0# 单个元素
        self.rt = 0
        self.isPeak(0, len(self.ls)-1)
        return self.rt

    def isPeak(self, start, end):
        # 找到就返回
        idx = (start + end) // 2
        if start > end: return False
        if 0==idx and self.ls[idx]>self.ls[idx+1]: # 左边界，
            self.rt = idx
            return True
        if idx==(len(self.ls)-1) and self.ls[idx]>self.ls[idx-1]: # 中间元素
            self.rt = idx
            return True
        if self.ls[idx-1] < self.ls[idx] > self.ls[idx+1]: # 右边界
            self.rt = idx
            return True
        else:
            # 二分搜索
            self.isPeak(start, idx-1)
            self.isPeak(idx+1, end)

s = Solution()
print(s.findPeakElement([1,2,1,0]))