bruh

1Y-2H/dsa/lab2/code/head.h

@@ -5,15 +5,16 @@
 #include <stdlib.h>
 #include <inttypes.h>
 #include <time.h>
+#include <string.h>
 
 #define AVG_TIME_LOOPS 1
 #define AVG_RAND_MAX 100000
 #define MILLION 1000000
 
-void sort_radix(uint32_t* arr,int n);
-void sort_heap(uint32_t* arr,int n);
-void sort_bubble(uint32_t* arr,int n);
-void sort_merge(uint32_t* arr,int left, int right);
+void sort_radix(uint32_t* arr,uint32_t n);
+void sort_heap(uint32_t* arr,uint32_t n);
+void sort_bubble(uint32_t* arr,uint32_t n);
+void sort_merge(uint32_t* arr,uint32_t left, uint32_t right);
 
 
 void run_exp();

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

@@ -2,7 +2,7 @@
 #include <time.h>
 
 double get_time();
-void fill_rand(uint32_t *arr, int n);
+void fill_rand(uint32_t *arr, uint32_t n);
 
 int main(int argc,char **argv) {
     srand(get_time());
@@ -14,42 +14,42 @@ int main(int argc,char **argv) {
             break;
         case '2': // Test Sorts
             {
-            int n;
+            uint32_t n;
             if(!(argv[1][1]>='a'&&argv[1][1]<='z')){ 
                 printf("\nPrint 2(r/h/b/m) to sort or 3 to see var");
                 printf("\n2r - radix\n2h - heap\n2b - bubble\n2m - merge\n");
                 return 0;}
             printf("Write n:");
-            scanf("%d",&n);
+            scanf("%" SCNu32, &n);
             while(getchar()>'\n');
             uint32_t *arr = (uint32_t*)malloc(sizeof(uint32_t) * n);
             printf("Write n nums:");
-            for (int i = 0;i<n;i++){
-                scanf("%d",&arr[i]);
+            for (uint32_t i = 0;i<n;i++){
+                scanf("%" SCNu32, &arr[i]);
             }
             
-            for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+            for(uint32_t i = 0; i<n;i++)printf("%p %d\n",&arr[i],arr[i]);
             putchar('\n');
 
             switch(argv[1][1]){
                 case 'r': // Radix
                 sort_radix(arr,n); 
-                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                for(uint32_t i = 0; i<n;i++)printf("%p %d\n",&arr[i],arr[i]);
                 break;
                 case 'h': // Heap
                 sort_heap(arr,n);  
-                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                for(uint32_t i = 0; i<n;i++)printf("%p %d\n",&arr[i],arr[i]);
                     break;
                 case 'b': //Bubble
                 sort_bubble(arr,n);    
-                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                for(uint32_t i = 0; i<n;i++)printf("%p %d\n",&arr[i],arr[i]);
                     break;
                 case 'm': //Merge
                 sort_merge(arr,0,n-1);    
-                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                for(uint32_t i = 0; i<n;i++)printf("%p %d\n",&arr[i],arr[i]);
                     break;
                 default:
-                printf("\nPrint 2(r/h/b/m) to sort or 3 to see var");
+                printf("\nPruint32_t 2(r/h/b/m) to sort or 3 to see var");
                 printf("\n2r - radix\n2h - heap\n2b - bubble\n2m - merge\n");
                 return 0;
             }
@@ -63,7 +63,7 @@ int main(int argc,char **argv) {
             }
         default:
             {
-            printf("\nPrint 2(r/h/b/m) to sort or 3 to see var");
+            printf("\nPruint32_t 2(r/h/b/m) to sort or 3 to see var");
             printf("\n2r - radix\n2h - heap\n2b - bubble\n2m - merge\n");
             return 0;
             }
@@ -82,7 +82,7 @@ void run_exp(void) {
 
     fprintf(f, "# N Radix Heap Bubble \n");
 
-    int n = MILLION,end=MILLION,step = 50000;
+    uint32_t n = MILLION,end=MILLION,step = 50000;
     for (;n<=end;n+=step){
 
         uint32_t *arrA = (uint32_t*)malloc(sizeof(uint32_t) * n);
@@ -92,9 +92,11 @@ void run_exp(void) {
         double tRadTotal = 0;
         double tHeapTotal = 0;
         double tBubblTotal = 0;
-        for (int i = 0; i < AVG_TIME_LOOPS; i++) {
+        for (uint32_t i = 0; i < AVG_TIME_LOOPS; i++) {
             fill_rand(arrA, n);
-            arrC = arrB = arrA;
+
+            memcpy(arrB, arrA, n * sizeof(uint32_t));
+            memcpy(arrC, arrA, n * sizeof(uint32_t));
 
             double ta = get_time();
             sort_radix(arrA,n);
@@ -126,11 +128,11 @@ void run_exp(void) {
     return;
 }
 
-int get_rand(int min, int max) {
+uint32_t get_rand(uint32_t min, uint32_t max) {
      return (double)rand() / (RAND_MAX + 1.0) * (max - min) + min;
 }
-void fill_rand(uint32_t *arr, int n) {
-    for (int i = 0; i < n; i++) arr[i] = get_rand(0, AVG_RAND_MAX);
+void fill_rand(uint32_t *arr, uint32_t n) {
+    for (uint32_t i = 0; i < n; i++) arr[i] = get_rand(0, AVG_RAND_MAX);
 }
 
 double get_time() {

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);
 }

1Y-2H/dsa/lab2/data/graph.gp

@@ -5,6 +5,7 @@ set encoding utf8
 
 set grid xtics ytics ls 1 lc rgb "#bbbbbb" lw 1 dt 2
 set title "Radix, Heap и Bubble (Log scale)"
+set xlabel "Количество элементов в массиве, тыс" offset 0,-1
 set ylabel "Время выполнения, с"
 set xtics rotate by 90 right