链表问题相对容易掌握。 不要忘记 “双指针解法” ,它不仅适用于数组问题,而且还适用于链表问题。
另一种大大简化链接列表问题的方法是 “Dummy node” 节点技巧 ,所谓 Dummy Node 其实就是带头节点的指针。
"我们推荐以下题目:反转链表,合并两个有序链表和链接环。
更有额外的挑战,你可以尝试运用 递归 来解决这些问题:反转链表,回文链表和合并两个有序链表。"
3.1 删除链表中的节点
请编写一个函数,用于 删除单链表中某个特定节点 。在设计函数时需要注意,你无法访问链表的头节点 head ,只能直接访问 要被删除的节点 。
题目数据保证需要删除的节点 不是末尾节点 。
示例 1:
输入:head = [4,5,1,9], node = 5
输出:[4,1,9]
解释:指定链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9
示例 2:
输入:head = [4,5,1,9], node = 1
输出:[4,5,9]
解释:指定链表中值为 1 的第三个节点,那么在调用了你的函数之后,该链表应变为 4 -> 5 -> 9
示例 3:
输入:head = [1,2,3,4], node = 3
输出:[1,2,4]
示例 4:
输入:head = [0,1], node = 0
输出:[1]
示例 5:
输入:head = [-3,5,-99], node = -3
输出:[5,-99]
提示:
- 链表中节点的数目范围是 [2, 1000]
- -1000 <= Node.val <= 1000
- 链表中每个节点的值都是唯一的
- 需要删除的节点 node 是 链表中的一个有效节点 ,且 不是末尾节点
相关标签 链表
输入:
class ListNode(object):
"""单链表的结点"""
def __init__(self, x):
self.val = x # x存放元素
self.next = None # next是下一个节点的标识
class SingleLinkList(object):
"""单链表"""
def __init__(self):
self.head = None
class Solution(object):
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
# 创建链表
link_list = SingleLinkList()
# 创建结点
node1 = ListNode(4)
node2 = ListNode(5)
node3 = ListNode(1)
node4 = ListNode(9)
# 将结点添加到链表
link_list.head = node1
# 将第一个结点的next指针指向下一结点
node1.next = node2
node2.next = node3
node3.next = node4
Solution().deleteNode(node2)
# 访问链表
print(link_list.head.val) # 访问第一个结点数据
print(link_list.head.next.val) # 访问第二个结点数据
print(link_list.head.next.next.val)
输出:
4
1
9
执行用时:20 ms, 在所有 Python 提交中击败了88.13%的用户
内存消耗:13.4 MB, 在所有 Python 提交中击败了32.15%的用户
通过测试用例:41 / 41
3.2 删除链表的倒数第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]
提示:
- 链表中结点的数目为 sz
- 1 <= sz <= 30
- 0 <= Node.val <= 100
- 1 <= n <= sz
进阶:你能尝试使用一趟扫描实现吗?
相关标签 链表
双指针
输入:
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
new_head = ListNode(0, head)
first = head
second = new_head
for i in range(n):
first = first.next
while first:
first = first.next
second = second.next
second.next = second.next.next
return new_head.next
head = [1,2,3,4,5]
n = 2
输出:
[1,2,3,5]
执行用时:20 ms, 在所有 Python 提交中击败了58.20%的用户
内存消耗:13 MB, 在所有 Python 提交中击败了65.78%的用户
通过测试用例:208 / 208
3.3 反转链表
给你单链表的头节点 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
进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?
相关标签 递归
链表
输入:
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
# 申请两个指针pre和cur,pre指向None
pre = None
cur = head
while cur:
tmp = cur.next # 记录当前节点的下一个节点
cur.next = pre # 反转
# 更新指针,pre和cur都前进一位
pre = cur
cur = tmp
return pre
head = [1,2,3,4,5]
输出:
[5,4,3,2,1]
执行用时:12 ms, 在所有 Python 提交中击败了98.50%的用户
内存消耗:15 MB, 在所有 Python 提交中击败了43.47%的用户
通过测试用例:28 / 28
3.4 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例 1:
输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
示例 2:
输入:l1 = [], l2 = []
输出:[]
示例 3:
输入:l1 = [], l2 = [0]
输出:[0]
提示:
- 两个链表的节点数目范围是 [0, 50]
- -100 <= Node.val <= 100
- l1 和 l2 均按 非递减顺序 排列
相关标签 递归
链表
输入:
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution(object):
def mergeTwoLists(self, l1, l2):
"""
:type list1: Optional[ListNode]
:type list2: Optional[ListNode]
:rtype: Optional[ListNode]
"""
# # 递归解法
# 判断跳出递归条件
if l1 is None: return l2
if l2 is None: return l1
# 单次递归方法,比较当前节点值
if l1.val <= l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1,l2.next)
return l2
l1,l2 = [1,2,4], [1,3,4]
Solution().mergeTwoLists(l1,l2)
输出:
[1,1,2,3,4,4]
执行用时:20 ms, 在所有 Python 提交中击败了81.73%的用户
内存消耗:13 MB, 在所有 Python 提交中击败了71.73%的用户
通过测试用例:208 / 208