哈喽大家好,好久不见!又进入新的一个学期,这学期小编要进行python的算法学习啦,今天更新链表的部分题目~
牛客 NC78 反转链表
题目如下:
算法思想如下:
1.初始化两个指针pre和cur,分别表示前驱节点和当前节点。初始时,pre为空,cur指向头节点。
2.使用一个循环遍历链表,直到cur为空。
3.在每次循环中,首先保存当前节点的下一个节点到临时变量temp。
4.然后将当前节点的next指针指向前驱节点pre。
5.更新前驱节点pre为当前节点cur。
6.更新当前节点cur为下一个节点temp。
7.当循环结束时,所有节点的next指针都已反转,此时pre指向新的头节点,即反转后的链表的头节点。
8.返回反转后的链表头节点pre。
代码如下:
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
# @param head ListNode类
# @return ListNode类
#
class Solution:
def ReverseList(self, head: ListNode) -> ListNode:
pre = None # 初始化前驱节点为空
if not head: # 如果链表为空,直接返回None
return None
cur = head # 当前节点指向头节点
while cur: # 遍历链表
temp = cur.next # 保存当前节点的下一个节点
cur.next = pre # 将当前节点的下一个节点指向前驱节点
pre = cur # 更新前驱节点为当前节点
cur = temp # 更新当前节点为下一个节点
return pre # 返回反转后的链表头节点
牛客 NC33 合并两个有序链表
题目如下:
算法思想如下:
1. 创建一个新的头结点new
,用于存储合并后的链表。
2. 初始化一个指针cur
指向新链表的头结点。
3. 判断两个链表是否为空,如果其中一个为空,则直接返回另一个链表。
4. 使用两个指针p1
和p2
分别遍历两个链表。
5. 比较p1
和p2
所指向的节点的值,将较小的节点添加到新链表中,并将对应的指针向后移动一位。
6. 重复步骤5,直到其中一个链表遍历完毕。
7. 如果p1
还有剩余节点,将其添加到新链表的末尾;如果p2
还有剩余节点,将其添加到新链表的末尾。
8. 返回新链表的头结点的下一个节点,即合并后链表的第一个节点。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
#
# @param pHead1 ListNode类
# @param pHead2 ListNode类
# @return ListNode类
#
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def Merge(self , pHead1: ListNode, pHead2: ListNode) -> ListNode:
# write code here
new=ListNode(0)
cur=new
if not pHead1:
return pHead2
if not pHead2:
return pHead1
p1=pHead1
p2=pHead2
while p1 and p2:
if p1.val<=p2.val:
cur.next=p1
p1=p1.next
else:
cur.next=p2
p2=p2.next
cur=cur.next
if p1:
cur.next=p1
if p2:
cur.next=p2
return new.next
牛客 NC4 判断链表是否有环
题目如下:
算法思想如下:
1. 初始化两个指针,一个慢指针(low)和一个快指针(fast),都指向链表的头节点。
2. 在循环中,慢指针每次移动一步,快指针每次移动两步。
3. 如果链表中存在环,那么快指针最终会追上慢指针,即它们会在环中的某个位置相遇。
4. 如果链表中不存在环,那么快指针会先到达链表的尾部,此时循环结束,返回False。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# @param head ListNode类
# @return bool布尔型
#
class Solution:
def hasCycle(self , head: ListNode) -> bool:
if not head or not head.next:
return False
low=head
fast=head.next
while fast and fast.next:
if low!=fast:
low=low.next
fast=fast.next.next
else:
return True
return False
牛客 NC69 链表中倒数最后k个结点
题目如下:
算法思想如下:
1.指向链表的头节点pHead。
2. 初始化计数器count为0。
3. 遍历链表,每遍历一个节点,计数器count加1。
4. 如果k大于链表长度count,说明k超出了链表的范围,返回None。
5. 将指针cur重新指向链表头节点pHead。
6. 再次遍历链表,这次遍历到第count-k个节点,即倒数第k个节点。
7. 返回当前指针cur所指向的节点。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
# @param pHead ListNode类
# @param k int整型
# @return ListNode类
#
class Solution:
def FindKthToTail(self , pHead: ListNode, k: int) -> ListNode:
# write code here
if not pHead or k<=0:
return None
cur=pHead
count=0
while cur :
cur=cur.next
count+=1
if k>count:
return None
cur=pHead
for _ in range(count-k):
cur=cur.next
return cur
牛客 NC66 两个链表的第一个公共结点
题目如下:
算法思想如下:
1. 首先检查输入的两个链表是否为空,如果有一个为空,则返回None,因为没有公共节点。
2. 初始化两个指针p1和p2分别指向两个链表的头节点。
3. 遍历两个链表,分别计算它们的长度length1和length2。
4. 根据两个链表的长度差值x,将较长链表的指针向前移动x个节点,使得两个链表剩余的长度相等。
5. 同步遍历两个链表,比较当前节点是否相同。如果相同,则找到了第一个公共节点,返回该节点;否则继续遍历。
6. 如果遍历完两个链表都没有找到相同的节点,则返回None。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# @param pHead1 ListNode类
# @param pHead2 ListNode类
# @return ListNode类
#
class Solution:
def FindFirstCommonNode(self , pHead1 , pHead2 ):
# write code here
if pHead1==None or pHead2==None:
return None
p1=pHead1
p2=pHead2
length1=0
length2=0
while p1:
p1=p1.next
length1+=1
while p2:
p2=p2.next
length2+=1
p1=pHead1
p2=pHead2
if length1>=length2:
x=length1-length2
for _ in range(x):
p1=p1.next
elif length2>length1:
x=length2-length1
for _ in range(x):
p2=p2.next
while p1 and p2:
if p1==p2:
return p1
else:
p1=p1.next
p2=p2.next
return None
牛客 NC96 判断一个链表是否为回文结构
题目如下:
算法思想:
1. 遍历链表,将链表中的元素依次存入一个列表中。
2. 再次遍历这个列表,同时从头部和尾部开始比较元素,如果发现不相等的元素,则说明链表不是回文结构,返回False。
3. 如果所有元素都相等,说明链表是回文结构,返回True。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
# @param head ListNode类 the head
# @return bool布尔型
#
class Solution:
def isPail(self , head: ListNode) -> bool:
# write code here
cur=head
count=0
mylist=[]
while cur:
mylist.append(cur.val)
cur=cur.next
count+=1
for i in range(count):
if mylist[i]!=mylist[count-i-1]:
return False
return True
牛客 NC25 删除有序链表中重复的元素-I
题目如下:
算法思想:
1. 首先检查链表是否为空,如果为空则直接返回None。
2. 如果链表只有一个节点,那么没有重复元素,直接返回头节点。
3. 初始化两个指针cur和x,分别指向链表的头节点和第二个节点。
4. 使用while循环遍历链表,直到cur或x为空。
5. 在循环中,比较cur和x的值,如果相等,说明有重复元素,将cur的next指针指向x的下一个节点,即跳过x节点。
6. 如果cur和x的值不相等,将cur和x都向后移动一位。
7. 循环结束后,返回处理后的链表头节点。
代码如下:
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
#
# 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
#
# @param head ListNode类
# @return ListNode类
#
class Solution:
def deleteDuplicates(self , head: ListNode) -> ListNode:
# write code here
if head is None:
return None
if head.next is None:
return head
cur=head
x=head.next
while cur and x:
if cur.val==x.val:
cur.next=x.next
x=x.next
else:
cur=cur.next
x=x.next
return head
今天的题目到这里就结束啦~ 如果觉得小编写的不错的话请三连支持一下! 以后会继续更新优质内容~