def test_rand1(self):
randints = []
for _ in range(1000):
randints.append(randint(1, 9999))
a = randints.copy()
num_cmps = 0
qsort(a, 0, len(a) - 1, num_cmps)
randints.sort()
self.assertEqual(a, randints)
def test_txt(self):
a = []
with open('QuickSort.txt') as file:
a = [int(x) for x in file]
exp_arr = a.copy()
exp_arr.sort()
num_cmps = 0
qsort(a, 0, len(a) - 1, num_cmps)
self.assertEqual(a, exp_arr)
def generateGameResult():
# player 1 always win, player 1 is the lowest-valued ID defined below
global myGameConf
numToPlayerID = {}
convertedNum = []
for pid in myGameConf.gamePlyrs:
convertedNum += [sum([ord(i) for i in str(pid)])]
numToPlayerID[convertedNum[-1]] = pid
qsort.qsort(convertedNum)
winner = numToPlayerID[convertedNum[0]]
thisResList = plyrResList([plyrRes(playerID, 1) if playerID == winner else plyrRes(playerID, 0) for playerID in myGameConf.gamePlyrs])
return thisResList
def test_qsort(self):
for i in range(30):
list_wait_to_sort = [
random.randint(-1000, 1000) for i in range(100)
]
self.failUnless(
sorted(list_wait_to_sort) == qsort(list_wait_to_sort))
def main():
# Read each test case
line = sys.stdin.readline()
items = line.strip().split()
# print(items)
orig = list(items)
# print(orig)
#print(items)
result = qsort(items)
if items != sorted(orig):
print("The list is not sorted.")
else:
print(result)
def main():
algorithms = {
'sorted': sorted,
'np_quicksort': lambda a: np.sort(a, kind='quicksort'),
'np_mergesort': lambda a: np.sort(a, kind='mergesort'),
'np_insertionsort': lambda a: insertion_sort(a),
'np_selectionsort': lambda a: selection_sort(a),
'np_qsort': lambda a: qsort(a)
}
sizes = list(range(1, 50, 5)) + list(range(200, 1000, 50))
avg_time = {alg: [] for alg in algorithms}
for sz in tqdm(sizes):
for alg_name, f in algorithms.items():
avg_time[alg_name].append(measure_search_time(f, sz, 20))
for alg_name in algorithms:
plt.plot(sizes, avg_time[alg_name], label=alg_name)
plt.legend()
plt.ylim(0.1)
plt.show()
def main():
ls = [100 * n for n in xrange(50)]
algo = [
('insertionsort', insertion_sort, True),
('heapsort', heapsort, False),
('mergesort', mergesort, False),
('qsort', lambda v: qsort(v, 0, len(v) - 1), True),
('counting_sort', csort, False),
('radix_sort', radix_sort, False),
('bucket_sort', bucket_sort, False),
]
res = {}
for algo_name, algo_f, in_place in algo:
print algo_name
res[algo_name] = []
for l in ls:
print l
v = [random.randint(0, 100) for _ in xrange(l)]
nrep = 3
tot = []
for _ in xrange(nrep):
if in_place:
w = v[:]
t1 = time.time()
algo_f(w)
t2 = time.time()
else:
t1 = time.time()
w = algo_f(v)
t2 = time.time()
assert w == sorted(v), "%s, %s" % (w, sorted(v))
tot.append(t2 - t1)
res[algo_name].append((l, min(tot)))
# references
res['n'] = [(l, l) for l in ls]
res['n_log_n'] = [(l, l * log(l + .1)) for l in ls]
res['n2'] = [(l, l * l) for l in ls]
return res
def testQSortNormalList(self):
A = [3, 5, 7, 1, 3, 6, 7]
qsort.qsort(A)
self.assertEqual(A, [1, 3, 3, 5, 6, 7, 7])
def testQSortEmptyList(self):
A = []
qsort.qsort(A)
self.assertEqual(A, [])
def sort(numbers):
#numbers.sort()
qs.qsort(numbers)
def testQSortEmptyList(self):
A = []
qsort.qsort(A)
self.assertEqual(A, [])
#!/usr/bin/python3
import random
import qsort
A = [random.randrange(0, 10) for i in range(10)]
qsort.qsort(A)
print(A)
B = [{'value': random.randrange(0,10)} for i in range(10)]
qsort.qsort(B, key=lambda x: -x['value'])
print(B)
def test_2_elems(self):
self.assertEquals([3, 5], qsort([5, 3]))
def test_qsort(self):
self.assertEqual([-90, 2, 3, 4, 10], qsort(lambda x, y: x < y, [2, 4, -90, 3, 10]))
self.assertEqual([10, 4, 3, 2, -90], qsort(lambda x, y: x > y, [2, 4, -90, 3, 10]))
def test_qsort(self):
self.assertEqual([-90, 2, 3, 4, 10],
qsort(lambda x, y: x < y, [2, 4, -90, 3, 10]))
self.assertEqual([10, 4, 3, 2, -90],
qsort(lambda x, y: x > y, [2, 4, -90, 3, 10]))
def test_slencmp(self):
self.assertEqual(['int', 'long', 'short', 'double'], qsort(slencmp, ["short", "double", "int", "long"]))
def test_1_elem(self):
self.assertEquals([5], qsort([5]))
def test_empty(self):
self.assertEquals([], qsort([]))
def test_many_elems(self):
self.assertEquals([1, 2, 3, 3, 5, 9], qsort([5, 3, 9, 3, 2, 1]))
def test_slencmp(self):
self.assertEqual(['int', 'long', 'short', 'double'],
qsort(slencmp, ["short", "double", "int", "long"]))
def insitu():
perm = list(range(len(obj)))
qsort(perm, key=lambda i: obj[i])
rearrange(obj, perm)
def check():
arr = gen_arr(50, 10)
qsort.qsort(arr)
return _checkfun(arr)
def test_qsort1(self):
a = [3, 8, 2, 5, 1, 4, 7, 6]
num_cmps = 0
qsort(a, 0, len(a) - 1, num_cmps)
self.assertEqual([1, 2, 3, 4, 5, 6, 7, 8], a)
def normal():
qsort(obj)
#!/usr/bin/python3
import random
import qsort
A = [random.randrange(0, 10) for i in range(10)]
qsort.qsort(A)
print(A)
B = [{'value': random.randrange(0, 10)} for i in range(10)]
qsort.qsort(B, key=lambda x: -x['value'])
print(B)
free(v);
}
}
Py_INCREF(Py_None);
return Py_None;
}
static PyMethodDef qsortMethods[] = {
{ "qsort", pyqsort, METH_VARARGS },
{ NULL, NULL }
};
__declspec(dllexport) void initqsort(void) {
PyObject *m;
m = Py_InitModule("qsort", qsortMethods);
}
In Python
ActivePython 2.1, build 210 ActiveState)
based on Python 2.1 (#15, Apr 23 2001, 18:00:35) [MSC 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import qsort
>>> a = [9, 3, 5, 4, 1]
>>> def revcmp(a, b): return cmp(b, a)
...
>>> qsort.qsort(a, revcmp)
>>> a
[9, 5, 4, 3, 1]
>>>
from stack import Stack
# search
sorted_data = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
73, 79, 83, 89, 97
]
print(binary_search(sorted_data, 37, 0, 24))
# sorting
unsorted_data = [
13, 17, 19, 23, 29, 59, 61, 67, 71, 2, 3, 5, 7, 11, 31, 37, 41, 43, 47, 53,
73, 79, 83, 89, 97
]
print(selection_sort(unsorted_data))
print(qsort(unsorted_data))
# Stack
s = Stack()
print(s)
s.push(42)
print(s)
s.pop()
print(s)
# HashTable
h = HashTable()
print(h)
h.set('name', 'Jesus')
print(h)
print(h.get('name'))
temp = self.A[r + 1]
self.A[r + 1] = x
self.A[q] = temp
return r + 1
def subFind(self, i, p, q):
if p < q:
r = self.partition(p, q)
if i + p == r + 1:
return self.A[r]
elif i + p < r + 1:
return self.subFind(i, p, r - 1)
else:
return self.subFind(i - (r - p) - 1, r + 1, q)
if p == q:
return self.A[p]
def find(self, i):
if i < 1 or i > len(A):
return "invalid parameter"
return self.subFind(i, 0, len(self.A) - 1)
if __name__ == "__main__":
A = list((2, 3, 9, 4, 10, 4))
fd = findithminmal(A)
qa = qsort(A)
print(fd.find(7))
print(qa.sort())
def test_Basics(self):
self.assertEqual(qsort([1, 2, 3]), [1, 2, 3])
self.assertEqual(qsort([3, 2, 1]), [1, 2, 3])
self.assertEqual(qsort([1]), [1])
self.assertEqual(qsort([2, 1]), [1, 2])
self.assertEqual(qsort([2, 1, 6, 7, 7, 2, 8, 1, 99, 4, 9, 16]), [1, 1, 2, 2, 4, 6, 7, 7, 8, 9, 16, 99])
def testQSortNormalList(self):
A = [3,5,7,1,3,6,7]
qsort.qsort(A)
self.assertEqual(A, [1,3,3,5,6,7,7])
def do_qsort():
arr = read_array(args.input)
qsort(arr, 0, len(arr) - 1)
print_array(args.output, arr)
