leetCodeday12

一：方法总结

1.排序

ArrayList实现排序，需要用Collections.sort(list,new Comparator{//重写方法})

HashMap排序，需要将entrySet放入ArrayList(Map.Entry<,>)，然后用Collections.sort实现排序

二：题目

448.找到所有数组中消失的数字

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
思路：1-n 用数组下标值来记录，比如nums[1] =2 ;则认为数字2已经出现，在数组第二个位置做记录。最后看数组哪一个位置没被做记录，返回该位置

public List<Integer> findDisappearedNumbers(int[] nums) {
        int l=nums.length;
        for (int i=0;i<l;i++){
            int j=(nums[i]-1)%l;//如果该位置已经做了记录，不取模会脚标越界
            nums[j]=nums[j]+l;//对已经出现的数字做记录
        }
        List<Integer> list = new ArrayList<>();
        for (int i=0;i<l;i++){
            if (nums[i]<=l)
                list.add(i+1);
        }
        return list;
    }

461.汉明距离

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。
思路：相同的数字异或=0，不同数字异或=1

 public int hammingDistance(int x, int y) {
        int s = x ^ y;
        int res = 0;
        while (s != 0) {
            res =res+ (s & 1);
            s >>= 1;
        }
        return res;
    }

543.二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

int level=0;
    public int diameterOfBinaryTree(TreeNode root) {
        if (root==null)
            return 0;
        dfs1(root);
        return level-1;
    }
    public int dfs1(TreeNode node){
        if (node==null)
            return 0;
        int leftLevel=dfs1(node.left);
        int rightLevel=dfs1(node.right);
        level=Math.max(level,leftLevel+rightLevel+1);
        return Math.max(leftLevel,rightLevel)+1;
    }

617.合并二叉树

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1==null )
            return root2;
        if (root2==null)
            return root1;
        dfs(root1,root2);
        return root1;
    }
    public void dfs(TreeNode node1,TreeNode node2){
        if (node1==null || node2==null)
            return;
        dfs(node1.left,node2.left);
        dfs(node1.right,node2.right);
        if (node1.left==null){
            node1.left=node2.left;
        }
        if (node1.right==null){
            node1.right=node2.right;
        }
        node1.val=node1.val+ node2.val;
    }

621.任务调度器

思路：Arraylist记录字母的个数，并按降序排列。一个时间片内依次做一个任务，若该种任务只有1次则直接从Arraylist里去掉。

public int leastInterval(char[] tasks, int n) {
        int ans=0;//记录结果
        //将同种任务的个数记录在ArrayList中
        Arrays.sort(tasks);
        ArrayList<Integer> list = new ArrayList<>();
        for (int i=0;i<tasks.length;i++){
            int j=1;
            while (i+1<tasks.length &&tasks[i+1]==tasks[i]){
                j++;
                i++;
            }
            list.add(j);
        }
        int d=0;
        while (!list.isEmpty()){
            ans=ans+n+1;
            d=n+1-list.size();//最后一次任务不需要待命
            int l=Math.min(n+1,list.size());
            for (int i=0;i<l;i++){
                Integer integer = list.remove(0);
                if (integer>1)
                    list.add(integer-1);
            }
            Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return -Integer.compare(o1,o2);
                }
            });

        }
        return ans-d;
    }

647.回文子串

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
思路：两个指针指向回文子串的中心

public int countSubstrings(String s) {
        int ans=0;
        int l=s.length();
        for (int i=0;i<l;i++){
            for(int j=i;j<i+2;j++){
                int m=i;
                int n=j;
                while (m>=0 && n<l && s.charAt(m)==s.charAt(n)){
                 m--;
                 n++;
                 ans++;
                }
            }
        }
        return ans;
    }