链表面试题
题1、移除链表元素
代码随想录的算法公开课:手把手带你学会操作链表 | LeetCode:203.移除链表元素_哔哩哔哩_bilibili
题目描述:给你一个链表的头节点 head
和一个整数 val
,请你删除链表中所有满足 Node.val == val
的节点,并返回 新的头节点 。
示例1:
示例2:
示例3:
解题思路:
遍历整个链表,找到数据域等于题目给出数据的节点,直接删除。由于我使用的是Python所以不用额外free节点,如果使用别的语言要注意一下free操作。
本题的大体思路较为简单。但还是有个难点,如果要删除的节点是头结点要怎么办?
这里我们可以采用设置一个虚拟头节点的方式。也就是说,我们可以先设置一个虚拟头节点,再进行删除操作。
我们把虚拟头节点设置在真正的头节点之前,此时再要删除元素一只需要跟删除别的节点一样的操作即可。
由于在删除,链表的头节点可能会发生改变,所以我们在最后return的时候,return的是dummyNode.next。
本题代码如下:
# 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 removeElements(self, head, val):
dummy = ListNode(0)
dummy.next = head
prev = dummy
while head:
if head.val == val:
prev.next = head.next
else:
prev = head
head = head.next
return dummy.next
"""
:type head: ListNode
:type val: int
:rtype: ListNode
"""
题2 设计链表
代码随想录算法公开课:
帮你把链表操作学个通透!LeetCode:707.设计链表_哔哩哔哩_bilibili
题目描述:
你可以选择使用单链表或者双链表,设计并实现自己的链表。
单链表中的节点应该具备两个属性:val
和 next
。val
是当前节点的值,next
是指向下一个节点的指针/引用。
如果是双向链表,则还需要属性 prev
以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList
类:
MyLinkedList()
初始化MyLinkedList
对象。int get(int index)
获取链表中下标为index
的节点的值。如果下标无效,则返回-1
。void addAtHead(int val)
将一个值为val
的节点插入到链表中第一个元素之前。在插入完成后,新节点会成为链表的第一个节点。void addAtTail(int val)
将一个值为val
的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)
将一个值为val
的节点插入到链表中下标为index
的节点之前。如果index
等于链表的长度,那么该节点会被追加到链表的末尾。如果index
比长度更大,该节点将 不会插入 到链表中。void deleteAtIndex(int index)
如果下标有效,则删除链表中下标为index
的节点。
示例:
解题思路:
这道题目就是对链表基础知识的考查,如果还不够了解的可以看下本人这篇博客:代码随想录——力扣刷题笔记之链表-CSDN博客
本题可以直接使用原来的链表来进行操作,也可以设置一个虚拟头节点再进行操作。
本人采用的是第二种方式。
本题代码如下:
class LinkNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class MyLinkedList(object):
def __init__(self):
self.dummy_head = LinkNode()
self.size = 0
def get(self, index):
if index < 0 or index >= self.size:
return -1
current = self.dummy_head.next
count = 0
while current is not None:
if count == index:
return current.val
current = current.next
count += 1
return -1
def addAtHead(self, val):
node = LinkNode(val)
node.next = self.dummy_head.next
self.dummy_head.next = node
self.size += 1
def addAtTail(self, val):
current = self.dummy_head
while current.next is not None:
current = current.next
tail = LinkNode(val)
current.next = tail
self.size += 1
def addAtIndex(self, index, val):
if index < 0 or index > self.size:
return
current = self.dummy_head
count = 0
while count < index:
current = current.next
count += 1
node = LinkNode(val)
node.next = current.next
current.next = node
self.size += 1
def deleteAtIndex(self, index):
if index < 0 or index >= self.size:
return
current = self.dummy_head
count = 0
while count < index:
current = current.next
count += 1
current.next = current.next.next
self.size -= 1
# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)
题3 反转链表
代码随想录公开课:
帮你拿下反转链表 | LeetCode:206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili
题目描述:
给你单链表的头节点 head
,请你反转链表,并返回反转后的链表
示例1:
示例2:
示例3:
解题思路:
最简单的、最暴力的方法就是重新定义一个链表,然后把原链表从尾到头移动到新链表中。但是这种方法对内存空间要求比较大。
其实我们也可以用一种很巧妙的方法来实现这道题,那就是我们直接改变链表next指针的指向就可以实现反转链表了,根本不需要重新定义一个新链表。
在这里,我采用的是三指针法。
首先定义一个pre指针,一个cur指针,还有一个next_node指针。让pre指针先指向空,然后cur指针指向头节点,然后进入循环部分。
为了防止断链,所以我们需要用next_node指针来标记反转节点的后一个节点。
本题代码如下所示:
# 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):
pre = None
cur = head
while cur is not None:
next_node = cur.next
cur.next = pre
pre = cur
cur = next_node
return pre
"""
:type head: ListNode
:rtype: ListNode
"""
题4 两两交换链表中的节点
代码随想录算法公开课
帮你把链表细节学清楚! | LeetCode:24. 两两交换链表中的节点_哔哩哔哩_bilibili
题目描述:
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例1:
示例2:
示例3:
解题思路
这道题只要理清指针之间的指向关系就没啥问题了,如果不清楚的话可以画图模拟一下交换过程。建议设置一个虚拟头节点,这样操作起来更方便。
大致交换过程如下:
初始时,cur指针指向虚拟头结点,然后再按上图所示的步骤进行操作。
本题的代码如下所示:
# 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 swapPairs(self, head):
dummy_head = ListNode()
dummy_head.next = head
cur = dummy_head
while cur.next is not None and cur.next.next is not None:
pre = cur.next
pre1 = cur.next.next.next
cur.next = pre.next
pre.next.next = pre
pre.next = pre1
cur = cur.next.next
return dummy_head.next
题5 删除链表的倒数第N个节点
19. 删除链表的倒数第 N 个结点 - 力扣(LeetCode)
代码随想录算法公开课
链表遍历学清楚! | LeetCode:19.删除链表倒数第N个节点_哔哩哔哩_bilibili
题目描述:
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
示例1:
示例2:
示例3:
解题思路
这是一道双指针经典应用的题目。思路如下:设置一个fast指针,一个slow指针,当我们要删除第n个节点的时候,我们先让fast指针先移动n+1步,然后再让两个指针同时移动。这样当fast指针移动到null的时候,slow指针就会在要删除节点的上一个节点。
本题代码如下:
# 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):
dummy_head = ListNode()
dummy_head.next = head
count = 0
fast = dummy_head
slow = dummy_head
while count < n + 1:
fast = fast.next
count += 1
while fast is not None:
slow = slow.next
fast = fast.next
slow.next = slow.next.next
return dummy_head.next
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
题6 链表相交
面试题 02.07. 链表相交 - 力扣(LeetCode)
题目描述
给你两个单链表的头节点 headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
图示两个链表在节点 c1
开始相交:
题目数据 保证 整个链式结构中不存在环。
注意,函数返回结果后,链表必须 保持其原始结构 。
示例1:
示例2:
示例3:
解题思路
本题的题意简单来说,就是要我们求两个链表交点节点的指针。要注意一点,交点不是数值相等,而是指针相等。
为了方便,我们这里假设数值相等相当于节点指针相等。
具体解题思路就是,先求出两个链表的长度,然后求出他们的长度差,然后让长度长的链表的指针先移动长度差个单位,然后再让两个指针一起移动。如果相同,就是交点,不同则两个指针一起向后移动。
本题代码如下:
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def getIntersectionNode(self, headA, headB):
curA = headA
curB = headB
lenghtA = 0
lenghtB = 0
cur = headA
while cur is not None:
cur = cur.next
lenghtA += 1
cur = headB
while cur is not None:
cur = cur.next
lenghtB += 1
lenght = lenghtA - lenghtB
count = 0
while count < abs(lenght):
if lenght > 0 :
curA = curA.next
count += 1
else:
curB = curB.next
count += 1
while curA is not None or curB is not None:
if curA == curB:
return curA
else:
curA = curA.next
curB = curB.next
return None
"""
:type head1, head1: ListNode
:rtype: ListNode
"""
题7 环形链表II
代码随想录算法公开课
把环形链表讲清楚! 如何判断环形链表?如何找到环形链表的入口? LeetCode:142.环形链表II_哔哩哔哩_bilibili
题目描述
给定一个链表的头节点 head
,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
如果链表中有某个节点,可以通过连续跟踪 next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos
是 -1
,则在该链表中没有环。注意:pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。
不允许修改 链表。
示例1:
示例2:
示例3:
解题思路:
本题有两个难点:如何判断链表中存在环以及如果有环,环的入口在哪里。
由于代码随想录写得有点太复杂,讲解也有点难,所以我就直接把解题思路写出来。
对于怎么判断有环存在。我们可以使用快慢指针。他们同时从头节点出发,快指针每次移动两个节点,慢指针每次移动一个节点,如果他们俩在途中相遇,那就说明链表中有环存在。(具体证明过程过于繁琐,有兴趣可以自己探讨一下)
怎么找到入口。两个指针相遇的节点就是环的入口。(具体证明过程可以参考代码随想录)
本题代码如下:
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def detectCycle(self, head):
fast = head
slow = head
while fast is not None and fast.next is not None:
slow = slow.next
fast = fast.next.next
if fast == slow:
break
else:
return None
fast = head
while fast != slow :
fast = fast.next
slow = slow.next
return fast
"""
:type head: ListNode
:rtype: ListNode
"""