LeeCode刷题简记(十)

LeeCode热题(Medium)

Solution43字符串相乘、Solution204计数质数、Solution260只出现一次的数字Ⅲ、Solution422数组中的重复数据、Solution433最小基因变化、Solution560和为K的子数组、Solution1367二叉树中的列表、面试题04.06后继者、

Solution43字符串相乘

给定两个以字符串形式表示的非负整数 num1 和 num2，返回 num1 和 num2 的乘积，它们的乘积也表示为字符串形式。

注意：不能使用任何内置的 BigInteger 库或直接将输入转换为整数。

示例 1:

输入: num1 = "2", num2 = "3"
输出: "6"
示例 2:

输入: num1 = "123", num2 = "456"
输出: "56088"

class Solution {
    public String multiply(String num1, String num2) {
        /*乘数 num1 位数为 MM，被乘数 num2 位数为 NN， num1 x num2 结果 res 最大总位数为 M+N
          num1[i] x num2[j] 的结果为 tmp(位数为两位，"0x","xy"的形式)，
         其第一位位于 res[i+j]，第二位位于 res[i+j+1]。
        */
        if (num1.equals("0") || num2.equals("0")) {
            return "0";
        }
        int[] res = new int[num1.length() + num2.length()];
        for (int i = num1.length() - 1; i >= 0; i--) {
            int n1 = num1.charAt(i) - '0';
            for (int j = num2.length() - 1; j >= 0; j--) {
                int n2 = num2.charAt(j) - '0';
                int sum = (res[i + j + 1] + n1 * n2);
                res[i + j + 1] = sum % 10;
                res[i + j] += sum / 10;
            }
        }

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < res.length; i++) {
            if (i == 0 && res[i] == 0) continue;
            result.append(res[i]);
        }
        return result.toString();
    }
}

Solution204计数质数

给定整数 n ，返回 所有小于非负整数 n 的质数的数量 。

示例 1：

输入：n = 10
输出：4
解释：小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
示例 2：

输入：n = 0
输出：0
示例 3：

输入：n = 1
输出：0

class Solution {
    public int countPrimes(int n) {
        //厄拉多塞筛法. 比如说求20以内质数的个数,首先0,1不是质数.2是第一个质数,
        //然后把20以内所有2的倍数划去.2后面紧跟的数即为下一个质数3,
        //然后把3所有的倍数划去.3后面紧跟的数即为下一个质数5,再把5所有的倍数划去.
        if(n < 3) return 0;
        boolean[] f = new boolean[n];//谁不行就给谁打叉
        int count = n/2;//去除偶数个数
        for(int i = 3; i * i < n; i+=2){
            if(f[i]){
                continue;
            }
            //每次加上两倍的i；
            for(int j = i*i; j < n; j+=2*i){
                if(!f[j]){
                    --count;
                    f[j] = true;
                }
            }
        }
        return count;
    }
}

Solution260只出现一次的数字Ⅲ

给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。

先全部异或一次, 得到的结果, 考察其的某个非0位(比如最高非0位), 那么只出现一次的两个数中, 在这个位上一个为0, 一个为1, 由此可以将数组中的元素分成两部分,重新遍历, 求两个异或值

class Solution {
    public int[] singleNumber(int[] nums) {
        int[] res = new int[2];
        int diff = 0;
        for(int i = 0;i < nums.length;i++){
            diff ^= nums[i];
        }

        int tmp = diff &(-diff);
        int ans = 0;
        //重新遍历
        for(int i = 0; i < nums.length; i++){
            if((nums[i] & tmp) != 0){
                ans ^= nums[i];
            }
        }
        res[0] = ans;
        res[1] = ans ^ diff;
        return res;
    }
}

Solution422数组中的重复数据

给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数，并以数组形式返回。

你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。

有要求时间空间复杂度，那么只能原地修改数组

对数组下标动手，每个数最多出现两次且小于数组长度，则对（数值减一的下标）的值取反

亦或者对数值做偏移量

class Solution {
    public List<Integer> findDuplicates(int[] nums) {
        //用下标修改取反当前值表示有没有遇过当前这个数
        List<Integer> res = new ArrayList<>();
        for (int num : nums) {
            if (nums[Math.abs(num) - 1] < 0) {
                res.add(Math.abs(num));
            } else {
                nums[Math.abs(num) - 1] *= -1;
            }
        }
        return res;
    }
}

Solution433最小基因变化

基因序列可以表示为一条由 8 个字符组成的字符串，其中每个字符都是 'A'、'C'、'G' 和 'T' 之一。

假设我们需要调查从基因序列 start 变为 end 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。

例如，"AACCGGTT" --> "AACCGGTA" 就是一次基因变化。
另有一个基因库 bank 记录了所有有效的基因变化，只有基因库中的基因才是有效的基因序列。

给你两个基因序列 start 和 end ，以及一个基因库 bank ，请你找出并返回能够使 start 变化为 end 所需的最少变化次数。如果无法完成此基因变化，返回 -1 。

注意：起始基因序列 start 默认是有效的，但是它并不一定会出现在基因库中。

class Solution {
    public int minMutation(String start, String end, String[] bank) {
        // 1, start和end相同，则没有变异，-1
        if (start == end) {
            return -1;
        }

        // 把bank基因序列放入到map中
        Set<String> cnt = new HashSet<String>();
        // 如果bank中无end，则说明无法变异
        for (String w : bank) {
            cnt.add(w);
        }
        // 2，基因库总无end基因，无法变异
        if (!cnt.contains(end)) {
            return -1;
        }

        Queue<String> queue = new ArrayDeque<String>();
        // 3，把需要变异的基因序列放入队列
        queue.offer(start);
        // visited.add(start);
        int step = 0;
        // 防止变回来
        Set<String> visited = new HashSet<String>();
        char[] keys = {'A', 'C', 'G', 'T'};
        while (!queue.isEmpty()) {
            step++;
            // 一波一波走
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String curr = queue.poll();
            // 每一个序列都有3*8中变化的可能(一个8个字符，每个字符可以变换为另外3个字符，3*8)
                //  八个字符，一个一个遍历
                for (int j = 0; j < 8; j++) {
                    // 遍历看下是哪个字符，然后变异为其他字符
                    for (int k = 0; k < 4; k++) {
                        if (keys[k] != curr.charAt(j)) {
                            StringBuffer sb = new StringBuffer(curr);
                            sb.setCharAt(j, keys[k]);
                            String mutatedNxt = sb.toString();
                            if (!visited.contains(mutatedNxt) && 
                                 cnt.contains(mutatedNxt)) {
                                if (mutatedNxt.equals(end)) {
                                    return step;
                                }
                                queue.offer(mutatedNxt);
                                visited.add(mutatedNxt);
                            }
                        }
                    }
                }
            }
        }
        return -1;
    }
}

 

Solution560和为K的子数组

给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数 。

示例 1：

输入：nums = [1,1,1], k = 2
输出：2
示例 2：

输入：nums = [1,2,3], k = 3
输出：2

暴力解法

class Solution {
    public int subarraySum(int[] nums, int k) {
        int count = 0;
        for(int i = 0; i < nums.length; i++){
            int sum = 0;
            for(int j = i; j < nums.length; j++){
                sum += nums[j];
                count += sum == k ? 1 : 0;
            }
        }
        return count;
    }
}

Solution1367二叉树中的列表

给你一棵以 root 为根的二叉树和一个 head 为第一个节点的链表。

如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。

一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。

class Solution {
    public boolean isSubPath(ListNode head, TreeNode root) {
        if(root == null){
            return false;
        }
        return isSubPathFromRoot(head, root) ||
               isSubPath(head, root.left) ||
               isSubPath(head,root.right);
    }

    //从根结点往下找，避免锁定根结点而根结点的左右子树不符合顺序
    //如果root.val和head.val值相同,可以判断head.next 和 root.left以及root.right是否相同,
    //直到链表递归到了尾部节点即head.next == null
    private boolean isSubPathFromRoot(ListNode head, TreeNode root){
        if(head == null){
            return true;
        }
        if(root == null){
            return false;
        }
        if(root.val == head.val){
            return isSubPathFromRoot(head.next, root.left) || 
                   isSubPathFromRoot(head.next, root.right);
        }
        return false;
    }
}

面试题04.06后继者

设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。

如果指定节点没有对应的“下一个”节点，则返回null。

示例 1:

输入: root = [2,1,3], p = 1

  2
 / \
1   3

输出: 2
示例 2:

输入: root = [5,3,6,2,4,null,null,1], p = 6

      5
     / \
    3   6
   / \
  2   4
 /   
1

输出: null

class Solution {
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        if(root == null){
            return null;
        }
        // 当前节点值小于等于目标值，那么当前目标值的后继者必然在右子树
        if(p.val >= root.val){
            return inorderSuccessor(root.right,p);
        }
        // 否则结果有可能是当前节点，或者在当前节点的左子树中
        // 那么先去左子树找一下试试，找不到的话返回当前节点即是结果
        TreeNode node = inorderSuccessor(root.left,p);
        return node == null ? root : node;
    }
}