本文介绍了三个基于链表的编程问题解决方案，包括两两交换链表中的节点、删除链表的倒数第N个节点以及找出两个链表相交的起始节点。解题思路涉及创建虚拟头节点、遍历链表和双指针技术，同时分析了每个问题的时间和空间复杂度。
题目 24. 两两交换链表中的节点
题目描述：
给定一个链表，交换每两个相邻节点并返回它的头。 您必须在不修改列表节点中的值的情况下解决问题（即，只能更改节点本身。）
解题思路：
-
为了处理方便，我们先初始化一个预头节点
res，并且设置一个当前节点pre指向预头节点。 -
然后我们进入循环，判断
pre.next和pre.next.next是否存在。只有这两个节点都存在，我们才能进行交换。 -
交换的过程主要包括以下步骤：
- 首先我们需要记录下
pre.next（我们称之为节点1）和pre.next.next（我们称之为节点2）。 - 然后我们需要将节点1链接到节点2的下一个节点，这一步是为了防止链表断裂。
- 接着我们需要将当前节点
pre链接到节点2，完成节点2与前面节点的连接。 - 最后我们需要将节点2链接到节点1，完成两个节点的交换。
- 首先我们需要记录下
-
交换完成后，我们需要移动当前节点
pre到下一组需要交换的节点的前面，也就是pre.next.next。 -
最后我们返回预头节点的下一个节点，也就是交换后链表的头节点。
代码：
创造一个虚拟头节点，写出限制条件 ：
pre.next!=None and pre.next.next!=None
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
res=ListNode(next=head)
pre=res
# because first reverse point must be next to the cur
while(pre.next!=None and pre.next.next!=None):
temp1=pre.next
temp2=pre.next.next
#node1 point to node3
temp1.next=temp2.next
#cur point to node2
pre.next=temp2
#node2 point to node1
temp2.next=temp1
#move cur to a new round
pre=pre.next.next
return res.next
复杂度：
时间复杂度：O(n)，我们需要遍历所有的节点，进行交换，所以时间复杂度是 O(n)，n 是链表的长度。
空间复杂度：O(1)，我们只使用了常数级别的额外空间，所以空间复杂度是 O(1)。
题目 19.删除链表的倒数第N个节点
题目描述：
给定一个链表的头，从链表的末尾移除第 n 个节点并返回它的头。
解题思路：
-
首先，我们需要获取链表的长度，可以通过一次遍历完成。
-
其次，我们初始化一个预头节点
head_dummy，并将其next指向head。这是为了处理特殊情况，例如当需要删除的节点就是头节点时。 -
然后，我们计算出需要移动的次数
move_time，这个次数等于链表的长度len减去n。也就是说，我们需要移动到倒数第n个节点的前一个节点。 -
接着，我们移动
cur到指定的节点，然后修改它的next指针，使其指向下下个节点（也就是跳过下一个节点，达到删除的效果）。 -
最后，我们返回
head_dummy.next，也就是处理后的链表的头节点。
代码：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
#get the length of linkedList
current=head
len=0
while(current!=None):
current=current.next
len+=1
head_dummy=ListNode()
head_dummy.next=head
cur=head_dummy
#reach the node before the target node, slow/fast nend to move 3(len-n) time
move_time=len-n
while(move_time):
cur=cur.next
move_time-=1
cur.next=cur.next.next
return head_dummy.next
复杂度：
题目 160链表相交
题目描述：
给你两个单链表的头节点 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 个节点。
解题思路：
-
首先，我们需要计算链表A和链表B的长度。这可以通过定义一个获取链表长度的函数
getlen来实现。 -
然后，我们创建两个预头节点
dummy_nodeA和dummy_nodeB，并将它们分别指向链表A和链表B的头节点。 -
接下来，我们比较两个链表的长度。假设链表A的长度大于或等于链表B，我们就需要移动链表A的预头节点
dummy_nodeA，使其移动的步数等于两个链表长度的差值。如果链表B的长度大于链表A，我们就需要移动链表B的预头节点dummy_nodeB。 -
接着，我们同时移动两个链表的预头节点，直到它们指向的节点相同，也就是找到了相交的起始节点。
-
最后，我们返回相交的起始节点，如果没有找到相交节点，就返回 None。
代码：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
#write a len function
def getlen(node):
cur=node
len_=0
while node:
len_+=1
node=node.next
return len_
lenA=getlen(headA)
lenB=getlen(headB)
#create dummy_node for both A and B
dummy_nodeA=ListNode(next=headA)
dummy_nodeB=ListNode(next=headB)
#compare the length to know move which first
if lenA>=lenB:
stepA=lenA-lenB
while(stepA):
dummy_nodeA=dummy_nodeA.next
stepA-=1
while(dummy_nodeA.next!=dummy_nodeB.next):
dummy_nodeA=dummy_nodeA.next
dummy_nodeB=dummy_nodeB.next
if dummy_nodeA.next==dummy_nodeB.next:
return dummy_nodeA.next
else:
return None
else:
stepB=lenB-lenA
while (stepB):
dummy_nodeB=dummy_nodeB.next
stepB-=1
while(dummy_nodeA.next!=dummy_nodeB.next):
dummy_nodeA= dummy_nodeA.next
dummy_nodeB=dummy_nodeB.next
if dummy_nodeB.next== dummy_nodeA.next:
return dummy_nodeB.next
else:
return None
复杂度：
时间复杂度：O(n+m)，我们需要遍历两个链表计算长度，再遍历链表找到相交的起始节点，所以时间复杂度是 O(n+m)，n 和 m 分别是两个链表的长度。
空间复杂度：O(1)，我们只使用了常数级别的额外空间，所以空间复杂度是 O(1)。
题目 142环形链表II
题目描述：
给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
解题思路：
-
首先，我们定义两个指针，一个是快指针
fast，一个是慢指针slow。快指针每次走两步，慢指针每次走一步。 -
当快指针和慢指针相遇时，说明链表中存在环。此时，我们定义两个新的指针
index1和index2，index1从链表头开始，index2从相遇点开始，两个指针都每次走一步。 -
当
index1和index2再次相遇时，相遇的节点就是环的起始节点。
代码：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
#define fast and slow
slow,fast=head,head
while fast and fast.next:
slow=slow.next
fast=fast.next.next
if slow==fast:
index1=head
index2=slow
while(index1!=index2):
index1=index1.next
index2=index2.next
return index1复杂度：
时间复杂度：O(n)，我们最多遍历链表两次，所以时间复杂度是 O(n)，n 是链表的长度。
空间复杂度：O(1)，我们只使用了常数级别的额外空间，所以空间复杂度是 O(1)。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
