[leetcode top100] 0924 找到数组中消失的数，合并二叉树，比特位计数，汉明距离

目录

448. 找到所有数组中消失的数字 - 力扣（LeetCode）

617. 合并二叉树 - 力扣（LeetCode）

338. 比特位计数 - 力扣（LeetCode）

461. 汉明距离 - 力扣（LeetCode）

448. 找到所有数组中消失的数字 - 力扣（LeetCode）

 思路：原地修改，数组中的元素的范围应该是[1,n],遍历每一个元素,找到他们原本的下标，加上n,所有的元素的值都是大于n的，缺失的元素的值都是小于n的。

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        n = len(nums)
        for num in nums:
            idx = (num-1) % n
            nums[idx] += n
        ret = [i+1 for i,num in enumerate(nums) if num <= n]
        return ret

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        int n = nums.size();
        for (auto& num:nums){
            int idx = (num-1) % n;
            nums[idx] += n;
        }
        vector<int> ret;
        for (int i = 0;i < n;i++){
            if (nums[i] <= n) ret.push_back(i+1);
        }
        return ret;
    
    }
};

617. 合并二叉树 - 力扣（LeetCode）

 思路：可以使用深度优先搜索合并两个二叉树。从根节点开始同时遍历两个二叉树，并将对应的节点进行合并。两个二叉树的对应节点可能存在以下三种情况，对于每种情况使用不同的合并方式。如果两个二叉树的对应节点都为空，则合并后的二叉树的对应节点也为空；如果两个二叉树的对应节点只有一个为空，则合并后的二叉树的对应节点为其中的非空节点；如果两个二叉树的对应节点都不为空，则合并后的二叉树的对应节点的值为两个二叉树的对应节点的值之和，此时需要显性合并两个节点。
使用DFS，（python and  c++）

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def mergeTrees(self, root1: Optional[TreeNode], root2: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root1:return root2
        if not root2:return root1
        merged = TreeNode(root1.val + root2.val)
        merged.left = self.mergeTrees(root1.left,root2.left)
        merged.right = self.mergeTrees(root1.right,root2.right)
        return merged

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (root1 == nullptr) return root2;
        if (root2 == nullptr) return root1;
        TreeNode* merged = new TreeNode(root1->val +root2->val);
        merged->left = mergeTrees(root1->left,root2->left);
        merged->right = mergeTrees(root1->right,root2->right);
        return merged;
    }
};

338. 比特位计数 - 力扣（LeetCode）

思考：这道题需要计算从 0 到 n 的每个整数的二进制表示中的 1 的数目。

 每个int 型的数都可以用 32 位二进制数表示，只要遍历其二进制表示的每一位即可得到 1 的数目。按位与操作。

class Solution:
    def countBits(self, n: int) -> List[int]:
        ret = [self.count(i) for i in range(n+1)]
        return ret

    def count(self,n):
        count = 0
        while n:
            n &= (n-1)
            count += 1
        return count

class Solution {
public:
    int count_ones(int n){
        //计算1的数量
        int count = 0;
        while (n){
            n &= (n-1);
            count++;
        }
        return count;
    }

    vector<int> countBits(int n) {
        vector<int> res(n+1);
        //这种方式也可以
        for (int i = 0;i <= n;i++){
            res[i] = count_ones(i);
        }
        return res;
    }
};

461. 汉明距离 - 力扣（LeetCode）

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        res = 0
        tmp = x^y
        while tmp:
            tmp &= (tmp-1)
            res += 1
        return res

class Solution {
public:
    int hammingDistance(int x, int y) {
        int res = 0;
        int tmp = x^y;
        while (tmp){
            tmp &= (tmp-1);
            res++;
        }
        return res;
  
    }
};