initial commit

Author: umershaikh123

Bucket sort.py

@@ -0,0 +1,48 @@
+# Bucket Sort in Python
+
+
+def bucketSort(array):
+    bucket = []
+
+    # Create empty buckets
+    for i in range(len(array)):
+        bucket.append([])
+    print("Bucket " , bucket , "\n")
+
+    # Insert elements into their respective buckets
+    for j in array:
+        index_b = int(10 * j)
+        bucket[index_b].append(j)
+    print("Bucket " , bucket , "\n")
+
+    # Sort the elements of each bucket
+    for i in range(len(array)):
+        bucket[i] = sorted(bucket[i])
+    print("Bucket " , bucket , "\n")
+
+    a = []
+    # Get the sorted elements
+    for i in range(len(bucket)):
+        for j in range(len(bucket[i])):
+            if(bucket[i] != None ):
+                a.append(bucket[i][j])
+ 
+    return a
+
+
+array = [.42, .32, .33, .52, .37, .47, .51]
+arr = [9.8, 0.6, 10.1, 1.9, 3.07, 3.04, 5.0, 8.0, 4.8, 7.68]
+print("Sorted Array in descending order is")
+a = bucketSort(arr)
+print(a)
+
+
+
+
+
+#     k = 0
+#    for i in range(len(array)):
+#        for j in range(len(bucket[i])):
+#            array[k] = bucket[i][j]
+#            print("Bucket sortin " , array , "\n")            
+#            k += 1

Exam 1.py

@@ -0,0 +1,47 @@
+def Sort(array , n ):
+    for i in range(n):
+
+        for j in range(n-i-1):
+
+            if(array[j+1] < array[j]):
+                t = array[j]
+                array[j] = array[j+1]
+                array[j+1] = t
+    return array
+
+    
+
+def SpecificSort(array , k ):
+    for i in range(3):
+
+        for j in range(3-i-1):
+            
+            if(array[j+1][k] < array[j][k]):
+                t = array[j]
+                array[j] = array[j+1]
+                array[j+1] = t
+    return array
+
+
+
+A = [[9,8,5] ,[7,1,2],[4,3,6] ]
+M = []
+
+for i in range(3):
+    for j in range(3):
+        M.append(A[i][j])
+ 
+
+M = Sort(M , len(M))
+
+s = 0
+for i in range(3):
+    for j in range(3):
+        A[i][j] = M[s]
+        s += 1
+
+print(A)
+
+
+#for i in range(3):
+#    print(Sort(A[i] , len(A)))

External merge sort (Heap sort ).py

@@ -0,0 +1,71 @@
+sample_list = [45, 345, 2, 4, 6, 645, 56, 65, 78, 34, 34, 34, 345, 90, 55, 23, 12, 40, 11]
+# split 1 = L
+# split 2 = M
+
+def external_merge_sort(list):
+    L = []
+    M= []
+    n = len(list)
+
+    while len(L) == 0 or len(M) == 0:
+        for i in range(n):
+            
+            if i == 0:
+                L.append(list[i])
+                split_list = True
+                print("Split list 1 = " , split_list)
+ 
+            else:
+                if list[i] < list[i - 1]:
+                    if split_list == True:
+                        print("Split list 2 = " , split_list)
+                        split_list = False
+
+                    else:
+                        split_list = True
+    
+                if split_list == True:
+                    print("Split list 3 = " , split_list)
+                    L.append(list[i])
+                else:
+                    print("Split list 4 = " , split_list)
+                    M.append(list[i])
+    
+        print("L = " , L , "\n")
+        print("M = " , M , "\n")
+ 
+
+
+        list = []
+        Li = 0
+        Mi = 0
+        if len(M) == 0:
+            return L
+
+        for i in range(len(L) + len(M)):
+            if i == 0:
+                if L[i] < M[i]:
+                    list.append(L[Li])
+                    Li  += 1
+                else:
+                    list.append(M[Mi])
+                    Mi += 1
+            else:
+                if Li  == len(L):
+                    list.append(M[Mi])
+                    Mi += 1
+                elif Mi == len(M):
+                    list.append(L[Li ])
+                    Li  += 1
+                else:
+                    if L[Li ] < M[Mi]:
+                        list.append(L[Li ])
+                        Li  += 1
+                    else:
+                        list.append(M[Mi])
+                        Mi += 1        
+        L = []
+        M = []
+
+print("Unsorted List:", sample_list)
+print("Sorted List:", external_merge_sort(sample_list))

Linear_selection sort.py

@@ -0,0 +1,33 @@
+# Selection sort
+
+# Selection sort is a sorting algorithm that selects the smallest element
+# from an unsorted list in each iteration and places that element at the beginning of the unsorted list.
+
+
+
+
+
+
+def selectionSort(array, size):
+   
+    for i in range(size):
+        min_idx = i
+
+        for j in range(i + 1, size):
+         
+            # to sort in descending order, change > to < in this line
+            
+            if array[j] < array[min_idx]:
+                min_idx = j
+         
+       
+        (array[i], array[min_idx]) = (array[min_idx], array[i])
+
+
+
+
+data = [-2, 45, 0, 11, -9]
+size = len(data)
+selectionSort(data, size)
+print("\n", 'Sorted Array in Ascending Order: ' , "\n")
+print(data , "\n")

bubble sort.py

@@ -0,0 +1,27 @@
+# Bubble sort in Python
+
+def bubbleSort(array):
+    
+  # loop to access each array element
+  for i in range(len(array)):
+
+    # loop to compare array elements
+    for j in range(len(array) - i -1):
+
+      # compare two adjacent elements
+      # change > to < to sort in descending order
+      if array[j] > array[j + 1]:
+
+        # swapping elements if elements
+        # are not in the intended order
+        t = array[j]
+        array[j] = array[j+1]
+        array[j+1] = t
+
+
+
+data = [-2, 45, 0, 11, -9 , 0 , 8 , 10 , -9]
+bubbleSort(data)
+
+print('Sorted Array in Ascending Order:')
+print(data)

merge sort.py

@@ -0,0 +1,61 @@
+# Merge Sort is one of the most popular sorting algorithms that is based on the principle of Divide and Conquer Algorithm.
+
+
+# MergeSort in Python
+
+
+def mergeSort(array):
+    if len(array) > 1:
+
+        
+ 
+        r = len(array)//2
+        L = array[:r]
+        M = array[r:]
+
+ 
+       
+         
+        mergeSort(L)
+        mergeSort(M)
+
+        i = j = k = 0
+
+    
+        while i < len(L) and j < len(M):
+            if L[i] < M[j]:
+                array[k] = L[i]
+                i += 1
+            else:
+                array[k] = M[j]
+                j += 1
+            k += 1
+ 
+
+
+        while i < len(L):
+            array[k] = L[i]
+            i += 1
+            k += 1
+
+        while j < len(M):
+            array[k] = M[j]
+            j += 1
+            k += 1
+
+
+ 
+def printList(array):
+    for i in range(len(array)):
+        print(array[i], end=" ")
+    print()
+
+
+# Driver program
+if __name__ == '__main__':
+    array = [6, 5, 12, 10, 9, 1]
+
+    mergeSort(array)
+
+    print("Sorted array is: ")
+    printList(array)

quick sort.py

@@ -0,0 +1,61 @@
+# There are different variations of quicksort 
+# where the pivot element is selected from different positions.
+#  Here, we will be selecting the rightmost element of the array as the pivot element.
+
+# pivoit number = left side per less than values or right side greater than pivot values
+
+
+
+
+
+
+
+ 
+
+ 
+def partition(array, low, high):
+
+ 
+  pivot = array[high]
+  i = low - 1
+ 
+  for j in range(low, high):
+    if array[j] <= pivot:
+      i += 1
+      (array[i], array[j]) = (array[j], array[i])
+
+ 
+  (array[i + 1], array[high]) = (array[high], array[i + 1])
+
+ 
+  return i + 1
+
+
+
+
+
+
+
+ 
+def quickSort(array, low, high):
+  if low < high:
+
+
+    pi = partition(array, low, high)
+
+ 
+    quickSort(array, low, pi - 1)
+ 
+    quickSort(array, pi + 1, high)
+
+
+data = [8, 7, 2, 1, 0, 9, 6]
+print("Unsorted Array")
+print(data)
+
+size = len(data)
+
+quickSort(data, 0, size - 1)
+
+print('Sorted Array in Ascending Order:')
+print(data)