Question

所以，我在这里面临疑问。

我正在读“Cracking the coding Interview”一书。以下文字写在那里。

假设您有一个链接列表a1->b1->a2->b2->.....an->bn，并且您想将其重新排列为1. a1 (p1, p2)->a2->a3->b1->b2->b3 2. a1->a2 (p2)->a3 (p1)->b1->b2->b3 3. a1->a2->a3 (p2)->b1->b2 (p1)->b3 4. Index out of bounds error because p2 now points to a node after b3.。你不知道链表的长度，但你知道的是它是一个偶数。

（此处两个链接列表长度相同）

对于p2所做的每一次移动，你可以有一个指针p1（快速指针）每两个元素移动一次。当p1命中链表的末尾时，p2将位于端点。然后，将p1移回前面并开始“编织”元素。在每次迭代时，p2选择一个元素并在p1之后插入它。

我不明白当p1到达链表的末尾时，p2将处于中点。如果n = 3（长度= 6），这就是我想象的方式。下面的每个步骤代表一次迭代。

JAXBContext getContext(Class cls) {
  if (contexts.containsKey(cls)) return contexts.get(cls);
  JAXBContect context = JAXBContext.newInstance(cls);
  contexts.put(cls,context);
  return context;
}
...
JAXBContext jc =getContext(Bags.class);

我错了吗？

Answer 1

让n = 2。我们从列表开始：

a1 -> a2 -> b1 -> b2

让p1成为一个“快速”指针，最初指向头部的后继者让p2成为最初指向头部的“慢”指针。

      p1
a1 -> a2 -> b1 -> b2
p2

我们将p1移动2，将p2移动1，直到p1到达列表末尾（没有下一个）。

                  p1
a1 -> a2 -> b1 -> b2
      p2

将p1移回头部。

p1                  
a1 -> a2 -> b1 -> b2
      p2

提前p2。

p1                  
a1 -> a2 -> b1 -> b2
            p2

“编织”开始。

使用p2指向的元素并在p1之后移动它。插入元素后提前p1。

            p1                  
a1 -> b1 -> a2 -> b2
                  p2

使用p2指向的元素并在p1之后移动它。插入元素后提前p1。

                       p1      
a1 -> b1 -> a2 -> b2  
                  p2

p1为空，终止。

Answer 2

在第二个位置开始p2。

a1(p1)-> a2 (p2) -> a3 -> a4 -> b1 -> b2 -> b3 -> b4  
a1-> a2 (p1) -> a3 -> a4 (p2)-> b1 -> b2 -> b3 -> b4  
a1-> a2  -> a3(p1) -> a4 -> b1 -> b2(p2) -> b3 -> b4  
a1-> a2  -> a3 -> a4(p1) -> b1 -> b2 -> b3 -> b4(p2)

Answer 3

您可以简单地使用 Java 实现：

public static void findMidElOfLinkedList(FindMidElementOfLinkedList findMidElementOfLinkedList) {
    Node node = findMidElementOfLinkedList.head;
    Node slow = node;
    Node fast = node;

    while (fast != null && fast.next != null) {
        fast = fast.next.next; // increase 2
        slow = slow.next; // increate 1
    }
    System.out.println(slow.data);
    /*
    * Slow runner goes at a pace of 1 element per move, fast runner goes 2 elements per move.
    When the fast runner reaches the end of the linked list, then slow runner is sitting at the middle. Testing this out for one/two middle cases work.
    Time O(N), faster than the previous brute force method, Space: O(1).
    * */
}

Runner技术结合两个相等的链接列表

3 个答案: