Long time no see

2026-02-21 10:47:00 +07:00
parent 0d54fe176e
commit b7df98a55c
198 changed files with 3249 additions and 1 deletions
@@ -0,0 +1,22 @@
+#ifndef HEAD
+#define HEAD
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <time.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 run_exp();
+
+#endif
+
@@ -0,0 +1,126 @@
+#include "head.h"
+#include <time.h>
+
+double get_time();
+void fill_rand(uint32_t *arr, int n);
+
+int main(int argc,char **argv) {
+    srand(get_time());
+    
+    if(argc>1){
+        switch(argv[1][0]){
+        case '1': // Exp what sort is faster
+            run_exp();
+            break;
+        case '2': // Test Sorts
+            {
+            int n;
+            if(!(argv[1][1]>='a'&&argv[1][1]<='z')) return 0;
+            printf("Write n:");
+            scanf("%d",&n);
+            while(getchar()>'\n');
+            uint32_t *arr = (uint32_t*)malloc(sizeof(uint32_t) * n);
+            fill_rand(arr, n);
+            for(int i = 0; i<n;i++)printf("%d ",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]);
+                break;
+                case 'h': // Heap
+                sort_heap(arr,n);  
+                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                    break;
+                case 'b': //Bubble
+                sort_bubble(arr,n);    
+                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                    break;
+                case 'm': //Merge
+                sort_merge(arr,0,n-1);    
+                for(int i = 0; i<n;i++)printf("%d ",arr[i]);
+                    break;
+                default:
+                    break;
+            }
+            break;
+        default:
+            return 0;
+            }
+        case '3':
+            {
+            printf("\n N - %d",(18-1)%24+1);
+            break;
+            }
+        }
+    }
+    else{
+        run_exp();
+    }
+    return 0;
+}
+
+void run_exp(void) {
+
+    FILE *f = fopen("table.dat", "w");
+    if (!f) return;
+
+    fprintf(f, "# N Radix Heap Bubble \n");
+
+    int n = 50000,end=MILLION,step = n;
+    for (;n<end;n+=step){
+
+        uint32_t *arr = (uint32_t*)malloc(sizeof(uint32_t) * n);
+    
+        double tRadTotal = 0;
+        for (int i = 0; i < AVG_TIME_LOOPS; i++) {
+            fill_rand(arr, n);
+            double t = get_time();
+            sort_radix(arr,n);
+            tRadTotal += (get_time() - t);
+        }
+        double tRadRes = tRadTotal / AVG_TIME_LOOPS;
+    
+        double tHeapTotal = 0;
+        for (int i = 0; i < AVG_TIME_LOOPS; i++) {
+            fill_rand(arr, n);
+            double t = get_time();
+            sort_heap(arr, n);            
+            tHeapTotal += (get_time() - t);
+        }
+        double tHeapRes = tHeapTotal / AVG_TIME_LOOPS;
+
+        double tBubblTotal = 0;
+        for (int i = 0; i < AVG_TIME_LOOPS; i++) {
+            fill_rand(arr, n);
+            double t = get_time();
+            sort_bubble(arr,n);
+            tBubblTotal += (get_time() - t);
+        }
+        double tBubblRes = tBubblTotal / AVG_TIME_LOOPS;
+
+        fprintf(f, "%d %f %f %f\n", n, tRadRes, tHeapRes, tBubblRes);
+        free(arr);
+        printf("Sort: %d/%d  \r", n, end);
+        fflush(stdout);
+    }
+    fclose(f);
+    printf("\nTable 1 done.\n");
+    
+    return;
+}
+
+int get_rand(int min, int 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);
+}
+
+double get_time() {
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return ts.tv_sec + ts.tv_nsec * 1e-9;
+}
+
@@ -0,0 +1,123 @@
+#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 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 max = arr[0];
+    for(int i = 1; i < n; i++)
+        if(arr[i] > max)
+            max = arr[i];
+    return max;
+}
+void counting_sort(uint32_t* arr, int n, int exp) {
+    uint32_t output[n];
+    uint32_t count[10] = {0};
+
+    for(int i = 0; i < n; i++)
+        count[(arr[i] / exp) % 10]++;
+
+    for(int i = 1; i < 10; i++)
+        count[i] += count[i - 1];
+
+    for(int i = n - 1; i >= 0; i--) {
+        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
+        count[(arr[i] / exp) % 10]--;
+    }
+
+    for(int i = 0; i < n; i++)
+        arr[i] = output[i];
+}
+// === === === HEAP SORT  === === ===
+void heapify(uint32_t* arr, int n, int 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);
+
+    for(int 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;
+    *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;
+
+    if(left < n && arr[left] > arr[largest])
+        largest = left;
+
+    if(right < n && arr[right] > arr[largest])
+        largest = right;
+
+    if(largest != i) {
+        swap(&arr[i], &arr[largest]);
+        
+        heapify(arr, n, largest);
+    }
+}
+
+// === === === 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++) {
+            if(arr[j] > arr[j + 1]) {
+                int temp = arr[j];
+                arr[j] = arr[j + 1];
+                arr[j + 1] = temp;
+                swapped = 1;
+            }
+        }
+        if(!swapped) break; 
+    }
+}
+
+// === === === 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;
+
+        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;
+
+    int L[n1], R[n2];
+
+    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];
+
+    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++;
+        }
+        k++;
+    }
+    while(i < n1) { arr[k] = L[i]; i++; k++;}
+    while(j < n2) { arr[k] = R[j]; j++; k++;}
+}
@@ -0,0 +1,28 @@
+CC = gcc
+
+CFLAGS = -Wall -Wextra -I../ -g 
+TARGET = sort
+
+SRC_DIR = ../code
+OBJ_DIR = ../.o
+
+SRCS = $(wildcard $(SRC_DIR)/*.c)
+OBJS = $(patsubst $(SRC_DIR)/%.c, $(OBJ_DIR)/%.o, $(SRCS))
+
+.PHONY: all clean run
+
+all: $(TARGET)
+
+$(TARGET): $(OBJS)
+	$(CC) $(CFLAGS) $(OBJS) -o $(TARGET)
+
+$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
+	@mkdir -p $(OBJ_DIR)
+	$(CC) $(CFLAGS) -c $< -o $@
+
+run: $(TARGET)
+	./$(TARGET) < input > output
+	@cat output
+
+clean:
+	rm -rf $(OBJ_DIR) $(TARGET) output