从零开始的力扣刷题记录-第二十七天

112.路经总和-简单

题目描述：
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

题解：
经典的递归题

代码（Go）：

func hasPathSum(root *TreeNode, targetSum int) bool {
    if root == nil{
        return false
    }
    if root.Left == nil && root.Right == nil && root.Val == targetSum{
        return true
    }
    return hasPathSum(root.Left, targetSum - root.Val) || hasPathSum(root.Right,targetSum - root.Val)
}

191.位1的个数-简单

题目描述：
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

题解：
位运算搞不明白，除数取余法做的。官方题解有两种方法一种是让num与2的i次幂与运算第i位为1时结果不为0，第二种是让num与num-1与运算，每运算一次可以让一个1翻转为0，所以只需要统计运算次数就可以了

代码（Go）：

func hammingWeight(num uint32) int {
    re := 0
    for num != 0{
        if num%2 == 1{
            re++
        }
        num = num/2
    }
    return re
}

1005. K 次取反后最大化的数组和-简单

题目描述：
给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。
重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
以这种方式修改数组后，返回数组 可能的最大和 。

题解：
计数排序后从小往大遍历，优先反转负数，如果负数反转完还有剩余全部反转绝对值最小的数。官方题解和我的代码思路完全一样，但我写的代码麻烦很多

代码（Go）：

func largestSumAfterKNegations(nums []int, k int) int {
    sort := [201]int{}
    for _,v := range nums{
        sort[v + 100]++
    }
    re := 0
    for i := 0;i < 201;i++{
        if i - 100 < 0 &&sort[i] > 0 && k != 0{
            if sort[i] <= k{
                k = k - sort[i]
                re = re + sort[i] * (-(i - 100))
            }else{
                sort[i] = sort[i] - k
                re = re + k * (-(i - 100))
                k = 0
                re = re + sort[i] * (i - 100)
            }
            if sort[-(i - 100) + 100] == 0{
                sort[-(i - 100) + 100] = -1
            }
        }else if i - 100 == 0 && sort[i] > 0 && k != 0{
            k = 0
        }else if i - 100 > 0 && sort[i] != 0 && k != 0{
            if k%2 == 1 && sort[i] == -1{
                re = re - 2 * (i - 100)
                k = 0
            }else if k%2 == 1 && sort[i] > 0{
                re = re - (i - 100)
                sort[i]--
                re = re + sort[i] * (i - 100)
                k = 0
            }else if sort[i] > 0{
                re = re + sort[i] * (i - 100)
                k = 0
            }
        }else if k == 0 && sort[i] > 0{
            re = re + sort[i] * (i - 100)
        }
    }
    return re
}

16.最接近的三数之和-中等

题目描述：
给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。
返回这三个数的和。
假定每组输入只存在恰好一个解。

题解：
和三数之和一模一样，排序加双指针

代码（Go）：

func threeSumClosest(nums []int, target int) int {
    sort.Ints(nums)
    min := int(math.Pow(10,5))
    sum := 0
    for i := 0;i < len(nums);i++{
        j := i + 1
        k := len(nums) - 1
        for j < k{
            if nums[j] + nums[k] < target - nums[i]{
                if target - nums[i] - nums[j] - nums[k] < min{
                    min = target - nums[i] - nums[j] - nums[k]
                    sum = target - min
                }
                j++
            }else if nums[j] + nums[k] > target - nums[i]{
                if nums[i] + nums[j] + nums[k] - target < min{
                    min = nums[i] + nums[j] + nums[k] - target
                    sum = target + min
                }
                k--
            }else{
                return target
            }
        }
    }
    return sum
}

总结

位运算还是不太会，反转K次那个题代码写的比较啰嗦