Add files via upload

Author: dipta-dhar

Algorithms/Sorting/BucketSort.cpp

@@ -0,0 +1,35 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define SIZE 1000
+
+void bucketSort(int a[], int n) {
+    int i, j, k, buckets[SIZE];
+
+    for(i = 0; i < SIZE; ++i)
+        buckets[i] = 0;
+
+    for(i = 0; i < n; ++i)
+        ++buckets[a[i]];
+
+    for(i = 0, j = 0; j < SIZE; ++j)
+        for(k = buckets[j]; k > 0; --k)
+            a[i++] = j;
+}
+
+int main() {
+    int i, a[] = {3, 6, 7, 1, 10, 4, 1, 2};
+    int n = sizeof(a)/sizeof(a[0]);
+
+    cout << "Before sorting:\n";
+    for(i = 0; i < n; ++i)
+        cout << a[i] << " ";
+
+    bucketSort(a, n);
+
+    cout<< "\n\nAfter sorting:\n";
+    for(i = 0; i < n; ++i)
+        cout<< a[i] << " ";
+
+    return 0;
+}

Algorithms/Sorting/BucketSort.java

@@ -0,0 +1,53 @@
+package sorting;
+
+import java.util.Random;
+
+public class BucketSort 
+{
+    static int[] sort(int[] sequence, int maxValue)  {
+        // Bucket Sort
+        int[] Bucket = new int[maxValue + 1];
+        int[] sorted_sequence = new int[sequence.length];
+ 
+        for (int i = 0; i < sequence.length; i++)
+            Bucket[sequence[i]]++;
+ 
+        int outPos = 0;
+        for (int i = 0; i < Bucket.length; i++)
+            for (int j = 0; j < Bucket[i]; j++)
+                sorted_sequence[outPos++] = i;
+ 
+        return sorted_sequence;
+    }
+ 
+    static void printSequence(int[] sorted_sequence) {
+        for (int i = 0; i < sorted_sequence.length; i++)
+            System.out.print(sorted_sequence[i] + " ");
+    }
+ 
+    static int maxValue(int[] sequence) {
+        int maxValue = 0;
+        for (int i = 0; i < sequence.length; i++)
+            if (sequence[i] > maxValue)
+                maxValue = sequence[i];
+        return maxValue;
+    }
+ 
+    public static void main(String args[]) {
+        System.out.println("Generate random numbers using BUCKET SORT:");
+        Random random = new Random();
+        int N = 20;
+        int[] sequence = new int[N];
+ 
+        for (int i = 0; i < N; i++)
+            sequence[i] = Math.abs(random.nextInt(100));
+ 
+        int maxValue = maxValue(sequence);
+ 
+        System.out.println("\nOriginal Sequence: ");
+        printSequence(sequence);
+ 
+        System.out.println("\nSorted Sequence: ");
+        printSequence(sort(sequence, maxValue));
+    }
+}

Algorithms/Sorting/BucketSort.py

@@ -0,0 +1,31 @@
+def sort(array, bucketSize=DEFAULT_BUCKET_SIZE):
+  if len(array) == 0:
+    return array
+
+  # Determine minimum and maximum values
+  minValue = array[0]
+  maxValue = array[0]
+  for i in range(1, len(array)):
+    if array[i] < minValue:
+      minValue = array[i]
+    elif array[i] > maxValue:
+      maxValue = array[i]
+
+  # Initialize buckets
+  bucketCount = math.floor((maxValue - minValue) / bucketSize) + 1
+  buckets = []
+  for i in range(0, bucketCount):
+    buckets.append([])
+
+  # Distribute input array values into buckets
+  for i in range(0, len(array)):
+    buckets[math.floor((array[i] - minValue) / bucketSize)].append(array[i])
+
+  # Sort buckets and place back into input array
+  array = []
+  for i in range(0, len(buckets)):
+    insertion_sort.sort(buckets[i])
+    for j in range(0, len(buckets[i])):
+      array.append(buckets[i][j])
+
+  return array

Algorithms/Sorting/CocktailSort.cs

@@ -0,0 +1,38 @@
+public class CocktailSort<T> : IGenericSortingAlgorithm<T> where T : IComparable
+{
+    public void Sort(IList<T> list)
+    {
+        int start = -1;
+        int end = list.Count - 2;
+        bool swapped;
+            
+        do {
+            swapped = false;
+            for (int i = ++start; i <= end; i++) {
+                if (list[i].CompareTo(list[i + 1]) > 0) {
+                    Swap(list, i, i + 1);
+                    swapped = true;
+                }
+            }
+
+            if (!swapped) {
+                break;
+            }
+
+            swapped = false;
+            for (int i = --end; i >= start; i--) {
+                if (list[i].CompareTo(list[i + 1]) > 0) {
+                    Swap(list, i, i + 1);
+                    swapped = true;
+                }
+            }
+        } while (swapped);
+    }
+
+    private void Swap(IList<T> list, int a, int b)
+    {
+        T temp = list[a];
+        list[a] = list[b];
+        list[b] = temp;
+    }
+}

Algorithms/Sorting/CocktailSort.java

@@ -0,0 +1,52 @@
+package sorting;
+
+public class CocktailSort {
+	
+	public static void main(String []args) {
+		int[] arr = {2,5,6,4,11,22,10,1};
+	    
+		System.out.println("Before Sorting:");
+	    for(int j=0; j<arr.length; j++)
+	    	System.out.print(arr[j] + " ");
+		
+	    sort(arr);
+	    
+	    System.out.println("\n\nAfter Sorting:");
+	    for(int j=0; j<arr.length; j++)
+	    	System.out.print(arr[j] + " ");
+	}
+	
+    public static void sort(int[] array) {
+        int start = -1;
+        int end = array.length - 2;
+        boolean swapped;
+        
+        do {
+            swapped = false;
+            for (int i = ++start; i <= end; i++) {
+                if (array[i] > array[i + 1]) {
+                    swap(array, i, i + 1);
+                    swapped = true;
+                }
+            }
+
+            if (!swapped) {
+                break;
+            }
+
+            swapped = false;
+            for (int i = --end; i >= start; i--) {
+                if (array[i] > array[i + 1]) {
+                    swap(array, i, i + 1);
+                    swapped = true;
+                }
+            }
+        } while (swapped);
+    }
+
+    private static void swap(int[] array, int a, int b) {
+        Integer temp = array[a];
+        array[a] = array[b];
+        array[b] = temp;
+    }
+}

Algorithms/Sorting/CombSort.py

@@ -0,0 +1,22 @@
+def default_compare(a, b):
+  if a < b:
+    return -1
+  elif a > b:
+    return 1
+  return 0
+
+def sort(array, compare=default_compare):
+  gap = len(array)
+  shrinkFactor = 1.3
+  swapped = False
+
+  while gap > 1 or swapped:
+    if gap > 1:
+      gap = math.floor(gap / shrinkFactor)
+    swapped = False
+    for i in range(len(array) - gap):
+      if compare(array[i], array[i + gap]) > 0:
+        array[i], array[i + gap] = array[i + gap], array[i]
+        swapped = True
+
+  return array

Algorithms/Sorting/CountingSort.cpp

@@ -0,0 +1,38 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void countingSort(int arr[], int n, int max) {
+    int i, j;
+    int B[20], C[100];
+
+    for(i=0; i<=max; i++)   C[i] = 0;
+    for(j=1; j<=n; j++)     C[arr[j]] = C[arr[j]] + 1;
+    for(i=1; i<=max; i++)   C[i] = C[i] + C[i-1];
+    for(j=n; j>=1; j--) {
+        B[C[arr[j]]] = arr[j];
+        C[arr[j]] = C[arr[j]] - 1;
+    }
+
+    printf("The Sorted array is:\n");
+    for(i=1; i<=n; i++)
+          printf("%d ", B[i]);
+    return;
+}
+
+int main()
+{
+    int a[50],n,i,max=0;
+    printf("Enter number of elements: ");
+    scanf("%d",&n);
+
+    printf("Enter elements:\n");
+    for(i=1; i<=n; ++i) {
+        scanf("%d",&a[i]);
+        if(a[i] > max)
+            max = a[i];
+    }
+
+    countingSort(a, n, max);
+
+    return 0;
+}

Algorithms/Sorting/CountingSort.cs

@@ -0,0 +1,36 @@
+public class CountingSort : IIntegerSortingAlgorithm {
+    public void Sort(int[] array) {
+        if (array.Length == 0) {
+            return;
+        }
+
+        // Determine minimum and maximum values
+        int minValue = array[0];
+        int maxValue = array[0];
+        for (int i = 1; i < array.Length; i++) {
+            if (array[i] < minValue) {
+                minValue = array[i];
+            } else if (array[i] > maxValue) {
+                maxValue = array[i];
+            }
+        }
+
+        Sort(array, minValue, maxValue);
+    }
+
+    public void Sort(int[] array, int minValue, int maxValue) {
+        int[] buckets = new int[maxValue - minValue + 1];
+
+        for (int i = 0; i < array.Length; i++) {
+            buckets[array[i] - minValue]++;
+        }
+
+        int sortedIndex = 0;
+        for (int i = 0; i < buckets.Length; i++) {
+            while (buckets[i] > 0) {
+                array[sortedIndex++] = i + minValue;
+                buckets[i]--;
+            }
+        }
+    }
+}

Algorithms/Sorting/CountingSort.java

@@ -0,0 +1,38 @@
+package sorting;
+
+public class CountingSort {
+    public static void sort(Integer[] array) {
+        if (array.length == 0) {
+            return;
+        }
+
+        // Determine minimum and maximum values
+        Integer minValue = array[0];
+        Integer maxValue = array[0];
+        for (int i = 1; i < array.length; i++) {
+            if (array[i] < minValue) {
+                minValue = array[i];
+            } else if (array[i] > maxValue) {
+                maxValue = array[i];
+            }
+        }
+
+        sort(array, minValue, maxValue);
+    }
+
+    public static void sort(Integer[] array, int minValue, int maxValue) {
+        int[] buckets = new int[maxValue - minValue + 1];
+
+        for (int i = 0; i < array.length; i++) {
+            buckets[array[i] - minValue]++;
+        }
+
+        int sortedIndex = 0;
+        for (int i = 0; i < buckets.length; i++) {
+            while (buckets[i] > 0) {
+                array[sortedIndex++] = i + minValue;
+                buckets[i]--;
+            }
+        }
+    }
+}