剑指offer 57、58：二叉树的下一个结点 、对称的二叉树

题目描述
给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
思路：如果有右子树，则下一节点就是右子树的最左边的节点。
如果没有右子树，并且是父节点的左子树，则下一节点是父节点
如果没有右子树，并且是父节点的右子树，找父节点的父节点，直到父节点位于左子树

/*
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {

    }
};
*/
class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if(pNode==NULL)
            return NULL;
        TreeLinkNode *p= pNode;
        if(p->right !=NULL)
        {
            p=p->right;
            while(p->left !=NULL)
                p=p->left;
            return p;
        }
        while(p->next !=NULL)
        {
            if(p->next->left==p)
                return p->next;
            p=p->next;
        }
        return NULL;
    }
};
# -*- 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):
        if pNode==None:
            return None
        if pNode.right:
            pNode=pNode.right
            while pNode.left:
                pNode=pNode.left
            return pNode
        while pNode.next:
            if pNode.next.left==pNode:
                return pNode.next
            pNode=pNode.next
        return None
        # write code here

58.题目描述
请实现一个函数，用来判断一颗二叉树是不是对称的。注意，如果一个二叉树同此二叉树的镜像是同样的，定义其为对称的。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool compare(TreeNode* pRoot1,TreeNode* pRoot2)
    {
        if(pRoot1==NULL && pRoot2==NULL)
            return true;
        if(pRoot1==NULL || pRoot2==NULL)
            return false;
        if(pRoot1->val != pRoot2->val)
            return false;
        return compare(pRoot1->left,pRoot2->right) && compare(pRoot1->right,pRoot2->left);
    }
    bool isSymmetrical(TreeNode* pRoot)
    {
        if(pRoot == NULL)
            return true;
        return compare(pRoot->left,pRoot->right);
    }

};
# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
class Solution:
    def process(self,pleft,pright):
        if pleft==None and pright==None:
            return True
        if pleft ==None or pright ==None:
            return False
        if pleft.val != pright.val:
            return False
        return self.process(pleft.left,pright.right) and self.process(pleft.right,pright.left)
    def isSymmetrical(self, pRoot):
        if pRoot==None:
            return True
        return self.process(pRoot.left,pRoot.right)
        # write code here