Java 关于查找链表的中间元素

我遵循下面的方法从

链表中计算中间元素，但我想知道是否有任何内置方法或任何其他方法也可以轻松找到相同的方法，我遵循的方法如下所示

import test.LinkedList.Node;
public class LinkedListTest {


    public static void main(String args[]) {
        //creating LinkedList with 5 elements including head
      LinkedList linkedList = new LinkedList();
      LinkedList.Node head = linkedList.head();
      linkedList.add( new LinkedList.Node("1"));
      linkedList.add( new LinkedList.Node("2"));
      linkedList.add( new LinkedList.Node("3"));
      linkedList.add( new LinkedList.Node("4"));

      //finding middle element of LinkedList in single pass
      LinkedList.Node current = head;
      int length = 0;
      LinkedList.Node middle = head;

      while(current.next() != null){
          length++;
          if(length%2 ==0){
              middle = middle.next();
          }
          current = current.next();
      }

      if(length%2 == 1){
          middle = middle.next();
      }

      System.out.println("length of LinkedList: " + length);
      System.out.println("middle element of LinkedList : " + middle);

    } 

}

class LinkedList{
    private Node head;
    private Node tail;

    public LinkedList(){
        this.head = new Node("head");
        tail = head;
    }

    public Node head(){
        return head;
    }

    public void add(Node node){
        tail.next = node;
        tail = node;
    }

    public static class Node{
        private Node next;
        private String data;

        public Node(String data){
            this.data = data;
        }

        public String data() {
            return data;
        }

        public void setData(String data) {
            this.data = data;
        }

        public Node next() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }

        public String toString(){
            return this.data;
        }
    }
}

输出：-
基本算法是


拿两个指针

使两者都指向第一个节点

一次先增加两个节点，然后增加一个节点

循环，直到第一个循环到达终点。此时，第二个将位于中间


示例：-

while ( p2.next != null ) {
    p2 = p2.next;
    if (p2.next != null) {
        p2 = p2.next;
        p1 = p1.next;
    }
}

它在奇数情况下肯定会起作用，对于偶数情况，您需要再检查一个条件，如果允许第一个点移动到下一个，但不移动到下一个，则两个指针都将位于中间，您需要决定将哪个指针作为中间点。
选项：


拥有一个双链接列表，同时从后面和前面开始，直到找到一个共同点
存储列表的大小，并在达到此大小的一半时停止（类似于标准API所做的）

除此之外，我不认为你能比你的算法做得更好。
我建议使用Java内置的

LinkedList<Object e>

I/p:5 10 15 25 25 40 O/p:25
此问题的解决方案：


使用两个索引，
first
和
second
，都初始化为0
将
first
增加1，将
second
增加
2*first
将
first
的值设置为middle
循环将一直执行，直到
second
的值小于列表大小

下面是获取列表或链表中间元素的代码片段：

private int getMiddle(LinkedList<String> list) {

   int middle = 0;
   int size = list.size();

   for (int i = 0, j = 0; j < size; j = i * 2) {
       middle = i++;
   }

   return middle;
}

LinkedList<String> list = new LinkedList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
int middle = getMiddle(list);
System.out.println(list.get(middle));

private int getMiddle（链接列表）{
int-middle=0；
int size=list.size（）；
对于（int i=0，j=0；j
如果我没有计数，那么我可以通过遍历列表获得计数，然后该值的一半将是中间值。我说的对吗？@R.J我想通过链接跳转找到中间点，但我不知道什么是“链接跳转”。这种方式被称为链接跳跃吗？杜克林的评论是正确的，但这个答案是最有效的。它不需要长度变量，这在严格的嵌入式系统中是非常有用的。虽然我在现实世界中工作，但我可能会认为这是错误的答案。当问这个问题时，通常假定长度未知。假设您得到的是根节点，而不是LinkedList类。
list.get((list.size())/2);

public Node getMiddleElement(Node head) {
    Node slow_pointer=head;
    Node fast_pointer=head;
    while(fast_pointer.next!=null && fast_pointer.next.next!=null)
    {
        slow_pointer=slow_pointer.next;
        fast_pointer=fast_pointer.next.next;
    }
    return slow_pointer;
}

Node mid_elem=PrintMiddleElement(head);
System.out.println(mid_elem.data);

private int getMiddle(LinkedList<String> list) {

   int middle = 0;
   int size = list.size();

   for (int i = 0, j = 0; j < size; j = i * 2) {
       middle = i++;
   }

   return middle;
}

LinkedList<String> list = new LinkedList<>();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
list.add("6");
list.add("7");
int middle = getMiddle(list);
System.out.println(list.get(middle));