每日算法

461. 汉明距离

两个整数之间的 汉明距离 指的是这两个数字对应二进制位不同的位置的数目。

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

示例 1：

输入：x = 1, y = 4
输出：2
解释：
1   (0 0 0 1)
4   (0 1 0 0)
       ↑   ↑
上面的箭头指出了对应二进制位不同的位置。

示例 2：

输入：x = 3, y = 1
输出：1

代码:

/**
 * @param {number} x
 * @param {number} y
 * @return {number}
 */
var hammingDistance = function(x, y) {
    var _xarr = x.toString(2).split('')
    var _yarr = y.toString(2).split('')
    var _xlen = _xarr.length
    var _ylen = _yarr.length
    var res = 0
    //统一长度
    var len = Math.max(_xarr.length,_yarr.length)
    if(_xlen < len) {
        for(var i = 0;i < len - _xlen; i++) {
            _xarr.unshift('0')
        }
    }

    if(_ylen < len) {
        for(var j = 0;j < len - _ylen; j++) {
            _yarr.unshift('0')
        }
    }

    for(var k = 0; k < len; k++) {
        if(_xarr[k] !== _yarr[k]) {
            res+=1
        }
    }
    return res
};

//我学到了 arr.unshift()  返回数组的长度  arr.join('-') 返回一个新的字符串 原数组不会改变
//提交了5次才正确,呜呜呜....

617. 合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
输出: 
合并后的树:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

我的代码:

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root1
 * @param {TreeNode} root2
 * @return {TreeNode}
 */
var mergeTrees = function(root1, root2) {
    if(!root1) {
        return root2
    }
    if(!root2) {
        return root1
    }
    return {
        val: root1?.val + root2?.val,
        left:mergeTrees(root1?.left,root2?.left),
        right:mergeTrees(root1?.right,root2?.right)
    }
};
                         
//递归递归 马马虎虎的写出来了