《1.3-1.8 Leetcode》

1. 对称二叉树

题目描述：
给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

代码：

package leetcode.week3;


/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 13:13
 * @desc 对称二叉树
 */
public class t101 {
    public static boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }
        return istric(root.left, root.right);
    }

    public static boolean istric(TreeNode left, TreeNode right) {
        if (left != null && right != null) {
            if (!left.data.equals(right.data)) {
                return false;
            }
        } else if (left == null && right == null) {
            return true;
        } else {
            return false;
        }
        return istric(left.left, right.right) && istric(left.right, right.left);
    }

    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(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;

        System.out.println(isSymmetric(node1));

    }
}

2. 二叉树的最大深度

题目描述：
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

代码：

package leetcode.week3;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 13:41
 * @desc 二叉树的最大深度
 */
public class t104 {
    public static int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }


    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(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;

        System.out.println(maxDepth(node1));
    }
}

3. 二叉树按层遍历

题目描述：
给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

代码：

package leetcode.week3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 15:40
 * @desc 二叉树按层遍历
 */
public class t107 {
    /**
     * 从后往前按层遍历二叉树
     *
     * @param root
     * @return
     */
    public static List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<>();
        if (root == null) {
            return lists;
        }
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode last = root;
        TreeNode nLast = null;
        ArrayList<Integer> arrayList = new ArrayList<>();
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            arrayList.add(temp.data);
            if (temp.left != null) {
                queue.offer(temp.left);
                nLast = temp.left;
            }
            if (temp.right != null) {
                queue.offer(temp.right);
                nLast = temp.right;
            }

            if (temp == last) {
                lists.add(arrayList);
                arrayList = new ArrayList<>();
                last = nLast;
            }
        }
        Collections.reverse(lists);
        return lists;
    }

    /**
     * 二叉树按层遍历
     *
     * @param root
     */
    public static void printLay(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.pop();
            System.out.println(temp.data);
            if (temp.left != null) {
                queue.offer(temp.left);
            }
            if (temp.right != null) {
                queue.offer(temp.right);
            }
        }
    }

    /**
     * 二叉树按层遍历并打印层数
     *
     * @param root
     */
    public static void printLayByLay(TreeNode root) {
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        TreeNode last = root;
        TreeNode nLast = null;
        int i = 1;
        System.out.println("第" + i++ + "层");
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            System.out.println(temp.data);

            if (temp.left != null) {
                queue.offer(temp.left);
                nLast = temp.left;
            }
            if (temp.right != null) {
                queue.offer(temp.right);
                nLast = temp.right;
            }

            if (temp == last && !queue.isEmpty()) {
                last = nLast;
                System.out.println("第" + i++ + "层");
            }
        }
    }

    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(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;

        List<List<Integer>> lists = levelOrderBottom(node1);
        for (List<Integer> list : lists) {
            for (Integer a : list) {
                System.out.print(a + " ");
            }
            System.out.println();
        }
    }
}

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

题目描述：
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

代码：

package leetcode.week3;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 17:21
 * @desc 将有序数组转换成二叉搜索树
 */
public class t108 {

    public static TreeNode sortedArrayToBST(int[] nums) {
        if (nums == null || nums.length == 0) {
            return null;
        }
        return help(nums, 0, nums.length - 1);
    }

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

    public static void main(String[] args) {
        int[] nums = {-10, -3, 0, 5, 9};
        sortedArrayToBST(nums);
    }
}

5. 平衡二叉树

题目描述：
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

代码：

package leetcode.week3;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 19:10
 * @desc 平衡二叉树
 */
public class t110 {
    public static boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        if (Math.abs(getDepth(root.left) - getDepth(root.right)) > 1) {
            return false;
        }
        return isBalanced(root.left) && isBalanced(root.right);
    }

    public static int getDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = getDepth(root.left);
        int rightDepth = getDepth(root.right);
        return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

    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(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node2.left = node4;
        System.out.println(isBalanced(node1));
    }
}

6. 二叉树的最小深度

题目描述：
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。

代码：

package leetcode.week3;

/**
 * @author chengzhengda
 * @version 1.0
 * @date 2020-01-08 19:30
 * @desc 二叉树的最小深度
 */
public class t111 {
    public static int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = minDepth(root.left);
        int rightDepth = minDepth(root.right);
        if (root.right == null || root.left == null) {
            return leftDepth + rightDepth + 1;
        }
        return leftDepth < rightDepth ? leftDepth + 1 : rightDepth + 1;
    }

    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(4);
        TreeNode node6 = new TreeNode(4);
        TreeNode node7 = new TreeNode(3);

        node1.left = node2;
        node1.right = node3;
        node3.left = node6;

        System.out.println(minDepth(node1));
    }
}