bruh

1Y-2H/dsa/lab2/code/sort.c

@@ -1,60 +1,60 @@
 #include "head.h"
 
 //=== === === RADIX SORT === === ===
-uint32_t get_max(uint32_t* arr,int n);
-void counting_sort(uint32_t* arr, int n, int exp);
-void sort_radix(uint32_t* arr,int n){
+uint32_t get_max(uint32_t* arr,uint32_t n);
+void counting_sort(uint32_t* arr, uint32_t n, uint32_t exp);
+void sort_radix(uint32_t* arr,uint32_t n){
     uint32_t max = get_max(arr, n);
 
     for(uint32_t exp = 1; max / exp > 0; exp *= 10)
         counting_sort(arr, n, exp);
 }
-uint32_t get_max(uint32_t* arr, int n) {
+uint32_t get_max(uint32_t* arr, uint32_t n) {
     uint32_t max = arr[0];
-    for(int i = 1; i < n; i++)
+    for(uint32_t i = 1; i < n; i++)
         if(arr[i] > max)
             max = arr[i];
     return max;
 }
-void counting_sort(uint32_t* arr, int n, int exp) {
+void counting_sort(uint32_t* arr, uint32_t n, uint32_t exp) {
     uint32_t output[n];
     uint32_t count[10] = {0};
 
-    for(int i = 0; i < n; i++)
+    for(uint32_t i = 0; i < n; i++)
         count[(arr[i] / exp) % 10]++;
 
-    for(int i = 1; i < 10; i++)
+    for(uint32_t i = 1; i < 10; i++)
         count[i] += count[i - 1];
 
-    for(int i = n - 1; i >= 0; i--) {
+    for(uint32_t i = n; i-- > 0;){
         output[count[(arr[i] / exp) % 10] - 1] = arr[i];
         count[(arr[i] / exp) % 10]--;
     }
 
-    for(int i = 0; i < n; i++)
+    for(uint32_t i = 0; i < n; i++)
         arr[i] = output[i];
 }
 // === === === HEAP SORT  === === ===
-void heapify(uint32_t* arr, int n, int i);
+void heapify(uint32_t* arr, uint32_t n, uint32_t i);
 void swap(uint32_t* a, uint32_t *b);
-void sort_heap(uint32_t* arr,int n){
-    for(int i = n/2 - 1; i >= 0; i--)
-        heapify(arr, n, i);
+void sort_heap(uint32_t* arr,uint32_t n){
+    for(int i = n/2 - 1; i >= 0; i--)    
+     heapify(arr, n, i);
 
-    for(int i = n - 1; i > 0; i--) {
+    for(uint32_t i = n - 1; i > 0; i--) {
         swap(&arr[0], &arr[i]);
         heapify(arr, i, 0);
     }
 }
 void swap(uint32_t* a, uint32_t *b) {
-    int temp = *a;
+    uint32_t temp = *a;
     *a = *b;
     *b = temp;
 }
-void heapify(uint32_t* arr, int n, int i) {
-    int largest = i;
-    int left = 2 * i + 1;
-    int right = 2 * i + 2;
+void heapify(uint32_t* arr, uint32_t n, uint32_t i) {
+    uint32_t largest = i;
+    uint32_t left = 2 * i + 1;
+    uint32_t right = 2 * i + 2;
 
     if(left < n && arr[left] > arr[largest])
         largest = left;
@@ -70,12 +70,12 @@ void heapify(uint32_t* arr, int n, int i) {
 }
 
 // === === === BUBBLE SORT === === ===
-void sort_bubble(uint32_t* arr,int n){
-    for(int i = 0; i < n - 1; i++) {
-        int swapped = 0;
-        for(int j = 0; j < n - i - 1; j++) {
+void sort_bubble(uint32_t* arr,uint32_t n){
+    for(uint32_t i = 0; i < n - 1; i++) {
+        uint32_t swapped = 0;
+        for(uint32_t j = 0; j < n - i - 1; j++) {
             if(arr[j] > arr[j + 1]) {
-                int temp = arr[j];
+                uint32_t temp = arr[j];
                 arr[j] = arr[j + 1];
                 arr[j + 1] = temp;
                 swapped = 1;
@@ -86,38 +86,45 @@ void sort_bubble(uint32_t* arr,int n){
 }
 
 // === === === MERGE SORT === === ===
-void merge(uint32_t* arr, int left, int mid, int right);
-void sort_merge(uint32_t* arr, int left, int right){
-    if(left < right) {
-        int mid = left + (right - left) / 2;
+void sort_merge(uint32_t* arr, uint32_t left, uint32_t right)
+{
+    uint32_t n = right - left + 1;
 
-        sort_merge(arr, left, mid);
-        sort_merge(arr, mid + 1, right);
-        merge(arr, left, mid, right);
-    }
-}
-void merge(uint32_t* arr, int left, int mid, int right) {
-    int n1 = mid - left + 1;
-    int n2 = right - mid;
+    uint32_t *temp = malloc(sizeof(uint32_t) * n);
+    if(!temp) return;
 
-    int L[n1], R[n2];
+    for(uint32_t size = 1; size < n; size *= 2)
+    {
+        for(uint32_t start = 0; start < n; start += 2 * size)
+        {
+            uint32_t mid = start + size;
+            uint32_t end = start + 2 * size;
 
-    for(int i = 0; i < n1; i++)
-        L[i] = arr[left + i];
-    for(int j = 0; j < n2; j++)
-        R[j] = arr[mid + 1 + j];
+            if(mid > n) mid = n;
+            if(end > n) end = n;
 
-    int i = 0, j = 0, k = left;
-    while(i < n1 && j < n2) {
-        if(L[i] <= R[j]) {
-            arr[k] = L[i];
-            i++;
-        } else {
-            arr[k] = R[j];
-            j++;
+            uint32_t i = start;
+            uint32_t j = mid;
+            uint32_t k = start;
+
+            while(i < mid && j < end)
+            {
+                if(arr[left + i] <= arr[left + j])
+                    temp[k++] = arr[left + i++];
+                else
+                    temp[k++] = arr[left + j++];
+            }
+
+            while(i < mid)
+                temp[k++] = arr[left + i++];
+
+            while(j < end)
+                temp[k++] = arr[left + j++];
         }
-        k++;
+
+        for(uint32_t i = 0; i < n; i++)
+            arr[left + i] = temp[i];
     }
-    while(i < n1) { arr[k] = L[i]; i++; k++;}
-    while(j < n2) { arr[k] = R[j]; j++; k++;}
+
+    free(temp);
 }