one-file-projects/sorting_algorithms.py

from random import randint
from time import clock
from sys import argv

class SortAlgorithm(object):
    def __init__(self):
    	self.swaps = 0
    	self.vgls = 0

    def sort(self,a):
    	raise Exception("Fail")

    def swap(self,a,i,j):
    	self.swaps += 1
    	a[i],a[j] = a[j],a[i]

    def set(self,a,i,v):
    	self.swaps += 1
    	a[i] = v

    def vgl(self,b):
    	self.vgls += 1
    	return b

class BubbleSort(SortAlgorithm):
    def sort(self,a):
    	n = len(a)
    	swapped = True
    	while swapped and n > 1:
    		swapped = False
    		for i in range(0,n-1):
    			if self.vgl(a[i] > a[i+1]):
    				self.swap(a,i,i+1)
    				swapped = True
    		n-=1
    	return a

class InsertSort(SortAlgorithm):
    def sort(self,a):
    	for i in range(1,len(a)):
    		t = a[i]
    		j = i-1
    		while j >= 0 and self.vgl(a[j] > t):
    			self.set(a,j,a[j+1])
    			j-=1
    		#a[j+1] = t
    		self.set(a, j+1, t)
    	return a

class QuickSort(SortAlgorithm):
    def sort(self,a):
    	self.qsort(a, 0, len(a)-1)
    	return a

    def qsort(self,a, left, right):
    	if left < right:
    		pivot = self.seperate(a, left, right)
    		self.qsort(a, left, pivot - 1)
    		self.qsort(a, pivot+1, right)

    def seperate(self, a, left, right):
    	i = left
    	j = right-1
    	pivot = a[right]

    	while i < j:
    		while self.vgl(a[i] <= pivot) and i < right: i+=1
    		while self.vgl(a[j] >= pivot) and j > left: j-=1

    		if i < j:
    			self.swap(a,i,j)

    	if a[i] > pivot:
    		self.swap(a,i,right)

    	return i

class HeapSort(SortAlgorithm):
    def sort(self,a):
    	self.heapsort(a)
    	return list(reversed(a))

    def heapify(self, data, i, w):
    	#indexes = filter(lambda v: v < w, [i,2*(i+1)-1,2*(i+1)])
    	#largest = max(indexes,key=lambda v: data[v])
    	r = 2*(i+1)
    	l = r-1
    	largest = i
    	if l < w and self.vgl(data[l] < data[largest]):
    		largest = l
    	if r < w and self.vgl(data[r] < data[largest]):
    		largest = r
    	if largest != i:
    		self.swap(data,i,largest)
    		self.heapify(data, largest, w)

    def build_heap(self, data):
    	w = len(data)
    	i = int(w/2-1)
    	while i>=0:
    		self.heapify(data, i, w)
    		i-=1

    def heapsort(self,data):
    	self.build_heap(data)
    	i = len(data)-1
    	while i > 0:
    		self.swap(data,i,0)
    		self.heapify(data, 0, i)
    		i-=1

class MergeSort(SortAlgorithm):
    def sort(self, a):
    	return self.mergesort(a)

    def mergesort(self,a):
    	if len(a) <= 1:
    		return a
    	else:
    		n = int(len(a)/2);
    		return self.merge(self.mergesort(a[:n] or []), self.mergesort(a[n:] or []))

    def merge(self,a,b):
    	l = []
    	while True:
    		if len(a) == 0:
    			l += b
    			break
    		if len(b) == 0:
    			l += a
    			break

    		if self.vgl(a[0] < b[0]):
    			l.append(a[0])
    			a = a[1:]
    		else:
    			l.append(b[0])
    			b = b[1:]
    		self.swaps+=1
    	return l

class ShellSort(SortAlgorithm):
    def sort(self,a):
    	spalten = [2147483647, 1131376761, 410151271, 157840433, 58548857, 21521774, 8810089, 3501671, 1355339, 543749, 213331,
    	84801, 27901, 11969, 4711, 1968, 815, 271, 111, 41, 13, 4, 1]

    	for k in range(0,23):
    		h = spalten[k]
    		for i in range(h,len(a)):
    			t = a[i]
    			j = i
    			while j>=h and self.vgl(a[j-h]>t):
    				#a[j] = a[j-h]
    				self.swap(a,j,j-h)
    				j-=h
    			a[j] = t
    	return a

class SelectSort(SortAlgorithm):
    def sort(self,a):
    	n = len(a)
    	left = 0
    	while left < n:
    		m = left
    		for i in range(left,n):
    			if self.vgl(a[i] < a[m]):
    				m = i
    		self.swap(a,m,left)
    		left+=1
    	return a

class SortTester:
    def __init__(self, algorithms):
    	self.algorithms = algorithms

    def test(self, size=1000):
    	results = {}

    	data = list([ randint(0, size) for i in range(0,size) ])

    	for algorithm in self.algorithms:
    		print("Testing %s..." % algorithm.__name__)
    		inst = algorithm()
    		c = data[:]
    		s = inst.sort(c)
    		if not SortedTest().test(s):
    			raise Exception(algorithm.__name__+" failed to sort")
    		results[algorithm] = (inst.vgls,inst.swaps)

    	return results

class SortedTest:
    def test(self, a):
    	v = a[0]
    	for n in a[1:]:
    		if v > n:
    			return False
    		v = n
    	return True

def main():
    try:
    	size = int( argv[1])
    except Exception:
    	size= 1000
    result = SortTester(list( SortAlgorithm.__subclasses__() )).test(size=size)
    for cls, r in sorted(result.items(),key=lambda e: e[1][0]+e[1][1]):
    	print("%-12s: %10d, %10d compares, %10d swaps" % (cls.__name__, r[0]+r[1], r[0],r[1]))

def test():
    print(HeapSort().sort([randint(0,500) for i in range(0,100)]))

if __name__ == '__main__':
    main()