pyhton 现有两个递增有序的整数单链表A和B，设计一个尽可能高效的算法，求两个集合的交集C，C仍然是递增有序的单链表，并给出算法的时间和空间复杂度。例如A=(1, 3, 5, 7)，B=(1, 2, 4, 5, 7)，交集C=(1, 5, 7)。

算法思路：

由于两个单链表都是递增有序的，可以使用双指针法，分别指向两个链表的头节点，比较两个节点的值，如果相同则添加到结果链表中，如果不同则将值较小的节点所在链表的指针向后移动一位，直到其中一个链表遍历完毕。

时间复杂度：O(min(m, n))，其中m和n分别是两个链表的长度。因为两个链表是递增有序的，所以每个节点最多只会被访问一次。

空间复杂度：O(1)，只需要常数个指针变量。

Python代码实现：

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

def getIntersectionNode(headA: ListNode, headB: ListNode) -> ListNode:
    pA, pB = headA, headB
    dummy = ListNode()
    tail = dummy
    while pA and pB:
        if pA.val == pB.val:
            tail.next = ListNode(pA.val)
            tail = tail.next
            pA = pA.next
            pB = pB.next
        elif pA.val < pB.val:
            pA = pA.next
        else:
            pB = pB.next
    return dummy.next

测试代码：

# 构造链表A：1 -> 3 -> 5 -> 7
A = ListNode(1)
A.next = ListNode(3)
A.next.next = ListNode(5)
A.next.next.next = ListNode(7)

# 构造链表B：1 -> 2 -> 4 -> 5 -> 7
B = ListNode(1)
B.next = ListNode(2)
B.next.next = ListNode(4)
B.next.next.next = ListNode(5)
B.next.next.next.next = ListNode(7)

# 计算链表A和链表B的交集
C = getIntersectionNode(A, B)

# 输出链表C的值：1 -> 5 -> 7
while C:
    print(C.val, end=' -> ')
    C = C.next
print('None')