3.21剑指33, 34, 36

剑指 Offer 33. 二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。

class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:
        def exam(L):
            if L:tmp = L.pop()
            else: return True
            if L:
                llen = len(L)
                cur = 0
                while cur<llen and L[cur]<tmp:
                    cur += 1
                lowcur = cur-1
                while cur<llen-1:
                    cur += 1
                    if L[cur]<tmp:
                        return False
                left = L[0:lowcur+1]
                right = L[lowcur+1:]
                return exam(left) and exam(right)
            else: return True
        return exam(postorder)

剑指 Offer 34. 二叉树中和为某一值的路径

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        if not root: return[]
        dic = {}
        pardic = {}
        stack = [root]
        parent,cur = root,root
        res,tmp = [],[]
        while stack:
            cur = stack.pop()
            if cur is root:
                pardic[cur]=None
                dic[cur] = cur.val
            else:
                dic[cur] = dic[pardic[cur]]+cur.val
            if cur.right:
                stack.append(cur.right)
                pardic[cur.right]=cur
            if cur.left:
                pardic[cur.left]=cur
                stack.append(cur.left)
        stack = [root]
        cur = root
        while stack:
            cur = stack.pop()
            if dic[cur] == target and cur.left==None and cur.right==None:
                tcur = cur
                tmp = []
                while pardic[tcur]:
                    tmp.insert(0,tcur.val)
                    tcur = pardic[tcur]
                tmp.insert(0,root.val)
                res.append(tmp)
            if cur.left: stack.append(cur.left)
            if cur.right: stack.append(cur.right)
        res.reverse()
        return res

剑指 Offer 36. 二叉搜索树与双向链表

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

"""
# Definition for a Node.
class Node:
    def __init__(self, val, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
"""
class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        if not root: return
        pre, cur, head=Node(),Node(),Node()
        si=[0, pre, head]
        def mido(root):
            if root.left: mido(root.left)
            if si[0]==0:
                si[0]=1
                si[2] = root
                si[1] = root
            else:
                si[1].left = root
                si[1] = root
            if root.right: mido(root.right)
        mido(root)
        si[1].left = None
        head = si[2]
        cur = head
        while cur.left:
            cur.right = cur.left
            cur = cur.left
        cur.right=None
        cur = head
        while cur.right:
            cur.right.left = cur
            cur = cur.right

        cur.right=head
        head.left =cur

        return head