二叉树基本操作

记录二叉树基本操作

一.二叉树构建

1.树节点定义

public class TreeNode {

    public int value;

    public TreeNode left;
    public TreeNode right;
    public TreeNode(int value) {
        this.value = value;
    }

    public TreeNode () {}

}

2.二叉树构建

根据层序遍历的结果构建满二叉树

• 给出的数组一定可构建满二叉树，构建代码中没有增加是否可构建满二叉树的判断
• 构建中使用队列暂存节点，根据进入队列的顺序构建二叉树

private static TreeNode root; // 二叉树根节点
public static final int[] nums = {1,2,3,4,5,5,4}; 

private static void initTree() {
        root = new TreeNode(nums[0]);

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        for (int i=1; i<nums.length; i+=2) {
            TreeNode current = queue.poll();
            current.left = new TreeNode(nums[i]);
            queue.offer(current.left);
            if (i+1 < nums.length) {
                current.right = new TreeNode(nums[i+1]);
                queue.offer(current.right);
            }
        }
    }

二.二叉树遍历

1.递归遍历

三种遍历方式中，只有更根节点输出的位置不同

 private static void preOrderTree(TreeNode node) {
        if (node == null) {
            return ;
        }
        System.out.print(node.value + " ");
        preOrderTree(node.left);
        preOrderTree(node.right);
    }

    private static void midOrderTree(TreeNode node) {
        if (node == null) {
            return;
        }
        midOrderTree(node.left);
        System.out.print(node.value + " ");
        midOrderTree(node.right);
    }

    private static void lastOrderTree(TreeNode node) {
        if (node == null){
            return;
        }
        lastOrderTree(node.left);
        lastOrderTree(node.right);
        System.out.print(node.value + " ");
    }

2.非递归

a.先序遍历

非递归方式中，使用到了栈结构，先将根节点压栈。后续遍历栈，pop节点后输出，之后先压入右节点，在压入左节点。

public static void preOrderTreeStack() {
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.value + " ");
            if (node.right != null) {
                stack.push(node.right);
            }

            if (node.left != null) {
                stack.push(node.left);
            }
        }
    }

中序遍历

• 使用栈

public static void midOrderTreeStack() {

        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                System.out.print(node.value + " ");
                node = node.right;
            }
        }

    }

三.镜像二叉树

判断是否是镜像二叉树。从根节点开始，判断左右两个子树。

左子树的左节点 == 右子树的右节点 && 左子树的右节点 == 右子树的左节点。

递归出口

• 到叶子节点
• 节点值不同： 值不同 或 其中一个为null

 public static boolean isMirrorTree() {
        return isMirrorTree(root, root);
    }

    public static boolean isMirrorTree(TreeNode leftTree, TreeNode rightTree) {

        if (leftTree == null && rightTree == null) {
            return true;
        }

        if (leftTree == null || rightTree == null) {
            return false;
        }

        if (leftTree.value != rightTree.value) {
            return false;
        }

        return isMirrorTree(leftTree.left, rightTree.right) && isMirrorTree(leftTree.right, rightTree.left);

    }