检查链表中是否存在循环的算法

Question

我想找到checks a linked-list with n elements for consistency 的算法。链表使用dummy head（也称为哨兵节点）。该算法需要run in O(n) time 并且允许use O(1) extra space 除了遍历列表所需的空间。列表is unknown 的size。另外它是forbidden to modify the list。

如果存在指向前一个列表项的列表项，则列表计为不一致。 首先，我考虑存储第一个元素，然后在将当前元素与第一个元素进行比较时遍历列表。

Answer 1

列表是否提供 Size 属性，告诉您它包含多少个元素 (n) 而无需遍历它？

如果确实如此，那么满足您所有 big-O 要求的简单解决方案是尝试遍历列表，同时计算元素。如果计数超过列表中预期的元素数，则它有一个循环。

伪代码看起来像这样：

bool isConsistent (List list)
{
    bool consistent = true;
    Node node = list.Sentinel.Next;
    int count = 0;

    while (node != list.Sentinel && consistent)
    {
         count++;

         if (count > list.Size)
             consistent = false;

         node = node.Next;
    }

    return consistent;
}

这在 O(n) 内完成并使用 O(1) 存储。

Answer 2

Floyd's "Tortoise and Hare" algorithm 可以满足您的需要，只需稍作修改即可使用您的虚拟头/尾（哨兵）节点。

下面是我将如何编写伪代码：

bool IsConsistent (List list)
{
    Node tortoise = list.Sentinel.Next;
    Node hare = tortoise.Next;

    while (tortoise != list.Sentinel && hare != list.Sentinel)
    {
        if (tortoise == hare)
            return false;

        tortoise = tortoise.Next;
        hare = hare.Next.Next;
    }

    return true;
}

Answer 3

如果您在链接列表中的每个项目上都没有 Visited 属性，您将需要一些 RAM。 如果您有一个已访问的属性，您首先需要在运行算法之前清除它。这可能不符合您的 big-O 要求。

不清楚“指向上一个列表项”是什么意思。通过引用（对象）或相同的值/属性值集（结构）是否相等？我假设参考。下面的代码也可以很容易地修改为处理结构。

static void Main(string[] args)
{
    var list = BuildALinkedListFromSomeData();
    var isConsitent = IsConsistent(list);
}

static bool IsConsistent(LinkedList<Item> list)
{ 
    var visited = new List<LinkedListNode<Item>>()
    var runner = list.First;
    while(runner != null)
    {
        if (visited.Contains(runner))
            return false;
        visited.Add(runner);
        runner = runner.Next;
    }
    return true;
}

使用已使用存储空间（无需额外存储）的现有数字 VisitCounter 的 O(n) 解决方案：

static bool IsConsistent(LinkedList<Item> list)
{
    var runner = list.First;
    if (runner == null)
        return false;  // Assume consistent if empty

    var consistent = true; 
    var runId = runner.Value.VisitCount;
    while (runner != null)
    {
        // Does the traversed item match the current run id?
        if(runner.Value.VisitCount > runId)
        {
            // No, Flag list as inconsistent. It must have been visited previously during this run
            consistent = false;
            // Reset the visit count (so that list is ok for next run)
            runner.Value.VisitCount = runId; 
        }
        // Increase visit count
        runner.Value.VisitCount++;
        // Visit next item in list
        runner = runner.Next;
    }
    return consistent;
}

这会更改列表中项目的内容，但不会更改列表本身。如果您不允许更改列表中某个项目的内容，那么这当然也不是解决方案。好吧，再想一想，这根本不是一个可能的解决方案。当不一致时，您的列表是循环的，最后一个算法永远不会完成:)

然后，您必须从列表中的每个访问项目向后遍历列表，这将打破您的 O(n+1) 要求。

结论：如果 Count 可用，则不是那么不可能的任务。查看 GrahamS 的回答

Answer 4

这是我对第二个问题的解决方案。

IsConsistent(LinkedList<Item> list) :N
    slow = List.Sentinel.next :Element
    fast = slow.next :Element
    isConsistent = true :boolean
    while(fast != list.Sentinel && fast.next != list.Sentinel && isConsistent) do
        if(slow == fast)
            isConsistent = false
        else 
            slow:= slow.next
            fast:= fast.next.next 
    od
    if(isConsistent)
        return 0
    else
        position = 0 : N
        slow:= list.Sentinel
        while(slow != fast) do
            slow:= slow.next
            fast:= fast.next
            position:= position + 1
        od
        return position

Answer 5

基本上，指向前一个项目意味着在列表中有一个循环。在这种情况下，循环检查似乎是合适的。

Answer 6

一开始我并没有考虑使用 list.Sentinel。现在我有了一个新想法。

IsConsistent(LinkedList<Item> list) :boolean
    slow = List.Sentinel.next :Element
    fast = slow.next :Element
    while(slow != list.Sentinel && fast != list.Sentinel) do
        if(slow == fast) return false
        else 
              slow:= slow.next
              fast:= fast.next.next 
    od
    return true