Question

I made an algorithm for sorting but I then I thought perhaps I had just reinvented quicksort.

However I heard quicksort is O(N^2) worst case; I think my algorithm should be only O(NLogN) worst case.

Is this the same as quicksort?

The algorithm works by swapping values so that all values smaller than the median are moved to the left of the array. It then works recursively on each side.

The algorithm starts with i=0, j = n-1

i and j move towards each other with list[i] and list[j] being swapped if necessary.

Here is some code for the first iteration before the recursion:

_list = [1,-4,2,-5,3,-6]

def in_place(_list,i,j,median):
    while i<j:
        a,b = _list[i],_list[j]
        if (a<median and b>=median):
            i+=1
            j-=1
        elif (a>=median and b<median):
            _list[i],_list[j]=b,a
            i+=1
            j-=1
        elif a<median:
            i+=1
        else:
            j-=1
    print "changed to ", _list



def get_median(_list):
    #approximate median in O(N) with O(1) space
    return -4

median = get_median(_list)
in_place(_list,0,len(_list)-1,median)

"""
changed1 to  [-6, -5, 2, -4, 3, 1]
"""

Answer 1

http://en.wikipedia.org/wiki/Quicksort#Selection-based_pivoting

Conversely, once we know a worst-case O(n) selection algorithm is
available, we can use it to find the ideal pivot (the median) at every
step of quicksort, producing a variant with worst-case O(n log n)
running time. In practical implementations, however, this variant is
considerably slower on average.

Another variant is to choose the Median of Medians as the pivot
element instead of the median itself for partitioning the elements.
While maintaining the asymptotically optimal run time complexity of
O(n log n) (by preventing worst case partitions), it is also
considerably faster than the variant that chooses the median as pivot.