已知两个链表A和B分别表示两个集合，其元素递增排列。 请设计算法求出A与B的交集，并存放于A链表中。

1. 定义两个指针pA和pB，分别指向A和B的头节点。
2. 循环遍历链表A和B，当pA和pB所指向的值相同时，将该值加入结果链表，并将pA和pB同时向后移动，否则将较小的节点向后移动一位。
3. 当其中一个链表遍历结束时，返回结果链表。

代码实现：

def getIntersection(A, B):
    pA, pB = A.head, B.head
    result = LinkedList()
    while pA and pB:
        if pA.val == pB.val:
            result.append(pA.val)
            pA = pA.next
            pB = pB.next
        elif pA.val < pB.val:
            pA = pA.next
        else:
            pB = pB.next
    return result

时间复杂度为O(n)，其中n为A和B元素个数的最大值。

相关问题

已知两个链表a和b分别表示两个集合，其元素递增排列。请设计算法求出a与b的交集，并存放于a链表中

算法步骤如下：

1. 定义两个指针p1和p2，分别指向链表a和b的头结点。
2. 遍历链表a和b，比较p1和p2所指向的元素大小。
3. 如果p1所指向的元素小于p2所指向的元素，则p1指向下一个元素。
4. 如果p1所指向的元素大于p2所指向的元素，则p2指向下一个元素。
5. 如果p1和p2所指向的元素相等，则将该元素插入到新的链表c中，并同时将p1和p2指向下一个元素。
6. 遍历完a和b后，将链表c中的元素复制到链表a中。

代码实现如下：

def intersection(a, b):
    p1, p2 = a.head, b.head
    c = LinkedList()
    while p1 and p2:
        if p1.data < p2.data:
            p1 = p1.next
        elif p1.data > p2.data:
            p2 = p2.next
        else:
            c.append(p1.data)
            p1 = p1.next
            p2 = p2.next
    a.clear()
    for item in c:
        a.append(item)

其中，LinkedList为链表类，head为头结点，append方法为在链表尾部添加元素，clear方法为清空链表。

已知两个链表A和B分别表示两个集合，其元素递增排列，请设计算法求出A与B的交集，并存放于A链表中

1. 定义两个指针pA和pB分别指向链表A和链表B的头节点。
2. 遍历两个链表，比较pA和pB指向的节点的值，如果相等，则将该节点加入结果链表中，并将pA和pB都指向下一个节点；如果pA指向的节点的值小于pB指向的节点的值，则将pA指向下一个节点；反之，将pB指向下一个节点。
3. 当其中一个链表遍历完毕时，结束循环。
4. 将结果链表中的元素复制到链表A中。
5. 返回链表A作为交集。

代码实现：

void intersection(ListNode* A, ListNode* B){
    ListNode* pA = A->next;
    ListNode* pB = B->next;
    ListNode* result = new ListNode(0);
    ListNode* p = result;
    while(pA != nullptr && pB != nullptr){
        if(pA->val == pB->val){
            p->next = pA;
            p = p->next;
            pA = pA->next;
            pB = pB->next;
        }else if(pA->val < pB->val){
            pA = pA->next;
        }else{
            pB = pB->next;
        }
    }
    p->next = nullptr;
    A->next = result->next;
}