Python testalgo Examples

Example #1

File: mediansort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

def selectKth(A, k, l, r):
    idx = selectPivotIndex(A, l, r)
    pivotIdx = partition(A, l, r, idx)

    if l + k - 1 == pivotIdx:
        return pivotIdx

    if l + k - 1 < pivotIdx:
        return selectKth(A, k, l, pivotIdx - 1)
    else:
        return selectKth(A, k - (pivotIdx - l + 1), pivotIdx + 1, r)


#! Note there is also a non-recursive way to implment this
def mediansort(A, l, r):
    if r <= l:
        return

    mid = int((r - l + 1) / 2)
    me = selectKth(A, mid + 1, l, r)

    mediansort(A, l, l + mid - 1)
    mediansort(A, l + mid + 1, r)


#-- Run -------------------------------------#

if __name__ == "__main__":

    testalgo(mediansort)

Example #2

File: bucketsort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

		insertionsort( B[i], 0, len(B[i]) )

		for m in range(0,len(B[i])):

			A[idx] = B[i][m]
			idx += 1

def bucketsort( A ):

	# Purely for demonstation purposes
	hashN = 5 

	B = [ [] for _ in xrange(hashN) ]

	for i in range(0,len(A)):
		k = hash(A[i], hashN )
		B[k].append( A[i] )

	extract( B, A )

#-- Run ----------------------#

if __name__ == "__main__":

	testalgo( bucketsort )

Example #3

File: quicksort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

def selectPivotIndex(A, l, r):
    return int((l + r) / 2)


def partition(A, l, r):
    p = selectPivotIndex(A, l, r)
    swap(A, p, r)
    store = l
    for i in range(l, r):
        if cmp(A[i], A[r]) <= 0:
            swap(A, i, store)
            store += 1
    swap(A, store, r)
    return store


def quicksort(A, l, r):
    if l < r:
        pi = partition(A, l, r)
        quicksort(A, l, pi - 1)
        quicksort(A, pi + 1, r)


#-- Run -------------------------------------#

if __name__ == "__main__":

    testalgo(quicksort)

Example #4

File: insertionsort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

use for small and nearly sorted arrays

works by expanding sorted area one element
at a time.
'''

from common import cmp, randomArray, testalgo

#-- Methods -------------------------------------#


def insert(arr, idx):
    i = idx - 1
    val = arr[idx]
    while i >= 0 and cmp(arr[i], val) > 0:
        arr[i + 1] = arr[i]
        i -= 1
    arr[i + 1] = val


def insertionsort(arr, l, r):
    for j in range(1, len(arr)):
        insert(arr, j)


#-- Run -------------------------------------#

if __name__ == "__main__":

    testalgo(insertionsort)

Example #5

File: quicksort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

from common import cmp, swap, log, testalgo

#-- Methods -------------------------------------#

def selectPivotIndex(A,l,r):
	return int( (l+r)/2 )

def partition(A,l,r):
	p = selectPivotIndex(A,l,r)
	swap(A,p,r)
	store = l
	for i in range(l,r):
		if cmp(A[i], A[r]) <= 0:
			swap(A,i,store)
			store += 1
	swap(A,store,r)
	return store
 
def quicksort( A, l, r ):
	if l < r:
		pi = partition(A,l,r)
		quicksort(A,l,pi-1)
		quicksort(A,pi+1,r)

#-- Run -------------------------------------#

if __name__ == "__main__":

	testalgo( quicksort )

Example #6

File: mediansort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

	return int( (l+r)/2 )

def selectKth(A, k, l, r):
	idx = selectPivotIndex(A,l,r)
	pivotIdx = partition(A,l,r,idx)

	if l+k-1 == pivotIdx:
		return pivotIdx

	if l+k-1 < pivotIdx :
		return selectKth(A, k, l, pivotIdx-1)
	else:
 		return selectKth(A, k-(pivotIdx-l+1), pivotIdx+1, r)

#! Note there is also a non-recursive way to implment this
def mediansort( A, l, r ):
	if r <= l:
		return

	mid = int( (r-l+1)/2 )
	me = selectKth(A, mid+1, l, r)

	mediansort( A, l, l+mid-1)
	mediansort(A, l+mid+1, r)

#-- Run -------------------------------------#

if __name__ == "__main__":

	testalgo( mediansort )

Example #7

File: heapsort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

    l = 2 * idx + 1
    r = 2 * idx + 2
    if l < max and A[l] > A[idx]:
        largest = l
    else:
        largest = idx
    if r < max and A[r] > A[largest]:
        largest = r
    if largest != idx:
        swap(A, idx, largest)
        heapify(A, largest, max)


def buildHeap(A):
    for i in range(int(len(A) / 2) - 1, -1, -1):  # range is [ |n/2|-1 ... 0 ]
        heapify(A, i, len(A))


def heapsort(A, l, r):  # note l and r not used here
    buildHeap(A)
    for i in range(len(A) - 1, 0, -1):  # range is [ n-1 ... 0 ]
        swap(A, 0, i)
        heapify(A, 0, i)


#-- Run -------------------------------------#

if __name__ == "__main__":

    testalgo(heapsort)

Example #8

File: insertionsort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

'''>
insertion sort
use for small and nearly sorted arrays

works by expanding sorted area one element
at a time.
'''

from common import cmp, randomArray, testalgo

#-- Methods -------------------------------------#

def insert( arr, idx ):
	i = idx - 1
	val = arr[idx]
	while i >=0 and cmp( arr[i], val ) > 0 :
		arr[i+1] = arr[i]
		i -= 1	
	arr[i+1] = val

def insertionsort( arr, l, r ):
	for j in range(1, len(arr)):
		insert( arr, j )

#-- Run -------------------------------------#

if __name__ == "__main__":

	testalgo( insertionsort )

Example #9

File: heapsort.py Project: jeffreyleblanc/algorithms_in_a_nutshell

def heapify(A,idx,max):
	l = 2*idx+1
	r = 2*idx+2
	if l < max and A[l] > A[idx] :
		largest = l
	else:
		largest = idx
	if r < max and A[r] > A[largest] :
		largest = r
	if largest != idx :
		swap( A, idx, largest )
		heapify( A, largest, max)

def buildHeap(A):
	for i in range(int(len(A)/2)-1,-1,-1): # range is [ |n/2|-1 ... 0 ]
		heapify(A,i,len(A))

def heapsort(A, l, r): # note l and r not used here
	buildHeap(A)
	for i in range(len(A)-1,0,-1): # range is [ n-1 ... 0 ]
		swap(A,0,i)
		heapify(A,0,i)

#-- Run -------------------------------------#

if __name__ == "__main__":

	testalgo( heapsort )