数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数。
解题思路
- 暴力法:遍历查询
- HashMap:对于查询类的问题,HashMap有独有的遍历,但是却会牺牲空间复杂度
- 因为数组是有序数组可以想到二分法
代码
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));
}
}
二叉树的深度
输入一棵二叉树,求该树的深度。从根结点到叶结点依次经过的结点(含根、叶结点)形成树的一条路径,最长路径的长度为树的深度。
解题思路
- 递归完成
- 层序遍历
代码
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));
}
}