Java “我执行”的错误在哪里；两个链表的交集；？

我正在准备Leet Code的算法测试，下面是对以下内容的描述：

编写一个程序来查找两个单链表的交点开始的节点

例如，以下两个链接列表：

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

开始在节点c1处相交

注:

• 如果两个链表根本没有交集，则返回

  null

• 函数返回后，链表必须保留其原始结构
• 您可以假设整个链接结构中的任何位置都没有循环
• 您的代码最好在O（n）时间内运行，并且只使用O（1）内存

---

然后我编写了一个Java程序来解决这个问题。它通过了39/42个测试用例，然后在测试39时失败。我已经学习了一个多小时没有找到错误线。有人能帮我吗

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        Stack<Integer> stackA = new Stack<>();
        Stack<Integer> stackB = new Stack<>();
        ListNode pointerA = headA;
        ListNode pointerB = headB;
        while (pointerA != null) {
            stackA.push(pointerA.val);
            pointerA = pointerA.next;
        }
        while (pointerB != null) {
            stackB.push(pointerB.val);
            pointerB = pointerB.next;
        }

        // find the common part between A & B, then build the comment node
        ListNode intersect = null;
        while (!stackA.empty() && !stackB.empty() && stackA.peek() == stackB.peek()) {
            ListNode newHead = new ListNode(stackA.peek());
            newHead.next = intersect;
            intersect = newHead;
            stackA.pop();
            stackB.pop();
        }
        return intersect;
    }
}

/**
*单链表的定义。
*公共类列表节点{
*int-val；
*listnodenext；
*ListNode（intx）{
*val=x；
*next=null；
*     }
* }
*/
公共类解决方案{
公共ListNode getIntersectionNode（ListNode头A、ListNode头B）{
Stack stackA=新堆栈（）；
Stack stackB=新堆栈（）；
ListNode pointerA=headA；
ListNode pointerB=头B；
while（pointerA！=null）{
stackA.push（pointerA.val）；
pointerA=pointerA.next；
}
while（pointerB！=null）{
stackB.push（指针B.val）；
pointerB=pointerB.next；
}
//找到A和B之间的公共部分，然后构建注释节点
ListNode intersect=null；
而（！stackA.empty（）&&&！stackB.empty（）&&stackA.peek（）==stackB.peek（））{
ListNode newHead=新的ListNode（stackA.peek（））；
newHead.next=相交；
intersect=新头；
stackA.pop（）；
stackB.pop（）；
}
返回交点；
}
}

提交结果：回答错误

• 输入：在“10000”处相交：
  • [1,3,5,7,9，…，9991999399959999799910000]
  • [2,4,6,8,10，…，99909299994999981000]
• 输出：无交叉点
• 预期：在“10000”处相交

---

我知道有更好的算法来处理这个测试，但在这篇文章中，我只想找出哪一行是错误的。

堆栈数据结构使用object

Integer

而不是primitive type

int

。所以我需要将比较改为

stackA.peek().equals(stackB.peek())

这一次提交的材料被接受了

---

现在，如果您对这个算法测试感兴趣，您可以在danh中找到更好的解决方案。

您指的是这个吗？看起来解决方案是沿着两个列表中较长的一个向前移动一个头指针，直到长度相同。然后做一个头部对头部的比较，沿着两个方向向前推进头部。不需要堆栈，O（n）。谢谢@danh，我将在第二次查看其他解决方案。但正如我所说的，在这篇文章中，我只想找出哪一行是错误的。我明白了，但你怎么会认为你的解决方案只有一行是错误的呢？例如，如果您的列表在尾部再次出现分歧怎么办？底部循环将立即失败。或者，您可以使用

Integer.intValue（）

并与

=

进行比较。