исключение нулевого указателя в моей пузырьковой сортировке и других методах сортировки

У меня есть проект, в котором я должен написать кучу методов сортировки и измерить временную сложность для каждого и вывести результаты в выходной текстовый файл. программа запускается, но я получаю некоторые исключения нулевого указателя в методе пузырьковой сортировки. вот мой код и ошибка, если вы можете сказать мне, как исправить мои методы сортировки, это было бы здорово!

класс связанного списка:

public class LinkedList {
protected static class Node {
    Comparable item;
    Node prev, next;

    public Node(Comparable newItem, Node prev, Node next) {
        this.item = newItem;
        this.prev = prev;
        this.next = next;
    }

    public Node (Comparable newItem) {
        this(newItem, null, null);
    }

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

    public String toString() {
        return String.valueOf(item);
    }
}

private Node head;
private int size;
public int dataCompares, dataAssigns;
public int loopCompares, loopAssigns;
public int other;

public LinkedList() {
    head = new Node(null, null, null);
    head.prev = head;
    head.next = head;
    size = 0;
}

public boolean add(Comparable newItem) {
    Node newNode = new Node(newItem);
    Node curr;
    if(isEmpty()) {
        head.next = newNode;
        head.prev = newNode;
        newNode.next = head;
        newNode.prev = head;
    } else {
        newNode.next = head;
        newNode.prev = head.prev;
        head.prev.next = newNode;
        head.prev = newNode;
    }
    size++;
    return false;
}

public boolean remove(Comparable item) {
    if(!isEmpty()) {
        Node prev = null;
        Node curr = head;
        while(curr!=null) {
            if(curr.item.compareTo(item)==0) {
                if(prev==null) {
                    head=curr.next;
                } else {
                    prev.next = curr.next;
                    curr=curr.next;
                }
                size--;
                return true;
            }else{
                prev=curr;
                curr = curr.next;
            }
        }
    }
    return false;
}

public void removeAll() {
    this.head.prev = null;
    this.head.next = null;
    size = 0;
}

public boolean isEmpty() {
    return size == 0;
}

public boolean remove(Object item) {
    return true;
}

public void insertSortNode() {  
    Node back = head;
if (size < 2)
    return;
    back = back.next;           // SECOND entry in the list
    while ( back != null ) {      // I.e., end-of-list
           Comparable value = back.item;
        Node curr = head;        // Start at the front
  // Find insertion point for value;
    while (curr != back && value.compareTo(curr.item) >= 0)
            curr = curr.next;
  // Propogate values upward, inserting the value from back
    while (curr != back){  
            Comparable hold = curr.item;
        curr.item = value;
        value = hold;
        curr = curr.next;
    }
    back.item = value;      // Drop final value into place!
    back = back.next;       // Move sorted boundary up
}
} // end insertSort()

       public void selSort() {  
    Node front = head;
   // Nothing to do on an empty list
      if ( front == null )
         return;
      while ( front.next != null ) {     // skips a one-entry list
         Node tiny = front;
         Node curr = front.next;
         Comparable temp = front.item; // start the swap
         for ( ; curr != null ; curr = curr.next ) {  
                if ( tiny.item.compareTo(curr.item) > 0 )
                tiny = curr;
         }
         front.item = tiny.item;       // Finish the swap
         tiny.item = temp;
         front = front.next;           // Advance to the next node
      }
      // The structure is unchanged, so the validity of tail is unchanged.
       }


public void bubbleSort() {
    Node Trav=head.next;
    Node Trail=head.next;
    Comparable temp;
    if (Trav != null)
       Trav = Trav.next;
    while(Trav!=null) {
      if (Trav.item.compareTo(Trail.item)<0) {
        temp = Trail.item;
        Trail.item=Trav.item;
        Trav.item = temp;
      }
      Trail=Trav;
      Trav=Trav.next;
    }
   }

public void insertSortArray() {
    Node insert1, cur, tmp1;
    Comparable temp;
    for(insert1 = this.head.next.next; insert1!=this.head; insert1 = insert1.next) {
    //++loopcompares; ++loopassigns;
        for (cur = head.next; cur!=insert1; cur=cur.next) {
        //++loopCompares; ++loopassigns;
        //++datacompares;
            if(insert1.item.compareTo(cur.item)<0) {
                temp=insert1.item;
                //++dataassign
                tmp1=insert1;
                //++other
                while(tmp1!=cur.prev) {
                //++loopcomares
                    tmp1.item=tmp1.prev.item;
                    tmp1=tmp1.prev;
                    //++dataassign+=2
                }
                //++loopcompares
                cur.item = temp;
                //++dataassign;
                break;
            }
        }
        //++loopcompares; ++loopassigns;
    }
    //++loopcompares; ++loopassigns
}

public void disp6sortsFile(boolean disp, String fileName, String header, String data) {
    FileWriter fw = null;
    PrintWriter pw = null;
    try {
        File file = new File(fileName);
        fw = new FileWriter(file, true);
        pw = new PrintWriter(fw, true);
    } catch (IOException e) {
        System.err.println("File open failed for " +fileName+ "\n" + e);
        System.exit(-1);
    }
    if (disp) {
        pw.print(header + "\n");
    }
        pw.print(data + "\n");
        pw.close();
}
}

вот моя ошибка:

Exception in thread "main" java.lang.NullPointerException
    at LinkedList.bubbleSort(LinkedList.java:149)
    at LinkListTester.main(LinkListTester.java:51)

ошибка linkedlisttester просто list1.bubbleSort(); так что пузырьковая сортировка - это проблема.