算法学习Day10——二叉树1

递归注意点

1. 确定递归函数的参数和返回值

2. 确定终止条件

3. 确定单层递归的逻辑

二叉树的前序遍历

144. 二叉树的前序遍历 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result =new ArrayList<Integer>();
        preorder(root,result);
        return result;
    }
    public void preorder(TreeNode root,List<Integer> result){
        if(root == null) return ;
        result.add(root.val );
        preorder(root.left,result);
        preorder(root.right,result);
    }
}

二叉树的层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）

借助队列先进先出的特性来实现

每出去一个，都要将其左右孩子存进去。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> resultList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkfun(root);
        return resultList;
    }
    public void checkfun(TreeNode node){
        if(node == null) return;
        Queue<TreeNode> que =new LinkedList<TreeNode>();
        que.offer(node);

        while(!que.isEmpty()){
            List<Integer> item =new ArrayList<Integer>();
            int len = que.size();
            while(len>0){
                TreeNode tempNode = que.poll();
                item.add(tempNode.val);
                if(tempNode.left != null) que.offer(tempNode.left);//注意是tempNode不是node，一不注意写错了，绝了。
                if(tempNode.right != null) que.offer(tempNode.right);
                len--;
                //
            }
            resultList.add(item);
            //System.out.println(item);
        }
        
    }
}

翻转二叉树

226. 翻转二叉树 - 力扣（LeetCode）

遍历，然后左右翻转。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return null;
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;

    }
    private void swapChildren(TreeNode root){
        TreeNode tmp =root.left;
        root.left= root.right;
        root.right= tmp;
    }
}

对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

分为外侧和内侧两个部分来进行比较。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.right);

    }
    private boolean compare(TreeNode left, TreeNode right){
         if(left ==null && right != null) return false;
         if(left !=null && right == null) return false;
         if(left ==null && right==null) return true;
         if(left.val != right.val) return false;
         boolean compareOutside =compare(left.left,right.right);
         boolean compareInside = compare(left.right,right.left);
         return compareOutside && compareInside;
    }
}

二叉树的最大深度

104. 二叉树的最大深度 - 力扣（LeetCode）

前序遍历求得是深度，后序求的是高度。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;   
        int leftDepth=maxDepth(root.left);
        int rightDepth=maxDepth(root.right);

        return Math.max(leftDepth,rightDepth)+1;
    }
}

二叉树的最小深度

111. 二叉树的最小深度 - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root ==null) return 0;
        int leftDepth =minDepth(root.left);
        int rightDepth = minDepth(root.right);
        if(root.left==null) return rightDepth+1;
        if(root.right == null) return leftDepth+1;
        return Math.min(leftDepth,rightDepth)+1;
    }
}