Leetcode 160 两个链表的交集超时

Question

我正在尝试解决Leetcode 160。两个链表的交集：

给定两个单链表headA和headB的头部，返回两个列表相交的节点。 如果两个链表完全没有交集，则返回null 。

例如，以下两个链表在节点c1处开始相交：

生成测试用例使得整个链接结构中的任何地方都没有循环。

请注意，链表在 function 返回后必须保留其原始结构。

我想用这两个指针来解决它，但是 Leet Code 站点给我一个Time Limit Exceeded错误。

我的代码如下所示：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode *tempA = headA, *tempB = headB;
    while (tempA != tempB) {
        if (tempA->next != NULL) { tempA = tempA->next;}
        else { tempA->next = headB;}
        if (tempB->next != NULL) { tempB = tempB->next;}
        else { tempB->next = headA; }
    }
    return tempA;
}

然后我尝试了这个现有的解决方案并且它有效，但我不知道有什么不同：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode *tempA = headA, *tempB = headB;
    while (tempA != tempB) {
        if (tempA != NULL) { tempA = tempA->next;}
        else { tempA = headB;}
        if (tempB != NULL) { tempB = tempB->next;}
        else { tempB = headA;}
    }
    return tempA;
}

Answer 1

该算法应该是“只读”算法，即没有理由修改链表来确定解决方案。

然而，这就是代码的第一个版本所做的：它为节点的next属性分配一个新的引用。 这永远不应该发生：当您唯一想做的就是“计算”某个节点所在的位置并返回它时，没有充分的理由说明节点的next属性需要获取新值。

在这种特殊情况下tempA->next = headB; 正在链接链表 A 的末尾和链表 B 的开头。为了描绘这一点，让我们想象这两个列表最初是这样的：

                              tempA
                               ↓
                             ┌────────────┐
                    headA:─► │ data: 2    │
                             │ next: ───────┐
                             └────────────┘ │    ┌────────────┐
                                            └──► │ data: 3    │
                                            ┌──► │ next: NULL │
         ┌────────────┐      ┌────────────┐ │    └────────────┘     
headB:─► │ data: 4    │      │ data: 5    │ │
         │ next: ──────────► │ next: ───────┘
         └────────────┘      └────────────┘     
           ↑
          tempB

循环将在第一次迭代中始终执行if情况，因此在一次迭代后tempA和tempB将引用下一个节点：

                             ┌────────────┐
                    headA:─► │ data: 2    │          tempA
                             │ next: ───────┐         ↓
                             └────────────┘ │    ┌────────────┐
                                            └──► │ data: 3    │
                                            ┌──► │ next: NULL │
         ┌────────────┐      ┌────────────┐ │    └────────────┘     
headB:─► │ data: 4    │      │ data: 5    │ │
         │ next: ──────────► │ next: ───────┘
         └────────────┘      └────────────┘     
                               ↑
                              tempB

现在，在第二次迭代中，第一个else块将执行tempA->next = headB; 这改变了尾节点的next属性，导致以下情况：

                             ┌────────────┐
                    headA:─► │ data: 2    │          tempA
                             │ next: ───────┐         ↓
                             └────────────┘ │    ┌────────────┐
                                            └──► │ data: 3    │
                                            ┌──► │ next: ────────┐
         ┌────────────┐      ┌────────────┐ │    └────────────┘  │  
headB:─► │ data: 4    │      │ data: 5    │ │                    │
     ┌─► │ next: ──────────► │ next: ───────┘                    │
     │   └────────────┘      └────────────┘                      │
     └───────────────────────────────────────────────────────────┘
                               ↑
                              tempB

这在链表中引入了一个循环：现在不再有尾节点——不再有next属性为NULL的节点。 如您所见，这意味着while条件从现在开始将始终为真，...这已成为一个无限循环。 这解释了为什么运行此代码的平台发出“超出时间限制”错误的信号。