C 两个链表的交集

给出两个排序链表L1和L2，计算它们的 交叉口L1交叉口L2

L1\u节点=L1.head；
L1_node = L1.head;
L2_node = L2.head;
Result = new SList;
while L1_node != NULL and L2_node != NULL:
  if L1_node.value == L2_node.value:
     Result.append(L1_node.value)
     L1_node = L1_node.next
     L2_node = L2_node.next
  elif L1_node.value < L2_node.value:
     L1_node = L1_node.next
  else
     L2_node = L2_node.next

L2_节点=L2.head；
结果=新的滑动列表；
而L1_节点！=NULL和L2_节点！=无效的：
如果L1_node.value==L2_node.value：
Result.append（L1_node.value）
L1_节点=L1_节点。下一步
L2_节点=L2_节点。下一步
elif L1_node.value

---

<> P/>

< P>按顺序合并算法的基本方法是，你不需要一次考虑多于三个项——来自每个输入列表的前项，加上潜在的保存结果。

在这种情况下，我会使用

loop forever
  while in1.value < in2.value : transfer item from in1 to output
  while in2.value < in1.value : transfer item from in2 to output

  if in1.value == in2.value :
    transfer item from in1 to output
    discard item from in2

    while in1.value == value just transferred : disard item from in1
    while in2.value == value just transferred : disard item from in2

永远循环
而in1.value

现在这个讨厌的循环假设列表是无限的。如何处理空列表？这很微妙，除非您可以保留一个大于列表中可能出现的任何合法值的值

如果你不能保留一个哨兵，你可以假装效果——写一个比较函数，在比较值之前检查每个队列中是否有下一个项目，并将“队列耗尽”视为暗示哨兵值

这给了

loop forever
  while in1.value < in2.value : discard item from in1
  while in2.value < in1.value : discard item from in2

  if in1 exhausted, break out of loop
  if in2 exhausted, break out of loop

  if in1.value == in2.value :
    transfer item from in1 to output
    discard item from in2

    while in1.value == value just transferred : discard item from in1
    while in2.value == value just transferred : discard item from in2

永远循环
而in1.value

OOPS

这是一个联盟。将转换为交叉点留给读者作为练习

编辑

好的，现在是十字路口。只是丢弃少于项，而不是将它们添加到输出中。还修复了一个打字错误

---

注意-我的解释是交叉点的输出应该是一个集合，这意味着没有重复项。这允许输入中存在重复，但输出是无重复的。

下面的解决方案如何，它是O（n+m）并采用一个指向头部节点的虚拟节点。Head节点在这里是一个类级变量，因此即使L1指向当前节点，Head也始终具有完整的列表

我已经编译并测试过，对于像L1:1->5>6>7>8>10和L2:2>4>6>8这样的简单输入运行良好，输出为6>8

关于如何处理未排序的列表有什么想法吗？我想不出一个解决办法

公共节点返回交叉口（节点头，节点L2）
{
if（（Head==null）| |（L2==null））
返回null；

     Node temp = null;
      Node L1 = Head;


      while (L1.next != null && L2.next != null)
      {
          if (L1.data == L2.data)
          {
              L1 = L1.next;
              L2 = L2.next;
          }

          else if (L1.data < L2.data)
          {
              temp = L1.next;
              L1.data = temp.data;
              L1.next = temp.next;

          }

          else if (L1.data > L2.data)
          {
              L2 = L2.next;

          }

      }

      if (L1 != null)
      {
          while (L1.next != null)
          {
              L1.next = null;

          }
      }
      return Head;


  }

Node temp=null；
节点L1=头部；
while（L1.next！=null&&L2.next！=null）
{
if（L1.data==L2.data）
{
L1=L1.next；
L2=L2.next；
}
else if（L1.dataL2.data）
{
L2=L2.next；
}
}
如果（L1！=null）
{
while（L1.next！=null）
{
L1.next=null；
}
}
回流头；
}

由于它们是单链表，如果两个链表相交，它们将形成一个Y形，一只手臂更长或相等于另一只手臂。设l1为l1列表的长度，l2为l2列表的长度

假设l1>l2。 从点（L1-l2）开始匹配列表L1的指针，从列表l2的开始匹配列表l2的指针，无论它们指向哪个节点，该节点都将是匹配点

---

如果l2大于l1，则采用另一种方法

这是一个错误。在==的情况下，您没有跳过任何内容-您将得到一个无限系列的L1_node.value。也许这只是调试OP时的一个练习？如果我雇佣了一个人，提出了这个面试问题，并得到了这个确切的答案，我会质疑他作为程序员开始工作的动机，如果他只是简单地重复他在网上找到的答案。@Lasse-也许，这是个不错的主意。我下面的错误是故意的、诚实的。当涉及到Stack Overflow上的家庭作业和面试问题时，我本能的反应是尝试引导这个人朝着正确的方向前进，而不是把答案扔给他。当你雇佣程序员时，你需要的是能够思考、学习和应用的人，而不是能够使用复制/粘贴的人。嗯，复制/粘贴的诀窍是一个额外的收获。@KennyTM-这就是重点。您假设非唯一输入应该导致非唯一输出。交集是一个集合运算，这意味着可能不是真的-集合有唯一的值，所以[2,2,4]不是集合。我自己的解决方案（到联合体）假设输出应该是一个集合，但允许非唯一的输入——仍然生成一个唯一的集合作为输出。我对一个未说明的需求做了一个假设，并以不同的方式对您进行了猜测——正是看到您以不同的假设编写代码，使我意识到所需的输出并不是明确定义的。SO的目的是灌输知识和理解，而不是为您提供模糊问题的完整解决方案。