链表面试题 python

最新推荐文章于 2024-04-27 17:10:00 发布

陈林伟0036

最新推荐文章于 2024-04-27 17:10:00 发布

阅读量447

点赞数

文章标签：链表

本文链接：https://blog.csdn.net/weixin_44181070/article/details/108299019

版权

前11题敲了一遍

相交链表
思路：长链表+断链表，短链表+长链表，找到交点

# 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) -> ListNode:
        p1 = headA
        p2 = headB
        while p1 != p2:
            p1 = p1.next if p1 else headB
            p2 = p2.next if p2 else headA
        return p1

链表反转
思路：1个1个反转

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
		pre = None
		cur = head
		while cur:
		    tmp = cur.next
		    cur.next = pre
		    pre = cur
		    cur = tmp
		return pre

合并两个有序链表
思路：一个个链表值进行比较

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = ListNode(None)
        node = res
        while l1 and l2:
            if l1.val<l2.val: # 注：比较链表节点大小时用.val
                node.next = l1
                l1= l1.next
            else:
                node.next = l2
                l2 = l2.next
            node = node.next
        if l1:
            node.next = l1
        if l2:
            node.next = l2
        return res.next

从有序链表中删除重复节点
思路：遍历，判断是否相等

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        res = head # 有时候也可以改变head。
        while head and head.next:  # while head.next:会报错。AttributeError: 'NoneType' object has no attribute 'next'。先执行head，head存在才会执行head.next,因为head如果是none，那么head就没有next属性，就会报错。所以写成while head.next and head:也是不行的。
            if head.val == head.next.val:
                head.next = head.next.next
            else:
                head = head.next
        return res

删除链表的倒数第N个节点
思路：一个指针先走n-1步，然后两个指针一起走，判断next.next是否存在。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        p1 = ListNode(None)  # 记住：p1 = ListNode(None), p1.next = head就是为了在链表长度为1时，p1.next.next有意义。是ListNode不是NodeList
        p2 = ListNode(None)
        p1.next = head
        p2.next = head
        res = p2
        while n>1:
            p1=p1.next
            n -= 1
        while p1.next and p1.next.next:
            p1 = p1.next
            p2 = p2.next
        p2.next = p2.next.next
        return res.next

两两交换链表中的节点
思路：引入a,b，node指向b,a指向b.next，b再指向a。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        res = ListNode(None)
        res.next = head
        node = res
        while node.next and node.next.next: # 先执行node.next，如果node.next是none的话，node.next就不存在next属性。
            a, b = node.next, node.next.next
            node.next, a.next = b, b.next
            b.next = a
            node = node.next.next
        return res.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 addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        res = ListNode(None)
        node = res
        carry = 0
        while l1 or l2 or carry:
            a = l1.val if l1 else 0
            b = l2.val if l2 else 0
            cur = a + b + carry
            carry = cur // 10
            cur = cur % 10
            node.next = ListNode(cur)
            node = node.next
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
        return res.next

链表求和（两数相加 II）
思路：carry记录余数，cur记录和以及商。node.next = res，res = node这种方法把结点接在res前面。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        list1, list2 = [], [] 
        while l1: # 注：这里是l1
            list1.append(l1.val)
            l1 = l1.next
        while l2:
            list2.append(l2.val)
            l2 = l2.next
        res = None # res = ListNode(None)会报错,会输出[7,8,0,7,None]而不是[7,8,0,7]
        carry = 0
        while list1 or list2 or carry: # 这里要记住carry
            a = list1.pop() if list1 else 0
            b = list2.pop() if list2 else 0
            cur = a + b + carry
            carry = cur // 10
            cur %= 10
            node = ListNode(cur)
            node.next = res
            res = node
        return res

回文链表
思路：数学法，head可以做第一位，也可以做最后一位。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        sum1 = 0
        sum2 = 0
        node = head
        t = 1
        while node:
            sum1 = sum1 + node.val * t
            t *= 10
            sum2 = sum2 * 10 + node.val
            node = node.next
        return sum1 == sum2

分隔链表
思路：先对k循环（有k组），再对(1,avg + (i < rem))循环。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def splitListToParts(self, root, k):
        """
        :type root: ListNode
        :type k: int
        :rtype: List[ListNode]
        """
        node = root 
        l = 0
        res = []
        while node:
            l += 1
            node = node.next
        avg, rem = divmod(l,k)
        node = root # 这句话不能省啊！！！！！！
        for i in range(k):
            head = node
            for j in range(1,avg + (i < rem)): # 因为node初始为第一个节点，所以循环从1开始。
                if node:
                    node = node.next
            if node:
                tmp = node.next
                node.next = None
                node = tmp
            res.append(head)
        return res

奇偶链表
思路：p1, p2 = point1, point2，然后跑p1，p2，整合point1，point2。

# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    # 双指针法。
    def oddEvenList(self, head: ListNode) -> ListNode:
        if not head:  # 这个不能丢，会出错
            return
        point1, point2 = head, head.next
        p1, p2 = point1, point2
        while p2 and p2.next:
            p1.next = p1.next.next # 不要写成p1 = p1.next.next！！！！！！！
            p2.next = p2.next.next
            p1 = p1.next
            p2 = p2.next
        p1.next = point2 
        return point1

11.排序链表

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        # 时间复杂度O(nlogn)——>二分法，从而联想到归并排序。
        # 归并排序的空间复杂度为O(n)，由新开辟数组O(n)和递归函数调用O(logn)组成。
        # 但链表可以通过修改引用来更改节点顺序，无需像数组一样开辟额外空间，递归调用函数将带来O(logn)的空间复杂度，因此若希望达到O(1)空间复杂度，则不能使用递归。
        if not head or not head.next: #  写成if not head: return 会报错
            return head
        slow, fast = head, head.next
        while fast and fast.next: # 偶数个节点找到中心左边的节点
            slow, fast = slow.next, fast.next.next
        mid, slow.next = slow.next, None # 将链表切断
        l, r = self.sortList(head), self.sortList(mid)  # 递归切断。
        res = ListNode(0)  
        node = res
        while l and r:  # 合并左右链表。
            if l.val < r.val: 
                node.next, l = l, l.next
            else: 
                node.next, r = r, r.next
            node = node.next
        if l:
            node.next = l
        if r:
            node.next = r
        return res.next

12.判断链表中是否有环(牛客面试热题)

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None
# 思路：快慢指针,if not fast:return false.if fast == slow:return True。
# 时间复杂度O(n)，空间复杂度O(1)
class Solution:
    def hasCycle(self , head):
        # write code here
        if not head or not head.next:
            return False
        slow = head
        fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if not fast:
                return False
            if fast.val == slow.val:
                return True

13.链表中环的入口节点(牛客面试热题)
思路：由f=s+nb，f=2s得到s=nb，slow再走a到达入口可转为head走a到达入口。要用一个while True来使循环找到相等的点。

# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self , head ):
        # write code here
        slow = head
        fast = head
        while True:
            if not fast or not fast.next: #if not fast:错。涉及两next都要判断next是否存在。
                return 
            slow = slow.next # slow = slow.next, fast = fast.next.next不能放在if的上面，会报错。先判断，再赋值。要放在上面，必须在最前面加if not head or not head.next: return 
            fast = fast.next.next
            if fast == slow:
                break
        node = head
        while node != slow:
            node = node.next
            slow = slow.next
        return node

14.链表中的节点每k个一组翻转

class Solution:
    def reverseKGroup(self , head , k ):
        # write code here
        # 思路：计算长度l, l//k份，k次循环。tmp,cur,tmp,pre后面三个next
        pre = ListNode(None)
        cur = head
        pre.next = head
        res = pre
        node = head
        l = 0
        while node:
            l = l+1
            node = node.next
        for i in range(l//k):
            for j in range(k-1):
                tmp = cur.next
                cur.next = tmp.next
                tmp.next = pre.next
                pre.next = tmp
            pre = cur
            cur = cur.next
        return res.next

项目的难点是什么？

陈林伟0036

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
链表面试题 python

找出两个链表的交点 p1 = headA p2 = headB while p1 != p2: p1 = p1.next if p1 else headB p2 = p2.next if p2 else headA return p1链表反转# Definition for singly-linked list.# class ListNode(object):# def.
复制链接

扫一扫