代码随想录训练营day5

1. 两数之和、

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]
提示：
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

思路： 经典老题，有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来。
哈希表的经典问题，非常经典，val存下标，key保存 nums[i]即可，这点比较绕，处理明白就行，判断的时候判断hash[target-v]是否存在，存在就返回hash的val，下标

本月三刷：耗时6min

func twoSum(nums []int, target int) []int {
    hash:= make(map[int]int)
    for i,v := range nums{
        if _,ok := hash[target - nums[i]]; ok{
            return []int{hash[target-v],i}
        }
        hash[v] = i
    }
    return []int{}
}

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
思路：这题没做过，真的要抓头皮，以前做过，但是没记住思路，这次认真了。
思路就是一个逻辑，如果不是快乐数，结果一定会无限循环，如果是快乐数，结果一定一直不一样，最终到1结束。
所以对n的每个结果用hash保存，如果重复return false，如果不重复就一直等待直到变成1或者重复

func isHappy(n int) bool {
    hash:= make(map[int]bool)
    for n!=1 && !hash[n]{//如果hash[n] 曾经出现过，说明就是无限循环，此时n！=1 所以false，只要不无限循环就一定等等到 1 
        hash[n] = true
        n = getSum(n)
    }

    return n == 1
}
func getSum(num int)int{
    sum:=0
    for num >0 {
        sum +=(num%10)*(num%10)
        num= num/10
    }
    return sum
}

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序。
示例 1：
输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]
示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

思路：这题用set而不是map，用map还得去重，但我直接用chatgpt搜了个去重函数
一个数组充当hash，遍历第二个数组，如果能在hash中查到nums2的元素就追加

func intersection(nums1 []int, nums2 []int) []int {
    var res[]int
    hash:= make(map[int]int)
    for _,v := range nums1{
        hash[v]++
    }

    for _,val  := range nums2{
        if v,ok:= hash[val];ok{
            res= append(res,val)
            fmt.Println(v)
        }
    }
    return RemoveDuplicates(res)
   // return res
}

func RemoveDuplicates(arr []int) []int {
    uniqueMap := make(map[int]bool)
    uniqueArr := make([]int, 0, len(arr))
    for _, num := range arr {
        if !uniqueMap[num] {
            uniqueMap[num] = true
            uniqueArr = append(uniqueArr, num)
        }
    }
    return uniqueArr
}

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false

思路：做两个hash，然后对两个hash进行比对，如果两个hash一模一样就是异位词，否则就不是

func isAnagram(s string, t string) bool {
    s1:= []byte(s)
    t1:= []byte(t)
    hash1:= make(map[byte]int)
    hash2:= make(map[byte]int)
    for _,v := range s1{
        hash1[v]++
    }

    for _,v := range t1{
        hash2[v]++
    }
    res:= isMapsEqual(hash1,hash2)
    return res
}

// 判断两个map是否相同
func isMapsEqual(map1, map2 map[byte]int) bool {
    if len(map1) != len(map2) {
        return false
    }

    for key, value := range map1 {
        if map2Value, ok := map2[key]; ok {
            if map2Value != value {
                return false
            }
        } else {
            return false
        }
    }

    return true
}

143. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：

输入：head = [1,2,3,4]
输出：[1,4,2,3]
示例 2：

输入：head = [1,2,3,4,5]
输出：[1,5,2,4,3]

提示：

链表的长度范围为  [1, 5 * 104]
1 <= node.val <= 1000
思路一：保存到数组中，利用数组的性质进行交换，注意一个点，就是如果lf == ri 就不需要在进行ri的交换了，直接 break返回。

思路二：
寻找链表中点（在这里我出了差错，写成了slow.Next = slow.next ）
逆序中点后的链表，这里同样对于数组逆序出来问题，dummyNode解法同样需要 tem来new一个新节点。这样更容易理解一些。
合并链表，蛮有意思的。

总结：
        第一种思路5mintues AC
        第二种思路 花了小半个小时找bug，因为涉及三个函数，比较麻烦，这里也可以看出，中等题有些就是简单题的排列组合，所以，基础题要刷的熟练，才能做到中等题的游刃有余，无他，唯手熟而。 

143. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：
L0 → L1 → … → Ln - 1 → Ln
请将其重新排列后变为：
L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → …
不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例 1：

输入：head = [1,2,3,4]
输出：[1,4,2,3]
示例 2：

输入：head = [1,2,3,4,5]
输出：[1,5,2,4,3]

提示：

链表的长度范围为  [1, 5 * 104]
1 <= node.val <= 1000
思路一：保存到数组中，利用数组的性质进行交换，注意一个点，就是如果lf == ri 就不需要在进行ri的交换了，直接 break返回。

思路二：
寻找链表中点（在这里我出了差错，写成了slow.Next = slow.next ）
逆序中点后的链表，这里同样对于数组逆序出来问题，dummyNode解法同样需要 tem来new一个新节点。这样更容易理解一些。
合并链表，蛮有意思的。

总结：
        第一种思路5mintues AC
        第二种思路 花了小半个小时找bug，因为涉及三个函数，比较麻烦，这里也可以看出，中等题有些就是简单题的排列组合，所以，基础题要刷的熟练，才能做到中等题的游刃有余，无他，唯手熟而。

 func reorderList(head *ListNode)  {
    if head ==nil { return}

    nodes:=[]*ListNode{}

    for node:= head;node!=nil;node = node.Next{
        nodes= append(nodes,node)
    }
    lf,ri:=0,len(nodes)-1

    for lf < ri{
        nodes[lf].Next = nodes[ri]
        lf++
        if lf ==ri { break } 
        nodes[ri].Next = nodes[lf]
        ri--
    }
    nodes[lf].Next=nil
}
*/
func middleNode(head *ListNode)*ListNode{
    slow ,fast:= head,head
    for fast.Next!=nil && fast.Next.Next!=nil{
        slow = slow.Next
        fast =fast.Next.Next
    }
    return slow
}
func reverseList(head * ListNode)*ListNode{
    dummyNode:= &ListNode{Next:head}
    cur:= head
    pre:= dummyNode
    for cur.Next!=nil{
        tem:= new(ListNode)
        tem= cur.Next
        cur.Next = tem.Next
        tem.Next = pre.Next
        pre.Next = tem
    }
    return dummyNode.Next
}
func mergeList(l1,l2 *ListNode){
    var node1,node2 *ListNode
    for l1!=nil && l2!=nil{
        node1 = l1.Next
        node2 = l2.Next
        l1.Next = l2
        l1 = node1
        l2.Next = l1
        l2 = node2
    }
}
func reorderList(head *ListNode) {
    if head ==nil || head.Next == nil{return }
    mid := middleNode(head)
    l1 := head; l2 :=mid.Next;mid.Next = nil
    l2 = reverseList(l2)
    mergeList(l1,l2)
}