algorithm

Author: imgagandeep

001-linear-search.py

@@ -0,0 +1,18 @@
+# Linear Search Algorithm
+
+pos = 0
+def linearsearch(list, n):
+    i = 0
+    for i in range(len(list)):
+        if list[i] == n:
+            globals()['pos'] = i
+            return True
+        i = i + 1
+    return False
+
+list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+n = 6
+if linearsearch(list, n):
+    print("Found at position: ", pos)
+else:
+    print("Not Found in list")

002-binary-search.py

@@ -0,0 +1,29 @@
+# Binary Search Algorithm
+
+pos = 0
+def binarysearch(list, n):
+    # l -> lower bound
+    l = 0
+
+    # u -> upper bound
+    u = len(list) - 1
+
+    while l <= u:
+        # mid -> mid value
+        mid = (l + u) // 2
+        if list[mid] == n:
+            globals()['pos'] = mid
+            return True
+        else:
+            if list[mid] < n:
+                l = mid + 1
+            else:
+                u = mid - 1
+    return False
+
+list = [4,7,8,12,45,99,102,702,10987,56666]
+n = 99
+if binarysearch(list, n):
+    print("Found at position: ", pos+1)
+else:
+    print("Not Found in list")

003-depth-first-search.py

@@ -0,0 +1,22 @@
+# Depth First Search algorithm
+
+graph = {
+    'A' : ['B', 'S'],
+    'B' : ['A'],
+    'C' : ['D', 'E', 'F', 'S'],
+    'D' : ['C'],
+    'E' : ['C', 'H'],
+    'F' : ['C', 'G'],
+    'G' : ['F', 'S'],
+    'H' : ['E', 'G'],
+    'S' : ['A', 'C', 'G'],
+}
+
+def dfs(graph, node, visited):
+    if node not in visited:
+        visited.append(node)
+        for i in graph[node]:
+            dfs(graph, i, visited)
+    return visited
+visited = dfs(graph, 'A', [])
+print(visited)

004-breadth-first-search.py

@@ -0,0 +1,27 @@
+# Breadth First Search Algorithm
+
+graph = {
+    'A': ['B', 'C', 'E'],
+    'B': ['A','D', 'E'],
+    'C': ['A', 'F', 'G'],
+    'D': ['B'],
+    'E': ['A', 'B','D'],
+    'F': ['C'],
+    'G': ['C']
+}
+visited = []
+queue = []
+
+def bfs(visited, graph, node):
+    visited.append(node)
+    queue.append(node)
+    
+    while queue:
+        s = queue.pop(0)
+        print(s, end = " ")
+        for neighbour in graph[s]:
+            if neighbour not in visited:
+                visited.append(neighbour)
+                queue.append(neighbour)
+
+bfs(visited, graph, 'A')

005-bubble-sort.py

@@ -0,0 +1,11 @@
+# Bubble Sort Algorithm
+
+def bubblesort(nums):
+    for i in range(len(nums) - 1, 0, -1):
+        for j in range(i):
+            if nums[j] > nums[j+1]:
+                nums[j], nums[j+1] = nums[j+1], nums[j]
+
+nums = [5, 45, 8, 6, 7, 3, 2, 1, 0]
+bubblesort(nums)
+print("Sorted Array in asc order: ", nums)

006-selection-sort.py

@@ -0,0 +1,15 @@
+# Selection Sort Algorithm
+
+def selectionsort(nums):
+    for i in range(len(nums)):
+        minpos = i
+        for j in range(i + 1, len(nums)):
+            if nums[j] < nums[minpos]:
+                minpos = j
+        nums[i], nums[minpos] = nums[minpos], nums[i]
+        # print(nums)
+
+nums = [5, 3, 8, 9, 7, 2, 0, 4, 1, 6]
+print("Unsorted list: ", nums)
+selectionsort(nums)
+print("Sorted list:   ", nums)

007-insertion-sort.py

@@ -0,0 +1,14 @@
+# Insertion Sort Algorithm
+
+def insertionsort(list):
+    for index in range(0, len(list)):
+        current_element = list[index]
+        pos = index
+        while current_element < list[pos - 1] and pos > 0:
+            list[pos] = list[pos - 1]
+            pos -= 1
+        list[pos] = current_element
+
+list = [26, 5, 3, 78, 35, 42, 29, 66, 49]
+insertionsort(list)
+print(list)

008-merge-sort.py

@@ -0,0 +1,32 @@
+# Merge Sort Algorithm
+
+def mergesort(list):
+    if len(list) > 1:
+        mid = len(list) // 2
+        left = list[:mid]
+        right = list[mid:]
+        mergesort(left)
+        mergesort(right)
+        i = j = k = 0
+        while i < len(left) and j < len(right):
+            if left[i] < right[j]:
+                list[k] = left[i]
+                i += 1
+            else:
+                list[k] = right[j]
+                j += 1
+            k += 1
+        
+        while i < len(left):
+            list[k] = left[i]
+            i += 1
+            k += 1
+        
+        while j < len(right):
+            list[k] = right[j]
+            j += 1
+            k += 1
+
+list = [54, 26, 93, 17, 77, 31, 44, 55, 20]
+mergesort(list)
+print(list)

009-counting-sort.py

@@ -0,0 +1,18 @@
+# Counting Sort Algorithm
+
+def countingsort(array, high):
+    m = high + 1
+    count = [0] * m
+    for a in array:
+        count[a] += 1
+    i = 0
+    for a in range(m):
+        for c in range(count[a]):
+            array[i] = a
+            i += 1
+    return array
+
+array = [1, 2, 7, 3, 2, 1, 4, 2, 3, 2, 1, 8, 7, 9, 0]
+high = max(array)
+countingsort(array, high)
+print(array)

010-quick-sort.py

@@ -0,0 +1,65 @@
+# Quick Sort Algorithm
+
+""" 
+# In this program pivot = first
+def pivot_place(list, first, last):
+    pivot = list[first]
+    print(pivot)
+    left = first + 1
+    right = last
+    while True:
+        while left <= right and list[left] <= pivot:
+            left += 1
+        while left <= right and list[right] >= pivot:
+            right -= 1
+        if right < left:
+            break
+        else:
+            list[left], list[right] = list[right], list[left]
+    list[first], list[right] = list[right], list[first]
+    return right
+
+def quicksort(list, first, last):
+    if first < last:
+        p = pivot_place(list, first, last)
+        quicksort(list, first, p - 1)
+        quicksort(list, p + 1, last)
+
+list = [56, 26, 93, 17, 31, 44]
+n = len(list)
+quicksort(list, 0, n - 1)
+print(list)
+ """
+
+
+# In this program pivot = last
+import random
+def pivot_place(list, first, last):
+    rindex = random.randint(first, last)
+    list[rindex], list[last] = list[last], list[rindex]
+    pivot = list[last]
+    print(pivot)
+    left = first
+    right = last - 1
+    while True:
+        while left <= right and list[left] <= pivot:
+            left += 1
+        while left <= right and list[right] >= pivot:
+            right -= 1
+        if right < left:
+            break
+        else:
+            list[left], list[right] = list[right], list[left]
+    list[last], list[left] = list[left], list[last]
+    return left
+
+def quicksort(list, first, last):
+    if first < last:
+        p = pivot_place(list, first, last)
+        quicksort(list, first, p - 1)
+        quicksort(list, p + 1, last)
+
+list = [56, 26, 93, 17, 31, 44]
+n = len(list)
+quicksort(list, 0, n - 1)
+print(list)

011-bucket-sort.py

@@ -0,0 +1,28 @@
+# Bucket Sort Algorithm
+
+def bucketsort(array):
+    bucket = []
+
+    # Create empty buckets
+    for i in range(len(array)):
+        bucket.append([])
+
+    # Insert elements into their respective buckets
+    for j in array:
+        index = int(10 * j)
+        bucket[index].append(j)
+
+    # Sort the elements of each bucket
+    for i in range(len(array)):
+        bucket[i] = sorted(bucket[i])
+
+    # Get the sorted elements
+    k = 0
+    for i in range(len(array)):
+        for j in range(len(bucket[i])):
+            array[k] = bucket[i][j]
+            k += 1
+    return array
+
+array = [.42, .32, .33, .52, .37, .47, .51, .01, .00]
+print(bucketsort(array))

012-heap-sort.py

@@ -0,0 +1,17 @@
+# Heap Sort Algorithm
+
+from heapq import heappop, heappush
+def heapsort(array):
+    heap = []
+    for element in array:
+        heappush(heap, element)
+    
+    ordered = []
+
+    # while we have elements left in the heap
+    while heap:
+        ordered.append(heappop(heap))
+    return ordered
+
+array = [13, 21, 15, 5, 26, 4, 17, 18, 24, 2, 1, 0, 7, 49]
+print(heapsort(array))

013-radix-sort.py

@@ -0,0 +1,32 @@
+# Radix Sort Algorithm
+
+
+# get number of digits in largest item
+def __get_num_digits(array):
+    m = 0
+    for item in array:
+        m = max(item, m)
+    return len(str(m))
+
+from functools import reduce
+def __flatten(array):
+    return reduce(lambda x, y : x + y, array)
+
+def radix(array, num_digits):
+    for digit in range(0, num_digits):
+        bucket = [[] for i in range(10)]
+        for item in array:
+            # num is the bucket number that the item will be put into
+            num = item // 10 ** (digit) % 10
+            bucket[num].append(item)
+        array = __flatten(bucket)
+    return array
+
+def main():
+    array = [55, 45, 3, 289, 213, 1, 288, 53, 2, 0, 7865, 2]
+    
+    # find longest integer in our list
+    num_digits = __get_num_digits(array)
+    array = radix(array, num_digits)
+    print(array)
+main()

014-shell-sort.py

@@ -0,0 +1,17 @@
+# Shell Sort Algorithm
+
+def shellsort(list):
+    interval = len(list) // 2
+    while interval > 0:
+        for index in range(interval, len(list)):
+            current_element = list[index]
+            pos = index
+            while pos >= interval and current_element < list[pos - interval]:
+                list[pos] = list[pos - interval]
+                pos -= interval
+            list[pos] = current_element
+        interval = interval // 2
+
+list = [9, 8, 3, 7, 5, 6, 4, 1]
+shellsort(list)
+print(list)