二叉树的下一个结点

给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。

解题思路

1. 二叉树为空，返回空
2. 结点的右孩子存在，设置指针从右孩子出发，沿着左子结点出发直到找到叶子节点，这个就是下一个节点
3. 结点不是根结点，如果是父节点的左孩子，返回父节点；如果是父节点的右孩子，继续向上遍历其父节点；重复完成判断

代码

/**
 * 剑指offer一刷：二叉树的下一个结点
 *
 * @author User
 * @create 2019-06-07-8:31
 */
class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
public class jzo57 {
    public TreeLinkNode GetNext(TreeLinkNode pNode) {
        if (pNode==null){
            return null;
        }
        if (pNode.right!=null){
            pNode=pNode.right;
            while (pNode.left!=null){
                pNode=pNode.left;
            }
            return pNode;
        }
        while (pNode.next!=null){
            TreeLinkNode proot=pNode.next;
            if (proot.left==pNode){
                return proot;
            }
            pNode=pNode.next;
        }
        return null;
    }
    public static void main(String[] args){
        TreeLinkNode node1=new TreeLinkNode(1);
        TreeLinkNode node2=new TreeLinkNode(2);
        TreeLinkNode node3=new TreeLinkNode(3);
        TreeLinkNode node4=new TreeLinkNode(4);
        TreeLinkNode node5=new TreeLinkNode(5);
        TreeLinkNode node6=new TreeLinkNode(6);
        TreeLinkNode node7=new TreeLinkNode(7);
        TreeLinkNode node8=new TreeLinkNode(8);
        TreeLinkNode node9=new TreeLinkNode(9);
        node1.left=node2;
        node1.right=node3;
        node2.left=node4;
        node2.right=node5;
        node5.left=node7;
        node5.right=node8;
        node3.right=node6;
        node6.left=node9;
        jzo57 so=new jzo57();
        System.out.println(so.GetNext(node1).val);
    }
}

对称的二叉树

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

解题思路

判断根结点的左右子树是否相同:

1. 根结点为空，返回true；
2. 左右子树都为空，返回true；
3. 左右子树只有一个为空，肯定不对称；
4. 继续遍历根结点的左孩子的左节点是否和右孩子的右节点、左孩子的右节点和右孩子的左节点是否想同，相同返回true，不相同返回false；

代码

/**
 * 剑指offer一刷：对称的二叉树
 *
 * @author User
 * @create 2019-06-07-8:51
 */

public class jzo58 {
    boolean isSymmetrical(TreeNode pRoot)
    {
       if (pRoot==null){
           return true;
       }
       return nextRoot(pRoot.left,pRoot.right);
    }
    public boolean nextRoot(TreeNode left,TreeNode right){
        if (left==null){
            return right==null;
        }
        if (right==null){
            return false;
        }
        if (left.val!=right.val){
            return false;
        }
        return nextRoot(left.right,right.left)&&nextRoot(left.left,right.right);
    }
    boolean isSymmetrical1(TreeNode pRoot)
    {
        if (pRoot==null){
            return true;
        }
        return nextRoot1(pRoot.left,pRoot.right);
    }
    public boolean nextRoot1(TreeNode left,TreeNode right){
        if (left==null&&right==null){
            return true;
        }
        if (right==null||left==null){
            return false;
        }
        if (left.val==right.val){
            return nextRoot1(left.right,right.left)&&nextRoot(left.left,right.right);
        }
        return false;
    }
    public static void main(String[] args){
        TreeNode node1=new TreeNode(1);
        TreeNode node2=new TreeNode(2);
        TreeNode node3=new TreeNode(2);
        TreeNode node4=new TreeNode(3);
        TreeNode node5=new TreeNode(3);
        TreeNode node6=new TreeNode(4);
        TreeNode node7=new TreeNode(4);
        TreeNode node8=new TreeNode(5);
        TreeNode node9=new TreeNode(5);
        node1.left=node2;
        node1.right=node3;
        node2.right=node4;
        node3.left=node5;
        node4.left=node6;
        node5.right=node7;
        node4.right=node8;
        node5.left=node9;
        jzo58 so=new jzo58();
        System.out.println(so.isSymmetrical(node1));
        System.out.println(so.isSymmetrical1(node1));
    }
}

标签：结点,right,TreeNode,TreeLinkNode,二叉树,&&,new,null,left
来源： https://blog.csdn.net/weixin_41676282/article/details/91125765