Golang每日一练(leetDay0071) 同构字符串、反转链表

Hann Yang

已于 2023-06-14 21:32:07 修改

阅读量532

点赞数 7

分类专栏：刷题专栏文章标签：链表数据结构 golang leetcode

于 2023-05-20 07:00:00 首次发布

本文链接：https://blog.csdn.net/boysoft2002/article/details/130775426

版权

刷题专栏同时被 2 个专栏收录

629 篇文章 49 订阅

订阅专栏

Go Leetcode

121 篇文章 30 订阅

订阅专栏

205. 同构字符串 Isomorphic Strings 🌟

206. 反转链表 Reverse Linked-list 🌟

92. 反转链表 II Reverse Linked List II 🌟🌟

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>

92. 反转链表 II Reverse Linked List II

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：

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

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

提示：

链表中节点数目为 n
1 <= n <= 500
-500 <= Node.val <= 500
1 <= left <= right <= n

进阶： 你可以使用一趟扫描完成反转吗？

代码1：翻转、截取、翻转

package main
 
import "fmt"
 
type ListNode struct {
    Val  int
    Next *ListNode
}
 
func reverseBetween(head *ListNode, left int, right int) *ListNode {
    if head == nil {
        return nil
    }
    dummy := &ListNode{Next: head}
    pre := dummy
 
    // pre 指向 left 的前一个节点
    for i := 1; i < left; i++ {
        pre = pre.Next
    }
 
    cur := pre.Next
    for i := left; i < right; i++ {
        // 暂存 cur.Next
        next := cur.Next
        // 将 cur.Next 指向 next.Next
        cur.Next = next.Next
        // 将 next.Next 指向 pre.Next
        next.Next = pre.Next
        // 将 pre.Next 指向 next
        pre.Next = next
    }
    return dummy.Next
}
 
func createNodeList(nums []int) *ListNode {
    if len(nums) == 0 {
        return nil
    }
    head := &ListNode{Val: nums[0]}
    tail := head
    for i := 1; i < len(nums); i++ {
        tail.Next = &ListNode{Val: nums[i]}
        tail = tail.Next
    }
    return head
}
 
func (head *ListNode) travel() {
    for p := head; p != nil; p = p.Next {
        fmt.Print(p.Val)
        if p.Next != nil {
            fmt.Print("->")
        }
    }
    fmt.Println("<nil>")
}
 
func main() {
    nums := []int{1, 2, 3, 4, 5}
    head := createNodeList(nums)
    head.travel()
    left := 2
    right := 4
    head = reverseBetween(head, left, right)
    head.travel()
}

代码2：指针循环+头插法

package main
 
import "fmt"
 
type ListNode struct {
    Val  int
    Next *ListNode
}
 
func reverseBetween(head *ListNode, left int, right int) *ListNode {
    if head == nil {
        return nil
    }
    dummy := &ListNode{Next: head}
    pre := dummy
    // pre 指向 left 的前一个节点
    for i := 1; i < left; i++ {
        pre = pre.Next
    }
    // 使用头插法翻转链表，将节点插入到 left 节点的前面
    cur := pre.Next
    for i := left; i < right; i++ {
        next := cur.Next
        cur.Next = next.Next
        next.Next = pre.Next
        pre.Next = next
    }
    return dummy.Next
}
 
func createNodeList(nums []int) *ListNode {
    if len(nums) == 0 {
        return nil
    }
    head := &ListNode{Val: nums[0]}
    tail := head
    for i := 1; i < len(nums); i++ {
        tail.Next = &ListNode{Val: nums[i]}
        tail = tail.Next
    }
    return head
}
 
func (head *ListNode) travel() {
    for p := head; p != nil; p = p.Next {
        fmt.Print(p.Val)
        if p.Next != nil {
            fmt.Print("->")
        }
    }
    fmt.Println("<nil>")
}
 
func main() {
    nums := []int{1, 2, 3, 4, 5}
    head := createNodeList(nums)
    head.travel()
    left := 2
    right := 4
    head = reverseBetween(head, left, right)
    head.travel()
}

代码3：递归法

package main
 
import "fmt"
 
type ListNode struct {
    Val  int
    Next *ListNode
}
 
func reverseBetween(head *ListNode, left int, right int) *ListNode {
    if left == 1 {
        return reverseN(head, right)
    }
    head.Next = reverseBetween(head.Next, left - 1, right - 1)
    return head
}
 
var thd *ListNode
 
func reverseN(head *ListNode, n int) *ListNode {
    if n == 1 {
        thd = head.Next
        return head
    }
    last := reverseN(head.Next, n - 1)
    head.Next.Next = head
    head.Next = thd
    return last
}
 
func createNodeList(nums []int) *ListNode {
    if len(nums) == 0 {
        return nil
    }
    head := &ListNode{Val: nums[0]}
    tail := head
    for i := 1; i < len(nums); i++ {
        tail.Next = &ListNode{Val: nums[i]}
        tail = tail.Next
    }
    return head
}
 
func (head *ListNode) travel() {
    for p := head; p != nil; p = p.Next {
        fmt.Print(p.Val)
        if p.Next != nil {
            fmt.Print("->")
        }
    }
    fmt.Println("<nil>")
}
 
func main() {
    nums := []int{1, 2, 3, 4, 5}
    head := createNodeList(nums)
    head.travel()
    left := 2
    right := 4
    head = reverseBetween(head, left, right)
    head.travel()
}

输出：

1->2->3->4->5<nil>

1->4->3->2->5<nil>

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！

🌟 收藏，你的青睐是我努力的方向！

✎ 评论，你的意见是我进步的财富！

☸ 主页：https://hannyang.blog.csdn.net/

	Rust每日一练专栏（2023.5.16~）更新中...
	Golang每日一练专栏（2023.3.11~）更新中...
	Python每日一练专栏（2023.2.18~2023.5.18）暂停更
	C/C++每日一练专栏（2023.2.18~2023.5.18）暂停更
	Java每日一练专栏（2023.3.11~2023.5.18）暂停更

Hann Yang

关注

7
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
2
评论
Golang每日一练(leetDay0071) 同构字符串、反转链表

205. 同构字符串 Isomorphic Strings🌟　206. 反转链表 Reverse Linked-list🌟　92. 反转链表 II Reverse Linked-list ii🌟
复制链接

扫一扫

专栏目录

	Rust每日一练专栏（2023.5.16~）更新中...
	Golang每日一练专栏（2023.3.11~）更新中...
	Python每日一练专栏（2023.2.18~2023.5.18）暂停更
	C/C++每日一练专栏（2023.2.18~2023.5.18）暂停更
	Java每日一练专栏（2023.3.11~2023.5.18）暂停更

Golang每日一练(leetDay0071) 同构字符串、反转链表

205. 同构字符串 Isomorphic Strings

206. 反转链表 Reverse Linked-list

92. 反转链表 II Reverse Linked List II

🌟 每日一练刷题专栏 🌟

Rust每日一练 专栏

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

“相关推荐”对你有帮助么？

Rust每日一练专栏

Golang每日一练专栏

Python每日一练专栏

C/C++每日一练专栏

Java每日一练专栏