关于链表的算法题

1.输入一个链表，按链表值从尾到头的顺序返回一个ArrayList.

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None

        
class Solution():
    def print_list(self,node):
        list1 = []
        cur = node
        while cur:
            #在列表的头部插入元素
            list1.insert(0,cur.item)
            cur = cur.next
        return list1
    
if __name__ == "__main__":
    n1 = Node(1)
    n2 = Node(2)
    n3 = Node(3)
    n1.next = n2
    n2.next = n3
    s  = Solution()
    list1 = s.print_list(n1)
    print(list1)

输出结果：

2.输入一个链表，输出该链表中倒数第K个结点

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
        
        
class Solution():    
    def findKnode(self,head,k):
        first = head
        second = head
        #循环从1开始，是因为当first和second都指向head时，i为0
        #考虑特殊情况：当K大于链表长度时，first会指向None
        for i in range(1,k):
            first = first.next
            if first == None:
                return None
        #first和second开始同步移动，当first.next指向None时停止
        while first.next != None:
            first = first.next
            second = second.next
        return second.item

if __name__=="__main__":
    #构造单向链表
    head = Node(1)
    n2 = Node(2)
    n3 = Node(3)
    n4 = Node(4)
    n5 = Node(5)
    head.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5
    #输出倒数第一个结点
    s = Solution()
    data = s.findKnode(head,1)
    print(data)

输出结果：

3.输入一个链表，反转链表后，输出新链表的表头

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
        
        
class Solution():
    def reverselinklist(self,head):
        #特殊情况：链表为空或者只有一个元素
        if head == None:
            return None
        if head.next == None:
            return head.item
        #一般情况：应设置三个指针，right指针只需向前移动即可
        left = head
        middle = head.next
        right = middle.next
        
        left.next = None
        while right != None:
            middle.next = left
            left = middle
            middle = right
            right  = right.next
        middle.next = left
        return middle.item
    
if __name__=="__main__":
    head = Node(1)
    n2 = Node(2)
    n3 = Node(3)
    n4 = Node(4)
    n5 = Node(5)
    head.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5
    
    s = Solution()
    data = s.reverselinklist(head)
    print(data)

输出结果：

4.输入两个单调递增链表，输出两个链表合成后的链表，需要合成后的链表满足单调不减规则。

思路：其实就是归并排序的最后一步，将左右两部分已有序的元素比较。

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
        

class Solution():
    def merge(self,link1,link2):
        #考虑特殊情况：链表为空
        if link1 == None:
            return link2
        if link2 == None:
            return link1
        #分别对两个链表设置当前指针cur1和cur2
        cur1 = link1
        cur2 = link2
        #res表示合成后链表的输出指针
        res = cur1 if cur1.item < cur2.item else cur2
        if res == cur1:
            cur1 = cur1.next
        else:
            cur2 = cur2.next
        #设置pre指针
        pre = res
        #pre指针所指向的结点连接到cur1和cur2中较小值
        while cur1 and cur2:
            if cur1.item < cur2.item:
                pre.next = cur1
                pre = cur1
                cur1 = cur1.next
            else:
                pre.next = cur2
                pre = cur2               
                cur2 = cur2.next
        #当遍历某一链表到None时，pre指针将指向未遍历完的链表        
        if cur1 == None:
            pre.next = cur2
        else:
            pre.next = cur1
        #打印合成后的链表中元素
        while res is not None:
            print(res.item)
            res = res.next
#         return res

if __name__=="__main__":
    link1 = Node(1)
    n2 = Node(2)
    n3 = Node(4)
    n4 = Node(5)
    n5 = Node(7)
    link1.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5

    link2 = Node(3)
    m2 = Node(6)
    m3 = Node(8)
    m4 = Node(10)

    link2.next = m2
    m2.next = m3
    m3.next = m4

    s = Solution()
    s.merge(link1,link2)   

输出结果：

5.输入两个链表，找出它们的第一个公共结点

例如：

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
        

class Solution():
    def print_public(self,link1,link2): 
        #设置当前指针cur1和cur2
        cur1 = link1
        cur2 = link2
        #设置指针p1和p2
        p1 = link1
        p2 = link2
        #分别计算两个链表的长度
        count1 = 0
        count2 = 0
        while cur1 is not None:
            cur1 = cur1.next
            count1 += 1
        while cur2 is not None:
            cur2 = cur2.next
            count2 += 1 
        #求出多出的部分，让指针移动到两链表相同位置
        if count1 > count2:
            k = count1 - count2
            for i in range(k):
                p1 = p1.next
            #在两链表相同位置开始向后移动
            for j in range(count2):
                p1 = p1.next
                p2 = p2.next
                #当两指针指向的下一个结点相同时，则下一个结点为两链表的第一个公共结点
                if p1.next == p2.next:
                    print(p1.next.item)
                    return p1.next
                    break       
        elif count2 > count1:
            k = count2 - count1
            for i in range(k):
                p2 = p2.next
            for j in range(count1):
                p1 = p1.next
                p2 = p2.next
                if p1.next == p2.next:
                    print(p1.next.item)
                    return p1.next
                    break

if __name__=="__main__":
    #设置链表1
    link1 = Node(1)
    n2 = Node(2)
    n3 = Node(3)
    n4 = Node(4)
    n5 = Node(5)
    n6 = Node(6)
    n7 = Node(7)
    link1.next = n2
    n2.next = n3
    n3.next = n4
    n4.next = n5
    n5.next = n6
    n6.next = n7
    #设置链表2
    link2 = Node(8)
    m2 = Node(9)
    m3 = Node(10)
    m4 = Node(11)
    
    link2.next = m2
    m2.next = m3
    m3.next = m4
    m4.next = n6
    
    s = Solution()
    link = s.print_public(link1,link2)  
    print(link)

输出结果：

6.