春招冲刺百题计划|树

Java基础复习

1. Java数组的声明与初始化
2. Java ArrayList
3. Java HashMap
4. Java String 类
5. Java LinkedList
6. Java Deque继承LinkedList
7. Java Set
8. Java 队列
9. 优先队列！！！
10. Java数组划分
11. Java数组转ArrayList
12. String 转数字
13. String

碎碎碎碎念

发现一个可能会更有效的刷题方法：先看一遍灵茶山艾府的基础精讲，再刷一刷题。（我也不知道会不会更好，现在树这个专题上看看）
树：递归！（避免一开始就陷入细节！）
递归：边界条件和返回。

第一题：100. 相同的树

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {
        if(p==null&&q==null){
            return true;
        }
        if(p!=null&&q!=null&&p.val == q.val){
            return isSameTree(p.left, q.left)&&isSameTree(p.right, q.right);
        }else{
            return false;
        }
    }
}

第二题：236. 二叉树的最近公共祖先

自己就是给一个比较傻的办法：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    boolean findTarget(TreeNode root, TreeNode p){
        if(root==null){
            return false;
        }
        if(root==p){
            return true;
        }
        return findTarget(root.left, p)||findTarget(root.right, p);
    }


    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // p q的关系：p是q的子，q是p的子， 或者是不同子树。
        //if(findTarget(p, q)){
        //    return p;
        //}
        //if(findTarget(q, p)){
        //    return q;
       	// }
        TreeNode tmpR = root;
        while(tmpR!=null){
            if(findTarget(tmpR.right, p)&&findTarget(tmpR.right, q)){
                tmpR = tmpR.right;
            }
            else if(findTarget(tmpR.left, p)&&findTarget(tmpR.left, q)){
                tmpR = tmpR.left;
            }else{
                return tmpR;
            }
            
        }
        return root;

    }
}

一个大佬的代码：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            //只要当前根节点是p和q中的任意一个，就返回（因为不能比这个更深了，再深p和q中的一个就没了）
            return root;
        }
        //根节点不是p和q中的任意一个，那么就继续分别往左子树和右子树找p和q
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        //p和q都没找到，那就没有
        if(left == null && right == null) {
            return null;
        }
        //左子树没有p也没有q，就返回右子树的结果
        if (left == null) {
            return right;
        }
        //右子树没有p也没有q就返回左子树的结果
        if (right == null) {
            return left;
        }
        //左右子树都找到p和q了，那就说明p和q分别在左右两个子树上，所以此时的最近公共祖先就是root
        return root;
    }
}

突然想到二叉树一个终极知识点：前后中序遍历的实现方法。

第三题：230. 二叉搜索树中第K小的元素

二分搜索树（英语：Binary Search Tree），也称为 二叉查找树 、二叉搜索树 、有序二叉树或排序二叉树。满足以下几个条件：
若它的左子树不为空，左子树上所有节点的值都小于它的根节点。
若它的右子树不为空，右子树上所有的节点的值都大于它的根节点。
它的左、右子树也都是二分搜索树。
二叉搜索树中序遍历得到的值一定是升序的。

/**
 * 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 {
    List<Integer> res = new ArrayList<>();
    void inorderTraversal(TreeNode cur, int k){
        if(res.size()==k){
            return;
        }
        if(cur==null){
            return;
        }
        inorderTraversal(cur.left, k);
        res.add(cur.val);
        inorderTraversal(cur.right, k);
    }
    public int kthSmallest(TreeNode root, int k) {
        inorderTraversal(root, k);
        // System.out.println(res);
        return res.get(k-1);
    }
}

第四题：230. 二叉搜索树中第K小的元素

当时我这个的确不是按要求遍历。

/**
 * 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 {
    List<List<Integer>> res = new ArrayList<List<Integer>>(); //add
    void LevelOrder(List<TreeNode> nodes, int target){
        List<Integer> path = new ArrayList<Integer>();
        List<TreeNode> newNodes = new ArrayList<>(); //offer和poll
        if(nodes.isEmpty()){
            return;
        }
        for(int i=0; i<nodes.size(); i++){
            path.add(nodes.get(i).val);
            if(nodes.get(i).left!=null)
                newNodes.add(nodes.get(i).left);
            if(nodes.get(i).right!=null)
                newNodes.add(nodes.get(i).right);
        }
        if(target==-1){
            int l=0;
            int r=path.size()-1;
            while(l<r){
                int tmp = path.get(l);
                path.set(l, path.get(r));
                path.set(r, tmp);
                l++;
                r--;

            }
        }
        res.add(path);
        LevelOrder(newNodes, -1*target);
    }

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        res.clear();
        if(root==null){
            return res;
        }
        List<TreeNode> newNodes = new ArrayList<>();
        newNodes.add(root);
        LevelOrder(newNodes, 1);
        return res;
    }
}

官方代码和反转也没什么区别。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<List<Integer>>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> nodeQueue = new ArrayDeque<TreeNode>();
        nodeQueue.offer(root);
        boolean isOrderLeft = true;

        while (!nodeQueue.isEmpty()) {
            Deque<Integer> levelList = new LinkedList<Integer>();
            int size = nodeQueue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode curNode = nodeQueue.poll();
                if (isOrderLeft) {
                    levelList.offerLast(curNode.val);
                } else {
                    levelList.offerFirst(curNode.val);
                }
                if (curNode.left != null) {
                    nodeQueue.offer(curNode.left);
                }
                if (curNode.right != null) {
                    nodeQueue.offer(curNode.right);
                }
            }
            ans.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;
        }

        return ans;
    }
}

第五题：124. 二叉树中的最大路径和