从零开始的力扣刷题记录-第八天

剑指 Offer 39. 数组中出现次数超过一半的数字-简单

题目描述：
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

题解：
这个题不记得什么时候在哪看过了，但我印象比较深刻，可以遍历一遍数组求出结果，核心思想就是利用出现次数超过长度一半的特性。用一个temp标记元素，flag标记数量，当前元素与temp相等就让falg+1，否则-1，flag==0就更换元素，其实是通过两数抵消的思想，因为最终结果超过长度一半，这样多次进行两数抵消，留下的一定是出现次数最多的数。官方叫法是Boyer-Moore 投票算法

代码（Go）：

func majorityElement(nums []int) int {
    flag := 0
    temp := nums[0]
    for i := 0;i < len(nums);i++{
        if nums[i] == temp{
            flag++
        }else{
            flag--
        }
        if flag == 0{
            temp = nums[i]
            flag++
        }
    }
    return temp
}

2469.温度转换-简单

题目描述：
给你一个四舍五入到两位小数的非负浮点数 celsius 来表示温度，以 摄氏度（Celsius）为单位。
你需要将摄氏度转换为 开氏度（Kelvin）和 华氏度（Fahrenheit），并以数组 ans = [kelvin, fahrenheit] 的形式返回结果。
返回数组 ans 。与实际答案误差不超过 10-5 的会视为正确答案。

题解：
意义不明的一道题，建议和两数之和互换位置，题解少不是没有道理吧，完全不知道为啥要出这么个题，这道不算，今天再加一道

代码（Go）：

func convertTemperature(celsius float64) []float64 {
    return []float64{celsius + 273.15, celsius * 1.80 + 32.00}
}

141.环形链表-简单

题目描述：
给你一个链表的头节点 head ，判断链表中是否有环。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
如果链表中存在环 ，则返回 true 。 否则，返回 false 。

题解：
这个题也是之前在哪见过的题，快慢指针轻松解决。只需要让一个指针一次走两步，一个指针一次走一步，那么只有两种情况，要么快指针走到头，没有环；要么快指针与慢指针相遇，有环。

代码（Go）：

func hasCycle(head *ListNode) bool {
    p,q := head,head
    if q == nil{
        return false
    }
    for q.Next != nil{
        q = q.Next.Next
        p = p.Next
        if q == nil{
            return false
        }
        if q == p{
            return true
        }
    }
    return false
}

459.重复的子字符串-简单

题目描述：
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

题解：
一看就是KMP，然而不会，KMP属于每次看完觉得会了过几天就又忘了。看官方题解通过双倍字符串检查子串的方式更是秀的我头皮发麻，这题感觉不像简单题，起码比我前几天做的中等题难。啥也不说了，加练一道。

572.另一棵树的子树-简单

题目描述：
给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。
二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

题解：
只会暴力解，写了一大堆ifelse，结果用例还有一部分没通过，最后看了官方解，代码简单的很，方法二的DFS+KMP和方法三的哈希树都离大谱，完全没想到过，还是那句话，不像简单题。啥也不说了，加练一道。

代码（Go）：

//官方的方法一暴力解
func isSubtree(s *TreeNode, t *TreeNode) bool {
    if s == nil {
        return false
    }
    return check(s, t) || isSubtree(s.Left, t) || isSubtree(s.Right, t)
}

func check(a, b *TreeNode) bool {
    if a == nil && b == nil {
        return true
    }
    if a == nil || b == nil {
        return false
    }
    if a.Val == b.Val {
        return check(a.Left, b.Left) && check(a.Right, b.Right)
    }
    return false
}

242.有效的字母异位词-简单

题目描述：
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

题解：
前面已经做过好多次的类型题，如果没有进阶可以直接用数组解决，有进阶就用map就可以了，两个字符串各遍历一次，用哈希表的方法判断。

代码（Go）：

func isAnagram(s string, t string) bool {
    var dict = make(map[rune]int)
    for _,v := range s{
        if _, ok := dict[v]; ok{
		    dict[v] ++
	    }else{
            dict[v] = 1
        }
    }
    for _,v := range t{
        if _, ok := dict[v]; ok{
		    dict[v]--
	    }else{
            return false
        }
    }
    for _,v := range dict{
        if v != 0{
            return false
        }
    }
    return true
}

110.平衡二叉树-简单

题目描述：
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

题解：
递归遍历，写的时候没想太多直接从上到下遍历了一遍，看官方题解才发现，通过自底向上的方式遍历时间复杂度为O(n)，比自顶向下的遍历时间复杂度更小

代码（Go）：

func isBalanced(root *TreeNode) bool {
    if root == nil{
        return true
    }
    if math.Abs(float64(height(root.Left)) - float64(height(root.Right))) <= 1{
        return isBalanced(root.Left) && isBalanced(root.Right)
    }
    return false
}

func height(root *TreeNode) int {
    if root == nil{
        return 0
    }
    return max(height(root.Left),height(root.Right)) + 1
}

func max(x int,y int) int {
    if x > y{
        return x
    }else{
        return y
    }
}

总结

被KMP干碎，树的遍历也不是很熟练，还要多练