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] = truen = getSum(n)}return n == 1
}
func getSum(num int)int{sum:=0for 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[]inthash:= 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] = trueuniqueArr = 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)-1for 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,headfor fast.Next!=nil && fast.Next.Next!=nil{slow = slow.Nextfast =fast.Next.Next}return slow
}
func reverseList(head * ListNode)*ListNode{dummyNode:= &ListNode{Next:head}cur:= headpre:= dummyNodefor cur.Next!=nil{tem:= new(ListNode)tem= cur.Nextcur.Next = tem.Nexttem.Next = pre.Nextpre.Next = tem}return dummyNode.Next
}
func mergeList(l1,l2 *ListNode){var node1,node2 *ListNodefor l1!=nil && l2!=nil{node1 = l1.Nextnode2 = l2.Nextl1.Next = l2l1 = node1l2.Next = l1l2 = node2}
}
func reorderList(head *ListNode) {if head ==nil || head.Next == nil{return }mid := middleNode(head)l1 := head; l2 :=mid.Next;mid.Next = nill2 = reverseList(l2)mergeList(l1,l2)
}
