Question

我有一个算法比较两个链接列表，L1和L2，以及相同的元素，它将它们放在第三个列表L3中，同时从L2中删除它们。我不确定这是否是算法应该做的所有事情，并且我不理解某些概念，例如“p1prec”。我想理性地了解算法的设计，更大的图景。当我试图通过逐一检查说明来了解它时，我觉得我想记住它。关于设计相似算法的方法的一些建议也是非常受欢迎的。算法如下：

    Equal(L1,L2)

    head[L3] = NIL            //L3 is empty
    if head[L2] = NIL         //if there are no elements in L2 return NIL
       return L3
    p1 = head[L1]             //p1 points the head of L1
    p1prec = nil              //p1prec is supposed to be precedent I guess.
    while p1 =/= nil
          p2 = head[L2]       //p2 points head of L2
          p2prec = nil        //p2prec is precedent of p2; first cycle is nil
          while p2 =/= nil and key[p1] =/= key[p2]
                p2prec = p2          // pass p2 and p2prec through L2 until
                p2 = next[p2]        // key[p1] = key[p2]
          if p2 =/= nil        // if two elements are found equal
                next[p1prec] = next[p1]          // im not sure what this does
                insert(L3,p1)                    // insert the element in L3
                p1 = next[p1prec]                //neither this,
                next[p2prec] = next[p2]  //connects the p2prec with nextp2 because p2
                free(p2)                         //is going to be deleted
          p1prec = p1      //moves through L1, if no element of p2 is found          
          p1 = next[p1]                         //equal with first element of p1

Answer 1

有几件事：

1）它似乎正在从L1和L2中移除东西，但这是一个小细节

2）您对算法和数据结构了解多少？你知道链表是如何工作的吗？如何实现一个？有什么类型，它们之间有什么区别？

我问这个问题是因为基本了解单个链接列表很明显p1(2)prec是什么，next[p1(2)prec]是什么以及从单个链接列表中删除的方式是如何工作的。

也许首先阅读列表应该是要走的路？

3）基本上你说这个算法迭代两个列表，如果找到一个共同的元素，它会从两个列表中删除它并将它放在一个结果列表中（元素可以在列表中的sam位置但是不必 - 如果这就是你想要的，那就是一个不同的问题： - ）。

一个单独（这在这里很重要）链表看起来或多或少像这样：

prec    p1   next[p1]
el1 -> el2 -> el3 -> nil

你只能从左到右。现在让我们删除“el2”。但是等我们 “el2”，然后我们如何更改指针，以便“el1”现在指向“el3”？

这就是这个算法中“prec”的含义。在SLL中，您将更改为前一个指针指向的位置，就是这样！您删除了元素：

el1 - ＆gt; el3 - ＆gt;零

为什么会这样？还记得当我说你只能从左到右去这里吗？好吧，你把指针从next[el1]更改为el3所以右边的下一个元素是el3，即使我们不对它进行free也无法访问el2。

此处free(p2)还从第二个列表中释放元素使用的内存。请注意，它只对p2执行此操作，因为p1已插入L3，因此我们仍然需要它。

取决于此行的语言/实现：

next[p1prec]

可能有问题。如果第一个元素相等怎么办？那么p1prec和p2prec仍然是零但你正试图对它们进行一些操作。但正如我所说，这是一个实施细节。

4）这有O（n ^ 2）的复杂度（如果我没有错过任何东西），因为对于L1中的每个元素，你做（在最坏的情况下）完全遍历L2（注意在{{1}之后} p2再次指向头元素。）

这基本上就是......

Answer 2

由于我猜你的目标是了解如何解决这个问题，我将尝试向您解释基本算法，而不是告诉您每行的作用。

您有2个列表：L1和L2。

你基本上想要检查来自L1的每个元素与L2中的每个元素。设L1current和L2current为您正在检查的值。

您还需要L2Prec，因为当您删除L2元素时，您需要将prec链接到下一个。

You start with L1current = L1 and L2current = L2;
While ( L1current is not NULL)
{
    L2current = L2; // you set the L2Current to the begging of L2 list.
    While ( L2current is not NULL) // you run untill the end.
    {
        You check if L1current == L2current;
        {
            // If they are equal
            You add the L2 element to L3;
            You connect L2prec with L2next;
            You delete L2current;
        }
        Else
        {
                L2current = L2next;
        }
    }
       L1current = L1next; // after you are done with the first element of L1 you
                          // move to the next one.
}

查看两个链表是否相等的算法

2 个答案: