Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 11b367f

Browse files
Add files via upload
1 parent c9643d6 commit 11b367f

File tree

4 files changed

+208
-0
lines changed

4 files changed

+208
-0
lines changed

‎Main.py‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
"""
2+
about:
3+
This code was written by Mostafa El-Marzouki @iSuperMostafa
4+
------------------------------------------------------------
5+
summery:
6+
this project is a performance comparison among bunch of sorting algorithms
7+
it computes the time used in each algorithm to sort list of: Sorted numbers
8+
and Unsorted numbers
9+
input: the size of the numbers list
10+
output: the time each algorithm take to sort the numbers in ms
11+
"""
12+
import Manage
13+
14+
Manage = Manage.Manage()
15+
16+
print("Number size must be more than 5000 to notice the difference among the algorithms! \n"
17+
"Output is measured in seconds")
18+
while True:
19+
Manage.FillRandom(int(input("Numbers size: ")))
20+
Time = Manage.Sort()
21+
for Type, TypeValue in Time.items():
22+
print("--------------------\n"
23+
"-", Type, "-\n"
24+
"--------------------")
25+
for Sort, SortValue in TypeValue.items():
26+
print(Sort, " : ", SortValue)

‎Manage.py‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
"""
2+
about:
3+
This code was written by Mostafa El-Marzouki @iSuperMostafa
4+
------------------------------------------------------------
5+
summery:
6+
this project is a performance comparison among bunch of sorting algorithms
7+
it computes the time used in each algorithm to sort list of: Sorted numbers
8+
and Unsorted numbers
9+
input: the size of the numbers list
10+
output: the time each algorithm take to sort the numbers in ms
11+
"""
12+
import random, time
13+
import SortingAlgorithms
14+
15+
16+
Sort = SortingAlgorithms.SortingAlgorithms()
17+
class Manage:
18+
# fill Numbers.txt with random numbers
19+
def FillRandom(self, Size):
20+
open("data/UnsortedNumbers.txt", 'w').close()
21+
with open("data/UnsortedNumbers.txt", "w") as handle:
22+
for i in range(Size):
23+
print(random.randint(1, 10000), file=handle)
24+
25+
def ReadNumbers(self, File):
26+
Numbers = []
27+
with open("data/" + File) as Lines:
28+
for Line in Lines:
29+
Numbers.append(int(Line))
30+
return Numbers
31+
32+
# calculate the execution time of function
33+
def ExecutionTime(self, fun, *args):
34+
StartTime = int(round(time.time() * 1000))
35+
fun(args[0])
36+
EndTime = int(round(time.time() * 1000))
37+
return (EndTime - StartTime)
38+
39+
# apply the sorting algorithms on the random numbers we just generated in Numbers.txt
40+
def Sort(self):
41+
Numbers = []
42+
SortingTimes = {"UnsortedNumbers": {"BubbleSort": 0, "SelectionSort": 0, "InsertionSort": 0,
43+
"ShellSort": 0, "MergeSort": 0, "QuickSort": 0},
44+
"SortedNumbers": {"BubbleSort": 0, "SelectionSort": 0, "InsertionSort": 0,
45+
"ShellSort": 0, "MergeSort": 0, "QuickSort": 0}}
46+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
47+
SortingTimes['UnsortedNumbers']['BubbleSort'] = str(self.ExecutionTime(Sort.BubbleSort, Numbers)) + ' ms'
48+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
49+
SortingTimes['UnsortedNumbers']['SelectionSort'] = str(self.ExecutionTime(Sort.SelectionSort, Numbers)) + ' ms'
50+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
51+
SortingTimes['UnsortedNumbers']['InsertionSort'] = str(self.ExecutionTime(Sort.InsertionSort, Numbers)) + ' ms'
52+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
53+
SortingTimes['UnsortedNumbers']['ShellSort'] = str(self.ExecutionTime(Sort.ShellSort, Numbers)) + ' ms'
54+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
55+
SortingTimes['UnsortedNumbers']['MergeSort'] = str(self.ExecutionTime(Sort.MergeSort, Numbers)) + ' ms'
56+
Numbers = self.ReadNumbers("UnsortedNumbers.txt")
57+
SortingTimes['UnsortedNumbers']['QuickSort'] = str(self.ExecutionTime(Sort.QuickSort, Numbers)) + ' ms'
58+
SortingTimes['SortedNumbers']['BubbleSort'] = str(self.ExecutionTime(Sort.BubbleSort, Numbers)) + ' ms'
59+
SortingTimes['SortedNumbers']['SelectionSort'] = str(self.ExecutionTime(Sort.SelectionSort, Numbers)) + ' ms'
60+
SortingTimes['SortedNumbers']['InsertionSort'] = str(self.ExecutionTime(Sort.InsertionSort, Numbers)) + ' ms'
61+
SortingTimes['SortedNumbers']['ShellSort'] = str(self.ExecutionTime(Sort.ShellSort, Numbers)) + ' ms'
62+
SortingTimes['SortedNumbers']['MergeSort'] = str(self.ExecutionTime(Sort.MergeSort, Numbers)) + ' ms'
63+
SortingTimes['SortedNumbers']['QuickSort'] = str(self.ExecutionTime(Sort.QuickSort, Numbers)) + ' ms'
64+
return SortingTimes

‎SortingAlgorithms.py‎

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,108 @@
1+
"""
2+
about:
3+
This code was written by Mostafa El-Marzouki @iSuperMostafa
4+
------------------------------------------------------------
5+
summery:
6+
this project is a performance comparison among bunch of sorting algorithms
7+
it computes the time used in each algorithm to sort list of: Sorted numbers
8+
and Unsorted numbers
9+
input: the size of the numbers list
10+
output: the time each algorithm take to sort the numbers in ms
11+
"""
12+
import random
13+
14+
15+
class SortingAlgorithms:
16+
# Time Complexity of Bubble Sort:
17+
# Best: O(n^2), Average: O(n^2), Worst: O(n^2)
18+
def BubbleSort(self, Numbers):
19+
for i in range(len(Numbers)):
20+
for j in range(len(Numbers)-1, i, -1):
21+
if (Numbers[j] < Numbers[j-1]):
22+
Numbers[j], Numbers[j - 1] = Numbers[j - 1], Numbers[j]
23+
24+
# Time Complexity of Selection Sort:
25+
# Best: O(n^2), Average: O(n^2), Worst: O(n^2)
26+
def SelectionSort(self, Numbers):
27+
for i in range(len(Numbers)):
28+
Min = i
29+
for j in range(i+1, len(Numbers)):
30+
if Numbers[j] < Numbers[Min]:
31+
Min = j
32+
Numbers[i], Numbers[Min] = Numbers[Min], Numbers[i]
33+
34+
# Time Complexity of Insertion Sort:
35+
# Best: O(n), Average: O(n^2), Worst: O(n^2)
36+
def InsertionSort(self, Numbers):
37+
for i in range(len(Numbers)):
38+
Temp = Numbers[i]
39+
j = i
40+
while j > 0 and Temp < Numbers[j-1]:
41+
Numbers[j] = Numbers[j-1]
42+
j -= 1
43+
Numbers[j] = Temp
44+
45+
# Time Complexity of Shell Sort:
46+
# Best: O(n), Average: O(n),Worst: O(n^2)
47+
def ShellSort(self, Numbers):
48+
Gap = len(Numbers)//2
49+
while Gap:
50+
for i in range(len(Numbers)):
51+
j = i
52+
Temp = Numbers[i]
53+
while j >= Gap and Numbers[j-Gap] > Temp:
54+
Numbers[j] = Numbers[j-Gap]
55+
j -= Gap
56+
Numbers[j] = Temp
57+
Gap = Gap // 2 if Gap // 2 else (0 if Gap == 1 else 1)
58+
59+
# Time Complexity of Merge Sort: O(nlog(n))
60+
def MergeSort(self, Numbers):
61+
if len(Numbers) > 1:
62+
Center = len(Numbers)//2
63+
LeftHandSide = Numbers[:Center]
64+
RightHandSide = Numbers[Center:]
65+
self.MergeSort(LeftHandSide)
66+
self.MergeSort(RightHandSide)
67+
i = 0
68+
j = 0
69+
k = 0
70+
while i < len(LeftHandSide) and j < len(RightHandSide):
71+
if LeftHandSide[i] < RightHandSide[j]:
72+
Numbers[k] = LeftHandSide[i]
73+
i = i + 1
74+
else:
75+
Numbers[k] = RightHandSide[j]
76+
j = j + 1
77+
k = k + 1
78+
while i < len(LeftHandSide):
79+
Numbers[k] = LeftHandSide[i]
80+
i = i + 1
81+
k = k + 1
82+
while j < len(RightHandSide):
83+
Numbers[k] = RightHandSide[j]
84+
j = j + 1
85+
k = k + 1
86+
87+
# Time Complexity of Quick Sort:
88+
# Best: O(nlog(n)), Average: O(nlog(n)), Worst: O(n^2)
89+
def Partition(self, Values, LeftHandSide, RightHandSide):
90+
def partition(Values, LeftHandSide, RightHandSide, PivotIndex):
91+
pivot = Values[PivotIndex]
92+
Values[RightHandSide], Values[PivotIndex] = Values[PivotIndex], Values[RightHandSide]
93+
storeidx = LeftHandSide
94+
for idx in range(LeftHandSide, RightHandSide):
95+
if Values[idx] < pivot:
96+
Values[idx], Values[storeidx] = Values[storeidx], Values[idx]
97+
storeidx += 1
98+
Values[storeidx], Values[RightHandSide] = Values[RightHandSide], Values[storeidx]
99+
return storeidx
100+
if RightHandSide > LeftHandSide:
101+
PivotIndex = random.randint(LeftHandSide, RightHandSide)
102+
PivotIndex = partition(Values, LeftHandSide, RightHandSide, PivotIndex)
103+
self.Partition(Values, LeftHandSide, PivotIndex)
104+
self.Partition(Values, PivotIndex + 1, RightHandSide)
105+
return Values
106+
107+
def QuickSort(self, Numbers):
108+
return self.Partition(Numbers, 0, len(Numbers) - 1)

‎data/UnsortedNumbers.txt‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
9642
2+
7814
3+
4981
4+
9901
5+
2414
6+
2708
7+
1961
8+
8026
9+
4035
10+
8879

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /