【LeetCode】初级算法：三、链表

---

链表学习点这里

链表问题相对容易掌握。 不要忘记 “双指针解法” ，它不仅适用于数组问题，而且还适用于链表问题。

另一种大大简化链接列表问题的方法是 “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

---