LeetCode刷题：Linked List专题

目录

21. Merge Two Sorted Lists

23. Merge k Sorted Lists

82. Remove Duplicates from Sorted List II

83. Remove Duplicates from Sorted List

141. Linked List Cycle

328. Odd Even Linked List

 

---

21. Merge Two Sorted Lists

设置p1为被插入的列表,p2是待分解的列表，则必有p1.val<=p2.val。

1. p2.val<=p1.next.val则进行一次插入操作，更新p1，p2，这里的更新操作稍微麻烦一点。
2. 否则p1=p1.next

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

class Solution(object):
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val>l2.val:
            head1,head2=l2,l1
        else:
            head1,head2=l1,l2
            
        p1,p2=head1,head2
        while 1:
            if p2==None:
                break
            elif p1 and p1.next==None:
                p1.next=p2
                break
                
            if p2.val<=p1.next.val:
                tmp1=p1.next
                tmp2=p2.next
                p1.next=p2
                p2.next=tmp1
                p1=p2
                p2=tmp2

            else:
                p1=p1.next
        return head1

23. Merge k Sorted Lists

可以一次merge两个链表，也可以多个链表同时merge。

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        def merge( l1, l2):
            """
            :type l1: ListNode
            :type l2: ListNode
            :rtype: ListNode
            """
            if not l1:
                return l2
            if not l2:
                return l1
            if l1.val>l2.val:
                head1,head2=l2,l1
            else:
                head1,head2=l1,l2

            p1,p2=head1,head2
            while 1:
                if p2==None:
                    break
                elif p1 and p1.next==None:
                    p1.next=p2
                    break

                if p2.val<=p1.next.val:
                    tmp1=p1.next
                    tmp2=p2.next
                    p1.next=p2
                    p2.next=tmp1
                    p1=p2
                    p2=tmp2

                else:
                    p1=p1.next
            return head1
        l=len(lists)
        if l==0:
            return None
        x=lists[0]
        if l==1:
            return x
        else:
            for i in range(1,l):
                x=merge(x,lists[i])
        return x

82. Remove Duplicates from Sorted List II

主要是对于head.val有重复的情况要考察一下。

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p=head
        if  head==None:
            return head
        if  head.next==None:
            return head
        elif head.val==head.next.val:
            flag=1
        else:flag=0
        while p:
            tmp1=p.next
            if tmp1==None:
                break
            tmp2=tmp1.next
            if tmp2==None:
                break
            if tmp1.val==tmp2.val:
                tmp=tmp2
                while tmp.val==tmp1.val:
                    tmp=tmp.next
                    if tmp==None:
                        break
                p.next=tmp
                
            else:
                p=p.next
        if flag:
            if head.next==None:
                return None
            elif head.val==head.next.val:
                return head.next.next
            else:
                return head.next
        else:
            return head

83. Remove Duplicates from Sorted List

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        p=head
        while p:
            tmp=p.next
            if not tmp:
                break
            else:
                if tmp.val==p.val:
                    if tmp.next:
                        p.next=tmp.next
                        # p=p.next
                    else:
                        p.next=None
                        p=None
                else:
                    p=p.next
        return head

 

141. Linked List Cycle

这里采取了很笨的方法，把遍历过的节点存起来，每次比较是否遍历过。

也可以采取双指针法，一个指针在前速度为2，一个指针在后速度为1，如果链表有环则两个指针必定会相遇。

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool
        """
        p=head
        visited=[]
        if not head:
            return False
        else:
            # tmp=p.next
            # while tmp:
            #     if tmp.next==p:
            #         return False
            #     elif tmp.next==p.next:
            #         break
            #     else:
            #         tmp=tmp.next
            # return Ture
            while p:
                if p in visited:
                    return True
                else:
                    visited.append(p)
                p=p.next
            return False

 

328. Odd Even Linked List

要注意的是需要奇偶同步遍历链表，如果分开遍历的话，会出现不同步的问题。而同步遍历，可能会存在最后一个odd节点没有被遍历到，最后判断一下就好了。

class Solution(object):
    def oddEvenList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or head.next==None or head.next.next==None:
            return head
        res=head
        tmp=head.next
        odd,even=head,head.next
        # tmp=ListNode()
        while(odd.next and odd.next.next and even.next and even.next.next):
            odd.next=odd.next.next
            even.next=even.next.next
            odd=odd.next
            even=even.next
        # print(odd.val,even.val)
        if even.next:
            odd.next=even.next
            odd=odd.next
            print(odd.val,even.val)
            even.next=None
        
        # if odd.next!=None:
        #     odd=odd.next
        odd.next=tmp
        return res

 725. Split Linked List in Parts

class Solution(object):
    def splitListToParts(self, root, k):
        """
        :type root: ListNode
        :type k: int
        :rtype: List[ListNode]
        """
        p=root
        l=0
        while p:
            l+=1
            p=p.next
        i=l//k
        rest=l-i*k
        po=[i]*k
        for j in range(rest):
            po[j]+=1
        # print(po)
        p=root
        res=[]
        for i in po:
            if i==0:
                res.append(None)
            else:
                res.append(p)
                for j in range(i-1):
                    p=p.next
                k=p.next
                p.next=None
                p=k
        return res