diff --git a/Bubble sort.c 2841 b/Bubble sort.c 2841 new file mode 100644 index 0000000..9ccd89a --- /dev/null +++ b/Bubble sort.c 2841 @@ -0,0 +1,40 @@ +// Bubble sort in C + +#include + +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); +} + diff --git a/Bucketsort.c 2841 b/Bucketsort.c 2841 new file mode 100644 index 0000000..809d577 --- /dev/null +++ b/Bucketsort.c 2841 @@ -0,0 +1,154 @@ +// Bucket sort in C + +#include +#include + +#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; +} diff --git a/Radixsort.c2841 b/Radixsort.c2841 new file mode 100644 index 0000000..0a750f4 --- /dev/null +++ b/Radixsort.c2841 @@ -0,0 +1,70 @@ +// Radix Sort in C Programming + +#include + +// 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); +}