Bubble sort algorithm for a linked list

Question

I have written a bubble sort algorithm to sort a linked list. I am a Java beginner and trying to learn data structures. I am confused why my second element is not sorted properly.

class SListNode {
    Object item;
    SListNode next;

    SListNode(Object obj) {
        item = obj;
        next = null;
    }

    SListNode(Object obj, SListNode next) {
        item = obj;
        this.next = next;
    }
}

public class SList {
    private SListNode head;
    private SListNode temp;

    public void sortList() {
        SListNode node = head, i, j;
        head = node;
        i = node;
        j = node.next;
        while (i.next != null) {
            while (j.next != null) {
                if ((Integer) i.item < (Integer) j.item) {
                    temp = i.next;
                    i.next = j.next;
                    j.next = temp;
                }
                j = j.next;
            }
            i = i.next;
        }
    }
}

This is the output I am getting

List after construction: [  3  6  9  4  12  15  ]
After sorting: [  3  4  9  12  6  15  ]

Besides I know the worst case scenario of a bubble sort is O(n²). Can I use mergesort on a linked list to have a better time complexity?

Answer 1

There are many sorting algorithms that work on linked lists and mergesort works excellently in this case. I wrote an earlier answer to a question about sorting linked lists that explores many classic sorting algorithms on linked lists, along with their time and space complexities. You can use insertion sort, selection sort, mergesort, and quicksort on linked lists. With a bit of fudging, you can also get heapsort working. My older answer has details on how to do this.

With regards to your code, notice that in your inner loop you advance j forward until the next pointer becomes null. At this point, you never reset j to be anything else, so on each future iteration of the outer loop the inner loop never executes. You should probably set j = i.next at the start of each iteration. Moreover, you probably don't want to have the loop stop when j.next is null, but rather when j is null, since otherwise you skip the last element of the array.

Additionally, the sorting algorithm you've written here is selection sort rather than bubble sort, because you're making many passes over the linked list looking for the smallest element that you haven't positioned yet. I don't know if this is a problem or not, but I wasn't sure if you were aware of this. That said, I think that's probably a good thing, since bubble sort is less efficient than selection sort in most cases (unless the list is already close to being sorted).

Hope this helps!

Answer 2

If you have a List of Comparable items, then you can use Collections.sort method that uses a kind of merge sort algorithm with O(n log n) worst-case time complexity. Anyway, it is faster then bubble sort with O(n²).

If you want to use bubble sort algorithm, you can do it like this:

public static void bubbleSort(List<Integer> list) {
    boolean swapped;
    // repeat the passes through the list until
    // all the elements are in the correct order
    do {
        swapped = false;
        // pass through the list and
        // compare adjacent elements
        for (int i = 0; i < list.size() - 1; i++) {
            // if this element is greater than
            // the next one, then swap them
            if (list.get(i) > list.get(i + 1)) {
                Collections.swap(list, i, i + 1);
                swapped = true;
            }
        }
        // if there are no swapped elements at the
        // current pass, then this is the last pass
    } while (swapped);
}

public static void main(String[] args) {
    LinkedList<Integer> list = new LinkedList<>();
    Collections.addAll(list, 6, 1, 5, 8, 4, 3, 9, 2, 0, 7);
    bubbleSort(list);
    System.out.println(list); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
}

---

^{See also:
• Bubble sort output is incorrect
• Bubble sort with step-by-step output Java 8}