renaming

Author: Pl4tt

c++/sorting_algorithms/quicksort.cpp

@@ -0,0 +1,42 @@
+#include "utils.cpp"
+
+
+int partition(int arr[], int low, int high) {
+    int pivot = arr[high];
+    int l = (low - 1);
+
+    for (int pos = low; pos < high; pos++) {
+        if (arr[pos] <= pivot) {
+            l++;
+            swap(&arr[l], &arr[pos]);
+        }
+    }
+    
+    swap(&arr[l+1], &arr[high]);
+
+    return (l + 1);
+}
+
+void quicksort(int arr[], int low, int high) {
+    if (low < high) {
+        int pivot = partition(arr, low, high);
+
+        quicksort(arr, pivot+1, high);
+        quicksort(arr, low, high-1);
+    }
+}
+
+
+
+
+int main()
+{
+    print_array(arr, LENGTH);
+
+    quicksort(arr, 0, LENGTH-1);
+    print_array(arr, LENGTH);
+
+    cout << (equal_arrays(arr, sol, LENGTH) ? "true" : "false");
+
+    return 0;
+}

c++/sorting_algorithms/utils.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+using namespace std;
+
+#define LENGTH 68
+
+
+void swap(int *x, int *y) {
+    int temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+void print_array(int arr[], int size) {
+    for (int i = 0; i < size; i++) {
+        cout << arr[i] << " ";
+    }
+    cout << "end" << endl;
+}
+
+bool equal_arrays(int arr[], int arr2[], int size) {
+    for (int i = 0; i < size; i++) {
+        if (arr[i] != arr2[i]) return false;
+    }
+
+    return true;
+}
+
+
+int arr[] = {21561, 9, -124714, 0, -1247, 24171, 21742174, 47421, -7285, 261, 2, 521, 10, 3, 216, 7, 6216, 2, 62161, 7, 68, 9, -83148, -1235, 1, -10, 166, 389, 13, 63, 19361, 32, 7317, 8539, 32732, 24151621, -2, 7327, 2157105, 1235, 852, 121, 21, -100, -124, 23, 742, 7654, 87, 123456, 6543, 21261, 48245, 16, 8765, 987654321, 247, 125, 8421, 942, 532, 913, 126, 274, 135, 100000, 2162, 37272};
+int sol[] = {-124714, -83148, -7285, -1247, -1235, -124, -100, -10, -2, 0, 1, 2, 2, 3, 7, 7, 9, 9, 10, 13, 16, 21, 23, 32, 63, 68, 87, 121, 125, 126, 135, 166, 216, 247, 261, 274, 389, 521, 532, 742, 852, 913, 942, 1235, 2162, 6216, 6543, 7317, 7327, 7654, 8421, 8539, 8765, 19361, 21261, 21561, 24171, 32732, 37272, 47421, 48245, 62161, 100000, 123456, 2157105, 21742174, 24151621, 987654321};
+
+

c/sorting_algorithms/bubble_sort.c

@@ -0,0 +1,26 @@
+#include "utils.c"
+
+
+void bubble_sort(int arr[], int size) {
+    for (int j = 0; j < size; j++) {
+        for (int i = 0; i < size-j-1; i++) {
+            if (arr[i] > arr[i+1]) {
+                swap(&arr[i], &arr[i+1]);
+            }
+        }
+    }
+}
+
+
+
+
+int main()
+{
+    print_array(arr, LENGTH);
+    bubble_sort(arr, LENGTH);
+
+    print_array(arr, LENGTH);
+    printf("%s", equal_arrays(arr, sol, LENGTH) ? "true" : "false");
+
+    return 0;
+}

c/sorting_algorithms/merge_sort.c

@@ -0,0 +1,59 @@
+#include "utils.c"
+
+
+void merge(int arr[], int low, int middle, int high) {
+    int l = low;
+    int h = middle;
+    int index = 0;
+    
+    int result[LENGTH] = {0};
+
+    while (l < middle && h < high) {
+        if (arr[l] > arr[h]) {
+            result[index] = arr[h];
+            h++;
+        } else {
+            result[index] = arr[l];
+            l++;
+        }
+        index++;
+    }
+
+    while (l < middle) {
+        result[index] = arr[l];
+        index++;
+        l++;
+    }
+    
+    while (h < high) {
+        result[index] = arr[h];
+        index++;
+        h++;
+    }
+
+    for (int i = low; i < high; i++) {
+        arr[i] = result[i-low];
+    }
+}
+
+void merge_sort(int arr[], int low, int high) {
+    int middle = (int) (low + high) / 2;
+    
+    if (low == middle) return;
+
+    merge_sort(arr, middle, high);
+    merge_sort(arr, low, middle);
+    
+    merge(arr, low, middle, high);
+}
+
+int main()
+{
+    print_array(arr, LENGTH);
+    merge_sort(arr, 0, LENGTH);
+    
+    print_array(arr, LENGTH);
+    printf("%s", equal_arrays(arr, sol, LENGTH) ? "true" : "false");
+
+    return 0;
+}

c/sorting_algorithms/quicksort.c

@@ -0,0 +1,41 @@
+#include "utils.c"
+
+
+int partition(int arr[], int low, int high) {
+    int pivot = arr[high];
+    int l = (low - 1);
+
+    for (int pos = low; pos < high; pos++) {
+        if (arr[pos] <= pivot) {
+            l++;
+            swap(&arr[l], &arr[pos]);
+        }
+    }
+
+    swap(&arr[l+1], &arr[high]);
+    
+    return (l + 1);
+}
+
+void quicksort(int arr[], int low, int high) {
+    if (low < high) {
+        int pivot = partition(arr, low, high);
+
+        quicksort(arr, low, pivot-1);
+        quicksort(arr, pivot+1, high);
+    }
+}
+
+
+
+
+int main()
+{
+    print_array(arr, LENGTH);
+    quicksort(arr, 0, LENGTH-1);
+
+    print_array(arr, LENGTH);
+    printf("%s", equal_arrays(arr, sol, LENGTH) ? "true" : "false");
+
+    return 0;
+}

c/sorting_algorithms/utils.c

@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdbool.h>
+
+#define LENGTH 68
+
+
+void swap(int *x, int *y) {
+    int temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+void print_array(int arr[], int size) {
+    for (int i = 0; i < size; i++) {
+        printf("%d ", arr[i]);
+    }
+    printf("end\n");
+}
+
+bool equal_arrays(int arr[], int arr2[], int size) {
+    for (int i = 0; i < size; i++) {
+        if (arr[i] != arr2[i]) return false;
+    }
+
+    return true;
+}
+
+
+int sol[] = {-124714, -83148, -7285, -1247, -1235, -124, -100, -10, -2, 0, 1, 2, 2, 3, 7, 7, 9, 9, 10, 13, 16, 21, 23, 32, 63, 68, 87, 121, 125, 126, 135, 166, 216, 247, 261, 274, 389, 521, 532, 742, 852, 913, 942, 1235, 2162, 6216, 6543, 7317, 7327, 7654, 8421, 8539, 8765, 19361, 21261, 21561, 24171, 32732, 37272, 47421, 48245, 62161, 100000, 123456, 2157105, 21742174, 24151621, 987654321};
+int arr[] = {21561, 9, -124714, 0, -1247, 24171, 21742174, 47421, -7285, 261, 2, 521, 10, 3, 216, 7, 6216, 2, 62161, 7, 68, 9, -83148, -1235, 1, -10, 166, 389, 13, 63, 19361, 32, 7317, 8539, 32732, 24151621, -2, 7327, 2157105, 1235, 852, 121, 21, -100, -124, 23, 742, 7654, 87, 123456, 6543, 21261, 48245, 16, 8765, 987654321, 247, 125, 8421, 942, 532, 913, 126, 274, 135, 100000, 2162, 37272};
+