Question

我遵循以下方法来计算linked list中的中间元素，但我想要的是有任何内置方法或任何其他方法也可以轻松找到相同的方法，我遵循的方法是如下所示..

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;
        }
    }
}

输出： -

length of LinkedList: 4
middle element of LinkedList : 2

Answer 1

基本算法是

两点指示
同时指向第一个节点
首先使用两个节点递增，然后一次递增一次。
循环直到第一个循环到达结尾。此时，第二个将位于中间。

示例： -

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

它肯定会在奇怪的情况下工作，因为即使你需要再检查一个条件，如果第一个点允许下一个移动而不是下一个接下来那么两个指针都在中间你需要决定哪个作为中间

Answer 2

我建议使用内置的Java

LinkedList<Object e>

它为您提供了获取长度所需的所有功能：list.size()和中间对象：

list.get((list.size())/2);

Answer 3

选项：

有一个双重链表，同时从后面和前面走，直到你达到共同点。
存储列表的大小，当您达到这个尺寸的一半时就停止（类似于标准API的LinkedList）。

除此之外，我认为你不能比你的算法做得更好。

Answer 4

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);

I / P：5 10 15 25 35 25 40 O / P：25

Answer 5

此问题的解决方案：

使用两个索引first和second，两者都初始化为0
将first增加1，将second增加2 * first
将first的值设置为中间
循环将执行，直到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));

关于查找链表的中间元素

输出： -

5 个答案: