I need some explanation about sorting nodes

Question

I am confused how this comparing works, for example the second if statement, if comparison > 0 it should be before currentItem, but the lines inside the if statement have confused me too much, can you explain it to me how they work?

By the way

this.root

is an instance of ListItem and the code doesn't use LinkedList or ArrayList class, the code below trying to emulate something in LinkedList i think, If my questions need more explanation, tell me please. Best regards

@Override
    public boolean addItem(ListItem newItem) {
        if(this.root == null){
            this.root = newItem;
            return true;
        }
        ListItem currentItem = this.root;
        while (currentItem != null){
            int comparison = currentItem.compareTo(newItem);
            if (comparison < 0){
                if (currentItem.next()!=null){
                    currentItem = currentItem.next();
                }
                else{
                    currentItem.setNext(newItem);
                    newItem.setPrevious(currentItem);
                    return true;
                }
            }
            else if (comparison > 0){
                // new Item is less, insert before
                if (currentItem.previous()!= null){
                    currentItem.previous().setNext(newItem);
                    newItem.setPrevious(currentItem.previous());
                    newItem.setNext(currentItem);
                    currentItem.setPrevious(newItem);
                }else{
                    newItem.setNext(this.root);
                    this.root.setPrevious(newItem);
                    this.root = newItem;
                }

            }
        }
            return false;
    }

Answer 1

I added comments, plus some fixes:

public boolean addItem(ListItem newItem) {
    if(this.root == null){
        this.root = newItem;
        return true;
    }
    ListItem currentItem = this.root;
    while (currentItem != null){
        int comparison = currentItem.compareTo(newItem);
        if (comparison < 0){                               // if cur < new
            newItem.setPrevious(currentItem.previous());   //   advance cur
            if (currentItem.next()!=null){
                currentItem = currentItem.next();
            } else {                                       //   if end list
                currentItem.setNext(newItem);              //     append new
                newItem.setPrevious(currentItem);
                return true;
            }
        } else if (comparison > 0){
            // new < cur, insert before, fixes made to this part
            newItem.setNext(currentItem);                  // set   new.nxt
            newItem.setPrevious(currentItem.previous());   // set   new.prv
            if (newItem.previous()!= null){                // if    new.prv != 0
                newItem.previous().setNext(newItem);       //   set new.prv.nxt
            else                                           // else
                this.root = newItem;                       //   set root
            currentItem.setPrevious(newItem);              // set   cur.prv
            return true;
        }
        return false;     // return false if duplicate
    }
}

---

Using text graphics. Say the new node N is to be inserted after A and before B. Initial state, cur (currentItem) = B:

                                  cur         == B
    A <------ B    0 <- N         cur.prv     == A  new.prv = 0
    A ------> B         N -> 0    cur.prv.nxt == B  new.nxt = 0

The sequence is:

         N -> B                   new.nxt      = cur
    A <- N                        new.prv      = cur.prv
    A -> N                        new.prv.nxt  = new
         N <- B                   cur.prv      = new

resulting in

    A -> N -> B
    A <- N <- B