Sorting_algorithms.

py

1 import time
2 import random
3 def array(m):
4 arr=[]
5 for i in range(0,m):
6 a=random.randint(1,m*3)
7 arr.append(a)
8 return arr
9
10 def bubble_sort(a):
11 n = len(a)
12 for i in range(n):
13 for j in range(0, n-i-1):
14 if a[j] > a[j+1]:
15 a[j], a[j+1] = a[j+1], a[j]
16
17 def selection_sort(a):
18 n = len(a)
19 for i in range(n):
20 min_index = i
21 for j in range(i+1, n):
22 if a[j] < a[min_index]:
23 min_index = j
24 a[i], a[min_index] = a[min_index], a[i]
25
26 def insertion_sort(a):
27 n = len(a)
28 for i in range(n):
29 key = a[i]
30 j = i - 1
31 while j >= 0 and key < a[j]:
32 a[j+1] = a[j]
33 j -= 1
34 a[j+1] = key
35
36 def merge_sort(a):
37 n = len(a)
38 if n > 1:
39 mid = n // 2
40 left_half = a[:mid]
41 right_half = a[mid:]
42 merge_sort(left_half)
43 merge_sort(right_half)
44 i = k = j = 0
45 while i < len(left_half) and j < len(right_half):
46 if left_half[i] < right_half[j]:
47 a[k] = left_half[i]
48 i += 1
49 else:
50 a[k] = right_half[j]
51 j += 1
52 k += 1
53 while i < len(left_half):
54 a[k] = left_half[i]
55 i += 1
56 k += 1
 57 while j < len(right_half):
58 a[k] = right_half[j]
59 j += 1
60 k += 1
61
62 def quick_sort(arr):
63 if len(arr) <= 1:
64 return arr
65 pivot = arr[len(arr) // 2]
66 left = [x for x in arr if x < pivot]
67 middle = [x for x in arr if x == pivot]
68 right = [x for x in arr if x > pivot]
69 return quick_sort(left) + middle + quick_sort(right)
70
71 def Time(t):
72 start = time.perf_counter()
73 bubble_sort(array(t))
74 end = time.perf_counter()
75 print("Bubblesort")
76 print("Time taken for",t,"value is", (end - start) * 10**6, "µs")
77
78 start = time.perf_counter()
79 selection_sort(array(t))
80 end = time.perf_counter()
81 print("Selectionsort")
82 print("Time taken for",t,"value is", (end - start) * 10**6, "µs")
83
84 start = time.perf_counter()
85 insertion_sort(array(t))
86 end = time.perf_counter()
87 print("Insertionsort")
88 print("Time taken for",t,"value is", (end - start) * 10**6, "µs")
89
90 start = time.perf_counter()
91 merge_sort(array(t))
92 end = time.perf_counter()
93 print("Mergesort")
94 print("Time taken for",t,"value is", (end - start) * 10**6, "µs")
95
96 start = time.perf_counter()
97 quick_sort(array(t))
98 end = time.perf_counter()
99 print("Quicksort")
100 print("Time taken for",t,"value is", (end - start) * 10**6, "µs")
101 print()
102 print()
103 print()
104 def main():
105 Time(5)
106 Time(10)
107 Time(100)
108 Time(1000)
109 Time(10000)
110 Time(100000)
111 if __name__ == "__main__":
112 main()
searchc.py

1 import random
2 import time
3
4 ''' Array '''
5 def array(m):
6 arr=[]
7 while len(arr)<m:
8 a=random.randint(1,m*3)
9 if a not in arr:
10 arr.append(a)
11 return arr
12
13 ''' Quicksort '''
14 def quicksort(quiarr):
15 if len(quiarr) <= 1:
16 return quiarr
17 pivot = quiarr[len(quiarr) // 2]
18 left = [x for x in quiarr if x < pivot]
19 middle = [x for x in quiarr if x == pivot]
20 right = [x for x in quiarr if x > pivot]
21 return quicksort(left) + middle + quicksort(right)
22
23 ''' Linear Search '''
24 def linearsearch(arr, lsea):
25 for i in range(len(arr)):
26 if arr[i] == lsea:
27 return lsea,'found at index',i
28 return lsea,'not found'
29
30 ''' Binary Search '''
31 def binarysearch(arr, bsea):
32 left, right = 0, len(arr) - 1
33
34 while left <= right:
35 mid = left + (right - left) // 2
36
37 if arr[mid] == bsea:
38 return bsea,'found at index',mid
39 elif arr[mid] < bsea:
40 left = mid + 1
41 else:
42 right = mid - 1
43
44 return bsea,'not found'
45
46 ''' calculat time '''
47 def Time(t):
48 print("Time taken to Search From",t,"value in Microsecond")
49 print()
50 ''' For Linear Search '''
51 arr=array(t)
52 lbc = arr[0]
53 lac = arr[len(arr)//2]
54 lwc = arr[len(arr)-1]
55
56 ''' For Binary Search '''
57 sarr=quicksort(arr)
58 bbc = sarr[len(sarr)//2]
59 bac = sarr[len(sarr)//128]
60 bwc = sarr[len(sarr)-1]
61
62 start = time.perf_counter()
63 linearsearch(arr, lwc)
64 end = time.perf_counter()
65 print("Linear Search Worst Case =", (end - start) * 10**6, "µs")
66 start = time.perf_counter()
67 linearsearch(arr, lac)
68 end = time.perf_counter()
69 print("Linear Search Average Case =", (end - start) * 10**6, "µs")
70 start = time.perf_counter()
71 linearsearch(arr, lbc)
72 end = time.perf_counter()
73 print("Linear Search Best Case =", (end - start) * 10**6, "µs")
74
75 start = time.perf_counter()
76 binarysearch(arr, bwc)
77 end = time.perf_counter()
78 print("Binary Search Worst Case =", (end - start) * 10**6, "µs")
79 start = time.perf_counter()
80 binarysearch(arr, bac)
81 end = time.perf_counter()
82 print("Binary Search Average Case =", (end - start) * 10**6, "µs")
83 start = time.perf_counter()
84 binarysearch(arr, bbc)
85 end = time.perf_counter()
86 print("Binary Search Best Case =", (end - start) * 10**6, "µs")
87
88 def main():
89 Time(25000)
90 if __name__ == "__main__":
91 main()
max-heap.py

1 import time
2 import random
3
4 def array(m):
5 arr=[]
6 for i in range(0,m):
7 a=random.randint(1,m*3)
8 arr.append(a)
9 return arr
10
11 def heapify(arr, n, i):
12 largest = i
13 left = 2 * i + 1
14 right = 2 * i + 2
15 if left < n and arr[left] > arr[largest]:
16 largest = left
17 if right < n and arr[right] > arr[largest]:
18 largest = right
19 if largest != i:
20 arr[i], arr[largest] = arr[largest], arr[i]
21 heapify(arr, n, largest)
22
23 def heap_sort(arr):
24 n = len(arr)
25 for i in range(n // 2 - 1, -1, -1):
26 heapify(arr, n, i)
27 for i in range(n - 1, 0, -1):
28 arr[0], arr[i] = arr[i], arr[0]
29 heapify(arr, i, 0)
30
31 def Time(t):
32 print("Time taken to sort",t,"value using Heap Sort in Microsecond")
33 print()
34 start = time.perf_counter()
35 heap_sort(array(t))
36 end = time.perf_counter()
37 print("Heap Sort =", (end - start) * 10**6, "µs")
38 print()
39 print()
40
41 def main():
42 Time(5)
43 Time(10)
44 Time(100)
45 Time(1000)
46 Time(10000)
47 Time(100000)
48 if __name__ == "__main__":
49 main()