剑指 Offer 41. 数据流中的中位数 剑指 Offer 55 - I. 二叉树的深度 剑指 Offer 55 - II. 平衡二叉树 剑指 Offer 64. 求1+2+…+n

剑指 Offer 41. 数据流中的中位数

方法一：借用list集合来解决问题

class MedianFinder {
    List<Integer> res;

    /** initialize your data structure here. */
    public MedianFinder() {
        res=new ArrayList<>();
        
    }
    
    public void addNum(int num) {
        res.add(num);

    }
    
    // 1 2 3 4 5 6
    public double findMedian() {
        //对list集合进行排序
        Collections.sort(res);
        if(res.size()%2==0){
         
          double zw=(res.get(res.size()/2-1)+res.get(res.size()/2))/2.0;
                return zw;

        }else{
            // 1 2 3 4 5
            double zw=res.get(res.size()/2)*1.0;
            return zw;
        }

    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

方法二：
借用大顶堆和小顶堆

class MedianFinder {
    Queue<Integer> A,B;

    /** initialize your data structure here. */
    public MedianFinder() {
        A=new PriorityQueue<>(); //小顶堆，保存较大的一半
        B=new PriorityQueue<>((x,y) -> (y-x));//大顶堆，保存较小的一半
     
    }
    
    //当两堆的数据个数相等时候，左边堆添加元素。
    // 采用的方法不是直接将数据插入左边堆，而是将数据先插入右边堆，算法调整后
     //     将堆顶的数据插入到左边堆，这样保证左边堆插入的元素始终是右边堆的最小值。
       //  同理左边数据多，往右边堆添加数据的时候，先将数据放入左边堆，选出最大值放到右边堆中。
    public void addNum(int num) {
        if(A.size()==B.size()){
            A.add(num);
            B.add(A.poll());
        }else{
            B.add(num);
            A.add(B.poll());
        }

    }
    
    public double findMedian() {
        if(A.size()==B.size()){
            double res=(A.peek()+B.peek())/2.0;
            return res;
        }else{
            return (double)(B.peek());
        }

    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

剑指 Offer 55 - I. 二叉树的深度

方法一：层序遍历实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        int count=0;
        if(root==null) return 0;
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int n=queue.size();
            count++;
            while(n!=0){
                n--;
                TreeNode temp = queue.poll();
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
        }
    return count;
    }
}

方法二：递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
       if(root==null) return 0;
       else{
           //关键点： 此树的深度和其左（右）子树的深度之间的关系。显然，此树的深度 等于 左子树的深度 与 右子树的深度 中的 最大值 +1
           return Math.max(maxDepth(root.left)+1,maxDepth(root.right)+1);
       }
    }
}

剑指 Offer 55 - II. 平衡二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root==null) return true;
        else{
           return Math.abs(count(root.left)-count(root.right))<=1 && isBalanced(root.left) && isBalanced(root.right);
        }
        

    }
    public int count(TreeNode root){
        if(root==null) return 0;
        else{
            return Math.max(count(root.left),count(root.right))+1;
        }
    }
}

剑指 Offer 64. 求1+2+…+n

思路：短路效应实现递归

class Solution {
    int res=0;
    public int sumNums(int n) {
        //思路：本题实现 “当 n = 1时终止递归” 的需求，可通过短路效应实现
        boolean x=n>1&&sumNums(n-1)>0;
        res+=n;
       return res;
    }
}