相关疑难解决方法(0)

如何检测单个链表是否有循环？如果它有循环,那么如何找到循环的起始点,即循环开始的节点.

我已经看过一个问题,讨论在链表中查找循环的算法.我已经阅读了Floyd的循环寻找算法解决方案,在许多地方提到我们必须采取两个指针.一个指针(慢/龟)增加一个,其他指针(更快/野兔)增加2.当它们相等时我们找到循环,如果更快的指针到达null,则链表中没有循环.

现在我的问题是为什么我们将指针增加更快2.为什么不是别的呢？增加2是必要的,或者我们可以将它增加X来得到结果.如果我们将指针增加2,或者可能存在需要增加3或5或x的情况,我们是否有必要找到一个循环.

有没有人知道一个算法来查找链表是否只使用两个变量来遍历列表.假设您有一个链接的对象列表,它与哪种类型的对象无关.我在一个变量中有一个指向链表头部的指针,我只有一个其他变量来遍历列表.

所以我的计划是比较指针值以查看是否有任何指针相同.该列表的大小有限,但可能很大.我可以将两个变量都设置为头部,然后用另一个变量遍历列表,总是检查它是否等于另一个变量,但是,如果我确实打了一个循环,我将永远不会离开它.我认为它与遍历列表和比较指针值的不同速率有关.有什么想法吗？

如何查找单链表是循环/循环还是循环？我试图搜索但找不到满意的解决方案.如果可能,您能提供伪代码或Java实现吗？

例如:
1→交通3→交通5→交通71→交通45→交通7→交通5,其中第二个5实际上是列表的第三个元素.

确定链表是否有循环的最佳(暂停)算法是什么？

[编辑]对时间和空间的渐近复杂性的分析将是甜蜜的,因此可以更好地比较答案.

[编辑]原始问题没有解决超过1的节点,但有一些关于它的讨论.这个问题更像是"在有向图中检测周期的最佳算法".

我试图找到循环开始的单链接列表的要点.我想到的是2个指针*慢,*快速移动速度是其他速度的两倍.如果列表在某个时刻有循环

    5-6-7-8
    |     |
1-2-3-4-7-7

慢=快

可以有另一个优雅的解决方案,以便列表只遍历一次？

我读了关于链表检测算法的循环 ,我怀疑

1)如何检测"会议元素".例如,在以下情况中 - 如何检测会议是否在第3个元素？

2)如何检测列表的长度(如果超过 - 6)

运行时间O(n),存储器O(1)中的两个问题.

我想在下面的节点结构中列出列表中的循环或递归.我该如何识别？

public class EntityNode {
    private EntityNode nextNode; // Points to the next node
}

例,

Node1 -> Node2 -> Node3 -> Node4 -> Node5 -> Node6 -> Node4

在这里,你可以看到它Node6指向Node4,并且这里出现循环或递归,我的代码将进入无限.那么如果我想找出具有最佳性能水平的这种情况呢？

有人可以让我知道证明链表包含循环的最佳方法吗？我正在使用一个带有两个指针的算法,一个步骤缓慢移动一步,另一个步骤移动得更快.

class Node(object):
    def __init__(self, value, next=None):
        self.next=next
        self.value=value
def create_list():
    last = Node(8)
    head = Node(7, last)
    head = Node(6, head)
    head = Node(5, head)
    head = Node(4, head)
    head = Node(3, head)
    head = Node(2, head)
    head = Node(1, head)
    last.next = head
    return head

def is_circular(head):
    slow = head
    fast = head
    while True:
        slow = slow.next
        fast = fast.next.next
        print slow.value, fast.value
        if slow.value == fast.value:
            return True
        elif slow is fast:
            return False

if __name__ …

在文件啊：

class B;
class A
{
public:
    B *b;
    A(B *b = nullptr)
    {
        this->b = b;
    }
    ~A()
    {
        delete this->b;
    }
};

在文件 bh 中：

class A;
class B   
{
public:
    A *a;
    B(A *a = nullptr)
    {
        this->a = a;
    }
    ~B()
    {
        delete this->a;
    };
};

让我们假设我们有一个指向 A *对象的指针，并且我们想要删除它：

// ...
A *a = new A();
B *b = new B();
A->b = b;
B->a = a;
// ...

delete a;

// ...

A 的析构函数会说删除 B；即调用 …

这个问题与找到2个链表的交集有点不同.

考虑一个带循环的链表:A - B - C - D - E - F - C.

如果node A是函数的输入,那么它应该返回C.

由于我不知道该怎么称呼C,我使用了一个术语循环节点,C如问题中所示.虽然O(n ²)项似乎很明显,但是有没有办法找到复杂度较低的循环节点？

不允许使用O(n)的哈希表/额外空间.

链接列表中可能存在循环,如何确定循环在链接列表中的位置.