文章目录
归纳总结
做题技巧
- 一个指针快,一个指针慢,相隔距离是多少
- 两个指针的移动速度
- 递归
下面是一些总结题型
1. 链表的中间结点 (876)
题目可以看-原题地址
给定一个带有头结点 head 的非空单链表,返回链表的中间结点。
如果有两个中间结点,则返回第二个中间结点。
示例 1:
输入:[1,2,3,4,5]
输出:此列表中的结点 3 (序列化形式:[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意,我们返回了一个 ListNode 类型的对象 ans,这样:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL
思路:
- 设置两个指针 i 和 j,j 的移动速度是 i 的2倍,这样当 j 走到链表末尾的时候 i 走了总长度的一半,自然是中间节点了
class Solution:
def middleNode(self, head: ListNode) -> ListNode:
i = head
j = head
while j and j.next:
i = i.next
j = j.next.next
return i
2. 剑指Offer-22 链表中倒数第k个节点
输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。例如,一个链表有6个节点,从头节点开始,它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例:
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
思路:
设置两个指针a,b,b相隔a有k个节点,同速前行,直到b指针出界,那么a指针则为链表中倒数第K个节点。
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
i = head
j = head
for x in range(k):
j = j.next
while j:
i = i.next
j = j.next
return i
3. 剑指Offer-52 两个链表的第一个公共节点
题目可以看原题地址
编写一个程序,找到两个单链表相交的起始节点。
如下面的两个链表:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Reference of the node with value = 8
输入解释:相交节点的值为 8 (注意,如果两个列表相交则不能为 0)。从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
常规思路
(1)先固定一个节点如headA
(2)headB遍历一遍,虽然A得4和B得4值相同但是不是一个引用。B遍历完成之后,A走下一个,B在遍历一圈。直到A和B得节点重合
(3)这是一个双循环,时间复杂度为O(n^2)
思路:
(1)根据链表得特性我们可以知道,如果两个链表有公共节点是不可能出现以下情况得,因为每个节点,只有一个next。
(2)要求时间复杂度为 O(N),空间复杂度为 O(1)。如果不存在交点则返回 null。
(3)设 A 的长度为 a + c,B 的长度为 b + c,其中 c 为尾部公共部分长度,可知 a + c + b = b + c + a。
(4)当访问 A 链表的指针访问到链表尾部时,令它从链表 B 的头部开始访问链表 B;同样地,当访问 B 链表的指针访问到链表尾部时,令它从链表 A 的头部开始访问链表 A。这样就能控制访问 A 和 B 两个链表的指针能同时访问到交点。
(5)如果不存在交点,那么 a + b = b + a,以下实现代码中 node1 和 node2 会同时为 null,从而退出循环。
(6)单次循环,复杂度为O(n)
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
node1, node2 = headA, headB
while node1 != node2:
node1 = node1.next if node1 else headB
node2 = node2.next if node2 else headA
return node1
4. 环形链表 (141)
题目可以看原题地址
给定一个链表,判断链表中是否有环。
为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos 是 -1,则在该链表中没有环。
示例 1:
输入:head = [3,2,0,-4], pos = 1
输出:true
解释:链表中有一个环,其尾部连接到第二个节点。
示例2:
输入:head = [1], pos = -1
输出:false
解释:链表中没有环。
思路:
分析题目:题目要求我们判断他是否是环形链表。而不是说让我们根据pos连接环形链表。
首先我们设置一个快指针和一个慢指针slow,慢指针fast每次走一个,快指针每次走两个,当链表不是环形,那么fast最快走到链表尾部或者出界,那么代表不是环形链表。
然后,假如是环形链表,假如slow差一步,那么下次迭代相遇,若差两步以上,下下次跌倒也会相遇。
设置头节点为slow,头节点的下一个节点是fast,设置不一样的原因是,下面循环终止的条件是当fast = slow
class Solution:
def hasCycle(self, head: ListNode) -> bool:
slow = head
find = False
if slow == None or slow.next == None:
return find
fast = head.next
while slow != fast:
if (fast == None or fast.next ==None):
return find
slow = slow.next
fast = fast.next.next
find = True
return find
5. 删除链表中的节点 (273)
题目可以看原题地址
请编写一个函数,使其可以删除某个链表中给定的(非末尾)节点,你将只被给定要求被删除的节点。
示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9.
说明:
链表至少包含两个节点。
链表中所有节点的值都是唯一的。
给定的节点为非末尾节点并且一定是链表中的一个有效节点。
不要从你的函数中返回任何结果。
思路:
首先一定要审清题,由于我们只知道要删除的节点,和该节点之后的节点,所以不能够使用node之前的节点next指向node之后的节点。
然后分析,我们可以让node这个节点的值等于后一个节点的值,然后node.next = node.next.next,即可将后一个节点删除,完成题目要求。
class Solution:
def deleteNode(self, node):
"""
:type node: ListNode
:rtype: void Do not return anything, modify node in-place instead.
"""
node.val = node.next.val
node.next = node.next.next
6. 删除链表的倒数第N个节点 (19)
题目可以看原题地址
给定一个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。
示例:
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后,链表变为 1->2->3->5.
思路:
(1)首先我们遍历一遍链表,得到链表的总长度count
(2)然后将cur和pre遍历到相应位置count-n,此时cur所指向的位置就是我们要删除的倒数第n个节点。
(3)设置dummy节点,防止删除第一个节点时报错
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0)
dummy.next = head
pre = dummy
cur = head
count = 0
while cur :
cur = cur.next
count += 1
cur = head
for i in range(count - n):
pre = cur
cur = cur.next
pre.next = cur.next
return dummy.next
思路:
(1)可以利用两个指针之间得间隔,当cur指向None即出界时,利用距离为n的节点之前的pre节点来完成这道题目,pre.next = pre. next.next
(2)注意特殊情况,删除的为第一个节点时,这时我们要设置一个dummy节点
class Solution:
def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
dummy = ListNode(0)
dummy.next = head
cur = head
pre = dummy
for i in range(n):
cur = cur.next
while cur :
cur = cur.next
pre = pre.next
pre.next = pre.next.next
return dummy.next