Styjun

Depending on a number of factors, it may actually be faster to copy the list to an array and then use a Quicksort.

The reason this might be faster is that an array has much better
cache performance than a linked list. If the nodes in the list are dispersed in memory, you
may be generating cache misses all over the place. Then again, if the array is large you will get cache misses anyway.

Mergesort parallelises better, so it may be a better choice if that is what you want. It is also much faster if you perform it directly on the linked list.

Since both algorithms run in O(n * log n), making an informed decision would involve profiling them both on the machine you would like to run them on.

--- EDIT

I decided to test my hypothesis and wrote a C-program which measured the time (using clock()) taken to sort a linked list of ints. I tried with a linked list where each node was allocated with malloc() and a linked list where the nodes were laid out linearly in an array, so the cache performance would be better. I compared these with the built-in qsort, which included copying everything from a fragmented list to an array and copying the result back again. Each algorithm was run on the same 10 data sets and the results were averaged.

These are the results:

N = 1000:

Fragmented list with merge sort: 0.000000 seconds

Array with qsort: 0.000000 seconds

Packed list with merge sort: 0.000000 seconds

N = 100000:

Fragmented list with merge sort: 0.039000 seconds

Array with qsort: 0.025000 seconds

Packed list with merge sort: 0.009000 seconds

N = 1000000:

Fragmented list with merge sort: 1.162000 seconds

Array with qsort: 0.420000 seconds

Packed list with merge sort: 0.112000 seconds

N = 100000000:

Fragmented list with merge sort: 364.797000 seconds

Array with qsort: 61.166000 seconds

Packed list with merge sort: 16.525000 seconds

Conclusion:

At least on my machine, copying into an array is well worth it to improve the cache performance, since you rarely have a completely packed linked list in real life. It should be noted that my machine has a 2.8GHz Phenom II, but only 0.6GHz RAM, so the cache is very important.

Comparison sorts (i.e. ones based on comparing elements) cannot possibly be faster than n log n. It doesn't matter what the underlying data structure is. See Wikipedia.

Other kinds of sort that take advantage of there being lots of identical elements in the list (such as the counting sort), or some expected distribution of elements in the list, are faster, though I can't think of any that work particularly well on a linked list.

As stated many times, the lower bound on comparison based sorting for general data is going to be O(n log n). To briefly resummarize these arguments, there are n! different ways a list can be sorted. Any sort of comparison tree that has n! (which is in O(n^n)) possible final sorts is going to need at least log(n!) as its height: this gives you a O(log(n^n)) lower bound, which is O(n log n).

So, for general data on a linked list, the best possible sort that will work on any data that can compare two objects is going to be O(n log n). However, if you have a more limited domain of things to work in, you can improve the time it takes (at least proportional to n). For instance, if you are working with integers no larger than some value, you could use Counting Sort or Radix Sort, as these use the specific objects you're sorting to reduce the complexity with proportion to n. Be careful, though, these add some other things to the complexity that you may not consider (for instance, Counting Sort and Radix sort both add in factors that are based on the size of the numbers you're sorting, O(n+k) where k is the size of largest number for Counting Sort, for instance).

Also, if you happen to have objects that have a perfect hash (or at least a hash that maps all values differently), you could try using a counting or radix sort on their hash functions.

This is a nice little paper on this topic. His empirical conclusion is that Treesort is best, followed by Quicksort and Mergesort. Sediment sort, bubble sort, selection sort perform very badly.

A COMPARATIVE STUDY OF LINKED LIST SORTING ALGORITHMS
by Ching-Kuang Shene

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.31.9981

A Radix sort is particularly suited to a linked list, since it's easy to make a table of head pointers corresponding to each possible value of a digit.

Merge sort doesn't require O(1) access and is O ( n ln n ). No known algorithms for sorting general data are better than O ( n ln n ).

The special data algorithms such as radix sort ( limits size of data ) or histogram sort ( counts discrete data ) could sort a linked list with a lower growth function, as long as you use a different structure with O(1) access as temporary storage.

Another class of special data is a comparison sort of an almost sorted list with k elements out of order. This can be sorted in O ( kn ) operations.

Copying the list to an array and back would be O(N), so any sorting algorithm can be used if space is not an issue.

For example, given a linked list containing uint_8, this code will sort it in O(N) time using a histogram sort:

#include <stdio.h>
#include <stdint.h>
#include <malloc.h>

typedef struct _list list_t;
struct _list 
 uint8_t value;
 list_t *next;
;


list_t* sort_list ( list_t* list )

 list_t* heads[257] = 0;
 list_t* tails[257] = 0;

 // O(N) loop
 for ( list_t* it = list; it != 0; it = it -> next ) 
 list_t* next = it -> next;

 if ( heads[ it -> value ] == 0 ) 
 heads[ it -> value ] = it;
 else 
 tails[ it -> value ] -> next = it;
 

 tails[ it -> value ] = it;
 

 list_t* result = 0;

 // constant time loop
 for ( size_t i = 255; i-- > 0; ) 
 if ( tails[i] ) 
 tails[i] -> next = result;
 result = heads[i];
 
 

 return result;


list_t* make_list ( char* string )

 list_t head;

 for ( list_t* it = &head; *string; it = it -> next, ++string ) 
 it -> next = malloc ( sizeof ( list_t ) );
 it -> next -> value = ( uint8_t ) * string;
 it -> next -> next = 0;
 

 return head.next;


void free_list ( list_t* list )

 for ( list_t* it = list; it != 0; ) 
 list_t* next = it -> next;
 free ( it );
 it = next;
 


void print_list ( list_t* list )

 printf ( "[ " );

 if ( list ) 
 printf ( "%c", list -> value );

 for ( list_t* it = list -> next; it != 0; it = it -> next )
 printf ( ", %c", it -> value );
 

 printf ( " ]n" );



int main ( int nargs, char** args )

 list_t* list = make_list ( nargs > 1 ? args[1] : "wibble" );


 print_list ( list );

 list_t* sorted = sort_list ( list );


 print_list ( sorted );

 free_list ( list );

Not a direct answer to your question, but if you use a Skip List, it is already sorted and has O(log N) search time.

As I know, the best sorting algorithm is O(n*log n), whatever the container - it's been proved that sorting in the broad sense of the word (mergesort/quicksort etc style) can't go lower. Using a linked list will not give you a better run time.

The only one algorithm which runs in O(n) is a "hack" algorithm which relies on counting values rather than actually sorting.

Here's an implementation that traverses the list just once, collecting runs, then schedules the merges in the same way that mergesort does.

Complexity is O(n log m) where n is the number of items and m is the number of runs. Best case is O(n) (if the data is already sorted) and worst case is O(n log n) as expected.

It requires O(log m) temporary memory; the sort is done in-place on the lists.

(updated below. commenter one makes a good point that I should describe it here)

The gist of the algorithm is:

 while list not empty
 accumulate a run from the start of the list
 merge the run with a stack of merges that simulate mergesort's recursion
 merge all remaining items on the stack

Accumulating runs doesn't require much explanation, but it's good to take the opportunity to accumulate both ascending runs and descending runs (reversed). Here it prepends items smaller than the head of the run and appends items greater than or equal to the end of the run. (Note that prepending should use strict less-than to preserve sort stability.)

It's easiest to just paste the merging code here:

 int i = 0;
 for ( ; i < stack.size(); ++i) 
 if (!stack[i])
 break;
 run = merge(run, stack[i], comp);
 stack[i] = nullptr;
 
 if (i < stack.size()) 
 stack[i] = run;
 else 
 stack.push_back(run);
 

Consider sorting the list (d a g i b e c f j h) (ignoring runs). The stack states proceed as follows:

 [ ]
 [ (d) ]
 [ () (a d) ]
 [ (g), (a d) ]
 [ () () (a d g i) ]
 [ (b) () (a d g i) ]
 [ () (b e) (a d g i) ]
 [ (c) (b e) (a d g i ) ]
 [ () () () (a b c d e f g i) ]
 [ (j) () () (a b c d e f g i) ]
 [ () (h j) () (a b c d e f g i) ]

Then, finally, merge all these lists.

Note that the number of items (runs) at stack[i] is either zero or 2^i and the stack size is bounded by 1+log2(nruns). Each element is merged once per stack level, hence O(n log m) comparisons. There's a passing similarity to Timsort here, though Timsort maintains its stack using something like a Fibonacci sequence where this uses powers of two.

Accumulating runs takes advantage of any already sorted data so that best case complexity is O(n) for an already sorted list (one run). Since we're accumulating both ascending and descending runs, runs will always be at least length 2. (This reduces the maximum stack depth by at least one, paying for the cost of finding the runs in the first place.) Worst case complexity is O(n log n), as expected, for data that is highly randomized.

(Um... Second update.)

Or just see wikipedia on bottom-up mergesort.

You can copy it into an array and then sort it.

• Copying into array O(n),




• sorting O(nlgn) (if you use a fast algorithm like merge sort ),




• copying back to linked list O(n) if necessary,

so it is gonna be O(nlgn).

note that if you do not know the number of elements in the linked list you won't know the size of array. If you are coding in java you can use an Arraylist for example.

Mergesort is the best you can do here.