重建二叉树和二叉树的下一个节点

1. 重建二叉树

1.1 知道前序和中序的情况下

/**
 * @author bro
 * @date 2020/9/21 19:30
 * @desc
 */
public class Rebuild {

    public static TreeNode rebuildBinaryTree(int[] preOrder, int[] inOrder) {
        if (preOrder == null || inOrder == null) return null;
        TreeNode root = rebuildBinaryTreeCore(preOrder, 0, preOrder.length - 1,
                inOrder, 0, inOrder.length - 1);
        return root;
    }

    public static TreeNode rebuildBinaryTreeCore(int[] preOrder, int startPreOrder, int endPreOrder,
                                                 int[] inOrder, int startInOrder, int endInOrder) {
        if (startInOrder > endInOrder || startPreOrder > endPreOrder) {
            return null;  //停止递归的条件
        }
        TreeNode root = new TreeNode(preOrder[startPreOrder]);
        for (int i = startInOrder; i < endInOrder; i++) {
            if (preOrder[startInOrder] == inOrder[i]) {
                //左子树
                root.left = rebuildBinaryTreeCore(preOrder, startPreOrder + 1, (i - startInOrder) + startPreOrder,
                        inOrder, startInOrder, i - 1);
                //右子树
                root.right = rebuildBinaryTreeCore(preOrder, (i - startInOrder) + startPreOrder + 1, endPreOrder,
                        inOrder, i + 1, endInOrder);
            }
        }
        return root;
    }

    public static void main(String[] args) {
        int preorder[] = {1, 2, 4, 7, 3, 5, 6, 8};
        int inorder[] = {4, 7, 2, 1, 5, 3, 8, 6};
        TreeNode treeNode = rebuildBinaryTree(preorder, inorder);
        System.out.println(treeNode.toString());
    }
}

2.2 知道中序和后序的情况下

/**
 * @author bro
 * @date 2020/9/21 19:58
 * @desc 有中序和后序重建二叉树代码：
 */
public class Rebuild2 {
    public static TreeNode rebuildBinaryTree(int[] postOrder, int[] inOrder) {
        if (postOrder == null || inOrder == null) return null;
        TreeNode root = rebuildBinaryTreeCore(postOrder, 0, postOrder.length - 1,
                inOrder, 0, inOrder.length - 1);
        return root;
    }

    public static TreeNode rebuildBinaryTreeCore(int[] postOrder, int startPostOrder, int endPostOrder,
                                                 int[] inOrder, int startInOrder, int endInOrder) {
        if (startPostOrder > endPostOrder || startInOrder > endInOrder) return null; //终止递归
        TreeNode root = new TreeNode(postOrder[endPostOrder]);
        for (int i = startInOrder; i <= endInOrder; i++) {
            if (postOrder[endPostOrder] == inOrder[i]) {
                //左子树
                root.left = rebuildBinaryTreeCore(postOrder, startInOrder, startPostOrder - 1 + (i - startInOrder),
                        inOrder, startInOrder, i - 1);
                //右子树
               root.right =  rebuildBinaryTreeCore(postOrder, startPostOrder + (i - startInOrder), endPostOrder - 1,
                        inOrder, i + 1, endInOrder);
            }
        }
        return root;
    }

    public static void main(String[] args) {
        int []inorder = {1, 2, 3, 4, 5, 6, 7};
        int []postorder = {2, 4, 3, 1, 6, 7, 5};
        TreeNode treeNode = rebuildBinaryTree(postorder, inorder);
        System.out.println(treeNode);
        System.out.println(treeNode.value);
        System.out.println(treeNode.left.value);
        System.out.println(treeNode.right.value);
    }
}

2.二叉树的下一个节点

三种情况分别是：

1. 如果节点有右子树，就是右子树的最左节点
2. 节点没有右子树，父节点的左节点，下一个节点就是父节点
3. 节点没有右子树，父节点的右节点，父节点一直向上遍历，直到他是它父节点的左节点。

/**
 * @author bro
 * @date 2020/9/21 21:16
 * @desc 二叉树的下一个节点
 * 1. 如果节点有右子树，就是右子树的最左节点
 * 2. 节点没有右子树，是父节点的左节点，下一个节点就是父节点
 * 3. 节点没有右子树，是父节点的右节点，父节点一直向上遍历，直到他是它父节点的左节点
 */
public class GetNext {
    public static BinaryTreeNode nextNode(BinaryTreeNode pNode) {
        if (pNode == null) return null;
        BinaryTreeNode pNext = null;
        if (pNode.right != null) {  // 第一种情况
            BinaryTreeNode pRight = pNode.right;
            while (pRight.left != null) pRight = pRight.left;
            pNext = pRight;
        } else if (pNode.parent != null) {
            BinaryTreeNode pCurrent = pNode;
            BinaryTreeNode pParent = pNode.parent;
            while (pParent != null && pCurrent == pParent.right) { //第三种情况
                pCurrent = pParent;
                pParent = pCurrent.parent;
            }
            pNext = pParent;  //第二种
        }
        return pNext;
    }

    public static void main(String[] args) {
        BinaryTreeNode a = new BinaryTreeNode('a');
        BinaryTreeNode b = new BinaryTreeNode('b');
        BinaryTreeNode c = new BinaryTreeNode('c');
        BinaryTreeNode d = new BinaryTreeNode('d');
        BinaryTreeNode e = new BinaryTreeNode('e');
        BinaryTreeNode f = new BinaryTreeNode('f');
        BinaryTreeNode g = new BinaryTreeNode('g');
        BinaryTreeNode h = new BinaryTreeNode('h');
        BinaryTreeNode i = new BinaryTreeNode('i');
        a.left = b;
        a.right = c;
        a.parent = null;
        b.left = d;
        b.right = e;
        b.parent = a;
        c.left = f;
        c.right = g;
        c.parent = a;
        d.left = null;
        d.right = null;
        d.parent = b;
        e.left = h;
        e.right = i;
        e.parent = b;
        f.left = null;
        f.right = null;
        f.parent = c;
        g.left = null;
        g.right = null;
        g.parent = c;
        h.left = null;
        h.right = null;
        h.parent = e;
        i.left = null;
        i.right = null;
        i.parent = e;

        System.out.println(nextNode(a) != null ? nextNode(a).value : "null");
        System.out.println(nextNode(b) != null ? nextNode(b).value : "null");
        System.out.println(nextNode(c) != null ? nextNode(c).value : "null");
        System.out.println(nextNode(d) != null ? nextNode(d).value : "null");
        System.out.println(nextNode(e) != null ? nextNode(e).value : "null");
        System.out.println(nextNode(f) != null ? nextNode(f).value : "null");
        System.out.println(nextNode(g) != null ? nextNode(g).value : "null");
        System.out.println(nextNode(h) != null ? nextNode(h).value : "null");
        System.out.println(nextNode(i) != null ? nextNode(i).value : "null");
    }
}

class BinaryTreeNode {
    char value;
    BinaryTreeNode left;
    BinaryTreeNode right;
    BinaryTreeNode parent;
    public BinaryTreeNode(char value) {
        this.value = value;
    }
}