Bucket sort.c

Bubble sort.c 2841

@@ -0,0 +1,40 @@
+// Bubble sort in C
+
+#include <stdio.h>
+
+void bubbleSort(int array[], int size) {
+
+  // run loops two times: one for walking throught the array
+  // and the other for comparison
+  for (int step = 0; step < size - 1; ++step) {
+    for (int i = 0; i < size - step - 1; ++i) {
+
+      // To sort in descending order, change">" to "<".
+      if (array[i] > array[i + 1]) {
+
+        // swap if greater is at the rear position
+        int temp = array[i];
+        array[i] = array[i + 1];
+        array[i + 1] = temp;
+      }
+    }
+  }
+}
+
+// function to print the array
+void printArray(int array[], int size) {
+  for (int i = 0; i < size; ++i) {
+    printf("%d  ", array[i]);
+  }
+  printf("\n");
+}
+
+// driver code
+int main() {
+  int data[] = {-2, 45, 0, 11, -9};
+  int size = sizeof(data) / sizeof(data[0]);
+  bubbleSort(data, size);
+  printf("Sorted Array in Ascending Order:\n");
+  printArray(data, size);
+}
+

Bucketsort.c 2841

@@ -0,0 +1,154 @@
+// Bucket sort in C
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NARRAY 7   // Array size
+#define NBUCKET 6  // Number of buckets
+#define INTERVAL 10  // Each bucket capacity
+
+struct Node {
+  int data;
+  struct Node *next;
+};
+
+void BucketSort(int arr[]);
+struct Node *InsertionSort(struct Node *list);
+void print(int arr[]);
+void printBuckets(struct Node *list);
+int getBucketIndex(int value);
+
+// Sorting function
+void BucketSort(int arr[]) {
+  int i, j;
+  struct Node **buckets;
+
+  // Create buckets and allocate memory size
+  buckets = (struct Node **)malloc(sizeof(struct Node *) * NBUCKET);
+
+  // Initialize empty buckets
+  for (i = 0; i < NBUCKET; ++i) {
+    buckets[i] = NULL;
+  }
+
+  // Fill the buckets with respective elements
+  for (i = 0; i < NARRAY; ++i) {
+    struct Node *current;
+    int pos = getBucketIndex(arr[i]);
+    current = (struct Node *)malloc(sizeof(struct Node));
+    current->data = arr[i];
+    current->next = buckets[pos];
+    buckets[pos] = current;
+  }
+
+  // Print the buckets along with their elements
+  for (i = 0; i < NBUCKET; i++) {
+    printf("Bucket[%d]: ", i);
+    printBuckets(buckets[i]);
+    printf("\n");
+  }
+
+  // Sort the elements of each bucket
+  for (i = 0; i < NBUCKET; ++i) {
+    buckets[i] = InsertionSort(buckets[i]);
+  }
+
+  printf("-------------\n");
+  printf("Bucktets after sorting\n");
+  for (i = 0; i < NBUCKET; i++) {
+    printf("Bucket[%d]: ", i);
+    printBuckets(buckets[i]);
+    printf("\n");
+  }
+
+  // Put sorted elements on arr
+  for (j = 0, i = 0; i < NBUCKET; ++i) {
+    struct Node *node;
+    node = buckets[i];
+    while (node) {
+      arr[j++] = node->data;
+      node = node->next;
+    }
+  }
+
+  return;
+}
+
+// Function to sort the elements of each bucket
+struct Node *InsertionSort(struct Node *list) {
+  struct Node *k, *nodeList;
+  if (list == 0 || list->next == 0) {
+    return list;
+  }
+
+  nodeList = list;
+  k = list->next;
+  nodeList->next = 0;
+  while (k != 0) {
+    struct Node *ptr;
+    if (nodeList->data > k->data) {
+      struct Node *tmp;
+      tmp = k;
+      k = k->next;
+      tmp->next = nodeList;
+      nodeList = tmp;
+      continue;
+    }
+
+    for (ptr = nodeList; ptr->next != 0; ptr = ptr->next) {
+      if (ptr->next->data > k->data)
+        break;
+    }
+
+    if (ptr->next != 0) {
+      struct Node *tmp;
+      tmp = k;
+      k = k->next;
+      tmp->next = ptr->next;
+      ptr->next = tmp;
+      continue;
+    } else {
+      ptr->next = k;
+      k = k->next;
+      ptr->next->next = 0;
+      continue;
+    }
+  }
+  return nodeList;
+}
+
+int getBucketIndex(int value) {
+  return value / INTERVAL;
+}
+
+void print(int ar[]) {
+  int i;
+  for (i = 0; i < NARRAY; ++i) {
+    printf("%d ", ar[i]);
+  }
+  printf("\n");
+}
+
+// Print buckets
+void printBuckets(struct Node *list) {
+  struct Node *cur = list;
+  while (cur) {
+    printf("%d ", cur->data);
+    cur = cur->next;
+  }
+}
+
+// Driver code
+int main(void) {
+  int array[NARRAY] = {42, 32, 33, 52, 37, 47, 51};
+
+  printf("Initial array: ");
+  print(array);
+  printf("-------------\n");
+
+  BucketSort(array);
+  printf("-------------\n");
+  printf("Sorted array: ");
+  print(array);
+  return 0;
+}

Radixsort.c2841

@@ -0,0 +1,70 @@
+// Radix Sort in C Programming
+
+#include <stdio.h>
+
+// Function to get the largest element from an array
+int getMax(int array[], int n) {
+  int max = array[0];
+  for (int i = 1; i < n; i++)
+    if (array[i] > max)
+      max = array[i];
+  return max;
+}
+
+// Using counting sort to sort the elements in the basis of significant places
+void countingSort(int array[], int size, int place) {
+  int output[size + 1];
+  int max = (array[0] / place) % 10;
+
+  for (int i = 1; i < size; i++) {
+    if (((array[i] / place) % 10) > max)
+      max = array[i];
+  }
+  int count[max + 1];
+
+  for (int i = 0; i < max; ++i)
+    count[i] = 0;
+
+  // Calculate count of elements
+  for (int i = 0; i < size; i++)
+    count[(array[i] / place) % 10]++;
+
+  // Calculate cummulative count
+  for (int i = 1; i < 10; i++)
+    count[i] += count[i - 1];
+
+  // Place the elements in sorted order
+  for (int i = size - 1; i >= 0; i--) {
+    output[count[(array[i] / place) % 10] - 1] = array[i];
+    count[(array[i] / place) % 10]--;
+  }
+
+  for (int i = 0; i < size; i++)
+    array[i] = output[i];
+}
+
+// Main function to implement radix sort
+void radixsort(int array[], int size) {
+  // Get maximum element
+  int max = getMax(array, size);
+
+  // Apply counting sort to sort elements based on place value.
+  for (int place = 1; max / place > 0; place *= 10)
+    countingSort(array, size, place);
+}
+
+// Print an array
+void printArray(int array[], int size) {
+  for (int i = 0; i < size; ++i) {
+    printf("%d  ", array[i]);
+  }
+  printf("\n");
+}
+
+// Driver code
+int main() {
+  int array[] = {121, 432, 564, 23, 1, 45, 788};
+  int n = sizeof(array) / sizeof(array[0]);
+  radixsort(array, n);
+  printArray(array, n);
+}