剑指offer 57、58、59、60

57、二叉树的下一个节结点

思路：
（1）就是一个节点有右子树。比如要求节点B的下一个节点，其实是找到它的右子树的最左孩子，就是G节点。
（2）若该节点不存在右子树：这时分两种情况：
①对于G这个节点来说，没有右子节点了，它的父亲节点是E，G是E的左子节点，即E的左子节点是G，那么G的下一个节点就是E。
②对于E这个节点来说，也没有右子节点，它的父亲节点是B，此时E是B的右子节点，根据实际情况来说，E的下一个节点绝对不是B，因为E是B的右子节点，根据中序遍历的规则，此时肯定是先遍历B再遍历E，所以B肯定在E的前面，而不是后面，所以我们还需要再往上找父亲节点，此时B的父亲节点为A，B为A的左子节点，此时根据实际情况，A就是我们要找的E的下一个节点。

所以，对于一个没有右子节点的节点来说，只需要判断它有没有父节点并且是不是父节点的左子节点，是的话，就找到了，不是则要不断地向上找。

如果一直找到根还是找不到，像节点F，那就返回null，因为实际上F节点就是中序遍历的最后一个节点，没有所谓的下一个节点了。

# -*- coding:utf-8 -*-
# class TreeLinkNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#         self.next = None
class Solution:
    def GetNext(self, pNode):
        # write code here
        # 此节点有右子树：
        if pNode.right:
            p = pNode.right
            while p.left:
                p = p.left
            return p
        # 没有右子树，则找第一个当前节点是父节点左孩子的节点
        while pNode.next:
            if(pNode.next.left==pNode):
                return pNode.next
            # 沿着父节点向上遍历
            pNode = pNode.next
            # 找到根节点仍没找到，则返回为空
        return None

58、对称的二叉树

判断完pRoot节点后，便判断pRoot的左子树和右子树是不是镜像的，
那么这个compare函数首先判断val是否相等，如果不相等直接False了，
如果相等得进一步递归判断，左子树left和右子树right，左子树right和右子树left是不是镜像的，以此类推进行递归。
递归结束的条件就是1-叶子节点时返回True，2-root1或root2中有一个为None，另一个不为None时返回False。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def isSymmetrical(self, pRoot):
        # write code here
        if not pRoot:
            return True
        # 判断完pRoot节点后，便判断pRoot的左子树和右子树是不是镜像的，
        # 那么这个compare函数首先判断val是否相等，如果不相等直接False了，
        # 如果相等得进一步递归判断，左子树left和右子树right，左子树right和右子树left是不是镜像的，以此类推进行递归。
        # 递归结束的条件就是1-叶子节点时返回True，2-root1或root2中有一个为None，另一个不为None时返回False。
        def compare(root1,root2):
            if root1 is None and root2 is None:
                return True
            if root1 is None and root2 is not None:
                return False
            if root1 is not None and root2 is None:
                return False
            if root1.val == root2.val:
                if compare(root1.left, root2.right) and compare(root1.right, root2.left):
                    return True
                else:
                    return False
        return compare(pRoot.left, pRoot.right)

60、把二叉树打印成多行

1、初始状态下，队列中只保留根节点的元素：

2、当A出队时，将A的孩子节点加入队列中：

3、重复上面的动作，队首元素出队时，将孩子节点加入队尾…

思路:用两个列表分别保存当前层节点和下一层节点，结果.append([i.val for i in 当前层节点]),然后 当前层列表,下一层列表 = 下一层列表, [] 即可，直到当前层为空

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    # 返回二维列表[[1,2],[4,5]]
    def Print(self, pRoot):
        # write code here
        if not pRoot:
            return []
        current = [pRoot]
        next_layer = []
        res = []
        while current:
            for i in current:
                if i.left:
                    next_layer.append(i.left)
                if i.right:
                    next_layer.append(i.right)
            res.append([i.val for i in current])
            # current为next_layer的值，清空next_layer
            current,next_layer = next_layer,[]
        return res

59、按之字形顺序打印二叉树

在上一题的基础上，判断奇数偶数，然后判断从左到右还是从右到左。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def Print(self, pRoot):
        # write code here
        if not pRoot:
            return []
        current = [pRoot]
        result = []
        while current:
            res = []
            next_layer = []
            for i in current:
                res.append(i.val)
                if i.left:
                    next_layer.append(i.left)
                if i.right:
                    next_layer.append(i.right)
            current = next_layer
            result.append(res)
        returnResult=[]
        for i,v in enumerate(result):
            if i%2 == 0:
                returnResult.append(v)
            else:
                returnResult.append(v[::-1])
        return returnResult