Deterministic Selection Median of Medians

Question

As I understand, a quick-select algorithm could use median of medians to find best suited pivot to yield the i-th item in the array, say A.

I have referred to Median of Medians algorithm and steps given here for deterministic selection.

This is the pseudo code as I understood for the sake of algorithm.

define partition5(arr)
    Returns middle of the array

define median_of_medians(arr, N)
    Returns the median index
    if # of elements are 5 or less just find the median
        partition5(arr)

    get n/5 slices     
    create array of slices

    fill array with ranges of slices from 0 to n in step=5

    find the median for each of slice of len 5 or less using partition5

    find the median of this median array recursively


define a swap function

define partition(ar, lo, hi, pivotIndex):
    i.e. a 3 way djisktra partition method
    start = lo
    take the elemet @ hi as the pivot and swap it to pivotIndex position
    swap(pivotIndex, hi, ar)
    pivotIndex = hi
    eq = lo

    loop range
        if element == pivot
            inc eq
        if element < pivot
            swap index, lo
            inc lo
            inc eq
    swap(lo, pivotIndex, ar)
    return lo

find the kth smallest element using
define quickSelect(arr, startIndex, endIndex, k)
    get start, end index range
    if (startIndex <= endIndex):
        find pivot using median_of_medians()
        divide using Linear-partitioning partition(ar, startIndex, endIndex, pivot)
        if ( pivotIndex == k ): return arr[pivotIndex]

        if (pivotIndex > k):
                recurse using quickSelect [startIndex, pivotIndex-1]
        else if (pivotIndex < k):
                recurse using quickSelect [pivotIndex+1, endIndex]

This is how I understood how quickSelect could be implemented using median of medians.

def partition5(arr):
    '''Returns middle of the array'''
    return len(arr)/2

def median_of_medians(arr, n, orig_arr=None):
    '''Returns the median index'''
    if n < 6:
        # if # of elements are 5 or less just find the median
        return partition5(arr)
    orig_arr = orig_arr or arr

    # find the numbers of slices
    slot_num = n/5 + (1 if n%5 else 0)

    # create array of slices
    median_slots = ([None] * slot_num)
    # and a null aux array
    aux = [None]*slot_num

    count = 0
    # fill the aux array with extremum ranges of slices
    for slot_index in xrange(0,n,5):
        aux[count] = (slot_index,(n-slot_index)%n + 5)
        count += 1

    count = 0
    # find the median for each slice of len 5 or less
    for r in aux:
        median_slots[count] = partition5(sorted(xrange(r[0], r[1]), key = lambda x: orig_arr[x]))
        count += 1

    # print "median_slots is {}".format(median_slots)
    # find the median of this median array
    return median_of_medians(median_slots, len(median_slots), orig_arr)

def swap(findex, sindex, ar):
    ar[findex], ar[sindex] = ar[sindex], ar[findex]

def partition(ar, lo, hi, pivotIndex):
    '''3 way djisktra partition method'''
    start = lo
    # take the elemet @ hi as the pivot and swap it to pivotIndex position
    swap(pivotIndex, hi, ar)
    pivotIndex = hi
    pivot = ar[pivotIndex]
    eq = lo
    for index in xrange(lo, hi):
        if (ar[eq] == pivot):
            eq += 1
        if (ar[index] < pivot and index < pivotIndex):
            swap(index, lo, ar)
            lo += 1
            eq +=1
    swap(lo, pivotIndex, ar)
    return lo

# find the kth smallest element by comparing the returned pivot index
def quickSelectIter(arr, startIndex, endIndex, k):
    stack = deque([[startIndex,endIndex]], log(endIndex-startIndex+1, 2))
    pivot = pivotIndex=0

    while (stack):
        pop = stack.pop()
        startIndex, endIndex = pop[0], pop[1]
        if (startIndex <= endIndex):
            pivot = median_of_medians(arr, endIndex-startIndex+1)
            # divide using Linear-partitioning
            pivotIndex = partition(arr, startIndex, endIndex, pivot)
            if ( pivotIndex == k ): return arr[pivotIndex]

            if (pivotIndex > k):
                stack.appendleft([startIndex, pivotIndex-1])
            elif (pivotIndex < k):
                stack.appendleft([pivotIndex+1, endIndex])

Does it look like implementing this would yield O(N) complexity?

It seems correct while running but for some cases it is not.

Lets say,

A = [34, 40, 9, 20, 62, 89, 68, 0, 90, 83, 46, 98, 6, 41, 73, 99, 35, 82, 36, 53, 70, 27, 93, 54, 64, 52, 18, 85, 58, 69, 24, 49, 25, 30, 26, 79, 55, 1, 78, 7, 8, 28, 4, 38, 71, 10, 84, 72, 50, 29, 87, 51, 37]
    l = sorted(A)
    # res= median_of_medians(A, len(A))
    # print A[res]
    for index in xrange(len(A)):
        # the i-th element
        print quickSelectIter(A, 0, len(A)-1, index+1), l[index]

so there's a bug, conceptually. What would be the Fix?