205. 同构字符串 Isomorphic Strings
给定两个字符串 s 和 t ，判断它们是否是同构的。
如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
示例 1:
输入：s = "egg", t = "add"
输出：true
示例 2：
输入：s = "foo", t = "bar"
输出：false
示例 3：
输入：s = "paper", t = "title"
输出：true
提示：
1 <= s.length <= 5 * 10^4
t.length == s.length
s 和 t 由任意有效的 ASCII 字符组成
代码：三种方法，分别用哈希表、数组、字符串函数实现
package main import ( "fmt" "strings" ) func isIsomorphic(s string, t string) bool { if len(s) != len(t) { return false } sMap := make(map[byte]byte) // 字符映射表，用于保存每个字符的映射 tMap := make(map[byte]bool) // 标记表，用于记录每个字符是否已经有映射 for i := 0; i < len(s); i++ { if val, ok := sMap[s[i]]; ok { // 如果s[i]已经有映射，则检查其是否符合要求 if val != t[i] { return false } } else { // 如果s[i]没有映射，则添加映射 if tMap[t[i]] { // 如果t[i]已经有了映射，则说明不符合要求 return false } sMap[s[i]] = t[i] tMap[t[i]] = true } } return true } func isIsomorphic2(s string, t string) bool { if len(s) != len(t) { return false } s2t := make([]byte, 256) // 用数组保存映射关系 t2s := make([]byte, 256) // 用数组保存映射关系 for i := 0; i < len(s); i++ { if s2t[s[i]] != 0 && s2t[s[i]] != t[i] || t2s[t[i]] != 0 && t2s[t[i]] != s[i] { return false } s2t[s[i]] = t[i] t2s[t[i]] = s[i] } return true } func isIsomorphic3(s string, t string) bool { for i := 0; i < len(s); i++ { if strings.IndexByte(s, s[i]) != strings.IndexByte(t, t[i]) { return false } } return true } func main() { s := "egg" t := "add" fmt.Println(isIsomorphic(s, t)) fmt.Println(isIsomorphic2(s, t)) fmt.Println(isIsomorphic3(s, t)) s = "foo" t = "bar" fmt.Println(isIsomorphic(s, t)) fmt.Println(isIsomorphic2(s, t)) fmt.Println(isIsomorphic3(s, t)) s = "paper" t = "title" fmt.Println(isIsomorphic(s, t)) fmt.Println(isIsomorphic2(s, t)) fmt.Println(isIsomorphic3(s, t)) }
输出：
true
true
true
false
false
false
true
true
true
206. 反转链表 Reverse Linked-list
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：
输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
提示：
链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000
进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
代码：
package main import "fmt" // 链表节点的定义 type ListNode struct { Val int Next *ListNode } // 遍历链表 func (head *ListNode) print() { for head != nil { fmt.Printf("%d->", head.Val) head = head.Next } fmt.Println("<nil>") } // 创建链表 func create(arr []int) *ListNode { if len(arr) == 0 { return nil } head := &ListNode{Val: arr[0]} cur := head for i := 1; i < len(arr); i++ { node := &ListNode{Val: arr[i]} cur.Next = node cur = cur.Next } return head } func reverseList(head *ListNode) *ListNode { var prev, next *ListNode for head != nil { next = head.Next head.Next = prev prev = head head = next } return prev } func main() { arr1 := []int{1, 2, 3, 4, 5} head1 := create(arr1) head1.print() head11 := reverseList(head1) head11.print() arr2 := []int{1, 2} head2 := create(arr2) head2.print() head2 = reverseList(head2) head2.print() }
输出：
1->2->3->4->5-><nil>
5->4->3->2->1-><nil>
1->2-><nil>
2->1-><nil>
