Head value set to null but tail value still gets displayed-CodePudding

In java linked lists if head=null then the LinkedList is empty. However when I set head=null and print value of tail the value is displayed. Why is it that we say head==null means that the LinkedList is empty? Why is tail value being displayed when the linked list should be empty? Shouldn't we check id(tail==null)as well?

public class SinglyLinkedList{
  public Node head;
  public Node tail;
  public int size;

  public Node createLL(int num){
    Node node=new Node();
    node.value=num;
    node.next=null;
    head=node;
    tail=node;

    size=1;
    return head;
  }

  public void insertNode(int num,int location){
    Node node=new Node();
    node.value=num;
    
    if(head==null){//Check
      createLL(num);
      return;
    }

    else if(location==0){
      node.next=head;
      head=node;
    }

    else if(location>=size){
      node.next=null;
      tail.next=node;
      tail=node;
    }

    else{
      Node tempNode=head;
      int index=0;

      while(index<location-1){
        tempNode=tempNode.next;
        index  ;
      }
     node.next=tempNode.next;
     tempNode.next=node;
    }
    size  ;
  }

  public void traverse(){
    if(head==null){//Check
      System.out.println("The linked list is empty");
    }
    Node tempNode=head;
    for(int i=0;i<size;i  ){
      System.out.print(tempNode.value);
      if(i!=size-1){
        System.out.print("->");
      }
      tempNode=tempNode.next;
    }
    System.out.println();
  }

  public void deleteNode(int location){
    if(head==null){//Check
      System.out.println("The linked list is not present");
      return;
    }

    else if(location==0){
      head=head.next;
      size--;
      if(size==0){
        tail=null;
      }
    }

    else if(location>=size){
      Node tempNode=head;
      for(int i=0;i<size-1;i  ){
        tempNode=tempNode.next;
      }
      if(head==null){
        tail=null;
        size--;
        return;
      }
      tempNode.next=null;
      tail=tempNode;
      size--;
    }

    else{
      Node tempNode=head;
      int index=0;

      while(index<location-1){
        tempNode=tempNode.next;
        index  ;
      }
      tempNode.next=tempNode.next.next;
      size--;
    }
  }

Main class

class Main {
  public static void main(String[] args) {
    SinglyLinkedList sLL=new SinglyLinkedList();
    sLL.createLL(5);
    sLL.insertNode(15, 1);
    sLL.insertNode(20, 2);
    sLL.insertNode(39, 3);
    sLL.insertNode(45, 4);

    sLL.traverse();
    
    sLL.head=null;
    System.out.println(sLL.tail.value);
  }
}

Output: 5->15->20->39->45

CodePudding user response：

head being null just means that you cannot reach the first Node anymore. This also implies that you cannot access the whole chain via the next reference, since you've no starting point.
The garbage collector is allowed to "free" all objects which aren't reachable anymore. In your case all nodes except the tail Node, since you still keep a reference to it in your SinglyLinkedList.

So in fact you've an kind-of empty LinkedList, since you cannot correctly access it anymore. But you still keep the tail node alive, since you reference it. The correct solution would be to set tail to null as well, so the garbage collector can also free this node.

CodePudding user response：

By that assignment you make your list instance inconsistent. An empty list would have both its head and tail member set to null and its size equal to 0.

That's why you should not just alter a member of your class like that. You should probably even make them private to prevent the caller from doing such manipulations. If you want to have a way to empty a list, then create a proper method for it, which takes care of keeping the properties consistent:

public void clear() {
    head = tail = null;
    size = 0;
}

And in your main code, just call that sLL.clear() method.

If you keep a reference to a node, you will always be able to access it. To really lose a node, you must get rid of all references to it.