题目:
24. 两两交换链表中的节点
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:
输入:head = [1,2,3,4] 输出:[2,1,4,3]示例 2:
输入:head = [] 输出:[]示例 3:
输入:head = [1] 输出:[1]
思路:
1.操作两两交换,需要找到被交换的两个元素的前面一个元素,适合用虚拟头结点解题
2.操作cur.Next时,会丢掉原来的链表指向,因此需要设置tmp临时指向会丢失的节点
3.for循环跳出条件,若为奇数节点,最后一个值不用处理,因此cur.Next.Next==nil时可中止循环
算法:
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func swapPairs(head *ListNode) *ListNode {
if head == nil || head.Next == nil {
return head
}
dummyHead := &ListNode{}
dummyHead.Next = head
cur := dummyHead
for cur.Next != nil && cur.Next.Next != nil {
tmp := cur.Next
tmp1 := cur.Next.Next.Next
//注意:交换三步,先操作头结点cur的next,否则丢链接
cur.Next = cur.Next.Next
cur.Next.Next= tmp
tmp.Next = tmp1
cur = cur.Next.Next
}
return dummyHead.Next
}
注意:
两个tmp分别保存会被丢失的节点
题目:
19. 删除链表的倒数第 N 个结点
给你一个链表,删除链表的倒数第
n
个结点,并且返回链表的头结点。示例 1:
输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5]示例 2:
输入:head = [1], n = 1 输出:[]示例 3:
输入:head = [1,2], n = 1 输出:[1]
思路:
【法一】
1.先算出链表的总长度“l”
2.要找倒数第n个元素的前一个元素,才能做删除操作,那么也就是找到正数“l-n”对应下标的元素
3.做删除操作,若l-n=0, cur = dummyhead,操作cur.Next = cur.Next.Next,处理长度为1的链表,删除倒数第一个元素,cur.Next = nil
【法二】
1.采用双指针法,设置快慢指针,快指针先移动n步,这时快指针比慢指针间隔n个节点,然后再同时移动快指针和慢指针,直到快指针为最后一个节点
2.因为要找到倒数间隔为n的节点的前一个节点,才能做删除操作,因此快指针和慢指针需要间隔n+1
算法:
【法一】
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func removeNthFromEnd(head *ListNode, n int) *ListNode {
//先求list的长度
l := 0
dummyHead := &ListNode{Next:head}
cur := dummyHead
for cur.Next != nil {
l++
cur = cur.Next
}
ll := l - n
cur = dummyHead
for i := 0; i < ll; i++ {
cur = cur.Next
}
if cur.Next.Next != nil {
cur.Next = cur.Next.Next
} else {
cur.Next = nil
}
return dummyHead.Next
}
【法二】
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func removeNthFromEnd(head *ListNode, n int) *ListNode {
dummyHead := &ListNode{Next:head}
slow, fast := dummyHead, dummyHead
for i := 0; i < n; i++ {
fast =fast.Next
}
for fast != nil && fast.Next != nil {
fast = fast.Next
slow = slow.Next
}
if slow.Next.Next != nil {
slow.Next = slow.Next.Next
} else {
slow.Next = nil
}
return dummyHead.Next
}
注意:
第一个for循环判断条件 i<n 还是 i<=n,可代入具体的值进循环跑一遍
题目:
面试题 02.07. 链表相交
给你两个单链表的头节点
headA
和headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回null
。图示两个链表在节点
c1
开始相交:题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出:Intersected at '8' 解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。 在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。示例 2:
输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出:Intersected at '2' 解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。 从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。 在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。示例 3:
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2 输出:null 解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。 由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。 这两个链表不相交,因此返回 null 。提示:
listA
中节点数目为m
listB
中节点数目为n
0 <= m, n <= 3 * 104
1 <= Node.val <= 105
0 <= skipA <= m
0 <= skipB <= n
- 如果
listA
和listB
没有交点,intersectVal
为0
- 如果
listA
和listB
有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]
进阶:你能否设计一个时间复杂度
O(n)
、仅用O(1)
内存的解决方案?
思路:
【法一】哈希法,时间复杂度O(m+n),空间复杂度O(1)
1.判断两个链表是否相交,可以使用哈希集合存储链表节点
2.首先遍历链表 headA,并将链表 headA 中的每个节点加入哈希集合中。然后遍历链表 headB,对于遍历到的每个节点,判断该节点是否在哈希集合中:
3.如果当前节点不在哈希集合中,则继续遍历下一个节点;如果B中某一个节点在哈希集合中,说明有相交,否则返回null
算法:
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func getIntersectionNode(headA, headB *ListNode) *ListNode {
via := map[*ListNode]bool{}
for cur := headA; cur != nil; cur = cur.Next{
via[cur] = true
}
for cur := headB; cur != nil; cur = cur.Next{
if via[cur] {
return cur
}
}
return nil
}
注意:
题目:
142. 环形链表 II
给定一个链表的头节点
head
,返回链表开始入环的第一个节点。 如果链表无环,则返回null
。如果链表中有某个节点,可以通过连续跟踪
next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果pos
是-1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。不允许修改 链表。
示例 1:
输入:head = [3,2,0,-4], pos = 1 输出:返回索引为 1 的链表节点 解释:链表中有一个环,其尾部连接到第二个节点。示例 2:
输入:head = [1,2], pos = 0 输出:返回索引为 0 的链表节点 解释:链表中有一个环,其尾部连接到第一个节点。示例 3:
输入:head = [1], pos = -1 输出:返回 null 解释:链表中没有环。提示:
- 链表中节点的数目范围在范围
[0, 104]
内-105 <= Node.val <= 105
pos
的值为-1
或者链表中的一个有效索引进阶:你是否可以使用
O(1)
空间解决此题?
思路:
算法:
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func detectCycle(head *ListNode) *ListNode {
slow, fast := head, head
for fast != nil && fast.Next != nil {
//slow每次移动1步,fast每次移动两步
fast = fast.Next.Next
slow = slow.Next
//找相遇点
if fast == slow {
index1 := fast
index2 := head
for index1 != index2 {
index1 = index1.Next
index2 = index2.Next
}
return index1
}
}
return nil
}
注意:
理解数学推导公式
总结:
待补充