Java链表递归方法

Question

I don't understand the linked list data structure and how the recursion works in it. I understand normal recursion but with linked lists not at all.

The code is below is a linked list class with A elements. It has a head as A element and the rest of the list(tail) as another linked list.

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class LL<A>  {
  private final A hd;
  private final LL<A> tl;

  public boolean isEmpty(){    
    return hd==null && tl==null;
  }

  public LL(A hd, LL<A> tl) {
    this.hd = hd;
    this.tl = tl;
  }

 public LL() {
    this(null,null);
 }

public int size() {
    if (isEmpty())    
      return 0;    
    return 1 + tl.size();
 }

 public A get(int i) {
    return i==0?hd:tl.get(i-1);
 }

LL<A> drop(int i){

        if(i==0) return this;

        if(i<0) return new LL<>();

        if(isEmpty()) return new LL<A>();


        return this.tl.drop(i-1);
    }

}

So for example this drop method creates a new linked list with the elements other than the first i elements. I don't get how it works. Let's say if I call drop(1) on a linked list what will it do step by step?

Answer 1

drop only creates a new list in special cases.

If the list has n elements and you call drop(i) where i < n, it doesn't create a new list. It simply returns the i+1 'th link of the list, which is equivalent to the original list with the first i elements removed.

this.tl is the tail of the list references by this , which in other words means this.tl is the list you get from this after removing the first element.

For example, assuming a list has at least one element, drop(1) will return this.tl.drop(0) , which will return this.tl - ie the original list without the first element.