1.1从上到下打印二叉树

解题思路:
利用队列的先进先出。
队列出一个节点，就往队列当中添加此节点的左节点和右节点，并且往list当中添加节点值。
最后，将list转化为int数组。

class Solution {
 public  static int[] levelOrder(TreeNode root) {
        List<Integer> list=new ArrayList<>();
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node=queue.poll();
            if(node!=null){
                list.add(node.val);
                queue.add(node.left);
                queue.add(node.right);
            }
        }
        int[] result=new int[list.size()];
        for(int i=0;i<result.length;i++){
            result[i]=list.get(i);
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.2从上到下打印二叉树II

解题思路:队列
利用queue.size(),来控制二叉树的分层。记录一层的节点个数，然后将这一层的节点值加入到ret当中，然后将这一层节点的子节点加入到队列当中，最后，将ret加入到result当中。

class Solution {
 public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<>();
          if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            List<Integer> ret=new ArrayList<>();
            for(int i=0;i<size;i++){
                TreeNode node=queue.poll();
                ret.add(node.val);
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
            }
            result.add(ret);
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

1.3从上到下打印二叉树III

解题思路:
定义一个变量，boolean isOdd：判断当前行是否为奇数行。
遍历完一行之后，更新isOdd,将isOdd=!isOdd;
如果当前为奇数行，直接将ret添加到result当中；
如果当前为偶数行，将ret反转，Collections.reverse(ret),然后将其添加到result当中。

class Solution {
    public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        //是否为奇数行
        boolean isOdd=true;
        while(!queue.isEmpty()){
            int size=queue.size();
            List<Integer> ret=new ArrayList<>();
            for(int i=0;i<size;i++){
                TreeNode node=queue.poll();
                ret.add(node.val);
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
            }
            if(!isOdd){
                Collections.reverse(ret);
            }
            isOdd=!isOdd;
            result.add(ret);
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2.1数组中数字出现的次数

解题思路:hashMap
利用hashMap，统计出每一个元素出现的次数；
再从头到尾遍历hashMap,如果hashMap.get(i)等于1，将其记录在数组当中；
最后，返回数组即可。

class Solution {
      public static int[] singleNumbers(int[] nums) {
        HashMap<Integer,Integer> hashMap=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            hashMap.put(nums[i],hashMap.getOrDefault(nums[i],0)+1);
        }
        int[] result=new int[2];
        int j=0;
        for(int i=0;i<nums.length;i++){
            if(hashMap.get(nums[i])==1){
                result[j++]=nums[i];
            }
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2.2数组中数字出现的次数II

class Solution {
      public int singleNumber(int[] nums) {
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            map.put(nums[i],map.getOrDefault(nums[i],0)+1);
        }
        int index=-1;
        for(int i=0;i<nums.length;i++){
            if(map.get(nums[i])==1){
                index=nums[i];
            }
        }
        return index;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.每日温度(739)

双层for循环，解决此问题。

class Solution {
     public static int[] dailyTemperatures(int[] temperatures) {
        int[] result=new int[temperatures.length];
        for(int i=0;i<temperatures.length;i++){
            int count=1;
            for(int j=i+1;j<temperatures.length;j++){
                if(temperatures[j]>temperatures[i]){
                    result[i]=count;
                    break;
                }else{
                    count++;
                }
            }
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4.队列的最大值II

用数组的方式来实现，寻找队列中的最大值，遍历整个数组即可，定义两个下标，一个下标控制增加，一个下标控制删除。

class MaxQueue {
  int[] ret=new int[20000];
    int begin=0;
    int end=0;
    public MaxQueue() {

    }
    public int max_value() {
        int max=-1;
        for(int i=begin;i<end;i++){
            max=Math.max(max,ret[i]);
        }
        return max;
    }

    public void push_back(int value) {
        ret[end++]=value;
    }

    public int pop_front() {
        if(begin==end){
            return -1;
        }
        return ret[begin++];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

5.n个骰子的点数

class Solution {
  public double[] dicesProbability(int n) {
        double[] dp=new double[6];
        Arrays.fill(dp,1.0/6.0);
        for(int i=2;i<=n;i++){
            double[] temp=new double[5*i+1];
            for(int j=0;j<dp.length;j++){
                for(int k=0;k<6;k++){
                    temp[j+k]+=dp[j]/6.0;
                }
            }
            dp=temp;
        }
        return dp;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.股票的最大利润

class Solution {
      public static int maxProfit(int[] prices) {
            int max=0;
            for(int i=0;i<prices.length;i++){
                for(int j=i+1;j<prices.length;j++){
                    max=Math.max(max,prices[j]-prices[i]);
                }
            }
            return max;
        }
}
1
2
3
4
5
6
7
8
9
10
11

7.构建乘积数组

解题思路:

class Solution {
    public static int[] constructArr(int[] a) {
        int[] result=new int[a.length];
        int[] t1=new int[a.length];
        int[] t2=new int[a.length];
        int ans1=1;
        int ans2=1;
        for(int i=0,j=a.length-1;i<a.length && j>=0;i++,j--){
            t1[i]=ans1;
            ans1=ans1*a[i];

            t2[j]=ans2;
            ans2=ans2*a[j];
        } 
        for(int i=0;i<a.length;i++){
            result[i]=t1[i]*t2[i];
        }
        return result;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

8.数组中和为0的三个数

class Solution {
  public static List<List<Integer>> threeSum(int[] nums){
        List<List<Integer>> lists=new ArrayList<>();
        if(nums.length<3){
            return lists;
        }
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){
            if(nums[i]>0){
                continue;
            }
            int r1=nums[i];
            if(i!=0 && nums[i]==nums[i-1]){
                continue;
            }
            int left=i+1;
            int right=nums.length-1;
            while(left<right){
                int sum=r1+nums[left]+nums[right];
                if(sum==0){
                    lists.add(Arrays.asList(r1,nums[left],nums[right]));
                    left++;
                    while (left<right && nums[left-1]==nums[left]){
                        left++;
                    }
                }
                else if(sum>0){
                    right--;
                }else{
                    left++;
                }
            }
        }
        return lists;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

9.回文子串(647)

思路:
每一个单独的字符都是回文子串，所以，在初始化个数的时候，就直接等于字符串的长度。
其次，遍历字符串，截取字符串，判断截取到的字符串是否等于截取反转后的字符串，如果等于,count++即可。
最后，返回count即可。

class Solution {
     public static int countSubstrings(String s) {
        int count=s.length();
        if(s.length()==1){
            return count;
        }
        for(int i=0;i<s.length();i++){
            for(int j=i+1;j<s.length();j++){
                String temp=s.substring(i,j+1);
                StringBuilder stringBuilder=new StringBuilder(temp);
                if(temp.equals(stringBuilder.reverse().toString())){
                    count++;
                }
            }
        }
        return count;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

10.找到字符串中所有字母异位词(438)

class Solution {
    public static List<Integer> findAnagrams(String s, String p) {
        List<Integer> list=new ArrayList<>();
        if(s.length()<p.length()){
            return list;
        }
        //将字符串p进行字符排序，先将其变成字符数组，进行排序，在排序后，再将其转成字符串
        char[] aa=p.toCharArray();
        Arrays.sort(aa);
        String rep=new String(aa);
        //记录p字符串的长度
        int plength=p.length();
        //for循环，i下标小于s总长度-p字符串长度+1
        for(int i=0;i<s.length()-plength+1;i++){
            //进行字符串截取，substring区间:左闭右开
            String temp=s.substring(i,i+plength);
            //判断两个字符串是否相等
            boolean flag=isSame(temp,rep);
            //如果相等,list.add(下标)
            if(flag){
                list.add(i);
            }else{
                continue;
            }
        }
        return list;
    }
    public static boolean isSame(String ret,String p){
        //将传过来的字符串进行排序，先将字符串改成字符数组，排序后，再将字符数组转成字符串
        char[] rr=ret.toCharArray();
        Arrays.sort(rr);
        String ee=new String(rr);
        //字符串排序后，将排序后的字符串和p字符串进行比较
        return ee.equals(p);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36