Question

我在想Algo找到Singly Link List中的第3个元素，我自己想出一个（空间效率不高）
使用具有O（n）时间复杂度[很多空间复杂度]的循环将链接列表放在ArrayList中然后找到Arraylist的大小并在（size-2）索引位置检索元素[required element] 如果我的算法有意义，请指导我

FYI
我搜索的其他内容是：放两个指针，将第一个指针放在第一个元素上，将第二个指针放在第三个元素上，然后将它们平行移动当第二个指针到达LinkList的末尾时，检索由第一个指针

指向的节点[required node]

Answer 1

使用两个指针：pointer-1和pointer-2

使pointer-1指向单个链接列表中的第三个节点。

 pointer-1 = node1->next->next; // point to 3rd nd

 node1-->node2-->node3-->node4---> ...... -->node-last
                 ^
                 |
                pointer-1

现在将pointer-2点设置为第一个节点

 pointer-2 = node1;   // point to 1st nd

 node1-->node2-->node3-->node4---> ...... -->node-last
   ^              ^
   |              |
  pointer-2      pointer-1

现在，在循环中以链接列表行进，直到pointer-1指向最后一个节点，在循环中也更新指针-2（每次都到达自身的下一个节点）

while (pointer-1->next!=NULL){// points to last node 
     pointer-1 = pointer-1 -> next;
     pointer-2 = pointer-2 -> next;
}

When loop ends pointer-1 points to last-node, pointer-2 points to third last

 node1-->node2-->........ ->node-l3-->node-l2-->node-last
                             ^                   ^
                             |                   |
                           pointer-2            pointer-1

它工作在O（n）次，其中n是链表中的节点数。

Answer 2

由于链表是单链接的，你需要从头到尾遍历它以知道第3个到最后一个元素是什么，os O(n)时间是不可避免的（除非你保持指向第3个的指针）链接列表中的最后一个元素）。

你的2指针想法，将使用恒定的空间。这可能是更好的选择，因为创建ArrayList会产生更多开销，并且占用更多空间。

Answer 3

获得两点指示。 pA，pB 将pA移动到3个元素前进，将pB移到头部：

1->2->3->4-> .... ->99->100 
|     |
pB    pA

在此之后，将两个指针移动到同一个循环中，直到pA到达最后一个元素。

此时pB将指向最后一个第3个元素

1->2->3->4-> .... ->98->99->100 
                    |        |
                    pB       pA

编辑：遍历将是一个：

while(pA->next!=null){
   pA = pA->next;
   pB = pB->next;
}

这里pB将是最后一个

Answer 4

即使是O（n）

，另一种解决方案

创建一个空数组（n），在0处开始指向此数组的指针，并从链表的开头开始。每次访问节点时，都会将其存储在数组的当前索引中并推进数组指针。继续填充数组中的节点，当到达数组末尾时，请从头开始再覆盖以覆盖。现在，一旦你结束了列表的最后一端，指针nth elemtn从end：）

Answer 5

实际上，Java LinkedList会跟踪它的大小，所以你可以转到'list.get（list.size（） - 2）'，但是使用构造的链表，我会执行以下操作：

保留3个值的数组。在遍历列表时，将更新值添加到array[i%3]。如果没有更多值，请返回array[(i-2)%3]处的值。

Answer 6

我要做的第一件事是要求您重新考虑使用单链表。为什么不将数据存储在ArrayList中？它做了你想要的一切，它是一个内置的，所以它比大多数人写的相对有效。

如果你受到约束并决定使用链表，我建议保留一个指向第3个最后一个元素（tle）的直接指针。插入很容易 - 如果他们来到这里，什么都不做;如果之后，将tle指针前进到tle的下一个。删除更麻烦，但可能不是大部分时间。如果删除发生在tle之前，它仍然是tle。令人讨厌的情况是，如果要删除的元素是tle或更晚，在这种情况下，您将从头开始迭代，直到当前节点的next（）引用为tle。当前节点将成为新的节点，然后您可以继续删除。由于只有三个节点调用此级别的工作，如果列表大小合适，您可能大部分时间都可以正常工作。

最后一个选项，如果经常发生删除，则是将列表从后向前维护。然后，为了维护目的，tle成为前面的第三个。

Answer 7

    //We take here two pointers pNode and qNode both initial points to head
    //pNode traverse till end of list and the qNode will only traverse when difference
   // between the count and position is grater than 0 and pthNode increments once
  // in each loop
    static ListNode nthNode(int pos){
    ListNode pNode=head;
    ListNode qNode=head;
    int count =0;
    while(qNode!=null){
        count++;
        if(count - pos > 0)
            pNode=pNode.next;
        qNode=qNode.next;
    }
    return pNode;
}

找到单链接列表中的第3个最后一个元素 - 算法

7 个答案: