16、二叉樹的深度

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        else:
            return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

17、和為S的兩個數字
輸入一個遞增排序的數組和一個數字S，在數組中查找兩個數，是的他們的和正好是S，如果有多對數字的和等于S，輸出兩個數的乘積最小的。
排序數組可以在查找時進行優化。

class Solution:
    def FindNumbersWithSum(self, array, tsum):
        rst = [tsum, tsum]
        for i in range(len(array)):
            for j in range(i, len(array)):
                if array[i] + array[j] == tsum:
                    if array[i]*array[j] < rst[0]*rst[1]:
                        rst = [array[i], array[j]]
                        break
                if array[i] + array[j] > tsum:
                    break
        if rst == [tsum, tsum]:
            return False
        return rst

18、順時針打印矩陣
想了一會沒想出來，百度了別人的思路，不斷旋轉矩陣，自己實現

class Solution:

    def turn(self, matrix):
        '''旋轉矩陣'''
        length = len(matrix[0])
        height = len(matrix)
        rst = []
        for i in range(length):
            cur = []
            for j in range(height):
                cur.append(matrix[j][i])
            rst.append(cur)
        return rst[::-1]

    def printMatrix(self, matrix):
        rst = []
        while matrix:
            for i in matrix[0]:
                rst.append(i)
            matrix.pop(0)
            if matrix:
                matrix = self.turn(matrix)
        return rst

19、二叉樹的下一個節點
給定一個二叉樹和其中的一個結點，請找出中序遍歷順序的下一個結點并且返回。注意，樹中的結點不僅包含左右子結點，同時包含指向父結點的指針。
想了一會，最笨的辦法就是寫一個中序遍歷，存到列表里，然后找該節點的上一個節點。然后上網查了一下，分為三種情況：
1、二叉樹是空，返回None
2、該節點存在右子樹，一直沿著指向左子結點的指針找到的葉子節點即為下一個節點
3、若不存在右子樹，如果該節點是左子節點，返回它的父節點，如果該節點是右子節點，返回父節點的父節點

class Solution:
    def GetNext(self, pNode):
        if not pNode: return None
        if pNode.right:
            pNode = pNode.right
            while pNode.left:
                pNode = pNode.left
            return pNode
        else:
            while pNode.next:
                if pNode == pNode.next.left:
                    return pNode.next
                pNode = pNode.next
        return None

20、判斷一棵樹是不是左右對稱的樹
將根節點的右子樹整個翻轉，再判斷跟根節點的左子樹是不是相同就可以了

class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        
        def reverseTree(root):
            if root:
                reverseTree(root.left)
                reverseTree(root.right)
                root.left, root.right = root.right, root.left
                return root
            else:
                return root
        
        def isSameTree(p, q):
            """
            :type p: TreeNode
            :type q: TreeNode
            :rtype: bool
            """
            if p==None and q==None:
                return True
            if not p or not q:
                return False
            if p.val == q.val:
                return isSameTree(p.left, q.left) and isSameTree(p.right, q.right)
            else:
                return False
                            
        return isSameTree(root.left, reverseTree(root.right))