Java算法——树

前文索引：
字符串篇（初级）
链表篇（初级）

树（初级）

1.二叉树的遍历

• 先序遍历：根节点→左子树→右子树

  A→B→D→E→C→F

public static void preOrder(TreeNode tree) {
    if (tree == null)
        return;
    System.out.printf(tree.val);
    preOrder(tree.left);
    preOrder(tree.right);
}

• 中序遍历：左子树→根节点→右子树

  D→B→E→A→F→C

public static void inOrderTraversal(TreeNode node) {
    if (node == null)
        return;
    inOrderTraversal(node.left);
    System.out.println(node.val);
    inOrderTraversal(node.right);
}

• 后序遍历：左子树→右子树→根节点

  D→E→B→F→C→A

public static void postOrder(TreeNode tree) {
    if (tree == null)
        return;
    postOrder(tree.left);
    postOrder(tree.right);
    System.out.println(tree.val);
}

2. 二叉树的最大深度

问：给定一个二叉树，返回其最大深度

思路：

//递归 
public int maxDepth(TreeNode root) {
        return root==null? 0 : Math.max(maxDepth(root.left), maxDepth(root.right))+1;
    }

3. 验证二叉搜索树

问：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

思路：通过二叉搜索树中各节点的上下限性质即可，根节点的范围从Long.MIN_VALUE取到Long.MAX_VALUE。

//递归
class Solution {
    public boolean isValidBST(TreeNode root) {
    return helper(root, Long.MIN_VALUE, Long.MAX_VALUE);
}

public boolean helper(TreeNode root, long minVal, long maxVal) {
    if (root == null)
        return true;
    //每个节点如果超过这个范围，直接返回false
    if (root.val >= maxVal || root.val <= minVal)
        return false;
    //这里再分别以左右两个子节点分别判断，
    //左子树范围的最小值是minVal，最大值是当前节点的值，也就是root的值，因为左子树的值要比当前节点小
    //右子数范围的最大值是maxVal，最小值是当前节点的值，也就是root的值，因为右子树的值要比当前节点大
    return helper(root.left, minVal, root.val) && helper(root.right, root.val, maxVal);
}
}

4. 对称二叉树

问：给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例：

输入：root = [1,2,2,null,3,null,3]
输出：false

思路：判断二叉树是否是对称，需要从子节点开始比较，两个子节点的值必须相同，并且左子节点的右子节点（如果有）必须等于右子节点的左子节点，左子节点的左子节点必须等于右子节点的右子节点。如下图：

public boolean isSymmetric(TreeNode root) {
    if (root == null)
        return true;
    //从两个子节点开始判断
    return Helper(root.left, root.right);
}

public boolean Helper(TreeNode left, TreeNode right) {
    //如果左右子节点都为空，说明当前节点是叶子节点，返回true
    if (left == null && right == null)
        return true;
    //如果当前节点只有一个子节点或者有两个子节点，但两个子节点的值不相同，直接返回false
    if (left == null || right == null || left.val != right.val)
        return false;
    //然后左子节点的左子节点和右子节点的右子节点比较，左子节点的右子节点和右子节点的左子节点比较
    return Helper(left.left, right.right) && Helper(left.right, right.left);
}

5. 二叉树的层序遍历

问：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）

示例：

public List<List<Integer>> levelOrder(TreeNode root) {
    //边界条件判断
    if (root == null)
        return new ArrayList<>();
    //队列
    Queue<TreeNode> queue = new LinkedList<>();
    List<List<Integer>> res = new ArrayList<>();
    //根节点入队
    queue.add(root);
    //如果队列不为空就继续循环
    while (!queue.isEmpty()) {
        //BFS打印，levelNum表示的是每层的结点数
        int levelNum = queue.size();
        //subList存储的是每层的结点值
        List<Integer> subList = new ArrayList<>();
        for (int i = 0; i < levelNum; i++) {
            //出队
            TreeNode node = queue.poll();
            subList.add(node.val);
            //左右子节点如果不为空就加入到队列中
            if (node.left != null)
                queue.add(node.left);
            if (node.right != null)
                queue.add(node.right);
        }
        //把每层的结点值存储在res中，
        res.add(subList);
    }
    return res;
}

6. 将有序数组转换为二叉搜索树

问：给你一个整数数组 nums ，其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。

高度平衡二叉树是一棵满足每个节点的左右两个子树的高度差的绝对值不超过 1的二叉树。

思路：使用递归的方式，每次取数组中间的值比如m作为当前节点，m前面的值作为他左子树的结点值，m后面的值作为他右子树的节点值

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums.length == 0)
            return null;
        return sorted(nums, 0, nums.length-1);
    }

    public TreeNode sorted(int[] nums, int start, int end){
        if(start > end)
            return null;
        int mid = (start + end) >> 1;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = sorted(nums, start, mid-1);
        root.right = sorted(nums, mid+1, end);    
        return root;
        }
}