数字在排序数组中出现的次数&&二叉树的深度

数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

解题思路

1. 暴力法：遍历查询
2. HashMap：对于查询类的问题，HashMap有独有的遍历，但是却会牺牲空间复杂度
3. 因为数组是有序数组可以想到二分法

代码

import java.util.HashMap;

/**
 * 剑指offer一刷：数字在排序数组中出现的次数
 *
 * @author User
 * @create 2019-05-28-12:41
 */

public class jzo37 {
    //暴力法
    public int GetNumberOfK(int [] array , int k) {
        int count=0;
        for(int i=0;i<array.length;i++){
            if (array[i]==k){
                count++;
            }
        }
        return count;
    }
    //HashMap
    public int GetNumberOfK1(int [] array,int k){
        int count=0;
        HashMap<Integer,Integer> map=new HashMap<>();
        for (int i=0;i<array.length;i++){
            map.put(i,array[i]);
        }
        for (int i=0;i<array.length;i++){
            if (k==map.get(i)){
                count++;
            }
        }
        return count;
    }
//    二分法
    public int GetNumberOfK2(int [] array,int k){
        int length=array.length;
        if (length==0){
            return 0;
        }
        int firstK=getFirstK(array,k,0,length-1);
        int lastK=getLastK(array,k,0,length-1);
        if (firstK!=-1||lastK!=-1){
            return lastK-firstK+1;
        }
        return 0;
    }
    private int getFirstK(int[] array,int k,int start,int end){
        if (start>end){
            return -1;
        }
        int mid=(start+end)>>1;
        if (array[mid]>k){
            return getFirstK(array,k,start,mid-1);
        }else if (array[mid]<k){
            return getFirstK(array,k,mid+1,end);
        }else if (mid-1>=0&&array[mid-1]==k){
            return getFirstK(array,k,start,mid-1);
        }else {
            return mid;
        }
    }
    private int getLastK(int[] array,int k,int start,int end){
        int length=array.length;
        int mid=(start+end)>>1;
        while (start<=end){
            if (array[mid]>k){
                end=mid-1;
            }else if(array[mid]<k){
                start=mid+1;
            }else if (mid+1<length&&array[mid+1]==k){
                start=mid+1;
            }else {
                return mid;
            }
            mid=(start+end)>>1;
        }
        return -1;
    }
    public static void main(String[] args){
        int[] array={1,2,3,3,3,3,4,5};
        int k=3;
        jzo37 so=new jzo37();
        System.out.println(so.GetNumberOfK(array,k));
        System.out.println(so.GetNumberOfK1(array,k));
        System.out.println(so.GetNumberOfK2(array,k));
    }
}

二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

解题思路

1. 递归完成
2. 层序遍历

代码

import java.util.LinkedList;
import java.util.Queue;

/**
 * 剑指offer一刷：二叉树的深度
 *
 * @author User
 * @create 2019-05-28-13:08
 */

public class jzo38 {
    public int TreeDepth(TreeNode root) {
        if (root==null){
            return 0;
        }
        int nleft=TreeDepth(root.left);
        int nright=TreeDepth(root.right);
        return nleft>nright?(nleft+1):(nright+1);
    }
//    层序遍历
    public int TreeDepth1(TreeNode root) {
        if (root==null){
            return 0;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        int depth=0,count=0,nextCount=1;
        while (queue.size()!=0){
            TreeNode top=queue.poll();
            count++;
            if(top.left!=null){
                queue.add(top.left);
            }
            if (top.right!=null){
                queue.add(top.right);
            }
            if (count==nextCount){
                nextCount=queue.size();
                count=0;
                depth++;
            }
        }
        return depth;
    }
    public static void main(String[] args){
        TreeNode node1=new TreeNode(1);
        TreeNode node2=new TreeNode(2);
        TreeNode node3=new TreeNode(3);
        TreeNode node4=new TreeNode(4);
        TreeNode node5=new TreeNode(5);
        TreeNode node6=new TreeNode(6);
        TreeNode node7=new TreeNode(7);
        TreeNode node8=new TreeNode(8);
        TreeNode node9=new TreeNode(9);
        node1.left=node2;
        node2.left=node4;
        node2.right=node5;
        node5.left=node6;
        node5.right=node7;
        node7.right=node9;
        node1.right=node3;
        node3.right=node8;
        jzo38 so=new jzo38();
        System.out.println(so.TreeDepth(node1));
        System.out.println(so.TreeDepth1(node1));
    }
}